openAgent

1export * as QuestionV2 from "./question"
2 
3import { makeLocationNode } from "./effect/app-node"
4import { Context, Deferred, Effect, Layer, Schema } from "effect"
5import { Question } from "@opencode-ai/schema/question"
6import { EventV2 } from "./event"
7import { SessionSchema } from "./session/schema"
8 
9export const ID = Question.ID
10export type ID = typeof ID.Type
11 
12export const Option = Question.Option
13export type Option = typeof Option.Type
14 
15export const Info = Question.Info
16export type Info = typeof Info.Type
17 
18export const Prompt = Question.Prompt
19export type Prompt = typeof Prompt.Type
20 
21export const Tool = Question.Tool
22export type Tool = typeof Tool.Type
23 
24export const Request = Question.Request
25export type Request = typeof Request.Type
26 
27export const Answer = Question.Answer
28export type Answer = typeof Answer.Type
29 
30export const Reply = Question.Reply
31export type Reply = typeof Reply.Type
32 
33export const Event = Question.Event
34 
35export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionV2.RejectedError", {}) {
36  override get message() {
37    return "The user dismissed this question"
38  }
39}
40 
41export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("QuestionV2.NotFoundError", {
42  requestID: ID,
43}) {}
44 
45export interface AskInput {
46  readonly sessionID: SessionSchema.ID
47  readonly questions: ReadonlyArray<Info>
48  readonly tool?: Tool
49}
50 
51export interface ReplyInput {
52  readonly requestID: ID
53  readonly answers: ReadonlyArray<Answer>
54}
55 
56export interface Interface {
57  readonly ask: (input: AskInput) => Effect.Effect<ReadonlyArray<Answer>, RejectedError>
58  readonly reply: (input: ReplyInput) => Effect.Effect<void, NotFoundError>
59  readonly reject: (requestID: ID) => Effect.Effect<void, NotFoundError>
60  readonly list: () => Effect.Effect<ReadonlyArray<Request>>
61}
62 
63export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Question") {}
64 
65interface Pending {
66  readonly request: Request
67  readonly deferred: Deferred.Deferred<ReadonlyArray<Answer>, RejectedError>
68}
69 
70/**
71 * Location-owned pending prompts. The Location layer map must materialize this
72 * layer once per embedded Location so replies cannot settle another Location's
73 * deferred request.
74 */
75const layer = Layer.effect(
76  Service,
77  Effect.gen(function* () {
78    const events = yield* EventV2.Service
79    const pending = new Map<ID, Pending>()
80 
81    yield* Effect.addFinalizer(() =>
82      Effect.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new RejectedError()), {
83        discard: true,
84      }).pipe(
85        Effect.ensuring(
86          Effect.sync(() => {
87            pending.clear()
88          }),
89        ),
90      ),
91    )
92 
93    const ask = Effect.fn("QuestionV2.ask")((input: AskInput) =>
94      Effect.uninterruptibleMask((restore) =>
95        Effect.gen(function* () {
96          const id = ID.ascending()
97          const deferred = yield* Deferred.make<ReadonlyArray<Answer>, RejectedError>()
98          const request: Request = { id, ...input }
99          pending.set(id, { request, deferred })
100          return yield* events.publish(Event.Asked, request).pipe(
101            Effect.andThen(restore(Deferred.await(deferred))),
102            Effect.ensuring(
103              Effect.sync(() => {
104                pending.delete(id)
105              }),
106            ),
107          )
108        }),
109      ),
110    )
111 
112    const reply = Effect.fn("QuestionV2.reply")((input: ReplyInput) =>
113      Effect.uninterruptible(
114        Effect.gen(function* () {
115          const existing = pending.get(input.requestID)
116          if (!existing) return yield* new NotFoundError({ requestID: input.requestID })
117          yield* events.publish(Event.Replied, {
118            sessionID: existing.request.sessionID,
119            requestID: existing.request.id,
120            answers: input.answers.map((answer) => [...answer]),
121          })
122          yield* Deferred.succeed(existing.deferred, input.answers)
123          pending.delete(input.requestID)
124        }),
125      ),
126    )
127 
128    const reject = Effect.fn("QuestionV2.reject")((requestID: ID) =>
129      Effect.uninterruptible(
130        Effect.gen(function* () {
131          const existing = pending.get(requestID)
132          if (!existing) return yield* new NotFoundError({ requestID })
133          yield* events.publish(Event.Rejected, {
134            sessionID: existing.request.sessionID,
135            requestID: existing.request.id,
136          })
137          yield* Deferred.fail(existing.deferred, new RejectedError())
138          pending.delete(requestID)
139        }),
140      ),
141    )
142 
143    const list = Effect.fn("QuestionV2.list")(function* () {
144      return Array.from(pending.values(), (item) => item.request)
145    })
146 
147    return Service.of({ ask, reply, reject, list })
148  }),
149)
150 
151export const locationLayer = layer
152 
153export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node] })
154