openAgent

1import { afterEach, expect } from "bun:test"
2import { LayerNode } from "@opencode-ai/core/effect/layer-node"
3import { Cause, Effect, Exit, Fiber, Layer, Queue } from "effect"
4import { Question } from "../../src/question"
5import { InstanceRef } from "../../src/effect/instance-ref"
6import { InstanceStore } from "../../src/project/instance-store"
7import { QuestionID } from "../../src/question/schema"
8import { disposeAllInstances, provideInstance, testInstanceStoreLayer, tmpdirScoped } from "../fixture/fixture"
9import { SessionID } from "../../src/session/schema"
10import { testEffect } from "../lib/effect"
11import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
12import { EventV2Bridge } from "../../src/event-v2-bridge"
13 
14const questionLayer = LayerNode.compile(LayerNode.group([Question.node, EventV2Bridge.node, CrossSpawnSpawner.node]))
15const it = testEffect(questionLayer)
16const lifecycle = testEffect(Layer.mergeAll(questionLayer, testInstanceStoreLayer))
17 
18const askEffect = Effect.fn("QuestionTest.ask")(function* (input: {
19  sessionID: SessionID
20  questions: ReadonlyArray<Question.Info>
21  tool?: Question.Tool
22}) {
23  const question = yield* Question.Service
24  return yield* question.ask(input)
25})
26 
27const listEffect = Question.Service.use((svc) => svc.list())
28 
29const replyEffect = Effect.fn("QuestionTest.reply")(function* (input: {
30  requestID: QuestionID
31  answers: ReadonlyArray<Question.Answer>
32}) {
33  const question = yield* Question.Service
34  yield* question.reply(input)
35})
36 
37const rejectEffect = Effect.fn("QuestionTest.reject")(function* (id: QuestionID) {
38  const question = yield* Question.Service
39  yield* question.reject(id)
40})
41 
42afterEach(async () => {
43  await disposeAllInstances()
44})
45 
46/** Reject all pending questions so dangling Deferred fibers don't hang the test. */
47const rejectAll = Effect.gen(function* () {
48  yield* Effect.forEach(yield* listEffect, (req) => rejectEffect(req.id), { discard: true })
49})
50 
51const waitForPending = Effect.fn("QuestionTest.waitForPending")(function* (count: number) {
52  const question = yield* Question.Service
53  const events = yield* EventV2Bridge.Service
54  const asked = yield* Queue.unbounded<void>()
55  const off = yield* events.listen((event) => {
56    if (event.type === Question.Event.Asked.type) Queue.offerUnsafe(asked, undefined)
57    return Effect.void
58  })
59  yield* Effect.addFinalizer(() => off)
60 
61  for (;;) {
62    const pending = yield* question.list()
63    if (pending.length === count) return pending
64    yield* Queue.take(asked).pipe(Effect.timeout("2 seconds"))
65  }
66})
67 
68it.instance(
69  "ask - remains pending until answered",
70  () =>
71    Effect.gen(function* () {
72      const fiber = yield* askEffect({
73        sessionID: SessionID.make("ses_test"),
74        questions: [
75          {
76            question: "What would you like to do?",
77            header: "Action",
78            options: [
79              { label: "Option 1", description: "First option" },
80              { label: "Option 2", description: "Second option" },
81            ],
82          },
83        ],
84      }).pipe(Effect.forkScoped)
85 
86      expect(yield* waitForPending(1)).toHaveLength(1)
87      yield* rejectAll
88      expect((yield* Fiber.await(fiber))._tag).toBe("Failure")
89    }),
90  { git: true },
91)
92 
93it.instance(
94  "ask - adds to pending list",
95  () =>
96    Effect.gen(function* () {
97      const questions = [
98        {
99          question: "What would you like to do?",
100          header: "Action",
101          options: [
102            { label: "Option 1", description: "First option" },
103            { label: "Option 2", description: "Second option" },
104          ],
105        },
106      ]
107 
108      const fiber = yield* askEffect({
109        sessionID: SessionID.make("ses_test"),
110        questions,
111      }).pipe(Effect.forkScoped)
112 
113      const pending = yield* waitForPending(1)
114      expect(pending.length).toBe(1)
115      expect(pending[0].questions).toEqual(questions)
116      yield* rejectAll
117      expect((yield* Fiber.await(fiber))._tag).toBe("Failure")
118    }),
119  { git: true },
120)
121 
122// reply tests
123 
124it.instance(
125  "reply - resolves the pending ask with answers",
126  () =>
127    Effect.gen(function* () {
128      const questions = [
129        {
130          question: "What would you like to do?",
131          header: "Action",
132          options: [
133            { label: "Option 1", description: "First option" },
134            { label: "Option 2", description: "Second option" },
135          ],
136        },
137      ]
138 
139      const fiber = yield* askEffect({
140        sessionID: SessionID.make("ses_test"),
141        questions,
142      }).pipe(Effect.forkScoped)
143 
144      const pending = yield* waitForPending(1)
145      const requestID = pending[0].id
146 
147      yield* replyEffect({
148        requestID,
149        answers: [["Option 1"]],
150      })
151 
152      expect(yield* Fiber.join(fiber)).toEqual([["Option 1"]])
153    }),
154  { git: true },
155)
156 
157it.instance(
158  "reply - removes from pending list",
159  () =>
160    Effect.gen(function* () {
161      const fiber = yield* askEffect({
162        sessionID: SessionID.make("ses_test"),
163        questions: [
164          {
165            question: "What would you like to do?",
166            header: "Action",
167            options: [
168              { label: "Option 1", description: "First option" },
169              { label: "Option 2", description: "Second option" },
170            ],
171          },
172        ],
173      }).pipe(Effect.forkScoped)
174 
175      const pending = yield* waitForPending(1)
176      expect(pending.length).toBe(1)
177 
178      yield* replyEffect({
179        requestID: pending[0].id,
180        answers: [["Option 1"]],
181      })
182      yield* Fiber.join(fiber)
183 
184      const after = yield* listEffect
185      expect(after.length).toBe(0)
186    }),
187  { git: true },
188)
189 
190it.instance(
191  "reply - fails for unknown requestID",
192  () =>
193    Effect.gen(function* () {
194      const exit = yield* replyEffect({
195        requestID: QuestionID.make("que_unknown"),
196        answers: [["Option 1"]],
197      }).pipe(Effect.exit)
198      expect(Exit.isFailure(exit)).toBe(true)
199      if (Exit.isFailure(exit)) {
200        expect(Cause.squash(exit.cause)).toMatchObject({ _tag: "Question.NotFoundError", requestID: "que_unknown" })
201      }
202    }),
203  { git: true },
204)
205 
206// reject tests
207 
208it.instance(
209  "reject - throws RejectedError",
210  () =>
211    Effect.gen(function* () {
212      const fiber = yield* askEffect({
213        sessionID: SessionID.make("ses_test"),
214        questions: [
215          {
216            question: "What would you like to do?",
217            header: "Action",
218            options: [
219              { label: "Option 1", description: "First option" },
220              { label: "Option 2", description: "Second option" },
221            ],
222          },
223        ],
224      }).pipe(Effect.forkScoped)
225 
226      const pending = yield* waitForPending(1)
227      yield* rejectEffect(pending[0].id)
228 
229      const exit = yield* Fiber.await(fiber)
230      expect(exit._tag).toBe("Failure")
231      if (exit._tag === "Failure") expect(exit.cause.toString()).toContain("QuestionRejectedError")
232    }),
233  { git: true },
234)
235 
236it.instance(
237  "reject - removes from pending list",
238  () =>
239    Effect.gen(function* () {
240      const fiber = yield* askEffect({
241        sessionID: SessionID.make("ses_test"),
242        questions: [
243          {
244            question: "What would you like to do?",
245            header: "Action",
246            options: [
247              { label: "Option 1", description: "First option" },
248              { label: "Option 2", description: "Second option" },
249            ],
250          },
251        ],
252      }).pipe(Effect.forkScoped)
253 
254      const pending = yield* waitForPending(1)
255      expect(pending.length).toBe(1)
256 
257      yield* rejectEffect(pending[0].id)
258      expect((yield* Fiber.await(fiber))._tag).toBe("Failure")
259 
260      const after = yield* listEffect
261      expect(after.length).toBe(0)
262    }),
263  { git: true },
264)
265 
266it.instance(
267  "reject - fails for unknown requestID",
268  () =>
269    Effect.gen(function* () {
270      const exit = yield* rejectEffect(QuestionID.make("que_unknown")).pipe(Effect.exit)
271      expect(Exit.isFailure(exit)).toBe(true)
272      if (Exit.isFailure(exit)) {
273        expect(Cause.squash(exit.cause)).toMatchObject({ _tag: "Question.NotFoundError", requestID: "que_unknown" })
274      }
275    }),
276  { git: true },
277)
278 
279// multiple questions tests
280 
281it.instance(
282  "ask - handles multiple questions",
283  () =>
284    Effect.gen(function* () {
285      const questions = [
286        {
287          question: "What would you like to do?",
288          header: "Action",
289          options: [
290            { label: "Build", description: "Build the project" },
291            { label: "Test", description: "Run tests" },
292          ],
293        },
294        {
295          question: "Which environment?",
296          header: "Env",
297          options: [
298            { label: "Dev", description: "Development" },
299            { label: "Prod", description: "Production" },
300          ],
301        },
302      ]
303 
304      const fiber = yield* askEffect({
305        sessionID: SessionID.make("ses_test"),
306        questions,
307      }).pipe(Effect.forkScoped)
308 
309      const pending = yield* waitForPending(1)
310 
311      yield* replyEffect({
312        requestID: pending[0].id,
313        answers: [["Build"], ["Dev"]],
314      })
315 
316      expect(yield* Fiber.join(fiber)).toEqual([["Build"], ["Dev"]])
317    }),
318  { git: true },
319)
320 
321// list tests
322 
323it.instance(
324  "list - returns all pending requests",
325  () =>
326    Effect.gen(function* () {
327      const fiber1 = yield* askEffect({
328        sessionID: SessionID.make("ses_test1"),
329        questions: [
330          {
331            question: "Question 1?",
332            header: "Q1",
333            options: [{ label: "A", description: "A" }],
334          },
335        ],
336      }).pipe(Effect.forkScoped)
337 
338      const fiber2 = yield* askEffect({
339        sessionID: SessionID.make("ses_test2"),
340        questions: [
341          {
342            question: "Question 2?",
343            header: "Q2",
344            options: [{ label: "B", description: "B" }],
345          },
346        ],
347      }).pipe(Effect.forkScoped)
348 
349      const pending = yield* waitForPending(2)
350      expect(pending.length).toBe(2)
351      yield* rejectAll
352      expect((yield* Fiber.await(fiber1))._tag).toBe("Failure")
353      expect((yield* Fiber.await(fiber2))._tag).toBe("Failure")
354    }),
355  { git: true },
356)
357 
358it.instance(
359  "list - returns empty when no pending",
360  () =>
361    Effect.gen(function* () {
362      const pending = yield* listEffect
363      expect(pending.length).toBe(0)
364    }),
365  { git: true },
366)
367 
368lifecycle.live("questions stay isolated by directory", () =>
369  Effect.gen(function* () {
370    const one = yield* tmpdirScoped({ git: true })
371    const two = yield* tmpdirScoped({ git: true })
372 
373    const fiber1 = yield* askEffect({
374      sessionID: SessionID.make("ses_one"),
375      questions: [
376        {
377          question: "Question 1?",
378          header: "Q1",
379          options: [{ label: "A", description: "A" }],
380        },
381      ],
382    }).pipe(provideInstance(one), Effect.forkScoped)
383 
384    const fiber2 = yield* askEffect({
385      sessionID: SessionID.make("ses_two"),
386      questions: [
387        {
388          question: "Question 2?",
389          header: "Q2",
390          options: [{ label: "B", description: "B" }],
391        },
392      ],
393    }).pipe(provideInstance(two), Effect.forkScoped)
394 
395    const onePending = yield* waitForPending(1).pipe(provideInstance(one))
396    const twoPending = yield* waitForPending(1).pipe(provideInstance(two))
397 
398    expect(onePending.length).toBe(1)
399    expect(twoPending.length).toBe(1)
400    expect(onePending[0].sessionID).toBe(SessionID.make("ses_one"))
401    expect(twoPending[0].sessionID).toBe(SessionID.make("ses_two"))
402 
403    yield* rejectEffect(onePending[0].id).pipe(provideInstance(one))
404    yield* rejectEffect(twoPending[0].id).pipe(provideInstance(two))
405 
406    expect((yield* Fiber.await(fiber1))._tag).toBe("Failure")
407    expect((yield* Fiber.await(fiber2))._tag).toBe("Failure")
408  }),
409)
410 
411lifecycle.live("pending question rejects on instance dispose", () =>
412  Effect.gen(function* () {
413    const dir = yield* tmpdirScoped({ git: true })
414    const fiber = yield* askEffect({
415      sessionID: SessionID.make("ses_dispose"),
416      questions: [
417        {
418          question: "Dispose me?",
419          header: "Dispose",
420          options: [{ label: "Yes", description: "Yes" }],
421        },
422      ],
423    }).pipe(provideInstance(dir), Effect.forkScoped)
424 
425    expect(yield* waitForPending(1).pipe(provideInstance(dir))).toHaveLength(1)
426    const ctx = yield* Effect.gen(function* () {
427      return yield* InstanceRef
428    }).pipe(provideInstance(dir))
429    if (!ctx) return yield* Effect.die(new Error("missing test instance"))
430    yield* InstanceStore.Service.use((store) => store.dispose(ctx))
431 
432    const exit = yield* Fiber.await(fiber)
433    expect(Exit.isFailure(exit)).toBe(true)
434    if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Question.RejectedError)
435  }),
436)
437 
438lifecycle.live("pending question rejects on instance reload", () =>
439  Effect.gen(function* () {
440    const dir = yield* tmpdirScoped({ git: true })
441    const fiber = yield* askEffect({
442      sessionID: SessionID.make("ses_reload"),
443      questions: [
444        {
445          question: "Reload me?",
446          header: "Reload",
447          options: [{ label: "Yes", description: "Yes" }],
448        },
449      ],
450    }).pipe(provideInstance(dir), Effect.forkScoped)
451 
452    expect(yield* waitForPending(1).pipe(provideInstance(dir))).toHaveLength(1)
453    yield* InstanceStore.Service.use((store) => store.reload({ directory: dir }))
454 
455    const exit = yield* Fiber.await(fiber)
456    expect(Exit.isFailure(exit)).toBe(true)
457    if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Question.RejectedError)
458  }),
459)
460