@ai-sdk/harness 1.0.150 → 1.0.152

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness",
-  "version": "1.0.150",
+  "version": "1.0.152",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -45,8 +45,8 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.27",
-    "@ai-sdk/provider-utils": "5.0.59",
-    "ai": "7.0.139"
+    "@ai-sdk/provider-utils": "5.0.60",
+    "ai": "7.0.141"
   },
   "peerDependencies": {
     "ws": "^8.21.0",
@@ -58,7 +58,7 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/otel": "1.0.139",
+    "@ai-sdk/otel": "1.0.141",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",
     "@types/ws": "^8.5.13",

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

@@ -14,6 +14,9 @@ import type {
  * locally to find the original tool call before it can resume the paused turn.
  * Responses that already have a tool result are ignored, because those
  * approvals were already consumed by a prior continuation.
+ * An `execution-denied` result is synthesized by `convertToModelMessages`
+ * for a newly denied approval; it does not mean the harness has received
+ * the decision, so that approval response must still continue the turn.
  */
 export function collectHarnessAgentToolApprovalContinuations(input: {
   messages: readonly ModelMessage[];
@@ -38,7 +41,10 @@ export function collectHarnessAgentToolApprovalContinuations(input: {
 
   const toolResultIds = new Set<string>();
   for (const part of lastMessage.content) {
-    if (part.type === 'tool-result') {
+    if (
+      part.type === 'tool-result' &&
+      part.output.type !== 'execution-denied'
+    ) {
       toolResultIds.add(part.toolCallId);
     }
   }

package/src/agent/internal/harness-stream-text-result.ts

@@ -4,6 +4,7 @@ import {
   type AssistantModelMessage,
   type Context,
   type ToolModelMessage,
+  type ToolResultOutput,
   type ToolSet,
 } from '@ai-sdk/provider-utils';
 import {
@@ -11,6 +12,7 @@ import {
   asLanguageModelUsage,
   createAsyncIterableStream,
   createNullLanguageModelUsage,
+  createToolModelOutput,
   DefaultStepResult,
   toResponseMessages,
 } from 'ai/internal';
@@ -173,6 +175,7 @@ export class HarnessStreamTextResult<
   private stepStarted = false;
 
   private readonly tools: TOOLS;
+  private readonly toolModelOutputs = new Map<string, ToolResultOutput>();
   private readonly runtimeContext: RUNTIME_CONTEXT;
   private readonly toolsContext: InferToolSetContext<TOOLS>;
   private readonly providerName: string;
@@ -188,6 +191,13 @@ export class HarnessStreamTextResult<
   private aggregateWarnings: CallWarning[] = [];
   private settled = false;
 
+  setToolModelOutput(input: {
+    toolCallId: string;
+    output: ToolResultOutput;
+  }): void {
+    this.toolModelOutputs.set(input.toolCallId, input.output);
+  }
+
   constructor(options: {
     tools: TOOLS;
     runtimeContext: RUNTIME_CONTEXT;
@@ -512,13 +522,26 @@ export class HarnessStreamTextResult<
     this._response.resolve(finalStep.response);
     this._providerMetadata.resolve(this.finalProviderMetadata);
 
+    const responseTools: ToolSet = {};
+    for (const [name, tool] of Object.entries(this.tools)) {
+      responseTools[name] = {
+        ...tool,
+        toModelOutput: (options: {
+          toolCallId: string;
+          input: unknown;
+          output: unknown;
+        }) =>
+          this.toolModelOutputs.get(options.toolCallId) ??
+          createToolModelOutput({ ...options, tool, errorMode: 'none' }),
+      };
+    }
     const responseMessages: Array<AssistantModelMessage | ToolModelMessage> =
       [];
     for (const step of this.stepsBuffer) {
       responseMessages.push(
         ...(await toResponseMessages<TOOLS>({
           content: step.content,
-          tools: this.tools,
+          tools: responseTools as TOOLS,
         })),
       );
     }

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

@@ -24,6 +24,7 @@ import {
   type Experimental_SandboxSession as SandboxSession,
   type ToolApprovalResponse,
   type ToolResultPart,
+  type ToolResultOutput,
   type ToolSet,
 } from '@ai-sdk/provider-utils';
 import {
@@ -36,6 +37,7 @@ import {
   addLanguageModelUsage,
   asLanguageModelUsage,
   createNullLanguageModelUsage,
+  createToolModelOutput,
   parseToolCall,
   validateToolContext,
 } from 'ai/internal';
@@ -68,6 +70,8 @@ import {
 import { resolveCustomToolApproval } from './permission-mode';
 import { logBridgeError } from '../../utils/bridge-diagnostics';
 import { pinSandboxChannelEventCheckpoint } from '../../utils/sandbox-channel';
+import { normalizeHarnessToolModelOutput } from '../../utils/normalize-harness-tool-model-output';
+import { HarnessCapabilityUnsupportedError } from '../../errors/harness-capability-unsupported-error';
 
 const invalidToolInputMessage = 'Tool input validation failed.';
 
@@ -424,9 +428,24 @@ export function runPrompt<
       toolExecutions.clear();
       bufferedToolOutcomes = [];
     };
-    let expectedStepToolCallCount: number | undefined;
-    let observedStepToolCallCount = 0;
-    let pauseAfterStepToolCalls = false;
+    type FinishStepPart = Extract<HarnessV1StreamPart, { type: 'finish-step' }>;
+    /*
+     * An approval request or a pending client tool result does not end the
+     * response right away: the rest of the step (other tool calls, native
+     * results, host tool executions) still has to be surfaced. The pause
+     * happens at the next `finish-step`, once every host tool started in
+     * this response has been echoed back by the runtime.
+     */
+    let hostInputPauseRequested = false;
+    let deferredPauseFinishStep: FinishStepPart | undefined;
+    /*
+     * A `finish-step` that arrives while host tools started in this step have
+     * not been echoed back is the adapter signalling that the runtime waits on
+     * host input, not the end of the step. It is remembered so the step can
+     * still be closed if the turn finishes without another `finish-step`.
+     */
+    let ignoredFinishStep: FinishStepPart | undefined;
+    const hostToolCallIdsAwaitingEcho = new Set<string>();
     const buildModelCallContent = (): ContentPart<TOOLS>[] => {
       const parts: ContentPart<TOOLS>[] = [];
       if (stepText) parts.push({ type: 'text', text: stepText });
@@ -444,9 +463,7 @@ export function runPrompt<
       stepApprovalRequests = [];
       bufferedToolOutcomes = [];
       toolExecutions.clear();
-      expectedStepToolCallCount = undefined;
-      observedStepToolCallCount = 0;
-      pauseAfterStepToolCalls = false;
+      ignoredFinishStep = undefined;
     };
     const zeroUsage: LanguageModelV4Usage = {
       inputTokens: {
@@ -487,25 +504,27 @@ export function runPrompt<
       resetStepContent();
       return step;
     };
-    const finishForHostInputPause = async (options: {
-      completeCurrentStep: boolean;
-    }): Promise<void> => {
+    const finishForHostInputPause = async (): Promise<void> => {
       await waitForOutstandingHostToolExecutions();
-      if (options.completeCurrentStep) {
-        await completeStep({
-          finishReason: toolCallsFinishReason,
-          usage: zeroUsage,
-          providerMetadata: undefined,
-        });
-      } else {
-        await publishToolExecutions();
-      }
+      await publishToolExecutions();
       await lifecycle.end({
         steps: completedSteps,
         usage: asLanguageModelUsage(zeroUsage),
       });
       await result.finish();
     };
+    const pauseForHostInput = async (
+      finishStep: FinishStepPart | undefined,
+    ): Promise<void> => {
+      await waitForOutstandingHostToolExecutions();
+      closingResumedStep = false;
+      await completeStep({
+        finishReason: toolCallsFinishReason,
+        usage: finishStep?.usage ?? zeroUsage,
+        providerMetadata: finishStep?.harnessMetadata,
+      });
+      await finishForHostInputPause();
+    };
     const enqueueApprovalRequest = (approval: {
       approvalId: string;
       toolCall: ToolCallTextStreamPart;
@@ -612,7 +631,37 @@ export function runPrompt<
     };
     const submitToolResult: HarnessV1PromptControl['submitToolResult'] =
       async submission => {
+        if (submission.toolResult != null) {
+          let output: ToolResultOutput;
+          try {
+            output = normalizeHarnessToolModelOutput({
+              output: submission.toolResult.output,
+            });
+          } catch (error) {
+            if (
+              !continuationsByToolCallId.has(submission.toolCallId) ||
+              !HarnessCapabilityUnsupportedError.isInstance(error)
+            ) {
+              throw error;
+            }
+            output = {
+              type: 'text',
+              value: JSON.stringify(submission.output) ?? 'null',
+            };
+          }
+          submission = {
+            ...submission,
+            toolResult: { ...submission.toolResult, output },
+          };
+          result.setToolModelOutput({
+            toolCallId: submission.toolCallId,
+            output,
+          });
+        }
         if (!input.isTurnSuspending?.()) {
+          if (!settledHostToolCallIds.has(submission.toolCallId)) {
+            hostToolCallIdsAwaitingEcho.add(submission.toolCallId);
+          }
           return control.submitToolResult(submission);
         }
         const toolCall =
@@ -811,7 +860,7 @@ export function runPrompt<
       });
       if (!execution.executed) {
         recordPendingToolResult({ toolCall: rawToolCall });
-        await finishForHostInputPause({ completeCurrentStep: false });
+        await finishForHostInputPause();
         return 'awaiting-tool-result';
       }
       const toolExecution = toolExecutions.get(rawToolCall.toolCallId)!;
@@ -855,11 +904,10 @@ export function runPrompt<
 
       while (true) {
         if (
-          pauseAfterStepToolCalls &&
-          expectedStepToolCallCount != null &&
-          observedStepToolCallCount >= expectedStepToolCallCount
+          deferredPauseFinishStep != null &&
+          hostToolCallIdsAwaitingEcho.size === 0
         ) {
-          await finishForHostInputPause({ completeCurrentStep: true });
+          await pauseForHostInput(deferredPauseFinishStep);
           return;
         }
 
@@ -877,6 +925,9 @@ export function runPrompt<
           result.enqueueRaw(value.rawValue);
           continue;
         }
+        if (value.type === 'tool-result') {
+          hostToolCallIdsAwaitingEcho.delete(value.toolCallId);
+        }
 
         if (pendingStopBoundary != null) {
           if (value.type === 'finish') {
@@ -967,6 +1018,45 @@ export function runPrompt<
         if (settledHostInputReplay || settledBuiltinApprovalReplay) {
           continue;
         }
+        if (value.type === 'finish-step') {
+          if (hostInputPauseRequested) {
+            await waitForOutstandingHostToolExecutions();
+            if (hostToolCallIdsAwaitingEcho.size === 0) {
+              await pauseForHostInput(value);
+              return;
+            }
+            deferredPauseFinishStep = value;
+            continue;
+          }
+          if (hostToolCallIdsAwaitingEcho.size > 0) {
+            ignoredFinishStep = value;
+            continue;
+          }
+          ignoredFinishStep = undefined;
+        }
+        if (value.type === 'finish') {
+          if (hostInputPauseRequested) {
+            await pauseForHostInput(deferredPauseFinishStep);
+            return;
+          }
+          if (ignoredFinishStep != null) {
+            const finishStep = ignoredFinishStep;
+            ignoredFinishStep = undefined;
+            await waitForOutstandingHostToolExecutions();
+            if (closingResumedStep) {
+              closingResumedStep = false;
+              await publishToolExecutions();
+              resetStepContent();
+              result.discardCurrentStepContent();
+            } else {
+              await completeStep({
+                finishReason: finishStep.finishReason,
+                usage: finishStep.usage,
+                providerMetadata: finishStep.harnessMetadata,
+              });
+            }
+          }
+        }
         if (displayValue.type === 'finish-step' && closingResumedStep) {
           closingResumedStep = false;
           await publishToolExecutions();
@@ -997,6 +1087,12 @@ export function runPrompt<
                 `Harness '${input.harness.harnessId}' emitted a built-in tool approval request but does not support approval responses.`,
               );
             }
+            /*
+             * The runtime may report a step boundary while it waits for this
+             * decision. The decision is answered here, so that boundary must
+             * not end the step before the denied call's result arrives.
+             */
+            hostToolCallIdsAwaitingEcho.add(displayValue.toolCallId);
             await control.submitToolApproval({
               approvalId: displayValue.approvalId,
               approved: false,
@@ -1103,8 +1199,6 @@ export function runPrompt<
         }
 
         if (value.type === 'tool-call') {
-          observedStepToolCallCount += 1;
-          expectedStepToolCallCount ??= value.stepToolCallCount;
           const toolCall = toolCallsByToolCallId.get(value.toolCallId);
           if (toolCall != null) {
             stepToolCalls.push(toolCall as ContentPart<TOOLS>);
@@ -1204,8 +1298,8 @@ export function runPrompt<
             approvalId: pendingApproval.approvalId,
             toolCall,
           });
-          await finishForHostInputPause({ completeCurrentStep: true });
-          return;
+          hostInputPauseRequested = true;
+          continue;
         }
 
         // Drive step boundaries.
@@ -1273,15 +1367,8 @@ export function runPrompt<
           }
           if (isClientExecutedBuiltin) {
             recordPendingToolResult({ toolCall });
-            if (
-              expectedStepToolCallCount != null &&
-              observedStepToolCallCount < expectedStepToolCallCount
-            ) {
-              pauseAfterStepToolCalls = true;
-              continue;
-            }
-            await finishForHostInputPause({ completeCurrentStep: true });
-            return;
+            hostInputPauseRequested = true;
+            continue;
           }
           if (validatedHostToolCall == null) {
             throw new Error(
@@ -1396,28 +1483,15 @@ export function runPrompt<
               approvalId: pendingApproval.approvalId,
               toolCall: pendingParsedToolCall,
             });
-            if (
-              expectedStepToolCallCount != null &&
-              observedStepToolCallCount < expectedStepToolCallCount
-            ) {
-              pauseAfterStepToolCalls = true;
-              continue;
-            }
-            await finishForHostInputPause({ completeCurrentStep: true });
-            return;
+            hostInputPauseRequested = true;
+            continue;
           }
           if (!isExecutableTool(activeTools[toolCall.toolName])) {
             recordPendingToolResult({ toolCall });
-            if (
-              expectedStepToolCallCount != null &&
-              observedStepToolCallCount < expectedStepToolCallCount
-            ) {
-              pauseAfterStepToolCalls = true;
-              continue;
-            }
-            await finishForHostInputPause({ completeCurrentStep: true });
-            return;
+            hostInputPauseRequested = true;
+            continue;
           }
+          hostToolCallIdsAwaitingEcho.add(toolCall.toolCallId);
           startHostToolExecution(
             (async () => {
               const toolExecution = toolExecutions.get(toolCall.toolCallId);
@@ -1484,6 +1558,10 @@ export function runPrompt<
           );
         }
       }
+      if (hostInputPauseRequested && input.isTurnSuspending?.() !== true) {
+        await pauseForHostInput(deferredPauseFinishStep);
+        return;
+      }
       await waitForOutstandingHostToolExecutions();
       const isTurnSuspending = input.isTurnSuspending?.() === true;
       if (isTurnSuspending) {
@@ -1698,6 +1776,22 @@ async function maybeExecuteHostTool<TOOLS extends ToolSet>(input: {
     await input.submitToolResult({
       toolCallId: input.event.toolCallId,
       output,
+      ...(tool.toModelOutput == null
+        ? {}
+        : {
+            toolResult: {
+              type: 'tool-result' as const,
+              toolCallId: input.event.toolCallId,
+              toolName: input.event.toolName,
+              output: await createToolModelOutput({
+                toolCallId: input.event.toolCallId,
+                input: input.parsedToolCall.input,
+                output,
+                tool,
+                errorMode: 'none',
+              }),
+            },
+          }),
     });
     return { executed: true, outcome: { ok: true, output } };
   } catch (err) {

package/src/bridge/index.ts

@@ -15,6 +15,10 @@ import type { ToolResultPart } from '@ai-sdk/provider-utils';
 import { WebSocketServer, type WebSocket } from 'ws';
 
 export { HarnessBridgeCapabilityUnsupportedError } from './harness-bridge-capability-unsupported-error';
+export {
+  convertHarnessToolModelOutput,
+  type HarnessToolModelOutputContent,
+} from '../utils/convert-harness-tool-model-output';
 
 export type BridgeState = 'init' | 'waiting' | 'running' | 'draining' | 'done';
 

package/src/utils/convert-harness-tool-model-output.ts

@@ -0,0 +1,66 @@
+import type { ToolResultOutput } from '@ai-sdk/provider-utils';
+import { HarnessBridgeCapabilityUnsupportedError } from '../bridge/harness-bridge-capability-unsupported-error';
+
+export type HarnessToolModelOutputContent =
+  | { type: 'text'; text: string }
+  | { type: 'image'; data: string; mediaType: string };
+
+type ToolModelOutputContentPart = Extract<
+  ToolResultOutput,
+  { type: 'content' }
+>['value'][number];
+
+function getNormalizedInlineImage(
+  part: ToolModelOutputContentPart,
+): { data: string; mediaType: string } | undefined {
+  if (
+    part.type === 'file' &&
+    part.mediaType.startsWith('image/') &&
+    part.mediaType !== 'image/*' &&
+    part.data.type === 'data' &&
+    typeof part.data.data === 'string'
+  ) {
+    return { data: part.data.data, mediaType: part.mediaType };
+  }
+  return undefined;
+}
+
+export function convertHarnessToolModelOutput({
+  output,
+}: {
+  output: ToolResultOutput;
+}): { content: HarnessToolModelOutputContent[]; isError: boolean } {
+  switch (output.type) {
+    case 'text':
+    case 'error-text':
+      return {
+        content: [{ type: 'text', text: output.value }],
+        isError: output.type === 'error-text',
+      };
+    case 'json':
+    case 'error-json':
+      return {
+        content: [{ type: 'text', text: JSON.stringify(output.value) }],
+        isError: output.type === 'error-json',
+      };
+    case 'execution-denied':
+      return {
+        content: [
+          { type: 'text', text: output.reason ?? 'Tool execution denied.' },
+        ],
+        isError: true,
+      };
+    case 'content':
+      return {
+        content: output.value.map(part => {
+          if (part.type === 'text') return { type: 'text', text: part.text };
+          const image = getNormalizedInlineImage(part);
+          if (image != null) return { type: 'image', ...image };
+          throw new HarnessBridgeCapabilityUnsupportedError({
+            message: `Harnesses support only text and inline images in tool model output; unsupported content '${part.type}'.`,
+          });
+        }),
+        isError: false,
+      };
+  }
+}

package/src/utils/index.ts

@@ -71,3 +71,8 @@ export {
 export { resolveSandboxDefaultWorkingDirectory } from './resolve-sandbox-default-working-directory';
 export { getRestrictedSandboxSession } from './get-restricted-sandbox-session';
 export { sleep } from './sleep';
+export { normalizeHarnessToolModelOutput } from './normalize-harness-tool-model-output';
+export {
+  convertHarnessToolModelOutput,
+  type HarnessToolModelOutputContent,
+} from './convert-harness-tool-model-output';

package/src/utils/normalize-harness-tool-model-output.ts

@@ -0,0 +1,66 @@
+import {
+  convertInlineFileDataToUint8Array,
+  convertUint8ArrayToBase64,
+  detectMediaType,
+  getTopLevelMediaType,
+  isFullMediaType,
+  type ToolResultOutput,
+} from '@ai-sdk/provider-utils';
+import { HarnessCapabilityUnsupportedError } from '../errors/harness-capability-unsupported-error';
+
+export function normalizeHarnessToolModelOutput({
+  output,
+}: {
+  output: ToolResultOutput;
+}): ToolResultOutput {
+  try {
+    const normalized: ToolResultOutput =
+      output.type !== 'content'
+        ? output
+        : {
+            ...output,
+            value: output.value.map(part => {
+              if (part.type === 'text') return part;
+              const file =
+                part.type === 'image-data' || part.type === 'file-data'
+                  ? {
+                      ...part,
+                      type: 'file' as const,
+                      data: { type: 'data' as const, data: part.data },
+                    }
+                  : part;
+              if (
+                file.type !== 'file' ||
+                file.data.type !== 'data' ||
+                getTopLevelMediaType(file.mediaType) !== 'image'
+              ) {
+                throw new Error(
+                  `Unsupported content '${part.type}'${file.type === 'file' ? ` (${file.mediaType}, ${file.data.type})` : ''}.`,
+                );
+              }
+              const data =
+                typeof file.data.data === 'string'
+                  ? file.data.data
+                  : convertUint8ArrayToBase64(
+                      convertInlineFileDataToUint8Array(file.data),
+                    );
+              const mediaType = isFullMediaType(file.mediaType)
+                ? file.mediaType
+                : detectMediaType({ data, topLevelType: 'image' });
+              if (mediaType == null)
+                throw new Error('Cannot detect the inline image media type.');
+              return {
+                ...file,
+                mediaType,
+                data: { type: 'data' as const, data },
+              };
+            }),
+          };
+    return normalized;
+  } catch (cause) {
+    throw new HarnessCapabilityUnsupportedError({
+      message: `Harnesses support only text and inline images in tool model output. ${cause instanceof Error ? cause.message : String(cause)}`,
+      cause,
+    });
+  }
+}

package/src/v1/harness-v1-prompt-control.ts

@@ -13,6 +13,9 @@ export type HarnessV1PromptControl = {
   /**
    * Provide a result for a `tool-call` the adapter emitted. The adapter
    * forwards the result to the underlying runtime so the model can continue.
+   * `output` is the raw execution result for consumer-facing events. When
+   * `toolResult` is present, its output is the model-facing representation
+   * and takes precedence when constructing the runtime's tool response.
    */
   submitToolResult(input: {
     toolCallId: string;

package/src/v1/harness-v1-stream-part.ts

@@ -65,11 +65,6 @@ export type HarnessV1StreamPart =
   // when it differs from the wire `toolName` (e.g. `toolName: 'bash'`,
   // `nativeName: 'Bash'`).
   //
-  // `stepToolCallCount` lets adapters that know a step's complete tool-call
-  // set up front report its cardinality. The host uses it to collect every
-  // approval/result request from the step before pausing; adapters that cannot
-  // know the count omit it and retain pause-on-first behavior.
-  //
   // Whether the call was executed by the underlying runtime (Claude Code's
   // built-in `Bash`, Codex's `shell`) vs. needs host dispatch is signalled by
   // the standard `providerExecuted` field on `LanguageModelV4ToolCall` —
@@ -79,16 +74,21 @@ export type HarnessV1StreamPart =
   | Extract<LanguageModelV4StreamPart, { type: 'tool-input-end' }>
   | (LanguageModelV4ToolCall & {
       nativeName?: string;
-      /**
-       * Total tool calls in the current model step, when known before tool
-       * execution begins. Populate this on every tool call in the step.
-       */
-      stepToolCallCount?: number;
     })
   | LanguageModelV4ToolApprovalRequest
   | LanguageModelV4ToolResult
 
   // Step boundary inside a multi-step turn.
+  //
+  // Adapters also emit `finish-step` when the runtime cannot make progress
+  // without host input: every unsettled tool call of the step waits for
+  // `submitToolResult`, `submitToolApproval`, or a question answer. The
+  // runtime's step stays open, and the adapter emits another `finish-step`
+  // once those calls settle. Such a `finish-step` is only emitted when a
+  // waiting call was not already covered by an earlier one in the same step.
+  // The host may pause the turn there for pending approvals or client tool
+  // results, and ignores it while host tools it started have not been echoed
+  // back as `tool-result` parts yet.
   | {
       type: 'finish-step';
       finishReason: LanguageModelV4FinishReason;
@@ -304,7 +304,6 @@ export const harnessV1ToolCallPartSchema = z.object({
   dynamic: z.boolean().optional(),
   providerMetadata: harnessV1ProviderMetadataSchema.optional(),
   nativeName: z.string().optional(),
-  stepToolCallCount: z.number().int().positive().optional(),
 });
 
 export const harnessV1ToolApprovalRequestPartSchema = z.object({