@ai-sdk/harness 1.0.36 → 1.0.38

package/dist/index.d.ts

@@ -297,6 +297,11 @@ type HarnessV1PendingToolApproval = {
     readonly providerExecuted?: boolean;
     readonly nativeName?: string;
 };
+type HarnessV1PendingToolResult = {
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly input: string;
+};
 type HarnessV1LifecycleStateBase = {
     /**
      * Identifier of the harness that produced this state. Used by adapters to
@@ -339,6 +344,11 @@ type HarnessV1ContinueTurnState = HarnessV1LifecycleStateBase & {
      * without the harness framework owning storage.
      */
     readonly pendingToolApprovals?: readonly HarnessV1PendingToolApproval[];
+    /**
+     * Framework-owned client tool calls that are waiting for a caller-provided
+     * result before the underlying turn can continue.
+     */
+    readonly pendingToolResults?: readonly HarnessV1PendingToolResult[];
 };
 type HarnessV1LifecycleState = HarnessV1ResumeSessionState | HarnessV1ContinueTurnState;
 
@@ -1584,4 +1594,4 @@ declare class HarnessCapabilityUnsupportedError extends HarnessError {
     static isInstance(error: unknown): error is HarnessCapabilityUnsupportedError;
 }
 
-export { HARNESS_V1_BUILTIN_TOOLS, HARNESS_V1_BUILTIN_TOOL_NAMES, HarnessCapabilityUnsupportedError, HarnessError, type HarnessV1, type HarnessV1Bootstrap, type HarnessV1BootstrapCommand, type HarnessV1BootstrapFile, type HarnessV1BridgeDebugEvent, type HarnessV1BridgeOutboundMessage, type HarnessV1BridgeReady, type HarnessV1BridgeSandboxLog, type HarnessV1BridgeToolWire, type HarnessV1BuiltinTool, type HarnessV1BuiltinToolFiltering, type HarnessV1BuiltinToolName, type HarnessV1BuiltinToolUseKind, type HarnessV1CallWarning, type HarnessV1ContinueTurnOptions, type HarnessV1ContinueTurnState, type HarnessV1DebugConfig, type HarnessV1DebugLevel, type HarnessV1Diagnostic, type HarnessV1LifecycleState, type HarnessV1Metadata, type HarnessV1NetworkPolicy, type HarnessV1NetworkSandboxSession, type HarnessV1Observability, type HarnessV1PendingToolApproval, type HarnessV1PermissionMode, type HarnessV1Prompt, type HarnessV1PromptControl, type HarnessV1PromptTurnOptions, type HarnessV1ResumeSessionState, type HarnessV1SandboxProvider, type HarnessV1Session, type HarnessV1Skill, type HarnessV1StartOptions, type HarnessV1StreamPart, type HarnessV1ToolSpec, commonTool, getHarnessV1BuiltinToolFilteringDenialReason, harnessV1BridgeAbortInboundSchema, harnessV1BridgeBuiltinToolFilteringSchema, harnessV1BridgeDebugEventSchema, harnessV1BridgeDetachInboundSchema, harnessV1BridgeDetachSchema, harnessV1BridgeHelloSchema, harnessV1BridgeInboundCommandSchemas, harnessV1BridgeOutboundMessageSchema, harnessV1BridgePermissionModeSchema, harnessV1BridgeReadySchema, harnessV1BridgeResumeInboundSchema, harnessV1BridgeSandboxLogSchema, harnessV1BridgeShutdownInboundSchema, harnessV1BridgeStartBaseSchema, harnessV1BridgeThreadSchema, harnessV1BridgeToolApprovalResponseInboundSchema, harnessV1BridgeToolResultInboundSchema, harnessV1BridgeToolWireSchema, harnessV1BridgeUserMessageInboundSchema, harnessV1DebugConfigSchema, harnessV1DebugLevelSchema, harnessV1DiagnosticFromBridgeFrame, harnessV1ErrorPartSchema, harnessV1FileChangePartSchema, harnessV1FinishPartSchema, harnessV1FinishStepPartSchema, harnessV1RawPartSchema, harnessV1ReasoningDeltaPartSchema, harnessV1ReasoningEndPartSchema, harnessV1ReasoningStartPartSchema, harnessV1StreamPartSchema, harnessV1StreamStartPartSchema, harnessV1TextDeltaPartSchema, harnessV1TextEndPartSchema, harnessV1TextStartPartSchema, harnessV1ToolApprovalRequestPartSchema, harnessV1ToolCallPartSchema, harnessV1ToolResultPartSchema, isHarnessV1BuiltinToolIncluded };
+export { HARNESS_V1_BUILTIN_TOOLS, HARNESS_V1_BUILTIN_TOOL_NAMES, HarnessCapabilityUnsupportedError, HarnessError, type HarnessV1, type HarnessV1Bootstrap, type HarnessV1BootstrapCommand, type HarnessV1BootstrapFile, type HarnessV1BridgeDebugEvent, type HarnessV1BridgeOutboundMessage, type HarnessV1BridgeReady, type HarnessV1BridgeSandboxLog, type HarnessV1BridgeToolWire, type HarnessV1BuiltinTool, type HarnessV1BuiltinToolFiltering, type HarnessV1BuiltinToolName, type HarnessV1BuiltinToolUseKind, type HarnessV1CallWarning, type HarnessV1ContinueTurnOptions, type HarnessV1ContinueTurnState, type HarnessV1DebugConfig, type HarnessV1DebugLevel, type HarnessV1Diagnostic, type HarnessV1LifecycleState, type HarnessV1Metadata, type HarnessV1NetworkPolicy, type HarnessV1NetworkSandboxSession, type HarnessV1Observability, type HarnessV1PendingToolApproval, type HarnessV1PendingToolResult, type HarnessV1PermissionMode, type HarnessV1Prompt, type HarnessV1PromptControl, type HarnessV1PromptTurnOptions, type HarnessV1ResumeSessionState, type HarnessV1SandboxProvider, type HarnessV1Session, type HarnessV1Skill, type HarnessV1StartOptions, type HarnessV1StreamPart, type HarnessV1ToolSpec, commonTool, getHarnessV1BuiltinToolFilteringDenialReason, harnessV1BridgeAbortInboundSchema, harnessV1BridgeBuiltinToolFilteringSchema, harnessV1BridgeDebugEventSchema, harnessV1BridgeDetachInboundSchema, harnessV1BridgeDetachSchema, harnessV1BridgeHelloSchema, harnessV1BridgeInboundCommandSchemas, harnessV1BridgeOutboundMessageSchema, harnessV1BridgePermissionModeSchema, harnessV1BridgeReadySchema, harnessV1BridgeResumeInboundSchema, harnessV1BridgeSandboxLogSchema, harnessV1BridgeShutdownInboundSchema, harnessV1BridgeStartBaseSchema, harnessV1BridgeThreadSchema, harnessV1BridgeToolApprovalResponseInboundSchema, harnessV1BridgeToolResultInboundSchema, harnessV1BridgeToolWireSchema, harnessV1BridgeUserMessageInboundSchema, harnessV1DebugConfigSchema, harnessV1DebugLevelSchema, harnessV1DiagnosticFromBridgeFrame, harnessV1ErrorPartSchema, harnessV1FileChangePartSchema, harnessV1FinishPartSchema, harnessV1FinishStepPartSchema, harnessV1RawPartSchema, harnessV1ReasoningDeltaPartSchema, harnessV1ReasoningEndPartSchema, harnessV1ReasoningStartPartSchema, harnessV1StreamPartSchema, harnessV1StreamStartPartSchema, harnessV1TextDeltaPartSchema, harnessV1TextEndPartSchema, harnessV1TextStartPartSchema, harnessV1ToolApprovalRequestPartSchema, harnessV1ToolCallPartSchema, harnessV1ToolResultPartSchema, isHarnessV1BuiltinToolIncluded };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -45,8 +45,8 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.3",
-    "@ai-sdk/provider-utils": "5.0.11",
-    "ai": "7.0.31"
+    "@ai-sdk/provider-utils": "5.0.12",
+    "ai": "7.0.33"
   },
   "peerDependencies": {
     "ws": "^8.21.0",

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

@@ -11,11 +11,13 @@ import type {
   HarnessAgentAdapterSession,
   HarnessAgentContinueTurnState,
   HarnessAgentPendingToolApproval,
+  HarnessAgentPendingToolResult,
   HarnessAgentPrompt,
   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 { releaseBridgePort } from './internal/bridge-port-registry';
 import { validateLifecycleStateData } from './internal/lifecycle-state-validation';
 import { runPrompt } from './internal/run-prompt';
@@ -34,6 +36,7 @@ type HarnessAgentTurnState =
   | 'idle'
   | 'running'
   | 'awaiting-approval'
+  | 'awaiting-tool-result'
   | 'suspended';
 
 /**
@@ -71,6 +74,10 @@ export class HarnessAgentSession {
     string,
     HarnessAgentPendingToolApproval
   >();
+  private readonly pendingToolResults = new Map<
+    string,
+    HarnessAgentPendingToolResult
+  >();
   private sessionState: HarnessAgentSessionState = 'active';
   private turnState: HarnessAgentTurnState;
   private turnSequence = 0;
@@ -92,6 +99,7 @@ export class HarnessAgentSession {
     sessionWorkDir: string;
     toolApproval: HarnessAgentToolApprovalConfiguration | undefined;
     pendingToolApprovals?: readonly HarnessAgentPendingToolApproval[];
+    pendingToolResults?: readonly HarnessAgentPendingToolResult[];
     turnState?: HarnessAgentTurnState;
   }) {
     this.sessionId = options.sessionId;
@@ -105,9 +113,16 @@ export class HarnessAgentSession {
     for (const approval of options.pendingToolApprovals ?? []) {
       this.pendingToolApprovals.set(approval.approvalId, approval);
     }
+    for (const pendingResult of options.pendingToolResults ?? []) {
+      this.pendingToolResults.set(pendingResult.toolCallId, pendingResult);
+    }
     this.turnState =
       options.turnState ??
-      (this.pendingToolApprovals.size > 0 ? 'awaiting-approval' : 'idle');
+      (this.pendingToolApprovals.size > 0
+        ? 'awaiting-approval'
+        : this.pendingToolResults.size > 0
+          ? 'awaiting-tool-result'
+          : 'idle');
     this.isResume = options.underlyingSession.isResume;
   }
 
@@ -135,6 +150,10 @@ export class HarnessAgentSession {
     return this.sessionWorkDir;
   }
 
+  hasUnfinishedTurn(): boolean {
+    return this.turnState !== 'idle';
+  }
+
   promptTurn<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context>(options: {
     prompt: HarnessAgentPrompt;
     instructions: string | undefined;
@@ -167,6 +186,7 @@ export class HarnessAgentSession {
         telemetry: options.telemetry,
         toolApproval: this.toolApproval,
         pendingToolApprovals: this.getPendingToolApprovals(),
+        pendingToolResults: this.getPendingToolResults(),
         onPendingToolApproval: approval => {
           this.pendingToolApprovals.set(approval.approvalId, approval);
           this.markAwaitingApprovalIfActive();
@@ -174,11 +194,20 @@ export class HarnessAgentSession {
         onToolApprovalSettled: approvalId => {
           this.pendingToolApprovals.delete(approvalId);
         },
+        onPendingToolResult: pendingResult => {
+          this.pendingToolResults.set(pendingResult.toolCallId, pendingResult);
+          this.markAwaitingToolResultIfActive();
+        },
+        onToolResultSettled: toolCallId => {
+          this.pendingToolResults.delete(toolCallId);
+        },
         onTurnFinished: () => {
           this.finishTrackedTurn({ turnId });
         },
+        onTurnFailed: () => {
+          this.finishTrackedTurn({ turnId });
+        },
       });
-      this.trackTurnCompletion({ done: turn.done, turnId });
       return turn;
     } catch (error) {
       this.finishTrackedTurn({ turnId });
@@ -201,6 +230,9 @@ export class HarnessAgentSession {
     toolApprovalContinuations?:
       | readonly HarnessAgentToolApprovalContinuation[]
       | undefined;
+    toolResultContinuations?:
+      | readonly HarnessAgentToolResultContinuation[]
+      | undefined;
   }): HarnessAgentTurnResult<TOOLS, RUNTIME_CONTEXT> {
     const session = this.requireReusableSession();
     this.requireContinuableTurn();
@@ -223,7 +255,9 @@ export class HarnessAgentSession {
         telemetry: options.telemetry,
         toolApproval: this.toolApproval,
         pendingToolApprovals: this.getPendingToolApprovals(),
+        pendingToolResults: this.getPendingToolResults(),
         toolApprovalContinuations: options.toolApprovalContinuations,
+        toolResultContinuations: options.toolResultContinuations,
         onPendingToolApproval: approval => {
           this.pendingToolApprovals.set(approval.approvalId, approval);
           this.markAwaitingApprovalIfActive();
@@ -231,11 +265,20 @@ export class HarnessAgentSession {
         onToolApprovalSettled: approvalId => {
           this.pendingToolApprovals.delete(approvalId);
         },
+        onPendingToolResult: pendingResult => {
+          this.pendingToolResults.set(pendingResult.toolCallId, pendingResult);
+          this.markAwaitingToolResultIfActive();
+        },
+        onToolResultSettled: toolCallId => {
+          this.pendingToolResults.delete(toolCallId);
+        },
         onTurnFinished: () => {
           this.finishTrackedTurn({ turnId });
         },
+        onTurnFailed: () => {
+          this.finishTrackedTurn({ turnId });
+        },
       });
-      this.trackTurnCompletion({ done: turn.done, turnId });
       return turn;
     } catch (error) {
       this.finishTrackedTurn({ turnId });
@@ -382,11 +425,16 @@ export class HarnessAgentSession {
     return Array.from(this.pendingToolApprovals.values());
   }
 
-  private addPendingToolApprovals(
+  private getPendingToolResults(): readonly HarnessAgentPendingToolResult[] {
+    return Array.from(this.pendingToolResults.values());
+  }
+
+  private addPendingToolState(
     state: HarnessAgentContinueTurnState,
   ): HarnessAgentContinueTurnState {
     const pendingToolApprovals = this.getPendingToolApprovals();
-    if (pendingToolApprovals.length === 0) {
+    const pendingToolResults = this.getPendingToolResults();
+    if (pendingToolApprovals.length === 0 && pendingToolResults.length === 0) {
       return {
         type: state.type,
         harnessId: state.harnessId,
@@ -396,7 +444,8 @@ export class HarnessAgentSession {
     }
     return {
       ...state,
-      pendingToolApprovals,
+      ...(pendingToolApprovals.length > 0 ? { pendingToolApprovals } : {}),
+      ...(pendingToolResults.length > 0 ? { pendingToolResults } : {}),
     };
   }
 
@@ -410,7 +459,7 @@ export class HarnessAgentSession {
       expectedType: 'continue-turn',
     });
     this.turnState = 'suspended';
-    return this.addPendingToolApprovals(validated);
+    return this.addPendingToolState(validated);
   }
 
   private toResumeStateWithContinuation(options: {
@@ -441,6 +490,7 @@ export class HarnessAgentSession {
   private requireContinuableTurn(): void {
     if (
       this.turnState === 'awaiting-approval' ||
+      this.turnState === 'awaiting-tool-result' ||
       this.turnState === 'suspended'
     ) {
       return;
@@ -461,6 +511,12 @@ export class HarnessAgentSession {
     }
   }
 
+  private markAwaitingToolResultIfActive(): void {
+    if (this.sessionState === 'active') {
+      this.turnState = 'awaiting-tool-result';
+    }
+  }
+
   private startTrackedTurn(): number {
     const turnId = ++this.turnSequence;
     this.activeTurnSequence = turnId;
@@ -468,22 +524,12 @@ export class HarnessAgentSession {
     return turnId;
   }
 
-  private trackTurnCompletion(options: {
-    done: Promise<void>;
-    turnId: number;
-  }): void {
-    void Promise.resolve(options.done)
-      .finally(() => {
-        this.finishTrackedTurn({ turnId: options.turnId });
-      })
-      .catch(() => {});
-  }
-
   private finishTrackedTurn(options: { turnId: number }): void {
     if (this.sessionState !== 'active') return;
     if (this.activeTurnSequence !== options.turnId) return;
-    this.turnState =
-      this.pendingToolApprovals.size > 0 ? 'awaiting-approval' : 'idle';
+    this.pendingToolApprovals.clear();
+    this.pendingToolResults.clear();
+    this.turnState = 'idle';
   }
 
   private endLocalHandle(options: {

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

@@ -0,0 +1,62 @@
+import type { ModelMessage, ToolResultOutput } from '@ai-sdk/provider-utils';
+
+export type HarnessAgentToolResultContinuation = {
+  readonly toolCallId: string;
+  readonly output: unknown;
+  readonly isError?: boolean;
+};
+
+/**
+ * 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.
+ */
+export function collectHarnessAgentToolResultContinuations(input: {
+  messages: readonly ModelMessage[];
+}): readonly HarnessAgentToolResultContinuation[] {
+  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,
+      };
+  }
+}

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

@@ -9,6 +9,7 @@ import type {
   HarnessV1ContinueTurnState,
   HarnessV1LifecycleState,
   HarnessV1PendingToolApproval,
+  HarnessV1PendingToolResult,
   HarnessV1PermissionMode,
   HarnessV1Prompt,
   HarnessV1PromptControl,
@@ -45,6 +46,7 @@ export type HarnessAgentLifecycleState = HarnessV1LifecycleState;
 export type HarnessAgentResumeSessionState = HarnessV1ResumeSessionState;
 export type HarnessAgentContinueTurnState = HarnessV1ContinueTurnState;
 export type HarnessAgentPendingToolApproval = HarnessV1PendingToolApproval;
+export type HarnessAgentPendingToolResult = HarnessV1PendingToolResult;
 
 export type HarnessAgentSkill = HarnessV1Skill;
 export type HarnessAgentPermissionMode = HarnessV1PermissionMode;

package/src/agent/harness-agent.ts

@@ -39,6 +39,10 @@ import {
   collectHarnessAgentToolApprovalContinuations,
   type HarnessAgentToolApprovalContinuation,
 } from './harness-agent-tool-approval-continuation';
+import {
+  collectHarnessAgentToolResultContinuations,
+  type HarnessAgentToolResultContinuation,
+} from './harness-agent-tool-result-continuation';
 import { applyBootstrapRecipe } from './internal/bootstrap-recipe';
 import {
   acquireBridgePort,
@@ -348,13 +352,17 @@ export class HarnessAgent<
         sessionWorkDir,
         toolApproval: this.settings.toolApproval,
         pendingToolApprovals: effectiveContinueFrom?.pendingToolApprovals,
+        pendingToolResults: effectiveContinueFrom?.pendingToolResults,
         turnState:
           effectiveContinueFrom == null
             ? 'idle'
             : effectiveContinueFrom.pendingToolApprovals != null &&
                 effectiveContinueFrom.pendingToolApprovals.length > 0
               ? 'awaiting-approval'
-              : 'suspended',
+              : effectiveContinueFrom.pendingToolResults != null &&
+                  effectiveContinueFrom.pendingToolResults.length > 0
+                ? 'awaiting-tool-result'
+                : 'suspended',
       });
     } catch (error) {
       await cleanupAfterStartFailure({
@@ -426,6 +434,7 @@ export class HarnessAgent<
   async continueGenerate(options: {
     session: HarnessAgentSession;
     toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
+    toolResultContinuations?: readonly HarnessAgentToolResultContinuation[];
     abortSignal?: AbortSignal;
   }): Promise<
     GenerateTextResult<
@@ -441,6 +450,7 @@ export class HarnessAgent<
       turnInput: {
         mode: 'continue',
         toolApprovalContinuations: options.toolApprovalContinuations ?? [],
+        toolResultContinuations: options.toolResultContinuations ?? [],
       },
       runtimeContext,
       abortSignal: options.abortSignal,
@@ -460,6 +470,7 @@ export class HarnessAgent<
   async continueStream(options: {
     session: HarnessAgentSession;
     toolApprovalContinuations?: readonly HarnessAgentToolApprovalContinuation[];
+    toolResultContinuations?: readonly HarnessAgentToolResultContinuation[];
     abortSignal?: AbortSignal;
   }): Promise<
     StreamTextResult<
@@ -475,6 +486,7 @@ export class HarnessAgent<
       turnInput: {
         mode: 'continue',
         toolApprovalContinuations: options.toolApprovalContinuations ?? [],
+        toolResultContinuations: options.toolResultContinuations ?? [],
       },
       runtimeContext,
       abortSignal: options.abortSignal,
@@ -491,6 +503,7 @@ export class HarnessAgent<
       | {
           mode: 'continue';
           toolApprovalContinuations: readonly HarnessAgentToolApprovalContinuation[];
+          toolResultContinuations: readonly HarnessAgentToolResultContinuation[];
         };
     runtimeContext: RUNTIME_CONTEXT;
     abortSignal: AbortSignal | undefined;
@@ -516,6 +529,7 @@ export class HarnessAgent<
         abortSignal: input.abortSignal,
         telemetry: this.settings.telemetry,
         toolApprovalContinuations: input.turnInput.toolApprovalContinuations,
+        toolResultContinuations: input.turnInput.toolResultContinuations,
       });
     }
 
@@ -579,6 +593,7 @@ export class HarnessAgent<
     | {
         mode: 'continue';
         toolApprovalContinuations: readonly HarnessAgentToolApprovalContinuation[];
+        toolResultContinuations: readonly HarnessAgentToolResultContinuation[];
       } {
     if (typeof options.prompt === 'string') {
       return { mode: 'prompt', prompt: options.prompt };
@@ -589,10 +604,16 @@ export class HarnessAgent<
     if (Array.isArray(messages)) {
       const toolApprovalContinuations =
         collectHarnessAgentToolApprovalContinuations({ messages });
-      if (toolApprovalContinuations.length > 0) {
+      const toolResultContinuations =
+        collectHarnessAgentToolResultContinuations({ messages });
+      if (
+        toolApprovalContinuations.length > 0 ||
+        toolResultContinuations.length > 0
+      ) {
         return {
           mode: 'continue',
           toolApprovalContinuations,
+          toolResultContinuations,
         };
       }
       for (let i = messages.length - 1; i >= 0; i--) {

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

@@ -141,6 +141,7 @@ export class HarnessStreamTextResult<
   private currentStepContent: ContentPart<TOOLS>[] = [];
   private currentStepWarnings: CallWarning[] = [];
   private stepNumber = 0;
+  private stepStarted = false;
 
   private readonly tools: TOOLS;
   private readonly runtimeContext: RUNTIME_CONTEXT;
@@ -173,6 +174,13 @@ export class HarnessStreamTextResult<
     const baseStream = new ReadableStream<TextStreamPart<TOOLS>>({
       start(c) {
         controllerRef = c;
+        // Send the message-level start event as the first part, mirroring
+        // `streamText`. Downstream UI message stream consumers depend on it:
+        // `toUIMessageStream`'s persistence mode injects the response message
+        // id into this part (it never synthesizes one), so without it
+        // `useChat` clients keep a locally generated assistant message id
+        // that diverges from the id the server persists under.
+        c.enqueue({ type: 'start' });
       },
     });
     this.fullStreamController = controllerRef;
@@ -198,10 +206,30 @@ export class HarnessStreamTextResult<
    * into the current step's content array where applicable.
    */
   enqueue(part: TextStreamPart<TOOLS>): void {
+    this.startStep();
     this.fullStreamController.enqueue(part);
     this.appendToCurrentStepContent(part);
   }
 
+  /**
+   * Push a continuation input into the consumer stream without attributing it
+   * to the next model step. Approval responses and client tool results arrive
+   * between model calls and therefore must not create or alter a StepResult.
+   */
+  enqueueContinuation(part: TextStreamPart<TOOLS>): void {
+    this.fullStreamController.enqueue(part);
+  }
+
+  /**
+   * Drop content replayed while a suspended host-input pause closes its
+   * already-recorded model step.
+   */
+  discardCurrentStepContent(): void {
+    this.currentStepContent = [];
+    this.currentStepWarnings = [];
+    this.stepStarted = false;
+  }
+
   /**
    * Mark the end of a step. Builds a `StepResult` from the accumulated
    * content and records it in the steps array. Accepts the V4-shaped
@@ -213,7 +241,9 @@ export class HarnessStreamTextResult<
     usage: LanguageModelV4Usage;
     providerMetadata: ProviderMetadata | undefined;
     warnings: CallWarning[];
-  }): void {
+  }): StepResult<TOOLS, RUNTIME_CONTEXT> {
+    this.startStep();
+
     const normalizedUsage = asLanguageModelUsage(input.usage);
     const finishReason = input.finishReason.unified;
     const rawFinishReason = input.finishReason.raw;
@@ -267,6 +297,20 @@ export class HarnessStreamTextResult<
     this.stepNumber += 1;
     this.currentStepContent = [];
     this.currentStepWarnings = [];
+    this.stepStarted = false;
+
+    return step;
+  }
+
+  private startStep(): void {
+    if (this.stepStarted) return;
+
+    this.stepStarted = true;
+    this.fullStreamController.enqueue({
+      type: 'start-step',
+      request: {},
+      warnings: this.currentStepWarnings,
+    } as TextStreamPart<TOOLS>);
   }
 
   /**
@@ -278,7 +322,20 @@ export class HarnessStreamTextResult<
     providerMetadata: ProviderMetadata | undefined;
   }): Promise<void> {
     if (this.settled) return;
-    this.settled = true;
+
+    /*
+     * Do not flush trailing content that has not been captured by a
+     * `finish-step`. A terminal `finish` closes the turn but is not a semantic
+     * step boundary, so buffered content indicates an invalid harness stream.
+     */
+    if (this.currentStepContent.length > 0) {
+      this.fail(
+        new Error(
+          'HarnessAgent: received terminal finish with unclosed step content. Harness adapters must emit `finish-step` before `finish`.',
+        ),
+      );
+      return;
+    }
 
     if (input != null) {
       this.finalFinishReason = input.finishReason.unified;
@@ -287,39 +344,7 @@ export class HarnessStreamTextResult<
       this.accumulatedUsage = asLanguageModelUsage(input.totalUsage);
     }
 
-    // Flush any trailing content not yet captured by a finish-step. We
-    // construct the step directly here (the public `finishStep` takes V4
-    // shapes; we already have AI SDK shapes at this point).
-    if (this.currentStepContent.length > 0) {
-      const trailingStep = new DefaultStepResult<TOOLS, RUNTIME_CONTEXT>({
-        callId: generateId(),
-        stepNumber: this.stepNumber,
-        provider: this.providerName,
-        modelId: this.modelId,
-        runtimeContext: this.runtimeContext,
-        toolsContext: this.toolsContext,
-        content: this.currentStepContent,
-        finishReason: this.finalFinishReason,
-        rawFinishReason: this.finalRawFinishReason,
-        usage: createNullLanguageModelUsage(),
-        performance: createEmptyPerformance(),
-        warnings:
-          this.currentStepWarnings.length > 0
-            ? this.currentStepWarnings
-            : undefined,
-        request: {},
-        response: {
-          id: generateId(),
-          timestamp: new Date(),
-          modelId: this.modelId,
-          messages: [],
-        },
-        providerMetadata: this.finalProviderMetadata,
-      });
-      this.stepsBuffer.push(trailingStep);
-      this.currentStepContent = [];
-      this.currentStepWarnings = [];
-    }
+    this.settled = true;
 
     const finalStep =
       this.stepsBuffer.length > 0

package/src/agent/internal/lifecycle-state-validation.ts

@@ -46,6 +46,16 @@ export async function validateLifecycleStateData<
         'Resume session state cannot contain pending tool approvals; unfinished turns must be stored as `continueFrom`.',
     });
   }
+  if (
+    state.type === 'resume-session' &&
+    'pendingToolResults' in state &&
+    state.pendingToolResults !== undefined
+  ) {
+    throw new HarnessError({
+      message:
+        'Resume session state cannot contain pending tool results; unfinished turns must be stored as `continueFrom`.',
+    });
+  }
 
   const data =
     harness.lifecycleStateSchema == null
@@ -91,5 +101,8 @@ export async function validateLifecycleStateData<
     ...(state.pendingToolApprovals !== undefined
       ? { pendingToolApprovals: state.pendingToolApprovals }
       : {}),
+    ...(state.pendingToolResults !== undefined
+      ? { pendingToolResults: state.pendingToolResults }
+      : {}),
   } as STATE;
 }