fix(acp): OpenCode choice questions are asked once

packages/provider-acp-registry/src/server/adapter.ts

@@ -9,6 +9,7 @@ import {
   extractDevinSubagentUpdate,
 } from "./devinAcp.ts";
 import { extractDroidElicitationForm } from "./droidAcp.ts";
+import { extractOpenCodeElicitationForm } from "./opencodeAcp.ts";
 import {
   copilotClientCapabilitiesMeta,
   extractCopilotSubagentUpdate,
@@ -222,7 +223,9 @@ export const makeAcpRegistryAdapterV2 = Effect.fn("makeAcpRegistryAdapterV2")(fu
     promptFailure: (cause) => acpRegistryPromptFailure(registryAgentId, cause),
     ...(registryAgentId === "factory-droid"
       ? { extractElicitationForm: extractDroidElicitationForm }
-      : {}),
+      : registryAgentId === "opencode"
+        ? { extractElicitationForm: extractOpenCodeElicitationForm }
+        : {}),
     // glm-acp-agent is the one agent whose per-turn usage a live probe has verified.
     ...(registryAgentId === "glm-acp-agent" ? { reportsPerTurnPromptUsage: true } : {}),
     ...(registryAgentId === "mistral-vibe"

packages/provider-acp-registry/src/server/opencodeAcp.test.ts

@@ -0,0 +1,46 @@
+import { assert, describe, it } from "@effect/vitest";
+
+import { extractOpenCodeElicitationForm } from "./opencodeAcp.ts";
+
+describe("extractOpenCodeElicitationForm", () => {
+  it("asks a choice with its custom-answer companion as one question", () => {
+    const form = extractOpenCodeElicitationForm({
+      sessionId: "session-1",
+      mode: "form",
+      message: "Questions",
+      requestedSchema: {
+        type: "object",
+        properties: {
+          q0: {
+            type: "string",
+            title: "Button colour",
+            description: "Which colour should the button be?",
+            oneOf: [
+              { const: "Red", title: "Red", description: "Make the button red" },
+              { const: "Blue", title: "Blue", description: "Make the button blue" },
+            ],
+          },
+          q0_custom: {
+            type: "string",
+            title: "Button colour (other)",
+            description: "Type your own answer",
+          },
+        },
+        required: [],
+      },
+    });
+    assert(form !== undefined);
+    assert.deepStrictEqual(
+      form.questions.map((question) => question.question),
+      ["Which colour should the button be?"],
+    );
+    assert.deepStrictEqual(form.respond({ q0: "Red" }), {
+      action: "accept",
+      content: { q0: "Red" },
+    });
+    assert.deepStrictEqual(form.respond({ q0: "Purple" }), {
+      action: "accept",
+      content: { q0_custom: "Purple" },
+    });
+  });
+});

packages/provider-acp-registry/src/server/opencodeAcp.ts

@@ -0,0 +1,77 @@
+import { type OrchestrationV2UserInputQuestion, TrimmedNonEmptyString } from "@t3tools/contracts";
+import type { AcpAdapterV2Flavor } from "@t3tools/provider-acp/server/adapter";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+
+const isOpenCodeForm = Schema.is(
+  Schema.Struct({
+    properties: Schema.Record(Schema.String, Schema.Unknown),
+    required: Schema.Array(Schema.String),
+  }),
+);
+const isOpenCodeQuestion = Schema.is(
+  Schema.Struct({
+    type: Schema.Literal("string"),
+    title: TrimmedNonEmptyString,
+    description: TrimmedNonEmptyString,
+    oneOf: Schema.NonEmptyArray(
+      Schema.Struct({
+        const: Schema.String,
+        title: TrimmedNonEmptyString,
+        description: Schema.optional(Schema.String),
+      }),
+    ),
+  }),
+);
+const isOpenCodeCompanion = Schema.is(Schema.Struct({ type: Schema.Literal("string") }));
+
+// OpenCode pairs each optional choice q<n> with an optional q<n>_custom text
+// field. The client already offers custom answers, so hide the companion and
+// send a typed answer back in it.
+export const extractOpenCodeElicitationForm: NonNullable<
+  AcpAdapterV2Flavor["extractElicitationForm"]
+> = (request) => {
+  if (request.mode !== "form" || !isOpenCodeForm(request.requestedSchema)) return undefined;
+  const { properties, required } = request.requestedSchema;
+  const questions: Array<OrchestrationV2UserInputQuestion> = [];
+  for (const [id, field] of Object.entries(properties)) {
+    if (!/^q\d+$/.test(id)) continue;
+    if (!isOpenCodeQuestion(field) || !isOpenCodeCompanion(properties[`${id}_custom`])) {
+      return undefined;
+    }
+    questions.push({
+      id,
+      header: field.title,
+      question: field.description,
+      options: field.oneOf.map((option) => ({
+        label: option.title,
+        description: option.description?.trim() || option.title,
+        value: option.const,
+      })),
+    });
+  }
+  // Recognize only complete forms; leave every other schema to the ACP fallback.
+  if (
+    questions.length === 0 ||
+    Object.keys(properties).length !== questions.length * 2 ||
+    required.length !== 0
+  ) {
+    return undefined;
+  }
+  return {
+    questions,
+    respond: (answers) => {
+      const entries: Array<[string, string]> = [];
+      for (const question of questions) {
+        const answer = Object.hasOwn(answers, question.id) ? answers[question.id] : undefined;
+        if (!Predicate.isString(answer) || answer.trim().length === 0) continue;
+        entries.push(
+          question.options.some((option) => option.value === answer)
+            ? [question.id, answer]
+            : [`${question.id}_custom`, answer],
+        );
+      }
+      return { action: "accept", content: Object.fromEntries(entries) };
+    },
+  };
+};

packages/provider-acp/src/server/elicitationForm.test.ts

@@ -44,4 +44,25 @@ describe("parseElicitationForm", () => {
       },
     );
   }
+
+  it("keeps an optional choice and its `_custom`-named text field as separate questions", () => {
+    const form = parseElicitationForm(
+      {
+        type: "object",
+        properties: {
+          theme: { type: "string", title: "Theme", enum: ["light", "dark"] },
+          theme_custom: { type: "string", title: "Custom theme CSS" },
+        },
+        required: [],
+      },
+      "Settings",
+    );
+    assert(form !== undefined);
+    assert.deepStrictEqual(
+      form.questions.map((question) => question.id),
+      ["theme", "theme_custom"],
+    );
+    const content = { theme: "dark", theme_custom: "body { color: red; }" };
+    assert.deepStrictEqual(form.content(content), content);
+  });
 });