@ai-sdk/harness 1.0.149 → 1.0.151

package/src/agent/internal/translate-stream-part.ts

@@ -29,6 +29,17 @@ import { generateId, type ToolSet } from '@ai-sdk/provider-utils';
 export function translateStreamPart<TOOLS extends ToolSet>(
   event: HarnessV1StreamPart,
   options: {
+    /**
+     * Returns the parsed tool call that produced a result. Harness tool-result
+     * events only carry the output, so their input and execution origin must
+     * be restored from the originating call.
+     */
+    getToolCall?: (toolCallId: string) =>
+      | {
+          input: unknown;
+          providerExecuted?: boolean;
+        }
+      | undefined;
     /**
      * Whether the tool call that produced this event ran inside the harness
      * runtime. Host tools travel the same `tool-result` events and their
@@ -119,9 +130,12 @@ export function translateStreamPart<TOOLS extends ToolSet>(
       return [];
 
     case 'tool-result':
+      const toolCall = options.getToolCall?.(event.toolCallId);
       if (
         event.isError === true &&
-        (options.isProviderExecuted?.(event.toolCallId) ?? true)
+        (toolCall?.providerExecuted ??
+          options.isProviderExecuted?.(event.toolCallId) ??
+          true)
       ) {
         /*
          * `providerExecuted` decides whether the message survives:
@@ -134,7 +148,7 @@ export function translateStreamPart<TOOLS extends ToolSet>(
             type: 'tool-error',
             toolCallId: event.toolCallId,
             toolName: event.toolName,
-            input: undefined,
+            input: toolCall?.input,
             error: event.result,
             providerExecuted: true,
             ...(event.dynamic !== undefined ? { dynamic: event.dynamic } : {}),
@@ -150,8 +164,11 @@ export function translateStreamPart<TOOLS extends ToolSet>(
           type: 'tool-result',
           toolCallId: event.toolCallId,
           toolName: event.toolName,
-          input: undefined,
+          input: toolCall?.input,
           output: event.result,
+          ...(toolCall?.providerExecuted !== undefined
+            ? { providerExecuted: toolCall.providerExecuted }
+            : {}),
           ...(event.preliminary !== undefined
             ? { preliminary: event.preliminary }
             : {}),

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({