@ai-sdk/harness-opencode 1.0.101 → 1.0.103

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;
@@ -1035,7 +1044,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 +1091,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-harness.ts

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import {
   commonTool,
+  HARNESS_V1_BUILTIN_TOOLS,
   HarnessCapabilityUnsupportedError,
   harnessV1DiagnosticFromBridgeFrame,
   type HarnessV1,
@@ -123,6 +124,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',
@@ -336,8 +342,6 @@ export function createOpenCode(
           );
         }
         credentialsBrokered = true;
-      } else {
-        warnCredentialBrokeringUnavailable();
       }
       const bootstrapDir = path.posix.resolve(
         defaultWorkingDirectory,
@@ -457,6 +461,14 @@ export function createOpenCode(
               OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
             credentialForwarding: settings.credentialForwarding,
           });
+      if (!credentialsBrokered) {
+        warnCredentialBrokeringUnavailable({
+          environment: resolvedAuthEnvironment,
+          forwardedEnvironment: forwardedAuthEnvironment,
+          credentialEnvironmentVariables:
+            OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
+        });
+      }
       const env = {
         ...forwardedAuthEnvironment,
         AI_SDK_HARNESS_CLIENT_APP: OPENCODE_CLIENT_APP,
@@ -948,6 +960,9 @@ function createSession({
           toolCallId: input.toolCallId,
           output: input.output,
           isError: input.isError,
+          ...(input.toolResult !== undefined
+            ? { toolResult: input.toolResult }
+            : {}),
         });
       },
       submitToolApproval: async input => {