openAgent

1import { describe, expect } from "bun:test"
2import { Effect, Layer, Schema } from "effect"
3import { Database } from "@opencode-ai/core/database/database"
4import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
5import { LayerNode } from "@opencode-ai/core/effect/layer-node"
6import { EventV2 } from "@opencode-ai/core/event"
7import { Location } from "@opencode-ai/core/location"
8import { ProjectV2 } from "@opencode-ai/core/project"
9import { ProjectTable } from "@opencode-ai/core/project/sql"
10import { AbsolutePath } from "@opencode-ai/core/schema"
11import { SessionV2 } from "@opencode-ai/core/session"
12import { SessionExecution } from "@opencode-ai/core/session/execution"
13import { SessionProjector } from "@opencode-ai/core/session/projector"
14import { SessionStore } from "@opencode-ai/core/session/store"
15import { SessionTable } from "@opencode-ai/core/session/sql"
16import { testEffect } from "./lib/effect"
17 
18const projects = Layer.succeed(
19  ProjectV2.Service,
20  ProjectV2.Service.of({
21    resolve: (directory) => Effect.succeed({ id: ProjectV2.ID.global, directory }),
22    directories: () => Effect.succeed([]),
23    commit: () => Effect.void,
24  }),
25)
26const it = testEffect(
27  AppNodeBuilder.build(
28    LayerNode.group([Database.node, EventV2.node, SessionProjector.node, SessionStore.node, SessionV2.node]),
29    [
30      [ProjectV2.node, projects],
31      [SessionExecution.node, SessionExecution.noopLayer],
32    ],
33  ),
34)
35const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
36 
37const GapEvent = EventV2.define({
38  type: "test.session.history.gap",
39  durable: { aggregate: "sessionID", version: 1 },
40  schema: { sessionID: SessionV2.ID, value: Schema.String },
41})
42 
43describe("SessionV2.history", () => {
44  it.effect("returns an exhausted page for a migrated Session with no event sequence", () =>
45    Effect.gen(function* () {
46      const db = (yield* Database.Service).db
47      const session = yield* SessionV2.Service
48      const sessionID = SessionV2.ID.make("ses_empty_history")
49      yield* db
50        .insert(ProjectTable)
51        .values({ id: ProjectV2.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
52        .onConflictDoNothing()
53        .run()
54      yield* db
55        .insert(SessionTable)
56        .values({
57          id: sessionID,
58          project_id: ProjectV2.ID.global,
59          slug: "empty-history",
60          directory: "/project",
61          title: "Empty history",
62          version: "test",
63        })
64        .run()
65 
66      const first = yield* session.history({ sessionID, limit: 10 })
67 
68      expect(first).toEqual({ events: [], hasMore: false })
69    }),
70  )
71 
72  it.effect("treats after as an exclusive aggregate sequence", () =>
73    Effect.gen(function* () {
74      const session = yield* SessionV2.Service
75      const created = yield* session.create({ location })
76      yield* session.switchAgent({ sessionID: created.id, agent: "one" })
77      yield* session.switchAgent({ sessionID: created.id, agent: "two" })
78 
79      const page = yield* session.history({ sessionID: created.id, after: 1, limit: 10 })
80 
81      expect(page.events.map((event) => event.durable?.seq)).toEqual([2])
82      expect(page.hasMore).toBe(false)
83    }),
84  )
85 
86  it.effect("paginates public events in aggregate order across filtered gaps without duplicates", () =>
87    Effect.gen(function* () {
88      const session = yield* SessionV2.Service
89      const events = yield* EventV2.Service
90      const created = yield* session.create({ location })
91      yield* session.switchAgent({ sessionID: created.id, agent: "one" })
92      yield* events.publish(GapEvent, { sessionID: created.id, value: "filtered" })
93      yield* session.switchAgent({ sessionID: created.id, agent: "two" })
94      yield* session.switchAgent({ sessionID: created.id, agent: "three" })
95 
96      const first = yield* session.history({ sessionID: created.id, limit: 2 })
97      const after = first.events.at(-1)?.durable?.seq
98      const second = yield* session.history({
99        sessionID: created.id,
100        after,
101        limit: 2,
102      })
103      const sequence = [...first.events, ...second.events].map((event) => event.durable?.seq)
104 
105      expect(first.hasMore).toBe(true)
106      expect(second.hasMore).toBe(false)
107      expect(sequence).toEqual([1, 3, 4])
108      expect(new Set(sequence).size).toBe(sequence.length)
109    }),
110  )
111 
112  it.effect("includes events committed between pages", () =>
113    Effect.gen(function* () {
114      const session = yield* SessionV2.Service
115      const created = yield* session.create({ location })
116      yield* session.switchAgent({ sessionID: created.id, agent: "one" })
117      yield* session.switchAgent({ sessionID: created.id, agent: "two" })
118 
119      const first = yield* session.history({ sessionID: created.id, limit: 1 })
120      yield* session.switchAgent({ sessionID: created.id, agent: "later" })
121      const second = yield* session.history({
122        sessionID: created.id,
123        after: first.events.at(-1)?.durable?.seq,
124        limit: 10,
125      })
126 
127      expect(first.hasMore).toBe(true)
128      expect([...first.events, ...second.events].map((event) => event.durable?.seq)).toEqual([1, 2, 3])
129      expect(second.hasMore).toBe(false)
130    }),
131  )
132 
133  it.effect("reports exhaustion for exact-limit and limit-plus-one pages", () =>
134    Effect.gen(function* () {
135      const session = yield* SessionV2.Service
136      const created = yield* session.create({ location })
137      yield* session.switchAgent({ sessionID: created.id, agent: "one" })
138      yield* session.switchAgent({ sessionID: created.id, agent: "two" })
139 
140      const exact = yield* session.history({ sessionID: created.id, limit: 2 })
141      const oneMore = yield* session.history({ sessionID: created.id, limit: 1 })
142      const exhausted = yield* session.history({
143        sessionID: created.id,
144        after: oneMore.events.at(-1)?.durable?.seq,
145        limit: 1,
146      })
147 
148      expect(exact.events).toHaveLength(2)
149      expect(exact.hasMore).toBe(false)
150      expect(oneMore.events).toHaveLength(1)
151      expect(oneMore.hasMore).toBe(true)
152      expect(exhausted.events).toHaveLength(1)
153      expect(exhausted.hasMore).toBe(false)
154    }),
155  )
156 
157  it.effect("fails with NotFoundError for a missing Session", () =>
158    Effect.gen(function* () {
159      const session = yield* SessionV2.Service
160      const error = yield* session.history({ sessionID: SessionV2.ID.make("ses_missing"), limit: 10 }).pipe(Effect.flip)
161 
162      expect(error._tag).toBe("Session.NotFoundError")
163    }),
164  )
165})
166