@ai-sdk/harness-claude-code 1.0.103 → 1.0.105

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @ai-sdk/harness-claude-code
 
+## 1.0.105
+
+### Patch Changes
+
+- 951c54d: feat(harness): support `askUserQuestions` tool including support for normalization across harness adapters
+- a554cc8: fix (harness-claude-code): treat a `result` message flagged `is_error` as a terminal error
+- Updated dependencies [951c54d]
+  - @ai-sdk/harness@1.0.101
+
+## 1.0.104
+
+### Patch Changes
+
+- f21945b: fix(harness-claude-code): keep non-text tool result content and scalar MCP tool results intact instead of flattening them to a stringified or re-parsed value
+- 0c37bf0: fix(harness): avoid warning about lack of credential brokering support when `credentialForwarding` callback is used to replace all credentials with ephemeral fake secrets
+- Updated dependencies [0c37bf0]
+  - @ai-sdk/harness@1.0.100
+
 ## 1.0.103
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -214,6 +214,7 @@ async function runBridge(options) {
     }
   }
   const pendingToolResults = /* @__PURE__ */ new Map();
+  const bufferedToolResults = [];
   const pendingToolApprovals = /* @__PURE__ */ new Map();
   const writeBridgeMeta = async (state) => {
     try {
@@ -393,9 +394,23 @@ async function runBridge(options) {
         const userMessages = createBridgeUserMessageQueue({ respond: emit });
         const turn = {
           emit,
-          requestToolResult: (toolCallId) => new Promise((resolve) => {
-            pendingToolResults.set(toolCallId, resolve);
-          }),
+          requestToolResult: (requestInput) => {
+            const request = typeof requestInput === "string" ? { toolCallId: requestInput } : requestInput;
+            const bufferedIndex = bufferedToolResults.findIndex(
+              (buffered) => buffered.toolCallId === request.toolCallId || request.matches?.(buffered.result) === true
+            );
+            if (bufferedIndex >= 0) {
+              return Promise.resolve(
+                bufferedToolResults.splice(bufferedIndex, 1)[0].result
+              );
+            }
+            return new Promise((resolve) => {
+              pendingToolResults.set(request.toolCallId, {
+                resolve,
+                matches: request.matches
+              });
+            });
+          },
           requestToolApproval: (approvalId) => new Promise((resolve) => {
             pendingToolApprovals.set(approvalId, resolve);
           }),
@@ -437,10 +452,25 @@ async function runBridge(options) {
         return;
       }
       case "tool-result": {
-        const resolver = pendingToolResults.get(msg.toolCallId);
-        if (resolver) {
-          pendingToolResults.delete(msg.toolCallId);
-          resolver({ output: msg.output, isError: msg.isError });
+        const result = {
+          output: msg.output,
+          isError: msg.isError,
+          toolResult: msg.toolResult
+        };
+        const exactPending = pendingToolResults.get(msg.toolCallId);
+        const matchingPending = exactPending == null ? Array.from(pendingToolResults.entries()).find(
+          ([, pending2]) => pending2.matches?.(result) === true
+        ) : void 0;
+        const pending = exactPending ?? matchingPending?.[1];
+        const pendingId = exactPending != null ? msg.toolCallId : matchingPending?.[0];
+        if (pending != null && pendingId != null) {
+          pendingToolResults.delete(pendingId);
+          pending.resolve(result);
+        } else {
+          bufferedToolResults.push({
+            toolCallId: msg.toolCallId,
+            result
+          });
         }
         return;
       }
@@ -765,6 +795,11 @@ function createEmitStreamEvent({
             continue;
           }
           state.nativeToolCallNames.set(block.id, block.name);
+          if (block.name === "AskUserQuestion") {
+            state.pendingStepToolUseIds.add(block.id);
+            opensStep = true;
+            continue;
+          }
           const dynamic = isExternalMcpTool(block.name);
           if (dynamic) state.externalMcpToolUseIds.add(block.id);
           if (state.approvalRequestedToolUseIds.has(block.id)) {
@@ -810,9 +845,12 @@ function createEmitStreamEvent({
           const toolName = toCommonName2(nativeName);
           const dynamic = state.externalMcpToolUseIds.delete(block.tool_use_id);
           const isError = !!block.is_error;
-          const content = stringifyContent(block.content);
-          const contentResult = toolName === "bash" ? { exitCode: isError ? 1 : 0, stdout: content } : dynamic ? parseMcpToolResult(content) : content;
-          const result = toolUseResult !== void 0 ? toolUseResult : contentResult;
+          const result = toolUseResult !== void 0 ? toolUseResult : resolveToolResult({
+            toolName,
+            dynamic,
+            isError,
+            rawContent: block.content
+          });
           emit({
             type: "tool-result",
             toolCallId: block.tool_use_id,
@@ -901,6 +939,9 @@ function handleStreamEvent({
       if (nativeName === "StructuredOutput") {
         return;
       }
+      if (nativeName === "AskUserQuestion") {
+        return;
+      }
       const hostToolName = nativeName.startsWith(HOST_TOOL_PREFIX) ? nativeName.slice(HOST_TOOL_PREFIX.length) : void 0;
       const dynamic = isExternalMcpTool(nativeName);
       partialBlocks.set(index, { id, kind: "tool-input" });
@@ -947,18 +988,38 @@ function handleStreamEvent({
     }
   }
 }
+function isTextEntry(entry) {
+  return entry != null && typeof entry === "object" && "text" in entry;
+}
 function stringifyContent(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     return content.map(
-      (entry) => entry && typeof entry === "object" && "text" in entry ? String(entry.text ?? "") : JSON.stringify(entry)
+      (entry) => isTextEntry(entry) ? String(entry.text ?? "") : JSON.stringify(entry)
     ).join("");
   }
   return JSON.stringify(content);
 }
+function hasNonTextContent(content) {
+  return Array.isArray(content) && content.some((entry) => !isTextEntry(entry));
+}
+function resolveToolResult({
+  toolName,
+  dynamic,
+  isError,
+  rawContent
+}) {
+  if (toolName === "bash") {
+    return { exitCode: isError ? 1 : 0, stdout: stringifyContent(rawContent) };
+  }
+  if (hasNonTextContent(rawContent)) return rawContent;
+  const content = stringifyContent(rawContent);
+  return dynamic ? parseMcpToolResult(content) : content;
+}
 function parseMcpToolResult(content) {
   try {
-    return JSON.parse(content);
+    const parsed = JSON.parse(content);
+    return parsed !== null && typeof parsed === "object" ? parsed : content;
   } catch {
     return content;
   }
@@ -1098,7 +1159,7 @@ var PUBLIC_TO_NATIVE = {
   ExitPlanMode: "ExitPlanMode",
   EnterWorktree: "EnterWorktree",
   ExitWorktree: "ExitWorktree",
-  AskUserQuestion: "AskUserQuestion",
+  askUserQuestions: "AskUserQuestion",
   Skill: "Skill",
   ToolSearch: "ToolSearch"
 };
@@ -1118,6 +1179,74 @@ function resolveInactiveNativeTools(toolFiltering) {
   return inactiveToolNames.map((name) => toNativeName(name));
 }
 
+// src/bridge/question-tool.ts
+function claudeCodeQuestionKey(nativeInput) {
+  return JSON.stringify(nativeInput.questions);
+}
+function toHarnessQuestionsInput(nativeInput) {
+  return {
+    allowPartialAnswers: true,
+    questions: nativeInput.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,
+        ...option.preview !== void 0 ? { preview: option.preview } : {}
+      })),
+      allowMultiple: question.multiSelect,
+      allowFreeForm: true
+    }))
+  };
+}
+function toClaudeCodeQuestionResult(input) {
+  const output = input.output;
+  if (output.action === "declined" || output.action === "cancelled") {
+    return {
+      behavior: "deny",
+      message: `The user ${output.action} the questions.`
+    };
+  }
+  const canonicalInput = toHarnessQuestionsInput(input.nativeInput);
+  const answers = Object.fromEntries(
+    canonicalInput.questions.flatMap((question, questionIndex) => {
+      const answer = output.answers[question.id];
+      if (answer == null) return [];
+      const nativeQuestion = input.nativeInput.questions[questionIndex];
+      return [
+        [
+          nativeQuestion.question,
+          toClaudeCodeAnswer({
+            nativeQuestion,
+            optionIds: answer.optionIds,
+            freeform: answer.freeform
+          })
+        ]
+      ];
+    })
+  );
+  return {
+    behavior: "allow",
+    updatedInput: { ...input.nativeInput, answers }
+  };
+}
+function toClaudeCodeAnswer(input) {
+  if (input.freeform !== void 0) return input.freeform;
+  const labels = input.optionIds.flatMap((optionId) => {
+    const index = positionalIdIndex({ id: optionId, prefix: "option-" });
+    const option = index == null ? void 0 : input.nativeQuestion.options[index];
+    return option == null ? [] : [option.label];
+  });
+  return input.nativeQuestion.multiSelect ? labels.join(", ") : labels[0] ?? "";
+}
+function positionalIdIndex(input) {
+  if (!input.id.startsWith(input.prefix)) return void 0;
+  const oneBasedIndex = Number(input.id.slice(input.prefix.length));
+  return Number.isInteger(oneBasedIndex) && oneBasedIndex > 0 ? oneBasedIndex - 1 : void 0;
+}
+
 // src/bridge/index.ts
 var NATIVE_TO_COMMON = {
   Read: "read",
@@ -1126,7 +1255,8 @@ var NATIVE_TO_COMMON = {
   Bash: "bash",
   Glob: "glob",
   Grep: "grep",
-  WebSearch: "webSearch"
+  WebSearch: "webSearch",
+  AskUserQuestion: "askUserQuestions"
 };
 var NATIVE_TOOL_KINDS = {
   Read: "readonly",
@@ -1186,15 +1316,9 @@ function createPermissionOptions(input) {
     permissionMode,
     inactiveNativeTools
   });
-  if (permissionMode === "allow-all" && inactiveNativeTools.size === 0) {
-    return {
-      permissionMode: "bypassPermissions",
-      allowDangerouslySkipPermissions: true
-    };
-  }
   return {
-    permissionMode: permissionMode === "allow-edits" ? "acceptEdits" : "default",
-    allowDangerouslySkipPermissions: false,
+    permissionMode: permissionMode === "allow-all" ? "bypassPermissions" : permissionMode === "allow-edits" ? "acceptEdits" : "default",
+    allowDangerouslySkipPermissions: permissionMode === "allow-all",
     ...permissionSettings ? { settings: permissionSettings } : {},
     canUseTool: async (toolName, toolInput, options) => {
       if (toolName.startsWith("mcp__harness-tools__")) {
@@ -1233,6 +1357,56 @@ function createPermissionOptions(input) {
     }
   };
 }
+function createQuestionPreToolUseHook(input) {
+  return async (hookInput, toolUseID) => {
+    if (hookInput.hook_event_name !== "PreToolUse" || hookInput.tool_name !== "AskUserQuestion") {
+      return {};
+    }
+    const nativeInput = hookInput.tool_input;
+    const canonicalInput = toHarnessQuestionsInput(nativeInput);
+    const toolCallId = toolUseID ?? hookInput.tool_use_id;
+    input.nativeToolCallNames.set(toolCallId, hookInput.tool_name);
+    input.emit({
+      type: "tool-call",
+      toolCallId,
+      toolName: "askUserQuestions",
+      nativeName: hookInput.tool_name,
+      input: JSON.stringify(canonicalInput),
+      providerExecuted: false,
+      providerMetadata: {
+        "claude-code": {
+          nativeRequest: nativeInput
+        }
+      }
+    });
+    const questionKey = claudeCodeQuestionKey(nativeInput);
+    const result = await input.turn.requestToolResult({
+      toolCallId,
+      matches: (candidate) => {
+        const nativeRequest = candidate.toolResult?.providerOptions?.["claude-code"]?.nativeRequest;
+        return nativeRequest != null && claudeCodeQuestionKey(nativeRequest) === questionKey;
+      }
+    });
+    const nativeResult = toClaudeCodeQuestionResult({
+      nativeInput,
+      output: result.output
+    });
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        ...nativeResult.behavior === "allow" ? {
+          permissionDecision: "allow",
+          updatedInput: {
+            ...nativeResult.updatedInput
+          }
+        } : {
+          permissionDecision: "deny",
+          permissionDecisionReason: nativeResult.message
+        }
+      }
+    };
+  };
+}
 function createPermissionSettings(input) {
   const askRules = /* @__PURE__ */ new Set();
   for (const [nativeName, kind] of Object.entries(NATIVE_TOOL_KINDS)) {
@@ -1336,6 +1510,11 @@ async function runTurn(start, turn) {
     nativeToolCallNames: streamEventState.nativeToolCallNames,
     approvalRequestedToolUseIds: streamEventState.approvalRequestedToolUseIds
   });
+  const questionPreToolUseHook = createQuestionPreToolUseHook({
+    turn,
+    emit,
+    nativeToolCallNames: streamEventState.nativeToolCallNames
+  });
   const q = claudeSdk.query({
     prompt: queryInput.input,
     options: {
@@ -1359,6 +1538,12 @@ async function runTurn(start, turn) {
       // `compact_boundary` system message does not. Latch it for the unified
       // `compaction` event; return an empty output so compaction proceeds.
       hooks: {
+        PreToolUse: [
+          {
+            matcher: "AskUserQuestion",
+            hooks: [questionPreToolUseHook]
+          }
+        ],
         PostCompact: [
           {
             hooks: [
@@ -1437,6 +1622,12 @@ async function runTurn(start, turn) {
       emitStreamEvent(msg);
       if (type === "result") {
         if (msg.subtype === "success") {
+          if (msg.is_error) {
+            emitTerminalError(
+              msg.result?.trim() || streamEventState.observedTerminalError || (typeof msg.api_error_status === "number" ? `Claude Code reported an API error (HTTP ${msg.api_error_status})` : "Claude Code reported a failed result")
+            );
+            continue;
+          }
           const emptyResult = !msg.result?.trim?.();
           if (emptyResult && streamEventState.observedTerminalError) {
             emitTerminalError(streamEventState.observedTerminalError);