openAgent

1import { describe, expect } from "bun:test"
2import path from "path"
3import { Effect, Layer, Stream } from "effect"
4import { AgentV2 } from "@opencode-ai/core/agent"
5import { asc, eq } from "drizzle-orm"
6import { Database } from "@opencode-ai/core/database/database"
7import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
8import { LayerNode } from "@opencode-ai/core/effect/layer-node"
9import { EventV2 } from "@opencode-ai/core/event"
10import { EventTable } from "@opencode-ai/core/event/sql"
11import { Location } from "@opencode-ai/core/location"
12import { ModelV2 } from "@opencode-ai/core/model"
13import { ProjectV2 } from "@opencode-ai/core/project"
14import { ProjectTable } from "@opencode-ai/core/project/sql"
15import { ProviderV2 } from "@opencode-ai/core/provider"
16import { AbsolutePath } from "@opencode-ai/core/schema"
17import { SessionV2 } from "@opencode-ai/core/session"
18import { SessionV1 } from "@opencode-ai/core/v1/session"
19import { Prompt } from "@opencode-ai/core/session/prompt"
20import { SessionProjector } from "@opencode-ai/core/session/projector"
21import { SessionExecution } from "@opencode-ai/core/session/execution"
22import { SessionInput } from "@opencode-ai/core/session/input"
23import { SessionEvent } from "@opencode-ai/core/session/event"
24import { SessionTable } from "@opencode-ai/core/session/sql"
25import { SessionStore } from "@opencode-ai/core/session/store"
26import { WorkspaceV2 } from "@opencode-ai/core/workspace"
27import { testEffect } from "./lib/effect"
28import { tmpdir } from "./fixture/tmpdir"
29 
30const projects = Layer.succeed(
31  ProjectV2.Service,
32  ProjectV2.Service.of({
33    resolve: (directory) => Effect.succeed({ id: ProjectV2.ID.global, directory }),
34    directories: () => Effect.succeed([]),
35    commit: () => Effect.void,
36  }),
37)
38const it = testEffect(
39  AppNodeBuilder.build(
40    LayerNode.group([Database.node, EventV2.node, SessionProjector.node, SessionStore.node, SessionV2.node]),
41    [
42      [ProjectV2.node, projects],
43      [SessionExecution.node, SessionExecution.noopLayer],
44    ],
45  ),
46)
47const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
48const id = SessionV2.ID.create()
49 
50describe("SessionV2.create", () => {
51  it.effect("creates a fresh projected session when the ID is omitted", () =>
52    Effect.gen(function* () {
53      const session = yield* SessionV2.Service
54 
55      const first = yield* session.create({ location })
56      const second = yield* session.create({ location })
57 
58      expect(second.id).not.toBe(first.id)
59      expect(yield* session.list()).toHaveLength(2)
60    }),
61  )
62 
63  it.effect("returns the original session when the ID is retried", () =>
64    Effect.gen(function* () {
65      const session = yield* SessionV2.Service
66      const input = { id, location }
67 
68      const first = yield* session.create(input)
69      const retried = yield* session.create(input)
70 
71      expect(retried).toEqual(first)
72      expect(yield* session.list()).toEqual([first])
73    }),
74  )
75 
76  it.effect("stores supplied immutable create attributes", () =>
77    Effect.gen(function* () {
78      const session = yield* SessionV2.Service
79      const workspaceID = WorkspaceV2.ID.make("wrk_test")
80      const model = ModelV2.Ref.make({
81        id: ModelV2.ID.make("sonnet"),
82        providerID: ProviderV2.ID.anthropic,
83        variant: ModelV2.VariantID.make("fast"),
84      })
85 
86      expect(
87        yield* session.create({
88          location: Location.Ref.make({ directory: location.directory, workspaceID }),
89          agent: AgentV2.ID.make("build"),
90          model,
91        }),
92      ).toMatchObject({ location: { directory: location.directory, workspaceID }, agent: "build", model })
93    }),
94  )
95 
96  it.effect("returns the existing Session when one ID is reused with different create arguments", () =>
97    Effect.gen(function* () {
98      const session = yield* SessionV2.Service
99      const created = yield* session.create({ id, location })
100      const changed = [
101        { id, location: Location.Ref.make({ directory: AbsolutePath.make("/other") }) },
102        { id, location, agent: AgentV2.ID.make("build") },
103        {
104          id,
105          location,
106          model: ModelV2.Ref.make({ id: ModelV2.ID.make("sonnet"), providerID: ProviderV2.ID.anthropic }),
107        },
108      ]
109 
110      for (const input of changed) {
111        expect(yield* session.create(input)).toEqual(created)
112      }
113      expect(yield* session.list()).toHaveLength(1)
114    }),
115  )
116 
117  it.effect("returns one recorded session to concurrent exact retries", () =>
118    Effect.gen(function* () {
119      const session = yield* SessionV2.Service
120      const input = { id, location }
121 
122      const created = yield* Effect.all([session.create(input), session.create(input)], { concurrency: "unbounded" })
123 
124      expect(created[1]).toEqual(created[0])
125      expect(yield* session.list()).toEqual([created[0]])
126    }),
127  )
128 
129  it.effect("returns the current Session projection after updates", () =>
130    Effect.gen(function* () {
131      const session = yield* SessionV2.Service
132      const { db } = yield* Database.Service
133      const input = { id, location }
134      const created = yield* session.create(input)
135 
136      yield* db.update(SessionTable).set({ agent: "build" }).where(eq(SessionTable.id, id)).run().pipe(Effect.orDie)
137 
138      expect(yield* session.create(input)).toMatchObject({ id: created.id, agent: "build" })
139    }),
140  )
141 
142  it.effect("returns the current Session projection after projected updates", () =>
143    Effect.gen(function* () {
144      const session = yield* SessionV2.Service
145      const events = yield* EventV2.Service
146      const input = { id, location }
147      const created = yield* session.create(input)
148 
149      yield* events.publish(SessionV1.Event.Updated, {
150        sessionID: id,
151        info: SessionV1.SessionInfo.make({
152          id,
153          slug: "updated",
154          version: "test",
155          projectID: created.projectID,
156          directory: created.location.directory,
157          title: "updated",
158          agent: "build",
159          time: { created: 0, updated: 1 },
160        }),
161      })
162 
163      expect(yield* session.create(input)).toMatchObject({ id, agent: "build" })
164    }),
165  )
166 
167  it.effect("persists creation through the existing legacy created event", () =>
168    Effect.gen(function* () {
169      const session = yield* SessionV2.Service
170      const { db } = yield* Database.Service
171      const created = yield* session.create({ location })
172 
173      expect(
174        yield* db.select().from(EventTable).where(eq(EventTable.aggregate_id, created.id)).all().pipe(Effect.orDie),
175      ).toMatchObject([{ type: EventV2.versionedType(SessionV1.Event.Created.type, 1) }])
176    }),
177  )
178 
179  it.effect("persists caller-ID creation through the existing created event", () =>
180    Effect.gen(function* () {
181      const session = yield* SessionV2.Service
182      const { db } = yield* Database.Service
183      const created = yield* session.create({ id, location })
184 
185      expect(
186        yield* db.select().from(EventTable).where(eq(EventTable.aggregate_id, created.id)).get().pipe(Effect.orDie),
187      ).toMatchObject({
188        data: { sessionID: id },
189      })
190    }),
191  )
192 
193  it.effect("omits legacy creation rows from the V2 Session event stream", () =>
194    Effect.gen(function* () {
195      const session = yield* SessionV2.Service
196      const events = yield* EventV2.Service
197      const { db } = yield* Database.Service
198      const created = yield* session.create({ location })
199      yield* session.prompt({ sessionID: created.id, prompt: Prompt.make({ text: "Hello" }), resume: false })
200      yield* SessionInput.promoteSteers(db, events, created.id, Number.MAX_SAFE_INTEGER)
201 
202      expect(
203        Array.from(yield* session.events({ sessionID: created.id }).pipe(Stream.take(2), Stream.runCollect)),
204      ).toMatchObject([
205        { durable: { seq: 1 }, type: "session.next.prompt.admitted", data: { prompt: { text: "Hello" } } },
206        { durable: { seq: 2 }, type: "session.next.prompted" },
207      ])
208    }),
209  )
210 
211  it.effect("replays one prompt lifecycle into a fresh target database", () =>
212    Effect.gen(function* () {
213      const session = yield* SessionV2.Service
214      const sourceEvents = yield* EventV2.Service
215      const sourceDb = (yield* Database.Service).db
216      const created = yield* session.create({ id: SessionV2.ID.make("ses_fresh_target_replay"), location })
217      const admitted = yield* session.prompt({
218        sessionID: created.id,
219        prompt: Prompt.make({ text: "Replay lifecycle" }),
220        resume: false,
221      })
222      yield* SessionInput.promoteSteers(sourceDb, sourceEvents, created.id, Number.MAX_SAFE_INTEGER)
223      const serialized = (yield* sourceDb
224        .select()
225        .from(EventTable)
226        .where(eq(EventTable.aggregate_id, created.id))
227        .orderBy(asc(EventTable.seq))
228        .all()
229        .pipe(Effect.orDie)).map((event) => ({
230        id: event.id,
231        aggregateID: event.aggregate_id,
232        seq: event.seq,
233        type: event.type,
234        data: event.data,
235      }))
236 
237      const tmp = yield* Effect.acquireRelease(
238        Effect.promise(() => tmpdir()),
239        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
240      )
241      const targetDatabase = Database.layerFromPath(path.join(tmp.path, "target.sqlite"))
242      const targetLayer = AppNodeBuilder.build(
243        LayerNode.group([Database.node, EventV2.node, SessionProjector.node, SessionStore.node]),
244        [[Database.node, targetDatabase]],
245      )
246 
247      yield* Effect.gen(function* () {
248        const db = (yield* Database.Service).db
249        const events = yield* EventV2.Service
250        const store = yield* SessionStore.Service
251        yield* db
252          .insert(ProjectTable)
253          .values({ id: ProjectV2.ID.global, worktree: location.directory, sandboxes: [] })
254          .run()
255          .pipe(Effect.orDie)
256 
257        expect(yield* store.get(created.id)).toBeUndefined()
258        expect(yield* events.replayAll(serialized.slice(0, 2))).toBe(created.id)
259        expect(yield* SessionInput.find(db, admitted.id)).toMatchObject({
260          id: admitted.id,
261          sessionID: created.id,
262          prompt: { text: "Replay lifecycle" },
263          delivery: "steer",
264          admittedSeq: 1,
265        })
266        expect(yield* store.context(created.id)).toEqual([])
267 
268        expect(yield* events.replayAll(serialized.slice(2))).toBe(created.id)
269        expect(yield* SessionInput.find(db, admitted.id)).toMatchObject({
270          id: admitted.id,
271          sessionID: created.id,
272          prompt: { text: "Replay lifecycle" },
273          delivery: "steer",
274          admittedSeq: 1,
275          promotedSeq: 2,
276        })
277        expect(yield* store.context(created.id)).toMatchObject([
278          { id: admitted.id, type: "user", text: "Replay lifecycle" },
279        ])
280        expect(
281          (yield* db
282            .select()
283            .from(EventTable)
284            .where(eq(EventTable.aggregate_id, created.id))
285            .orderBy(asc(EventTable.seq))
286            .all()
287            .pipe(Effect.orDie)).map((event) => [event.seq, event.type]),
288        ).toEqual([
289          [0, EventV2.versionedType(SessionV1.Event.Created.type, 1)],
290          [1, EventV2.versionedType(SessionEvent.PromptAdmitted.type, 1)],
291          [2, EventV2.versionedType(SessionEvent.Prompted.type, 1)],
292        ])
293      }).pipe(Effect.provide(Layer.fresh(targetLayer)))
294    }),
295  )
296 
297  it.effect("does not mask unrelated created projector defects", () =>
298    Effect.gen(function* () {
299      const session = yield* SessionV2.Service
300      const event = yield* EventV2.Service
301      const defect = new Error("unrelated projector defect")
302      yield* event.project(SessionV1.Event.Created, () => Effect.die(defect))
303 
304      expect(yield* session.create({ id, location }).pipe(Effect.catchDefect(Effect.succeed))).toBe(defect)
305    }),
306  )
307 
308  it.effect("reports unfinished Session operations as unavailable", () =>
309    Effect.gen(function* () {
310      const session = yield* SessionV2.Service
311      const created = yield* session.create({ location })
312      const unavailable = (
313        effect: Effect.Effect<void, SessionV2.NotFoundError | SessionV2.OperationUnavailableError>,
314      ) =>
315        effect.pipe(
316          Effect.flip,
317          Effect.map((error) => (error instanceof SessionV2.OperationUnavailableError ? error.operation : "not-found")),
318        )
319 
320      expect(yield* unavailable(session.shell({ sessionID: created.id, command: "pwd" }))).toBe("shell")
321      expect(yield* unavailable(session.skill({ sessionID: created.id, skill: "review" }))).toBe("skill")
322    }),
323  )
324 
325  it.effect("switches the selected agent through the durable Session event", () =>
326    Effect.gen(function* () {
327      const session = yield* SessionV2.Service
328      const created = yield* session.create({ location })
329 
330      yield* session.switchAgent({ sessionID: created.id, agent: "plan" })
331 
332      expect(yield* session.get(created.id)).toMatchObject({ agent: "plan" })
333      expect(
334        Array.from(yield* session.events({ sessionID: created.id }).pipe(Stream.take(1), Stream.runCollect)),
335      ).toMatchObject([{ type: "session.next.agent.switched", data: { agent: "plan" } }])
336    }),
337  )
338 
339  it.effect("rejects an agent switch for a missing Session", () =>
340    Effect.gen(function* () {
341      const session = yield* SessionV2.Service
342      const missing = SessionV2.ID.make("ses_missing_agent_switch")
343 
344      expect(
345        yield* session.switchAgent({ sessionID: missing, agent: "plan" }).pipe(
346          Effect.flip,
347          Effect.map((error) => error._tag),
348        ),
349      ).toBe("Session.NotFoundError")
350    }),
351  )
352 
353  it.effect("switches the selected model through the durable Session event", () =>
354    Effect.gen(function* () {
355      const session = yield* SessionV2.Service
356      const created = yield* session.create({ location })
357      const model = ModelV2.Ref.make({
358        id: ModelV2.ID.make("sonnet"),
359        providerID: ProviderV2.ID.anthropic,
360        variant: ModelV2.VariantID.make("high"),
361      })
362 
363      yield* session.switchModel({ sessionID: created.id, model })
364 
365      expect(yield* session.get(created.id)).toMatchObject({ model })
366      expect(
367        Array.from(yield* session.events({ sessionID: created.id }).pipe(Stream.take(1), Stream.runCollect)),
368      ).toMatchObject([{ type: "session.next.model.switched", data: { model } }])
369    }),
370  )
371 
372  it.effect("ignores a model switch when the selected model is unchanged", () =>
373    Effect.gen(function* () {
374      const session = yield* SessionV2.Service
375      const created = yield* session.create({ location })
376      const model = ModelV2.Ref.make({ id: ModelV2.ID.make("sonnet"), providerID: ProviderV2.ID.anthropic })
377 
378      yield* session.switchModel({ sessionID: created.id, model })
379      yield* session.switchModel({ sessionID: created.id, model })
380 
381      const { db } = yield* Database.Service
382      expect(
383        yield* db.select().from(EventTable).where(eq(EventTable.aggregate_id, created.id)).all().pipe(Effect.orDie),
384      ).toHaveLength(2)
385      expect(yield* session.get(created.id)).toMatchObject({ model })
386    }),
387  )
388 
389  it.effect("treats an omitted variant as the default variant", () =>
390    Effect.gen(function* () {
391      const session = yield* SessionV2.Service
392      const model = ModelV2.Ref.make({ id: ModelV2.ID.make("sonnet"), providerID: ProviderV2.ID.anthropic })
393      const created = yield* session.create({ location, model })
394 
395      yield* session.switchModel({
396        sessionID: created.id,
397        model: ModelV2.Ref.make({ ...model, variant: ModelV2.VariantID.make("default") }),
398      })
399 
400      const { db } = yield* Database.Service
401      expect(
402        yield* db.select().from(EventTable).where(eq(EventTable.aggregate_id, created.id)).all().pipe(Effect.orDie),
403      ).toHaveLength(1)
404    }),
405  )
406 
407  it.effect("rejects a model switch for a missing Session", () =>
408    Effect.gen(function* () {
409      const session = yield* SessionV2.Service
410      const missing = SessionV2.ID.make("ses_missing_model_switch")
411 
412      expect(
413        yield* session
414          .switchModel({
415            sessionID: missing,
416            model: ModelV2.Ref.make({ id: ModelV2.ID.make("sonnet"), providerID: ProviderV2.ID.anthropic }),
417          })
418          .pipe(
419            Effect.flip,
420            Effect.map((error) => error._tag),
421          ),
422      ).toBe("Session.NotFoundError")
423    }),
424  )
425})
426