@ai-sdk/harness 1.0.99 → 1.0.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness",
-  "version": "1.0.99",
+  "version": "1.0.101",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -46,7 +46,7 @@
   "dependencies": {
     "@ai-sdk/provider": "4.0.10",
     "@ai-sdk/provider-utils": "5.0.36",
-    "ai": "7.0.90"
+    "ai": "7.0.92"
   },
   "peerDependencies": {
     "ws": "^8.21.0",
@@ -58,7 +58,7 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/otel": "1.0.90",
+    "@ai-sdk/otel": "1.0.92",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",
     "@types/ws": "^8.5.13",

package/src/agent/harness-agent-session.ts

@@ -1,6 +1,8 @@
 import type {
   Context,
   Experimental_SandboxSession as SandboxSession,
+  ToolApprovalResponse,
+  ToolResultPart,
   ToolSet,
 } from '@ai-sdk/provider-utils';
 import type {
@@ -29,8 +31,6 @@ import type {
   HarnessAgentResumeSessionState,
   HarnessAgentToolSpec,
 } from './harness-agent-types';
-import type { HarnessAgentToolApprovalContinuation } from './harness-agent-tool-approval-continuation';
-import type { HarnessAgentToolResultContinuation } from './harness-agent-tool-result-continuation';
 import { validateLifecycleStateData } from './internal/lifecycle-state-validation';
 import { runPrompt } from './internal/run-prompt';
 import { getRestrictedSandboxSession } from '../utils/get-restricted-sandbox-session';
@@ -306,12 +306,8 @@ export class HarnessAgentSession {
     output: OUTPUT | undefined;
     telemetry: TelemetryOptions | undefined;
     stopConditions: ReadonlyArray<StopCondition<TOOLS, RUNTIME_CONTEXT>>;
-    toolApprovalContinuations?:
-      | readonly HarnessAgentToolApprovalContinuation[]
-      | undefined;
-    toolResultContinuations?:
-      | readonly HarnessAgentToolResultContinuation[]
-      | undefined;
+    toolApprovalContinuations?: readonly ToolApprovalResponse[] | undefined;
+    toolResultContinuations?: readonly ToolResultPart[] | undefined;
   }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT, OUTPUT> {
     const session = this.requireReusableSession();
     this.requireContinuableTurn();

package/src/agent/harness-agent-tool-approval-continuation.ts

@@ -5,17 +5,6 @@ import type {
   ToolApprovalResponse,
 } from '@ai-sdk/provider-utils';
 
-export type HarnessAgentToolApprovalContinuation = {
-  readonly approvalResponse: ToolApprovalResponse;
-  readonly toolCall: {
-    readonly type: 'tool-call';
-    readonly toolCallId: string;
-    readonly toolName: string;
-    readonly input: unknown;
-    readonly providerExecuted?: boolean;
-  };
-};
-
 /**
  * Extract approval decisions that should continue a suspended harness turn.
  *
@@ -28,14 +17,11 @@ export type HarnessAgentToolApprovalContinuation = {
  */
 export function collectHarnessAgentToolApprovalContinuations(input: {
   messages: readonly ModelMessage[];
-}): readonly HarnessAgentToolApprovalContinuation[] {
+}): readonly ToolApprovalResponse[] {
   const lastMessage = input.messages.at(-1);
   if (lastMessage?.role !== 'tool') return [];
 
-  const toolCallsByToolCallId = new Map<
-    string,
-    HarnessAgentToolApprovalContinuation['toolCall']
-  >();
+  const toolCallIds = new Set<string>();
   const approvalRequestsByApprovalId = new Map<string, ToolApprovalRequest>();
   for (const message of input.messages) {
     if (message.role !== 'assistant' || typeof message.content === 'string') {
@@ -43,15 +29,7 @@ export function collectHarnessAgentToolApprovalContinuations(input: {
     }
     for (const part of message.content) {
       if (part.type === 'tool-call') {
-        toolCallsByToolCallId.set(part.toolCallId, {
-          type: 'tool-call',
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          input: part.input,
-          ...(part.providerExecuted !== undefined
-            ? { providerExecuted: part.providerExecuted }
-            : {}),
-        });
+        toolCallIds.add(part.toolCallId);
       } else if (part.type === 'tool-approval-request') {
         approvalRequestsByApprovalId.set(part.approvalId, part);
       }
@@ -65,7 +43,7 @@ export function collectHarnessAgentToolApprovalContinuations(input: {
     }
   }
 
-  const continuations: HarnessAgentToolApprovalContinuation[] = [];
+  const continuations: ToolApprovalResponse[] = [];
   for (const part of lastMessage.content) {
     if (part.type !== 'tool-approval-response') continue;
 
@@ -77,17 +55,13 @@ export function collectHarnessAgentToolApprovalContinuations(input: {
     }
     if (toolResultIds.has(approvalRequest.toolCallId)) continue;
 
-    const toolCall = toolCallsByToolCallId.get(approvalRequest.toolCallId);
-    if (toolCall == null) {
+    if (!toolCallIds.has(approvalRequest.toolCallId)) {
       throw new HarnessError({
         message: `Tool approval request '${approvalRequest.approvalId}' references unknown tool call '${approvalRequest.toolCallId}'.`,
       });
     }
 
-    continuations.push({
-      approvalResponse: part,
-      toolCall,
-    });
+    continuations.push(part);
   }
 
   return continuations;

package/src/agent/harness-agent-tool-result-continuation.ts

@@ -1,62 +1,13 @@
-import type { ModelMessage, ToolResultOutput } from '@ai-sdk/provider-utils';
-
-export type HarnessAgentToolResultContinuation = {
-  readonly toolCallId: string;
-  readonly output: unknown;
-  readonly isError?: boolean;
-};
+import type { ModelMessage, ToolResultPart } from '@ai-sdk/provider-utils';
 
 /**
- * Extract client-provided tool results from the trailing tool message and
- * convert AI SDK model-output wrappers back into values a harness runtime can
- * return from its pending host-tool invocation.
+ * Extract client-provided tool results from the trailing tool message.
  */
 export function collectHarnessAgentToolResultContinuations(input: {
   messages: readonly ModelMessage[];
-}): readonly HarnessAgentToolResultContinuation[] {
+}): readonly ToolResultPart[] {
   const lastMessage = input.messages.at(-1);
   if (lastMessage?.role !== 'tool') return [];
 
-  return lastMessage.content
-    .filter(part => part.type === 'tool-result')
-    .map(part =>
-      toToolResultContinuation({
-        toolCallId: part.toolCallId,
-        output: part.output,
-      }),
-    );
-}
-
-function toToolResultContinuation(input: {
-  toolCallId: string;
-  output: ToolResultOutput;
-}): HarnessAgentToolResultContinuation {
-  switch (input.output.type) {
-    case 'text':
-    case 'json':
-      return {
-        toolCallId: input.toolCallId,
-        output: input.output.value,
-      };
-    case 'error-text':
-    case 'error-json':
-      return {
-        toolCallId: input.toolCallId,
-        output: input.output.value,
-        isError: true,
-      };
-    case 'execution-denied':
-      return {
-        toolCallId: input.toolCallId,
-        output: {
-          type: input.output.type,
-          reason: input.output.reason,
-        },
-      };
-    case 'content':
-      return {
-        toolCallId: input.toolCallId,
-        output: input.output,
-      };
-  }
+  return lastMessage.content.filter(part => part.type === 'tool-result');
 }

package/src/agent/harness-agent.ts

@@ -1,5 +1,6 @@
 import { HarnessCapabilityUnsupportedError } from '../errors/harness-capability-unsupported-error';
 import type {
+  HarnessV1,
   HarnessV1BuiltinToolFiltering,
   HarnessV1JSONSchema,
   HarnessV1NetworkSandboxSession,
@@ -13,6 +14,8 @@ import {
   type Context,
   type Experimental_SandboxSession as SandboxSession,
   type ModelMessage,
+  type ToolApprovalResponse,
+  type ToolResultPart,
   type ToolSet,
 } from '@ai-sdk/provider-utils';
 import type {
@@ -41,14 +44,8 @@ import type {
   HarnessAgentSkill,
   HarnessAgentToolSpec,
 } from './harness-agent-types';
-import {
-  collectHarnessAgentToolApprovalContinuations,
-  type HarnessAgentToolApprovalContinuation,
-} from './harness-agent-tool-approval-continuation';
-import {
-  collectHarnessAgentToolResultContinuations,
-  type HarnessAgentToolResultContinuation,
-} from './harness-agent-tool-result-continuation';
+import { collectHarnessAgentToolApprovalContinuations } from './harness-agent-tool-approval-continuation';
+import { collectHarnessAgentToolResultContinuations } from './harness-agent-tool-result-continuation';
 import {
   applyBootstrapRecipe,
   hashHarnessBootstrap,
@@ -86,8 +83,8 @@ export interface HarnessAgentCallExtensions {
 }
 
 type HarnessAgentContinueTurnInput = {
-  toolApprovalContinuations: readonly HarnessAgentToolApprovalContinuation[];
-  toolResultContinuations: readonly HarnessAgentToolResultContinuation[];
+  toolApprovalContinuations: readonly ToolApprovalResponse[];
+  toolResultContinuations: readonly ToolResultPart[];
 };
 
 type PreparedHarnessAgentTurnSettings<
@@ -114,8 +111,8 @@ type PreparedHarnessAgentContinueTurnInput<
   THarness extends HarnessAgentAdapter<any>,
   TUserTools extends ToolSet,
 > = PreparedHarnessAgentTurnSettings<THarness, TUserTools> & {
-  toolApprovalContinuations: readonly HarnessAgentToolApprovalContinuation[];
-  toolResultContinuations: readonly HarnessAgentToolResultContinuation[];
+  toolApprovalContinuations: readonly ToolApprovalResponse[];
+  toolResultContinuations: readonly ToolResultPart[];
 };
 
 type HarnessAgentTurnResult<
@@ -224,6 +221,10 @@ export class HarnessAgent<
     this.sandboxConfig = sandboxConfig;
     this.id = settings.id;
     const userTools = settings.tools ?? ({} as TUserTools);
+    assertNoReservedQuestionTool({
+      harness: settings.harness,
+      userTools,
+    });
     this.permissionMode = resolvePermissionMode({
       permissionMode: settings.permissionMode,
     });
@@ -609,8 +610,8 @@ export class HarnessAgent<
    */
   async continueGenerate(options: {
     session: HarnessAgentSession;
-    toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
-    toolResultContinuations?: readonly HarnessAgentToolResultContinuation[];
+    toolApprovalContinuations?: readonly ToolApprovalResponse[];
+    toolResultContinuations?: readonly ToolResultPart[];
     abortSignal?: AbortSignal;
   }): Promise<
     GenerateTextResult<
@@ -643,8 +644,8 @@ export class HarnessAgent<
    */
   async continueStream(options: {
     session: HarnessAgentSession;
-    toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
-    toolResultContinuations?: readonly HarnessAgentToolResultContinuation[];
+    toolApprovalContinuations?: readonly ToolApprovalResponse[];
+    toolResultContinuations?: readonly ToolResultPart[];
     abortSignal?: AbortSignal;
   }): Promise<
     StreamTextResult<
@@ -903,8 +904,8 @@ export class HarnessAgent<
   }
 
   private _prepareContinueTurnInput(options: {
-    toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
-    toolResultContinuations?: readonly HarnessAgentToolResultContinuation[];
+    toolApprovalContinuations?: readonly ToolApprovalResponse[];
+    toolResultContinuations?: readonly ToolResultPart[];
   }): PreparedHarnessAgentContinueTurnInput<THarness, TUserTools> {
     return {
       ...this._prepareTurnSettings({
@@ -925,6 +926,10 @@ export class HarnessAgent<
     tools?: TUserTools;
   }): PreparedHarnessAgentTurnSettings<THarness, TUserTools> {
     const userTools = options.tools ?? ({} as TUserTools);
+    assertNoReservedQuestionTool({
+      harness: this.settings.harness,
+      userTools,
+    });
     const tools = {
       ...this.settings.harness.builtinTools,
       ...userTools,
@@ -1028,6 +1033,23 @@ export class HarnessAgent<
   }
 }
 
+function assertNoReservedQuestionTool(input: {
+  harness: HarnessV1;
+  userTools: ToolSet;
+}): void {
+  if (
+    Object.prototype.hasOwnProperty.call(
+      input.harness.builtinTools,
+      'askUserQuestions',
+    ) &&
+    Object.prototype.hasOwnProperty.call(input.userTools, 'askUserQuestions')
+  ) {
+    throw new Error(
+      "HarnessAgent tool name 'askUserQuestions' is reserved for harness question requests.",
+    );
+  }
+}
+
 /*
  * `GenerateTextResult` view over a drained `streamText` run. Non-deprecated
  * members derive from `steps` (the single source of truth), and the deprecated

package/src/agent/internal/run-prompt.ts

@@ -21,6 +21,8 @@ import {
   safeParseJSON,
   type Context,
   type Experimental_SandboxSession as SandboxSession,
+  type ToolApprovalResponse,
+  type ToolResultPart,
   type ToolSet,
 } from '@ai-sdk/provider-utils';
 import {
@@ -39,8 +41,6 @@ import type {
   TelemetryOptions,
   TextStreamPart,
 } from 'ai';
-import type { HarnessAgentToolApprovalContinuation } from '../harness-agent-tool-approval-continuation';
-import type { HarnessAgentToolResultContinuation } from '../harness-agent-tool-result-continuation';
 import type { HarnessAgentToolApprovalConfiguration } from '../harness-agent-settings';
 import { HarnessStreamTextResult } from './harness-stream-text-result';
 import { translateStreamPart } from './translate-stream-part';
@@ -54,6 +54,29 @@ import { resolveCustomToolApproval } from './permission-mode';
 import { logBridgeError } from '../../utils/bridge-diagnostics';
 import { pinSandboxChannelEventCheckpoint } from '../../utils/sandbox-channel';
 
+function unwrapToolResultOutput(toolResult: ToolResultPart): {
+  output: unknown;
+  isError?: boolean;
+} {
+  switch (toolResult.output.type) {
+    case 'text':
+    case 'json':
+      return { output: toolResult.output.value };
+    case 'error-text':
+    case 'error-json':
+      return { output: toolResult.output.value, isError: true };
+    case 'execution-denied':
+      return {
+        output: {
+          type: toolResult.output.type,
+          reason: toolResult.output.reason,
+        },
+      };
+    case 'content':
+      return { output: toolResult.output };
+  }
+}
+
 /**
  * Drive one prompt turn end-to-end:
  *  - call `session.doPromptTurn` via `toHarnessStream`
@@ -99,12 +122,8 @@ export function runPrompt<
   toolApproval?: HarnessAgentToolApprovalConfiguration | undefined;
   pendingToolApprovals?: readonly HarnessV1PendingToolApproval[];
   pendingToolResults?: readonly HarnessV1PendingToolResult[];
-  toolApprovalContinuations?:
-    | readonly HarnessAgentToolApprovalContinuation[]
-    | undefined;
-  toolResultContinuations?:
-    | readonly HarnessAgentToolResultContinuation[]
-    | undefined;
+  toolApprovalContinuations?: readonly ToolApprovalResponse[] | undefined;
+  toolResultContinuations?: readonly ToolResultPart[] | undefined;
   onPendingToolApproval?: (approval: HarnessV1PendingToolApproval) => void;
   onToolApprovalSettled?: (approvalId: string) => void;
   onPendingToolResult?: (pendingResult: HarnessV1PendingToolResult) => void;
@@ -267,7 +286,7 @@ export function runPrompt<
     );
     const continuationsByApprovalId = new Map(
       (input.toolApprovalContinuations ?? []).map(continuation => [
-        continuation.approvalResponse.approvalId,
+        continuation.approvalId,
         continuation,
       ]),
     );
@@ -433,15 +452,16 @@ export function runPrompt<
     };
     const enqueueApprovalResponse = (
       approval: HarnessV1PendingToolApproval,
-      continuation: HarnessAgentToolApprovalContinuation,
+      continuation: ToolApprovalResponse,
+      toolCall: ToolCallTextStreamPart,
     ): void => {
       result.enqueueContinuation({
         type: 'tool-approval-response',
         approvalId: approval.approvalId,
-        toolCall: continuation.toolCall,
-        approved: continuation.approvalResponse.approved,
-        ...(continuation.approvalResponse.reason !== undefined
-          ? { reason: continuation.approvalResponse.reason }
+        toolCall,
+        approved: continuation.approved,
+        ...(continuation.reason !== undefined
+          ? { reason: continuation.reason }
           : {}),
         ...(approval.providerExecuted !== undefined
           ? { providerExecuted: approval.providerExecuted }
@@ -457,6 +477,9 @@ export function runPrompt<
           toolCallId: options.toolCall.toolCallId,
           toolName: options.toolCall.toolName,
           input: options.toolCall.input,
+          ...(options.toolCall.providerMetadata !== undefined
+            ? { providerOptions: options.toolCall.providerMetadata }
+            : {}),
         } satisfies HarnessV1PendingToolResult);
       pendingResultsByToolCallId.set(pendingResult.toolCallId, pendingResult);
       onPendingToolResult(pendingResult);
@@ -464,19 +487,28 @@ export function runPrompt<
     };
     const processPendingToolResultContinuation = async (
       pendingResult: HarnessV1PendingToolResult,
-      continuation: HarnessAgentToolResultContinuation,
+      continuation: ToolResultPart,
     ): Promise<void> => {
+      const result = unwrapToolResultOutput(continuation);
       onToolResultSettled(pendingResult.toolCallId);
       pendingResultsByToolCallId.delete(pendingResult.toolCallId);
       settledHostToolCallIds.add(pendingResult.toolCallId);
       await control.submitToolResult({
         toolCallId: pendingResult.toolCallId,
-        output: continuation.output,
-        isError: continuation.isError,
+        output: result.output,
+        isError: result.isError,
+        toolResult: {
+          ...continuation,
+          toolName: pendingResult.toolName,
+          ...(continuation.providerOptions == null &&
+          pendingResult.providerOptions != null
+            ? { providerOptions: pendingResult.providerOptions }
+            : {}),
+        },
       });
     };
     const enqueueHostToolOutcome = (options: {
-      toolCall: HarnessAgentToolApprovalContinuation['toolCall'];
+      toolCall: ToolCallTextStreamPart;
       outcome: HostToolOutcome;
     }): void => {
       if (options.outcome.ok) {
@@ -512,9 +544,30 @@ export function runPrompt<
     };
     const processPendingApprovalContinuation = async (
       approval: HarnessV1PendingToolApproval,
-      continuation: HarnessAgentToolApprovalContinuation,
+      continuation: ToolApprovalResponse,
     ): Promise<'continued' | 'awaiting-tool-result'> => {
-      enqueueApprovalResponse(approval, continuation);
+      const rawToolCall =
+        rawToolCallsByToolCallId.get(approval.toolCallId) ??
+        ({
+          type: 'tool-call',
+          toolCallId: approval.toolCallId,
+          toolName: approval.toolName,
+          input: approval.input,
+          providerExecuted: approval.providerExecuted,
+          nativeName: approval.nativeName,
+        } satisfies Extract<HarnessV1StreamPart, { type: 'tool-call' }>);
+      const parsedInput = await safeParseJSON({ text: rawToolCall.input });
+      const toolCall: ToolCallTextStreamPart = {
+        type: 'tool-call',
+        toolCallId: rawToolCall.toolCallId,
+        toolName: rawToolCall.toolName,
+        input: parsedInput.success ? parsedInput.value : rawToolCall.input,
+        ...(rawToolCall.providerExecuted !== undefined
+          ? { providerExecuted: rawToolCall.providerExecuted }
+          : {}),
+      };
+
+      enqueueApprovalResponse(approval, continuation, toolCall);
       onToolApprovalSettled(approval.approvalId);
       pendingApprovalsByApprovalId.delete(approval.approvalId);
       pendingApprovalsByToolCallId.delete(approval.toolCallId);
@@ -528,33 +581,24 @@ export function runPrompt<
         }
         await control.submitToolApproval({
           approvalId: approval.approvalId,
-          approved: continuation.approvalResponse.approved,
-          reason: continuation.approvalResponse.reason,
+          approved: continuation.approved,
+          reason: continuation.reason,
         });
         return 'continued';
       }
 
       settledHostToolCallIds.add(approval.toolCallId);
-      if (!continuation.approvalResponse.approved) {
+      if (!continuation.approved) {
         await control.submitToolResult({
           toolCallId: approval.toolCallId,
           output: {
             type: 'execution-denied',
-            reason: continuation.approvalResponse.reason,
+            reason: continuation.reason,
           },
         });
         return 'continued';
       }
 
-      const rawToolCall =
-        rawToolCallsByToolCallId.get(approval.toolCallId) ??
-        ({
-          type: 'tool-call',
-          toolCallId: approval.toolCallId,
-          toolName: approval.toolName,
-          input: approval.input,
-        } satisfies Extract<HarnessV1StreamPart, { type: 'tool-call' }>);
-
       await telemetry.start(input.model);
       await telemetry.toolStart({
         toolCallId: rawToolCall.toolCallId,
@@ -597,7 +641,7 @@ export function runPrompt<
         return 'awaiting-tool-result';
       }
       enqueueHostToolOutcome({
-        toolCall: continuation.toolCall,
+        toolCall,
         outcome: execution.outcome,
       });
       await telemetry.toolEnd(rawToolCall.toolCallId, execution.outcome);
@@ -940,7 +984,16 @@ export function runPrompt<
               `Harness '${input.harness.harnessId}' could not find parsed tool call '${toolCall.toolCallId}' for custom tool approval.`,
             );
           }
-          if (!hasTool({ tools: activeTools, toolName: toolCall.toolName })) {
+          const isClientExecutedBuiltin =
+            toolCall.toolName === 'askUserQuestions' &&
+            Object.prototype.hasOwnProperty.call(
+              input.harness.builtinTools,
+              toolCall.toolName,
+            );
+          if (
+            !isClientExecutedBuiltin &&
+            !hasTool({ tools: activeTools, toolName: toolCall.toolName })
+          ) {
             const output = {
               type: 'execution-denied',
               reason: getHarnessV1BuiltinToolFilteringDenialReason({
@@ -954,6 +1007,18 @@ export function runPrompt<
             await telemetry.toolEnd(toolCall.toolCallId, { ok: true, output });
             continue;
           }
+          if (isClientExecutedBuiltin) {
+            recordPendingToolResult({ toolCall });
+            if (
+              expectedStepToolCallCount != null &&
+              observedStepToolCallCount < expectedStepToolCallCount
+            ) {
+              pauseAfterStepToolCalls = true;
+              continue;
+            }
+            await finishForHostInputPause({ completeCurrentStep: true });
+            return;
+          }
           const customToolApprovalDecision = resolveCustomToolApproval({
             toolName: toolCall.toolName,
             toolApproval: input.toolApproval,