feat(tui): render forms and route question tool through form service

packages/core/src/plugin/internal.ts

@@ -16,6 +16,7 @@ import { ConfigReferencePlugin } from "../config/plugin/reference"
 import { ConfigSkillPlugin } from "../config/plugin/skill"
 import { EventV2 } from "../event"
 import { FileMutation } from "../file-mutation"
+import { Form } from "../form"
 import { FileSystem } from "../filesystem"
 import { FSUtil } from "../fs-util"
 import { Global } from "../global"
@@ -69,6 +70,7 @@ export type Requirements =
   | EventV2.Service
   | FileMutation.Service
   | FileSystem.Service
+  | Form.Service
   | FSUtil.Service
   | Global.Service
   | HttpClient.HttpClient
@@ -116,6 +118,7 @@ const layer = Layer.effectDiscard(
       Context.make(EventV2.Service, yield* EventV2.Service),
       Context.make(FSUtil.Service, yield* FSUtil.Service),
       Context.make(FileSystem.Service, yield* FileSystem.Service),
+      Context.make(Form.Service, yield* Form.Service),
       Context.make(Global.Service, yield* Global.Service),
       Context.make(HttpClient.HttpClient, yield* HttpClient.HttpClient),
       Context.make(LocationMutation.Service, yield* LocationMutation.Service),
@@ -192,6 +195,7 @@ export const node = makeLocationNode({
     EventV2.node,
     FSUtil.node,
     FileSystem.node,
+    Form.node,
     Global.node,
     httpClient,
     PermissionV2.node,

packages/core/src/tool/question.ts

@@ -3,6 +3,7 @@ export * as QuestionTool from "./question"
 import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
 import { ToolFailure } from "@opencode-ai/llm"
 import { Effect, Schema } from "effect"
+import { Form } from "../form"
 import { PermissionV2 } from "../permission"
 import { QuestionV2 } from "../question"
 import { Tool } from "./tool"
@@ -42,10 +43,35 @@ export const toModelOutput = (
   return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`
 }
 
+// Each question becomes one field keyed by position; answers translate back positionally.
+export const toField = (question: QuestionV2.Prompt, index: number): Form.Field => {
+  const shared = {
+    key: `q${index}`,
+    title: question.header,
+    description: question.question,
+    options: question.options.map((option) => ({
+      value: option.label,
+      label: option.label,
+      description: option.description,
+    })),
+    custom: true,
+  }
+  if (question.multiple === true) return { ...shared, type: "multiselect" }
+  return { ...shared, type: "string" }
+}
+
+export const toAnswers = (questions: ReadonlyArray<QuestionV2.Prompt>, answer: Form.Answer) =>
+  questions.map((_, index): QuestionV2.Answer => {
+    const value = answer[`q${index}`]
+    if (value === undefined) return []
+    if (typeof value === "object") return Array.from(value)
+    return [String(value)]
+  })
+
 export const Plugin = {
   id: "core-question-tool",
   effect: Effect.fn("QuestionTool.Plugin")(function* (ctx: PluginContext) {
-    const question = yield* QuestionV2.Service
+    const forms = yield* Form.Service
     const permission = yield* PermissionV2.Service
 
     yield* ctx.tool
@@ -69,15 +95,23 @@ export const Plugin = {
               .pipe(
                 Effect.mapError(() => new ToolFailure({ message: "Permission denied: question" })),
                 Effect.andThen(
-                  question
+                  forms
                     .ask({
                       sessionID: context.sessionID,
-                      questions: input.questions,
-                      tool: { messageID: context.assistantMessageID, callID: context.toolCallID },
+                      metadata: {
+                        kind: "question",
+                        tool: { messageID: context.assistantMessageID, callID: context.toolCallID },
+                      },
+                      mode: "form",
+                      fields: input.questions.map(toField),
                     })
                     .pipe(Effect.orDie),
                 ),
-                Effect.map((answers) => ({ answers })),
+                Effect.flatMap((state) => {
+                  // The runner halts the loop on this exact defect (session/runner/llm.ts).
+                  if (state.status !== "answered") return Effect.die(new QuestionV2.RejectedError())
+                  return Effect.succeed({ answers: toAnswers(input.questions, state.answer) })
+                }),
               ),
         }),
       })

packages/core/test/tool-question.test.ts

@@ -2,8 +2,8 @@ import { describe, expect } from "bun:test"
 import { Effect, Exit, Fiber, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Form } from "@opencode-ai/core/form"
 import { PermissionV2 } from "@opencode-ai/core/permission"
-import { QuestionV2 } from "@opencode-ai/core/question"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { QuestionTool } from "@opencode-ai/core/tool/question"
@@ -14,7 +14,7 @@ import { toolIdentity, executeTool, registerToolPlugin, settleTool, toolDefiniti
 
 const sessionID = SessionV2.ID.make("ses_question_tool_test")
 const assertions: PermissionV2.AssertInput[] = []
-let captured: QuestionV2.AskInput | undefined
+let captured: Form.CreateInput | undefined
 let reject = false
 let deny = false
 const capturedInput = () => captured
@@ -32,28 +32,35 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const question = Layer.succeed(
-  QuestionV2.Service,
-  QuestionV2.Service.of({
-    ask: (input: QuestionV2.AskInput) =>
+const form = Layer.succeed(
+  Form.Service,
+  Form.Service.of({
+    ask: (input: Form.CreateInput) =>
       Effect.sync(() => {
         captured = input
-      }).pipe(Effect.andThen(reject ? Effect.fail(new QuestionV2.RejectedError()) : Effect.succeed([["Build"], []]))),
-    reply: () => Effect.die("unused"),
-    reject: () => Effect.die("unused"),
+      }).pipe(
+        Effect.andThen(
+          Effect.sync((): Form.State => (reject ? { status: "cancelled" } : { status: "answered", answer: { q0: "Build" } })),
+        ),
+      ),
+    create: () => Effect.die("unused"),
+    get: () => Effect.die("unused"),
     list: () => Effect.die("unused"),
+    state: () => Effect.die("unused"),
+    reply: () => Effect.die("unused"),
+    cancel: () => Effect.die("unused"),
   }),
 )
 const questionToolNode = makeLocationNode({
   name: "test/question-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(QuestionTool.Plugin)),
-  deps: [ToolRegistry.toolsNode, PermissionV2.node, QuestionV2.node],
+  deps: [ToolRegistry.toolsNode, PermissionV2.node, Form.node],
 })
 
 const it = testEffect(
   AppNodeBuilder.build(LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode, questionToolNode]), [
     [PermissionV2.node, permission],
-    [QuestionV2.node, question],
+    [Form.node, form],
     [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
   ]),
 )
@@ -124,8 +131,26 @@ describe("QuestionTool", () => {
       expect(assertions).toMatchObject([{ sessionID, action: "question", resources: ["*"] }])
       expect(capturedInput()).toEqual({
         sessionID,
-        questions,
-        tool: { messageID: toolIdentity.assistantMessageID, callID: "call-question" },
+        metadata: { kind: "question", tool: { messageID: toolIdentity.assistantMessageID, callID: "call-question" } },
+        mode: "form",
+        fields: [
+          {
+            key: "q0",
+            title: "Action",
+            description: "What should happen?",
+            options: [{ value: "Build", label: "Build", description: "Build it" }],
+            custom: true,
+            type: "string",
+          },
+          {
+            key: "q1",
+            title: "Environment",
+            description: "Which environment?",
+            options: [{ value: "Dev", label: "Dev", description: "Development" }],
+            custom: true,
+            type: "string",
+          },
+        ],
       })
     }),
   )
@@ -144,8 +169,9 @@ describe("QuestionTool", () => {
       })
       expect(capturedInput()).toEqual({
         sessionID,
-        questions: [],
-        tool: { messageID: toolIdentity.assistantMessageID, callID: "call-question" },
+        metadata: { kind: "question", tool: { messageID: toolIdentity.assistantMessageID, callID: "call-question" } },
+        mode: "form",
+        fields: [],
       })
     }),
   )