openAgent

1import { describe, expect } from "bun:test"
2import { Context, Deferred, Effect, Exit, Fiber, Layer, Scope } from "effect"
3import { LayerNode } from "@opencode-ai/core/effect/layer-node"
4import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
5import { EventV2 } from "@opencode-ai/core/event"
6import { QuestionV2 } from "@opencode-ai/core/question"
7import { SessionV2 } from "@opencode-ai/core/session"
8import { testEffect } from "./lib/effect"
9 
10const questions = AppNodeBuilder.build(LayerNode.group([EventV2.node, QuestionV2.node]))
11const it = testEffect(questions)
12 
13const sessionID = SessionV2.ID.make("ses_question_test")
14const question: QuestionV2.Info = {
15  question: "Which option?",
16  header: "Option",
17  options: [{ label: "One", description: "First option" }],
18}
19 
20const waitForAsk = Effect.fn("QuestionV2Test.waitForAsk")(function* (
21  service: QuestionV2.Interface,
22  input: QuestionV2.AskInput,
23) {
24  const events = yield* EventV2.Service
25  const asked = yield* Deferred.make<QuestionV2.Request>()
26  const unsubscribe = yield* events.listen((event) =>
27    event.type === QuestionV2.Event.Asked.type
28      ? Deferred.succeed(asked, event.data as QuestionV2.Request).pipe(Effect.asVoid)
29      : Effect.void,
30  )
31  yield* Effect.addFinalizer(() => unsubscribe)
32  const fiber = yield* service.ask(input).pipe(Effect.forkScoped)
33  return { fiber, request: yield* Deferred.await(asked) }
34})
35 
36describe("QuestionV2", () => {
37  it.effect("publishes lifecycle events and settles a pending reply", () =>
38    Effect.gen(function* () {
39      const service = yield* QuestionV2.Service
40      const events = yield* EventV2.Service
41      const published: EventV2.Payload[] = []
42      const unsubscribe = yield* events.listen((event) =>
43        Effect.sync(() => {
44          if (event.type.startsWith("question.v2.")) published.push(event)
45        }),
46      )
47      yield* Effect.addFinalizer(() => unsubscribe)
48      const { fiber, request } = yield* waitForAsk(service, { sessionID, questions: [question] })
49 
50      expect(request.id).toMatch(/^que_/)
51      expect(yield* service.list()).toEqual([request])
52      yield* service.reply({ requestID: request.id, answers: [["One"]] })
53 
54      expect(yield* Fiber.join(fiber)).toEqual([["One"]])
55      expect(yield* service.list()).toEqual([])
56      expect(published.map((event) => [event.type, event.data])).toEqual([
57        [QuestionV2.Event.Asked.type, request],
58        [QuestionV2.Event.Replied.type, { sessionID, requestID: request.id, answers: [["One"]] }],
59      ])
60    }),
61  )
62 
63  it.effect("publishes rejection, fails the ask, and rejects unknown IDs", () =>
64    Effect.gen(function* () {
65      const service = yield* QuestionV2.Service
66      const events = yield* EventV2.Service
67      const published: EventV2.Payload[] = []
68      const unsubscribe = yield* events.listen((event) =>
69        Effect.sync(() => {
70          if (event.type === QuestionV2.Event.Rejected.type) published.push(event)
71        }),
72      )
73      yield* Effect.addFinalizer(() => unsubscribe)
74      const { fiber, request } = yield* waitForAsk(service, { sessionID, questions: [question] })
75 
76      yield* service.reject(request.id)
77      const exit = yield* Fiber.await(fiber)
78      expect(Exit.isFailure(exit)).toBe(true)
79      if (Exit.isFailure(exit)) expect(exit.cause.toString()).toContain("QuestionV2.RejectedError")
80      expect(published.map((event) => event.data)).toEqual([{ sessionID, requestID: request.id }])
81 
82      const unknown = QuestionV2.ID.ascending("que_unknown")
83      expect(yield* service.reply({ requestID: unknown, answers: [] }).pipe(Effect.flip)).toEqual(
84        new QuestionV2.NotFoundError({ requestID: unknown }),
85      )
86      expect(yield* service.reject(unknown).pipe(Effect.flip)).toEqual(
87        new QuestionV2.NotFoundError({ requestID: unknown }),
88      )
89    }),
90  )
91 
92  it.effect("isolates pending requests by location-layer instance and rejects them on finalization", () =>
93    Effect.gen(function* () {
94      const firstScope = yield* Scope.make()
95      const secondScope = yield* Scope.make()
96      const first = Context.get(yield* Layer.buildWithScope(Layer.fresh(questions), firstScope), QuestionV2.Service)
97      const second = Context.get(yield* Layer.buildWithScope(Layer.fresh(questions), secondScope), QuestionV2.Service)
98      const fiber = yield* first.ask({ sessionID, questions: [question] }).pipe(Effect.forkScoped)
99      yield* Effect.yieldNow
100      const request = (yield* first.list())[0]!
101 
102      expect(yield* second.list()).toEqual([])
103      expect(yield* second.reply({ requestID: request.id, answers: [["One"]] }).pipe(Effect.flip)).toEqual(
104        new QuestionV2.NotFoundError({ requestID: request.id }),
105      )
106 
107      yield* Scope.close(firstScope, Exit.void)
108      const exit = yield* Fiber.await(fiber)
109      expect(Exit.isFailure(exit)).toBe(true)
110      if (Exit.isFailure(exit)) expect(exit.cause.toString()).toContain("QuestionV2.RejectedError")
111      yield* Scope.close(secondScope, Exit.void)
112    }),
113  )
114})
115