@ai-sdk/harness 1.0.149 → 1.0.150

package/package.json

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

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

@@ -22,6 +22,7 @@ import {
   createUIMessageStreamResponse,
   toUIMessageStream as toUIMessageStreamHelper,
   type CallWarning,
+  type Citation,
   type ContentPart,
   type FinishReason,
   type InferUIMessageChunk,
@@ -53,6 +54,19 @@ type EnrichedStreamPart<TOOLS extends ToolSet, PARTIAL_OUTPUT> = {
   partialOutput: PARTIAL_OUTPUT | undefined;
 };
 
+type AccumulatedTextContent = {
+  type: 'text';
+  text: string;
+  citations?: Citation[];
+  providerMetadata?: ProviderMetadata;
+};
+
+type AccumulatedReasoningContent = {
+  type: 'reasoning';
+  text: string;
+  providerMetadata?: ProviderMetadata;
+};
+
 /**
  * Concrete `StreamTextResult` implementation backed by a single
  * harness prompt turn.
@@ -149,6 +163,11 @@ export class HarnessStreamTextResult<
 
   private readonly stepsBuffer: StepResult<TOOLS, RUNTIME_CONTEXT>[] = [];
   private currentStepContent: ContentPart<TOOLS>[] = [];
+  private currentStepTextContent = new Map<string, AccumulatedTextContent>();
+  private currentStepReasoningContent = new Map<
+    string,
+    AccumulatedReasoningContent
+  >();
   private currentStepWarnings: CallWarning[] = [];
   private stepNumber = 0;
   private stepStarted = false;
@@ -261,6 +280,8 @@ export class HarnessStreamTextResult<
    */
   discardCurrentStepContent(): void {
     this.currentStepContent = [];
+    this.currentStepTextContent.clear();
+    this.currentStepReasoningContent.clear();
     this.currentStepWarnings = [];
     this.stepStarted = false;
   }
@@ -334,6 +355,8 @@ export class HarnessStreamTextResult<
 
     this.stepNumber += 1;
     this.currentStepContent = [];
+    this.currentStepTextContent.clear();
+    this.currentStepReasoningContent.clear();
     this.currentStepWarnings = [];
     this.stepStarted = false;
 
@@ -421,14 +444,12 @@ export class HarnessStreamTextResult<
       >,
     );
     this._text.resolve(finalStep.text);
-    // Reasoning content parts are not yet derived from harness events; the
-    // foundation surfaces an empty array. Adapters that emit reasoning
-    // deltas can be wired up to produce real reasoning content in a later
-    // pass.
     this._reasoning.resolve(
-      [] as StreamProp<TOOLS, RUNTIME_CONTEXT, OUTPUT, 'reasoning'>,
+      finalStep.content.filter(
+        part => part.type === 'reasoning' || part.type === 'reasoning-file',
+      ) as StreamProp<TOOLS, RUNTIME_CONTEXT, OUTPUT, 'reasoning'>,
     );
-    this._reasoningText.resolve(undefined);
+    this._reasoningText.resolve(finalStep.reasoningText);
     this._files.resolve(this.stepsBuffer.flatMap(s => s.files));
     this._sources.resolve(this.stepsBuffer.flatMap(s => s.sources));
     this._toolCalls.resolve(
@@ -491,10 +512,16 @@ export class HarnessStreamTextResult<
     this._response.resolve(finalStep.response);
     this._providerMetadata.resolve(this.finalProviderMetadata);
 
-    const responseMessages = await toResponseMessages<TOOLS>({
-      content: aggregatedContent,
-      tools: this.tools,
-    });
+    const responseMessages: Array<AssistantModelMessage | ToolModelMessage> =
+      [];
+    for (const step of this.stepsBuffer) {
+      responseMessages.push(
+        ...(await toResponseMessages<TOOLS>({
+          content: step.content,
+          tools: this.tools,
+        })),
+      );
+    }
     this._responseMessages.resolve(responseMessages);
 
     // Forward AI SDK finish event before closing.
@@ -755,6 +782,8 @@ export class HarnessStreamTextResult<
   toUIMessageStream<UI_MESSAGE extends UIMessage>({
     originalMessages,
     generateMessageId,
+    onStepEnd,
+    onStepFinish,
     onEnd,
     onFinish,
     messageMetadata,
@@ -772,6 +801,8 @@ export class HarnessStreamTextResult<
         tools: this.tools,
         originalMessages,
         generateMessageId,
+        onStepEnd,
+        onStepFinish,
         onEnd,
         onFinish,
         messageMetadata,
@@ -795,6 +826,8 @@ export class HarnessStreamTextResult<
   toUIMessageStreamResponse<UI_MESSAGE extends UIMessage>({
     originalMessages,
     generateMessageId,
+    onStepEnd,
+    onStepFinish,
     onEnd,
     onFinish,
     messageMetadata,
@@ -813,6 +846,8 @@ export class HarnessStreamTextResult<
       stream: this.toUIMessageStream<UI_MESSAGE>({
         originalMessages,
         generateMessageId,
+        onStepEnd,
+        onStepFinish,
         onEnd,
         onFinish,
         messageMetadata,
@@ -834,30 +869,88 @@ export class HarnessStreamTextResult<
 
   private appendToCurrentStepContent(part: TextStreamPart<TOOLS>): void {
     switch (part.type) {
+      case 'text-start': {
+        const content: AccumulatedTextContent = {
+          type: 'text',
+          text: '',
+          ...(part.providerMetadata != null
+            ? { providerMetadata: part.providerMetadata }
+            : {}),
+        };
+        this.currentStepTextContent.set(part.id, content);
+        this.currentStepContent.push(content);
+        return;
+      }
       case 'text-delta': {
-        // Coalesce contiguous text-deltas with the same id into one text part.
-        const last =
-          this.currentStepContent[this.currentStepContent.length - 1];
-        if (last && last.type === 'text') {
-          (last as { text: string }).text += part.text;
-        } else {
-          this.currentStepContent.push({
+        let content = this.currentStepTextContent.get(part.id);
+        if (content == null) {
+          content = {
             type: 'text',
-            text: part.text,
-          } as ContentPart<TOOLS>);
+            text: '',
+            ...(part.providerMetadata != null
+              ? { providerMetadata: part.providerMetadata }
+              : {}),
+          };
+          this.currentStepTextContent.set(part.id, content);
+          this.currentStepContent.push(content);
         }
+        content.text += part.text;
+        if (part.providerMetadata != null) {
+          content.providerMetadata = part.providerMetadata;
+        }
+        return;
+      }
+      case 'text-end': {
+        const content = this.currentStepTextContent.get(part.id);
+        if (content != null) {
+          if (part.providerMetadata != null) {
+            content.providerMetadata = part.providerMetadata;
+          }
+          if (part.citations != null) {
+            content.citations = part.citations;
+          }
+          this.currentStepTextContent.delete(part.id);
+        }
+        return;
+      }
+      case 'reasoning-start': {
+        const content: AccumulatedReasoningContent = {
+          type: 'reasoning',
+          text: '',
+          ...(part.providerMetadata != null
+            ? { providerMetadata: part.providerMetadata }
+            : {}),
+        };
+        this.currentStepReasoningContent.set(part.id, content);
+        this.currentStepContent.push(content);
         return;
       }
       case 'reasoning-delta': {
-        const last =
-          this.currentStepContent[this.currentStepContent.length - 1];
-        if (last && last.type === 'reasoning') {
-          (last as { text: string }).text += part.text;
-        } else {
-          this.currentStepContent.push({
+        let content = this.currentStepReasoningContent.get(part.id);
+        if (content == null) {
+          content = {
             type: 'reasoning',
-            text: part.text,
-          } as ContentPart<TOOLS>);
+            text: '',
+            ...(part.providerMetadata != null
+              ? { providerMetadata: part.providerMetadata }
+              : {}),
+          };
+          this.currentStepReasoningContent.set(part.id, content);
+          this.currentStepContent.push(content);
+        }
+        content.text += part.text;
+        if (part.providerMetadata != null) {
+          content.providerMetadata = part.providerMetadata;
+        }
+        return;
+      }
+      case 'reasoning-end': {
+        const content = this.currentStepReasoningContent.get(part.id);
+        if (content != null) {
+          if (part.providerMetadata != null) {
+            content.providerMetadata = part.providerMetadata;
+          }
+          this.currentStepReasoningContent.delete(part.id);
         }
         return;
       }

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

@@ -303,12 +303,15 @@ export function runPrompt<
     >();
     /*
      * Host results are echoed back as `tool-result` events too, so the event
-     * alone cannot say who ran the tool — classify by the originating
-     * `tool-call`. Only an explicit `true` counts: `LanguageModelV4ToolCall`
-     * defines an omitted flag as client-executed. A call missing from the map
-     * arrived in an earlier slice, where nothing here can classify it.
+     * alone cannot provide the parsed input or say who ran the tool — restore
+     * both from the originating `tool-call`. Only an explicit `true` counts:
+     * `LanguageModelV4ToolCall` defines an omitted flag as client-executed. A
+     * call missing from the map arrived in an earlier slice, where nothing
+     * here can classify it.
      */
     const translateOptions = {
+      getToolCall: (toolCallId: string) =>
+        toolCallsByToolCallId.get(toolCallId),
       isProviderExecuted: (toolCallId: string): boolean => {
         const rawToolCall = rawToolCallsByToolCallId.get(toolCallId);
         return rawToolCall == null || rawToolCall.providerExecuted === true;

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 }
             : {}),