add experimental question HttpApi slice (#22357)

packages/opencode/src/cli/cmd/tui/routes/session/index.tsx

@@ -2195,7 +2195,7 @@ function Question(props: ToolProps<typeof QuestionTool>) {
   const { theme } = useTheme()
   const count = createMemo(() => props.input.questions?.length ?? 0)
 
-  function format(answer?: string[]) {
+  function format(answer?: ReadonlyArray<string>) {
     if (!answer?.length) return "(no answer)"
     return answer.join(", ")
   }

packages/opencode/src/question/index.ts

@@ -3,8 +3,9 @@ import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
 import { SessionID, MessageID } from "@/session/schema"
+import { zod } from "@/util/effect-zod"
 import { Log } from "@/util/log"
-import z from "zod"
+import { withStatics } from "@/util/schema"
 import { QuestionID } from "./schema"
 
 export namespace Question {
@@ -12,67 +13,91 @@ export namespace Question {
 
   // Schemas
 
-  export const Option = z
-    .object({
-      label: z.string().describe("Display text (1-5 words, concise)"),
-      description: z.string().describe("Explanation of choice"),
-    })
-    .meta({ ref: "QuestionOption" })
-  export type Option = z.infer<typeof Option>
+  export class Option extends Schema.Class<Option>("QuestionOption")({
+    label: Schema.String.annotate({
+      description: "Display text (1-5 words, concise)",
+    }),
+    description: Schema.String.annotate({
+      description: "Explanation of choice",
+    }),
+  }) {
+    static readonly zod = zod(this)
+  }
 
-  export const Info = z
-    .object({
-      question: z.string().describe("Complete question"),
-      header: z.string().describe("Very short label (max 30 chars)"),
-      options: z.array(Option).describe("Available choices"),
-      multiple: z.boolean().optional().describe("Allow selecting multiple choices"),
-      custom: z.boolean().optional().describe("Allow typing a custom answer (default: true)"),
-    })
-    .meta({ ref: "QuestionInfo" })
-  export type Info = z.infer<typeof Info>
+  const base = {
+    question: Schema.String.annotate({
+      description: "Complete question",
+    }),
+    header: Schema.String.annotate({
+      description: "Very short label (max 30 chars)",
+    }),
+    options: Schema.Array(Option).annotate({
+      description: "Available choices",
+    }),
+    multiple: Schema.optional(Schema.Boolean).annotate({
+      description: "Allow selecting multiple choices",
+    }),
+  }
 
-  export const Request = z
-    .object({
-      id: QuestionID.zod,
-      sessionID: SessionID.zod,
-      questions: z.array(Info).describe("Questions to ask"),
-      tool: z
-        .object({
-          messageID: MessageID.zod,
-          callID: z.string(),
-        })
-        .optional(),
-    })
-    .meta({ ref: "QuestionRequest" })
-  export type Request = z.infer<typeof Request>
+  export class Info extends Schema.Class<Info>("QuestionInfo")({
+    ...base,
+    custom: Schema.optional(Schema.Boolean).annotate({
+      description: "Allow typing a custom answer (default: true)",
+    }),
+  }) {
+    static readonly zod = zod(this)
+  }
 
-  export const Answer = z.array(z.string()).meta({ ref: "QuestionAnswer" })
-  export type Answer = z.infer<typeof Answer>
+  export class Prompt extends Schema.Class<Prompt>("QuestionPrompt")(base) {
+    static readonly zod = zod(this)
+  }
 
-  export const Reply = z.object({
-    answers: z
-      .array(Answer)
-      .describe("User answers in order of questions (each answer is an array of selected labels)"),
-  })
-  export type Reply = z.infer<typeof Reply>
+  export class Tool extends Schema.Class<Tool>("QuestionTool")({
+    messageID: MessageID,
+    callID: Schema.String,
+  }) {
+    static readonly zod = zod(this)
+  }
+
+  export class Request extends Schema.Class<Request>("QuestionRequest")({
+    id: QuestionID,
+    sessionID: SessionID,
+    questions: Schema.Array(Info).annotate({
+      description: "Questions to ask",
+    }),
+    tool: Schema.optional(Tool),
+  }) {
+    static readonly zod = zod(this)
+  }
+
+  export const Answer = Schema.Array(Schema.String)
+    .annotate({ identifier: "QuestionAnswer" })
+    .pipe(withStatics((s) => ({ zod: zod(s) })))
+  export type Answer = Schema.Schema.Type<typeof Answer>
+
+  export class Reply extends Schema.Class<Reply>("QuestionReply")({
+    answers: Schema.Array(Answer).annotate({
+      description: "User answers in order of questions (each answer is an array of selected labels)",
+    }),
+  }) {
+    static readonly zod = zod(this)
+  }
+
+  class Replied extends Schema.Class<Replied>("QuestionReplied")({
+    sessionID: SessionID,
+    requestID: QuestionID,
+    answers: Schema.Array(Answer),
+  }) {}
+
+  class Rejected extends Schema.Class<Rejected>("QuestionRejected")({
+    sessionID: SessionID,
+    requestID: QuestionID,
+  }) {}
 
   export const Event = {
-    Asked: BusEvent.define("question.asked", Request),
-    Replied: BusEvent.define(
-      "question.replied",
-      z.object({
-        sessionID: SessionID.zod,
-        requestID: QuestionID.zod,
-        answers: z.array(Answer),
-      }),
-    ),
-    Rejected: BusEvent.define(
-      "question.rejected",
-      z.object({
-        sessionID: SessionID.zod,
-        requestID: QuestionID.zod,
-      }),
-    ),
+    Asked: BusEvent.define("question.asked", Request.zod),
+    Replied: BusEvent.define("question.replied", zod(Replied)),
+    Rejected: BusEvent.define("question.rejected", zod(Rejected)),
   }
 
   export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionRejectedError", {}) {
@@ -83,7 +108,7 @@ export namespace Question {
 
   interface PendingEntry {
     info: Request
-    deferred: Deferred.Deferred<Answer[], RejectedError>
+    deferred: Deferred.Deferred<ReadonlyArray<Answer>, RejectedError>
   }
 
   interface State {
@@ -95,12 +120,12 @@ export namespace Question {
   export interface Interface {
     readonly ask: (input: {
       sessionID: SessionID
-      questions: Info[]
-      tool?: { messageID: MessageID; callID: string }
-    }) => Effect.Effect<Answer[], RejectedError>
-    readonly reply: (input: { requestID: QuestionID; answers: Answer[] }) => Effect.Effect<void>
+      questions: ReadonlyArray<Info>
+      tool?: Tool
+    }) => Effect.Effect<ReadonlyArray<Answer>, RejectedError>
+    readonly reply: (input: { requestID: QuestionID; answers: ReadonlyArray<Answer> }) => Effect.Effect<void>
     readonly reject: (requestID: QuestionID) => Effect.Effect<void>
-    readonly list: () => Effect.Effect<Request[]>
+    readonly list: () => Effect.Effect<ReadonlyArray<Request>>
   }
 
   export class Service extends Context.Service<Service, Interface>()("@opencode/Question") {}
@@ -130,20 +155,20 @@ export namespace Question {
 
       const ask = Effect.fn("Question.ask")(function* (input: {
         sessionID: SessionID
-        questions: Info[]
-        tool?: { messageID: MessageID; callID: string }
+        questions: ReadonlyArray<Info>
+        tool?: Tool
       }) {
         const pending = (yield* InstanceState.get(state)).pending
         const id = QuestionID.ascending()
         log.info("asking", { id, questions: input.questions.length })
 
-        const deferred = yield* Deferred.make<Answer[], RejectedError>()
-        const info: Request = {
+        const deferred = yield* Deferred.make<ReadonlyArray<Answer>, RejectedError>()
+        const info = Schema.decodeUnknownSync(Request)({
           id,
           sessionID: input.sessionID,
           questions: input.questions,
           tool: input.tool,
-        }
+        })
         pending.set(id, { info, deferred })
         yield* bus.publish(Event.Asked, info)
 
@@ -155,7 +180,10 @@ export namespace Question {
         )
       })
 
-      const reply = Effect.fn("Question.reply")(function* (input: { requestID: QuestionID; answers: Answer[] }) {
+      const reply = Effect.fn("Question.reply")(function* (input: {
+        requestID: QuestionID
+        answers: ReadonlyArray<Answer>
+      }) {
         const pending = (yield* InstanceState.get(state)).pending
         const existing = pending.get(input.requestID)
         if (!existing) {

packages/opencode/src/server/instance/experimental.ts

@@ -18,6 +18,7 @@ import { lazy } from "../../util/lazy"
 import { Effect, Option } from "effect"
 import { WorkspaceRoutes } from "./workspace"
 import { Agent } from "@/agent/agent"
+import { HttpApiRoutes } from "./httpapi"
 
 const ConsoleOrgOption = z.object({
   accountID: z.string(),
@@ -39,6 +40,7 @@ const ConsoleSwitchBody = z.object({
 
 export const ExperimentalRoutes = lazy(() =>
   new Hono()
+    .route("/httpapi", HttpApiRoutes())
     .get(
       "/console",
       describeRoute({

packages/opencode/src/server/instance/httpapi/index.ts

@@ -0,0 +1,7 @@
+import { lazy } from "@/util/lazy"
+import { Hono } from "hono"
+import { QuestionHttpApiHandler } from "./question"
+
+export const HttpApiRoutes = lazy(() =>
+  new Hono().all("/question", QuestionHttpApiHandler).all("/question/*", QuestionHttpApiHandler),
+)

packages/opencode/src/server/instance/httpapi/question.ts

@@ -0,0 +1,94 @@
+import { AppLayer } from "@/effect/app-runtime"
+import { memoMap } from "@/effect/run-service"
+import { Question } from "@/question"
+import { QuestionID } from "@/question/schema"
+import { lazy } from "@/util/lazy"
+import { Effect, Layer, Schema } from "effect"
+import { HttpRouter, HttpServer } from "effect/unstable/http"
+import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
+import type { Handler } from "hono"
+
+const root = "/experimental/httpapi/question"
+
+const Api = HttpApi.make("question")
+  .add(
+    HttpApiGroup.make("question")
+      .add(
+        HttpApiEndpoint.get("list", root, {
+          success: Schema.Array(Question.Request),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "question.list",
+            summary: "List pending questions",
+            description: "Get all pending question requests across all sessions.",
+          }),
+        ),
+        HttpApiEndpoint.post("reply", `${root}/:requestID/reply`, {
+          params: { requestID: QuestionID },
+          payload: Question.Reply,
+          success: Schema.Boolean,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "question.reply",
+            summary: "Reply to question request",
+            description: "Provide answers to a question request from the AI assistant.",
+          }),
+        ),
+      )
+      .annotateMerge(
+        OpenApi.annotations({
+          title: "question",
+          description: "Experimental HttpApi question routes.",
+        }),
+      ),
+  )
+  .annotateMerge(
+    OpenApi.annotations({
+      title: "opencode experimental HttpApi",
+      version: "0.0.1",
+      description: "Experimental HttpApi surface for selected instance routes.",
+    }),
+  )
+
+const QuestionLive = HttpApiBuilder.group(
+  Api,
+  "question",
+  Effect.fn("QuestionHttpApi.handlers")(function* (handlers) {
+    const svc = yield* Question.Service
+
+    const list = Effect.fn("QuestionHttpApi.list")(function* () {
+      return yield* svc.list()
+    })
+
+    const reply = Effect.fn("QuestionHttpApi.reply")(function* (ctx: {
+      params: { requestID: QuestionID }
+      payload: Question.Reply
+    }) {
+      yield* svc.reply({
+        requestID: ctx.params.requestID,
+        answers: ctx.payload.answers,
+      })
+      return true
+    })
+
+    return handlers.handle("list", list).handle("reply", reply)
+  }),
+).pipe(Layer.provide(Question.defaultLayer))
+
+const web = lazy(() =>
+  HttpRouter.toWebHandler(
+    Layer.mergeAll(
+      AppLayer,
+      HttpApiBuilder.layer(Api, { openapiPath: `${root}/doc` }).pipe(
+        Layer.provide(QuestionLive),
+        Layer.provide(HttpServer.layerServices),
+      ),
+    ),
+    {
+      disableLogger: true,
+      memoMap,
+    },
+  ),
+)
+
+export const QuestionHttpApiHandler: Handler = (c, _next) => web().handler(c.req.raw)

packages/opencode/src/server/instance/question.ts

@@ -21,7 +21,7 @@ export const QuestionRoutes = lazy(() =>
             description: "List of pending questions",
             content: {
               "application/json": {
-                schema: resolver(Question.Request.array()),
+                schema: resolver(Question.Request.zod.array()),
               },
             },
           },
@@ -56,7 +56,7 @@ export const QuestionRoutes = lazy(() =>
           requestID: QuestionID.zod,
         }),
       ),
-      validator("json", Question.Reply),
+      validator("json", Question.Reply.zod),
       async (c) => {
         const params = c.req.valid("param")
         const json = c.req.valid("json")

packages/opencode/src/tool/question.ts

@@ -5,11 +5,11 @@ import { Question } from "../question"
 import DESCRIPTION from "./question.txt"
 
 const parameters = z.object({
-  questions: z.array(Question.Info.omit({ custom: true })).describe("Questions to ask"),
+  questions: z.array(Question.Prompt.zod).describe("Questions to ask"),
 })
 
 type Metadata = {
-  answers: Question.Answer[]
+  answers: ReadonlyArray<Question.Answer>
 }
 
 export const QuestionTool = Tool.define<typeof parameters, Metadata, Question.Service>(