@ai-sdk/harness-opencode 1.0.102 → 1.0.104

package/src/bridge/create-emit-stream-event.ts

@@ -202,7 +202,9 @@ export function createEmitStreamEvent({
     if (type === 'session.next.tool.called') {
       const callID = String(props.callID ?? event.id);
       const rawToolName = String(props.tool ?? 'unknown');
-      if (rawToolName === 'StructuredOutput') return;
+      if (rawToolName === 'StructuredOutput' || rawToolName === 'question') {
+        return;
+      }
       const toolName = toWireToolName(rawToolName);
       state.toolNames.set(callID, { rawToolName, toolName });
       const hostToolName = getHostToolName(toolName, props.tool);
@@ -238,7 +240,9 @@ export function createEmitStreamEvent({
       const rawToolName =
         cachedTool?.rawToolName ??
         String((props as { tool?: unknown }).tool ?? '');
-      if (rawToolName === 'StructuredOutput') return;
+      if (rawToolName === 'StructuredOutput' || rawToolName === 'question') {
+        return;
+      }
       const toolName =
         cachedTool?.toolName ?? toWireToolName(rawToolName || 'unknown');
       if (getHostToolName(toolName, rawToolName)) return;
@@ -397,7 +401,7 @@ function emitLegacyToolPart({
   }
   const callID = toolPart.callID;
   const rawToolName = toolPart.tool;
-  if (rawToolName === 'StructuredOutput') return;
+  if (rawToolName === 'StructuredOutput' || rawToolName === 'question') return;
   const toolName = toWireToolName(rawToolName);
   if (toolName === 'agent') {
     const metadata = {

package/src/bridge/index.ts

@@ -44,6 +44,12 @@ import {
   type OpenCodeObject,
 } from './opencode-types';
 import { startAuthorizedToolRelay, type ToolRelay } from './tool-relay';
+import {
+  openCodeQuestionKey,
+  toHarnessQuestionsInput,
+  toOpenCodeQuestionResponse,
+  type OpenCodeQuestionRequest,
+} from './question-tool';
 
 type Emit = (msg: Record<string, unknown>) => void;
 
@@ -65,7 +71,8 @@ type CommonBuiltinToolName =
   | 'edit'
   | 'bash'
   | 'glob'
-  | 'grep';
+  | 'grep'
+  | 'askUserQuestions';
 
 const NATIVE_TO_COMMON: Readonly<Record<string, CommonBuiltinToolName>> = {
   view: 'read',
@@ -75,6 +82,7 @@ const NATIVE_TO_COMMON: Readonly<Record<string, CommonBuiltinToolName>> = {
   bash: 'bash',
   glob: 'glob',
   grep: 'grep',
+  question: 'askUserQuestions',
 };
 
 const OPENCODE_TO_WIRE: Readonly<Record<string, string>> = {
@@ -83,6 +91,7 @@ const OPENCODE_TO_WIRE: Readonly<Record<string, string>> = {
   webfetch: 'webfetch',
   task: 'agent',
   agent: 'agent',
+  askUserQuestions: 'question',
   subtask: 'agent',
 };
 
@@ -256,7 +265,7 @@ function buildOpenCodeConfig({
       webfetch: 'ask',
       doom_loop: 'ask',
       task: 'ask',
-      question: 'deny',
+      question: 'allow',
     },
   };
   if (start.model) config.model = start.model;
@@ -333,8 +342,15 @@ function buildProviderConfig(
           apiKey: procEnv.AI_GATEWAY_API_KEY,
           baseURL: toOpenCodeGatewayBaseUrl(procEnv.AI_GATEWAY_BASE_URL),
           ...(HARNESS_CLIENT_APP
-            ? { headers: { 'x-client-app': HARNESS_CLIENT_APP } }
-            : {}),
+            ? {
+                headers: {
+                  ...start.headers,
+                  'x-client-app': HARNESS_CLIENT_APP,
+                },
+              }
+            : start.headers
+              ? { headers: start.headers }
+              : {}),
         },
         ...(modelID
           ? {
@@ -360,6 +376,7 @@ function buildProviderConfig(
           ...(procEnv.OPENAI_BASE_URL
             ? { baseURL: procEnv.OPENAI_BASE_URL }
             : {}),
+          ...(start.headers ? { headers: start.headers } : {}),
           ...parseOpenAIQueryParams(),
         },
         ...(modelID
@@ -391,6 +408,7 @@ function buildProviderConfig(
           ...(procEnv.ANTHROPIC_BASE_URL
             ? { baseURL: procEnv.ANTHROPIC_BASE_URL }
             : {}),
+          ...(start.headers ? { headers: start.headers } : {}),
         },
       },
     };
@@ -413,6 +431,7 @@ function buildProviderConfig(
           ...(procEnv.OPENAI_PROJECT
             ? { project: procEnv.OPENAI_PROJECT }
             : {}),
+          ...(start.headers ? { headers: start.headers } : {}),
           ...parseOpenAIQueryParams(),
         },
       },
@@ -1035,7 +1054,14 @@ async function consumeEvents({
           : undefined;
     if (!scopedSessionId) continue;
     const isDescendant = scopedSessionId !== sessionId;
-    if (event.type === 'permission.v2.asked') {
+    if (event.type === 'question.asked') {
+      await handleQuestion({
+        client,
+        turn,
+        emit,
+        event,
+      });
+    } else if (event.type === 'permission.v2.asked') {
       await handlePermissionV2({
         client,
         sessionId: scopedSessionId,
@@ -1075,6 +1101,79 @@ function getSubagentStepId(event: OpenCodeEvent | undefined) {
   return stringValue(event.properties?.stepID) ?? event.id;
 }
 
+async function handleQuestion({
+  client,
+  turn,
+  emit,
+  event,
+}: {
+  client: OpenCodeClient;
+  turn: BridgeTurn;
+  emit: Emit;
+  event: OpenCodeEvent;
+}): Promise<void> {
+  const nativeRequest = event.properties as OpenCodeQuestionRequest | undefined;
+  if (
+    nativeRequest == null ||
+    typeof nativeRequest.id !== 'string' ||
+    typeof nativeRequest.sessionID !== 'string' ||
+    !Array.isArray(nativeRequest.questions)
+  ) {
+    return;
+  }
+  const toolCallId = nativeRequest.tool?.callID ?? nativeRequest.id;
+
+  emit({
+    type: 'tool-call',
+    toolCallId,
+    toolName: 'askUserQuestions',
+    nativeName: 'question',
+    input: JSON.stringify(toHarnessQuestionsInput(nativeRequest)),
+    providerExecuted: false,
+    providerMetadata: {
+      opencode: {
+        nativeRequest,
+      },
+    },
+  });
+
+  const questionKey = openCodeQuestionKey(nativeRequest);
+  const result = await turn.requestToolResult({
+    toolCallId,
+    matches: candidate => {
+      const continuedRequest = candidate.toolResult?.providerOptions?.opencode
+        ?.nativeRequest as OpenCodeQuestionRequest | undefined;
+      return (
+        continuedRequest != null &&
+        openCodeQuestionKey(continuedRequest) === questionKey
+      );
+    },
+  });
+  const nativeResponse = toOpenCodeQuestionResponse({
+    nativeRequest,
+    output: result.output as Parameters<
+      typeof toOpenCodeQuestionResponse
+    >[0]['output'],
+  });
+
+  const response =
+    nativeResponse.action === 'reject'
+      ? await client.question.reject({
+          requestID: nativeRequest.id,
+          directory: workdir,
+        })
+      : await client.question.reply({
+          requestID: nativeRequest.id,
+          directory: workdir,
+          answers: nativeResponse.answers,
+        });
+  if (response.error != null) {
+    throw new Error(
+      `OpenCode question response failed: ${formatError(response.error)}`,
+    );
+  }
+}
+
 function sanitizeMcpToolName(value: string): string {
   return value.replace(/[^a-zA-Z0-9_-]/g, '_');
 }

package/src/bridge/question-tool.ts

@@ -0,0 +1,90 @@
+import type {
+  HarnessV1QuestionsToolInput,
+  HarnessV1QuestionsToolOutput,
+} from '@ai-sdk/harness';
+import type { QuestionInfo } from '@opencode-ai/sdk/v2';
+
+export type OpenCodeQuestionRequest = {
+  id: string;
+  sessionID: string;
+  questions: QuestionInfo[];
+  tool?: { messageID: string; callID: string };
+};
+
+export function openCodeQuestionKey(
+  nativeRequest: OpenCodeQuestionRequest,
+): string {
+  return JSON.stringify(nativeRequest.questions);
+}
+
+export function toHarnessQuestionsInput(
+  nativeRequest: OpenCodeQuestionRequest,
+): HarnessV1QuestionsToolInput {
+  return {
+    allowPartialAnswers: true,
+    questions: nativeRequest.questions.map((question, questionIndex) => ({
+      id: `question-${questionIndex + 1}`,
+      question: question.question,
+      header: question.header,
+      options: question.options.map((option, optionIndex) => ({
+        id: `option-${optionIndex + 1}`,
+        label: option.label,
+        description: option.description,
+      })),
+      ...(question.multiple !== undefined
+        ? { allowMultiple: question.multiple }
+        : {}),
+      ...(question.custom !== undefined
+        ? { allowFreeForm: question.custom }
+        : {}),
+    })),
+  };
+}
+
+export function toOpenCodeQuestionResponse(input: {
+  nativeRequest: OpenCodeQuestionRequest;
+  output: HarnessV1QuestionsToolOutput;
+}): { action: 'reply'; answers: string[][] } | { action: 'reject' } {
+  if (
+    input.output.action === 'declined' ||
+    input.output.action === 'cancelled'
+  ) {
+    return { action: 'reject' };
+  }
+
+  const answers = input.nativeRequest.questions.map(
+    (nativeQuestion, questionIndex) => {
+      const answer =
+        input.output.action === 'answered' ||
+        input.output.action === 'partially-answered'
+          ? input.output.answers[`question-${questionIndex + 1}`]
+          : undefined;
+      if (answer == null) return [];
+      const selectedLabels = answer.optionIds.flatMap(optionId => {
+        const index = positionalIdIndex({
+          id: optionId,
+          prefix: 'option-',
+        });
+        const option =
+          index == null ? undefined : nativeQuestion.options[index];
+        return option == null ? [] : [option.label];
+      });
+      return answer.freeform === undefined
+        ? selectedLabels
+        : [...selectedLabels, answer.freeform];
+    },
+  );
+
+  return { action: 'reply', answers };
+}
+
+function positionalIdIndex(input: {
+  id: string;
+  prefix: string;
+}): number | undefined {
+  if (!input.id.startsWith(input.prefix)) return undefined;
+  const oneBasedIndex = Number(input.id.slice(input.prefix.length));
+  return Number.isInteger(oneBasedIndex) && oneBasedIndex > 0
+    ? oneBasedIndex - 1
+    : undefined;
+}

package/src/opencode-bridge-protocol.ts

@@ -18,6 +18,7 @@ export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
   resumeSessionId: z.string().optional(),
   openCodeConfig: z.record(z.string(), z.unknown()).optional(),
   mcpServers: z.record(z.string(), z.unknown()).optional(),
+  headers: z.record(z.string(), z.string()).optional(),
 });
 
 export type StartMessage = z.infer<typeof startMessageSchema>;

package/src/opencode-harness.ts

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import {
   commonTool,
+  HARNESS_V1_BUILTIN_TOOLS,
   HarnessCapabilityUnsupportedError,
   harnessV1DiagnosticFromBridgeFrame,
   type HarnessV1,
@@ -13,6 +14,7 @@ import {
   type HarnessV1PermissionMode,
   type HarnessV1Prompt,
   type HarnessV1PromptControl,
+  type HarnessV1ResponseFormat,
   type HarnessV1PortEndpoint,
   type HarnessV1ResumeSessionState,
   type HarnessV1Session,
@@ -38,7 +40,7 @@ import {
   warnCredentialBrokeringUnavailable,
   waitForBridgeReady,
   withBridgeToken,
-  writeSkills as writeHarnessSkills,
+  writeSkills,
   type WriteSkillsResult,
 } from '@ai-sdk/harness/utils';
 import {
@@ -123,6 +125,11 @@ export type OpenCodeHarnessSettings = {
 const optionalStringRecord = z.record(z.string(), z.unknown()).optional();
 
 const OPENCODE_BUILTIN_TOOLS = {
+  askUserQuestions: {
+    ...HARNESS_V1_BUILTIN_TOOLS.askUserQuestions,
+    nativeName: 'question',
+    toolUseKind: 'readonly',
+  },
   read: commonTool('read', {
     nativeName: 'view',
     toolUseKind: 'readonly',
@@ -406,6 +413,7 @@ export function createOpenCode(
             reasoningVariant: settings.reasoningVariant,
             openCodeConfig: settings.openCodeConfig,
             mcpServers: settings.mcpServers,
+            headers: startOpts.headers,
             openCodeSessionId: resumeSessionId,
             isResume: true,
             seedResumeSessionOnFirstPrompt: false,
@@ -563,6 +571,7 @@ export function createOpenCode(
         reasoningVariant: settings.reasoningVariant,
         openCodeConfig: settings.openCodeConfig,
         mcpServers: settings.mcpServers,
+        headers: startOpts.headers,
         openCodeSessionId: resumeSessionId,
         isResume: respawnStrategy !== undefined,
         seedResumeSessionOnFirstPrompt: respawnStrategy !== undefined,
@@ -647,30 +656,6 @@ async function resolveBridgeEndpoint({
   });
 }
 
-async function writeOpenCodeSkills({
-  sandbox,
-  skills,
-  homeDir,
-  abortSignal,
-}: {
-  sandbox: SandboxSession;
-  skills: ReadonlyArray<HarnessV1Skill>;
-  homeDir: string;
-  abortSignal?: AbortSignal;
-}): Promise<WriteSkillsResult> {
-  const skillsDir = path.posix.join(homeDir, '.agents', 'skills');
-  return writeHarnessSkills({
-    sandbox,
-    rootDir: skillsDir,
-    skills,
-    abortSignal,
-    invalidSkillNameMessage: ({ name }) =>
-      `Invalid OpenCode skill name: ${name}`,
-    invalidSkillFilePathMessage: ({ skillName, filePath }) =>
-      `Invalid OpenCode skill file path for ${skillName}: ${filePath}`,
-  });
-}
-
 function openWebSocket({
   endpoint,
   helloTimeoutMs,
@@ -780,6 +765,7 @@ function createSession({
   reasoningVariant,
   openCodeConfig,
   mcpServers,
+  headers,
   openCodeSessionId,
   isResume,
   seedResumeSessionOnFirstPrompt,
@@ -803,6 +789,7 @@ function createSession({
   reasoningVariant: string | undefined;
   openCodeConfig: Record<string, unknown> | undefined;
   mcpServers: Record<string, unknown> | undefined;
+  headers: Readonly<Record<string, string>> | undefined;
   openCodeSessionId: string | undefined;
   isResume: boolean;
   seedResumeSessionOnFirstPrompt: boolean;
@@ -954,6 +941,9 @@ function createSession({
           toolCallId: input.toolCallId,
           output: input.output,
           isError: input.isError,
+          ...(input.toolResult !== undefined
+            ? { toolResult: input.toolResult }
+            : {}),
         });
       },
       submitToolApproval: async input => {
@@ -981,6 +971,7 @@ function createSession({
     ...(reasoningVariant ? { variant: reasoningVariant } : {}),
     ...(openCodeConfig == null ? {} : { openCodeConfig }),
     ...(mcpServers == null ? {} : { mcpServers }),
+    ...(headers == null ? {} : { headers }),
     ...(permissionMode ? { permissionMode } : {}),
     ...(builtinToolFiltering ? { builtinToolFiltering } : {}),
     ...(pendingResumeSessionId
@@ -991,30 +982,48 @@ function createSession({
     ...(debug ? { debug } : {}),
   });
 
+  const prepareTurn = async (opts: {
+    responseFormat?: HarnessV1ResponseFormat;
+    skills: ReadonlyArray<HarnessV1Skill>;
+    emit: (event: HarnessV1StreamPart) => void;
+    abortSignal?: AbortSignal;
+  }): Promise<{
+    control: HarnessV1PromptControl;
+    skillWriteResult: WriteSkillsResult;
+  }> => {
+    if (
+      opts.responseFormat?.type === 'json' &&
+      opts.responseFormat.schema == null
+    ) {
+      throw new HarnessCapabilityUnsupportedError({
+        message:
+          "Harness 'opencode' requires a JSON schema for structured output.",
+        harnessId: 'opencode',
+      });
+    }
+    const skillWriteResult = await writeSkills({
+      sandbox,
+      homePath: sandboxHomeDir,
+      skillsDir: '.agents/skills',
+      skills: opts.skills,
+      abortSignal: opts.abortSignal,
+      invalidSkillNameMessage: ({ name }) =>
+        `Invalid OpenCode skill name: ${name}`,
+      invalidSkillFilePathMessage: ({ skillName, filePath }) =>
+        `Invalid OpenCode skill file path for ${skillName}: ${filePath}`,
+    });
+    const control = wireTurn({
+      emit: opts.emit,
+      abortSignal: opts.abortSignal,
+    });
+    return { control, skillWriteResult };
+  };
+
   return {
     sessionId,
     isResume,
     doPromptTurn: async promptOpts => {
-      if (
-        promptOpts.responseFormat?.type === 'json' &&
-        promptOpts.responseFormat.schema == null
-      ) {
-        throw new HarnessCapabilityUnsupportedError({
-          message:
-            "Harness 'opencode' requires a JSON schema for structured output.",
-          harnessId: 'opencode',
-        });
-      }
-      const skillWriteResult = await writeOpenCodeSkills({
-        sandbox,
-        skills: promptOpts.skills,
-        homeDir: sandboxHomeDir,
-        abortSignal: promptOpts.abortSignal,
-      });
-      const control = wireTurn({
-        emit: promptOpts.emit,
-        abortSignal: promptOpts.abortSignal,
-      });
+      const { control, skillWriteResult } = await prepareTurn(promptOpts);
       const turnModel = promptOpts.model ?? selectedModel;
       if (turnModel) selectedModel = turnModel;
       channel.send({
@@ -1039,26 +1048,7 @@ function createSession({
       return control;
     },
     doContinueTurn: async continueOpts => {
-      if (
-        continueOpts.responseFormat?.type === 'json' &&
-        continueOpts.responseFormat.schema == null
-      ) {
-        throw new HarnessCapabilityUnsupportedError({
-          message:
-            "Harness 'opencode' requires a JSON schema for structured output.",
-          harnessId: 'opencode',
-        });
-      }
-      const skillWriteResult = await writeOpenCodeSkills({
-        sandbox,
-        skills: continueOpts.skills,
-        homeDir: sandboxHomeDir,
-        abortSignal: continueOpts.abortSignal,
-      });
-      const control = wireTurn({
-        emit: continueOpts.emit,
-        abortSignal: continueOpts.abortSignal,
-      });
+      const { control, skillWriteResult } = await prepareTurn(continueOpts);
       if (rerunContinue) {
         const turnModel = continueOpts.model ?? selectedModel;
         if (turnModel) selectedModel = turnModel;
@@ -1107,6 +1097,7 @@ function createSession({
         debug,
         openCodeConfig,
         mcpServers,
+        headers,
         resumeSessionId: latestOpenCodeSessionId,
         onCompaction: part => pendingCompactionParts.push(part),
       });
@@ -1280,6 +1271,7 @@ async function runCompactOperation({
   debug,
   openCodeConfig,
   mcpServers,
+  headers,
   resumeSessionId,
   onCompaction,
 }: {
@@ -1290,6 +1282,7 @@ async function runCompactOperation({
   debug: HarnessV1DebugConfig | undefined;
   openCodeConfig: Record<string, unknown> | undefined;
   mcpServers: Record<string, unknown> | undefined;
+  headers: Readonly<Record<string, string>> | undefined;
   resumeSessionId: string | undefined;
   onCompaction: (part: HarnessV1StreamPart) => void;
 }): Promise<void> {
@@ -1319,6 +1312,7 @@ async function runCompactOperation({
     provider,
     ...(openCodeConfig == null ? {} : { openCodeConfig }),
     ...(mcpServers == null ? {} : { mcpServers }),
+    ...(headers == null ? {} : { headers }),
     ...(permissionMode ? { permissionMode } : {}),
     ...(resumeSessionId ? { resumeSessionId } : {}),
     ...(debug ? { debug } : {}),