@ai-sdk/harness 1.0.41 → 1.0.43

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

@@ -103,6 +103,11 @@ export function runPrompt<
   onToolResultSettled?: (toolCallId: string) => void;
   onTurnFinished?: () => void;
   onTurnFailed?: () => void;
+  /**
+   * Reports that the adapter stream closed because the host intentionally
+   * suspended the still-running turn at a workflow slice boundary.
+   */
+  isTurnSuspending?: () => boolean;
   onStopConditionMet?: () => Promise<void>;
 }): {
   result: HarnessStreamTextResult<TOOLS, RUNTIME_CONTEXT>;
@@ -140,10 +145,13 @@ export function runPrompt<
    * `toUIMessageStream` consumers observe an `abort` chunk and
    * `isAborted: true` instead of a spurious `onError`. Every other failure
    * stays a real `error` part. Both outcomes notify `onTurnFailed` so the
-   * session's turn tracking returns to idle and the session stays usable.
+   * session's turn tracking returns to idle and the session stays usable,
+   * unless the turn is being suspended for a future continuation.
    */
   const settleFailure = (err: unknown) => {
-    input.onTurnFailed?.();
+    if (!input.isTurnSuspending?.()) {
+      input.onTurnFailed?.();
+    }
     if (input.abortSignal?.aborted) {
       result.abort({
         error: err,
@@ -908,7 +916,18 @@ export function runPrompt<
           await telemetry.toolEnd(toolCall.toolCallId, execution.outcome);
         }
       }
-      if (finalFinish != null) {
+      const isTurnSuspending = input.isTurnSuspending?.() === true;
+      if (isTurnSuspending) {
+        if (finalFinish == null) {
+          /*
+           * A timed slice may stop in the middle of a model step. Its partial
+           * content remains in the bridge replay log for the next slice, but it
+           * cannot form a valid StepResult in this slice because no finish-step
+           * has arrived yet.
+           */
+          result.discardCurrentStepContent();
+        }
+      } else if (finalFinish != null) {
         input.onTurnFinished?.();
       } else {
         input.onTurnFailed?.();

package/src/agent/internal/turn-telemetry.ts

@@ -1,6 +1,6 @@
 import { generateId, type ModelMessage } from '@ai-sdk/provider-utils';
 import { createTelemetryDispatcher } from 'ai/internal';
-import type { TelemetryOptions } from 'ai';
+import type { LanguageModelUsage, TelemetryOptions } from 'ai';
 
 /*
  * Drives AI SDK's pluggable `Telemetry` lifecycle from a harness turn.
@@ -92,6 +92,69 @@ const NOOP: TurnTelemetry = {
   async error() {},
 };
 
+function normalizeFinishReason(finishReason: unknown): unknown {
+  if (
+    finishReason != null &&
+    typeof finishReason === 'object' &&
+    'unified' in finishReason
+  ) {
+    return (finishReason as { unified: unknown }).unified;
+  }
+
+  return finishReason;
+}
+
+function addTokenCounts(
+  tokenCount1: number | undefined,
+  tokenCount2: number | undefined,
+): number | undefined {
+  return tokenCount1 == null && tokenCount2 == null
+    ? undefined
+    : (tokenCount1 ?? 0) + (tokenCount2 ?? 0);
+}
+
+function normalizeUsage(usage: unknown): LanguageModelUsage | unknown {
+  if (
+    usage == null ||
+    typeof usage !== 'object' ||
+    !('inputTokens' in usage) ||
+    !('outputTokens' in usage)
+  ) {
+    return usage;
+  }
+
+  const inputTokens = (usage as { inputTokens: unknown }).inputTokens;
+  const outputTokens = (usage as { outputTokens: unknown }).outputTokens;
+
+  if (
+    inputTokens == null ||
+    typeof inputTokens !== 'object' ||
+    outputTokens == null ||
+    typeof outputTokens !== 'object'
+  ) {
+    return usage;
+  }
+
+  const input = inputTokens as Record<string, number | undefined>;
+  const output = outputTokens as Record<string, number | undefined>;
+
+  return {
+    inputTokens: input.total,
+    inputTokenDetails: {
+      noCacheTokens: input.noCache,
+      cacheReadTokens: input.cacheRead,
+      cacheWriteTokens: input.cacheWrite,
+    },
+    outputTokens: output.total,
+    outputTokenDetails: {
+      textTokens: output.text,
+      reasoningTokens: output.reasoning,
+    },
+    totalTokens: addTokenCounts(input.total, output.total),
+    raw: (usage as { raw?: LanguageModelUsage['raw'] }).raw,
+  };
+}
+
 export function createTurnTelemetry(opts: {
   telemetry: TelemetryOptions | undefined;
   harnessId: string;
@@ -119,6 +182,15 @@ export function createTurnTelemetry(opts: {
   let stepOpen = false;
   let stepNumber = 0;
   let ended = false;
+  let finalStepText = '';
+  let finalStepReasoning: Array<{ text: string }> = [];
+  let finalStepProviderMetadata: unknown;
+  let outputToolCalls: Array<{
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+  }> = [];
   /** Tool calls started in the current turn and not yet ended. */
   const openTools = new Map<
     string,
@@ -200,17 +272,40 @@ export function createTurnTelemetry(opts: {
     usage: unknown;
     content: TurnContentPart[];
   }): Promise<void> => {
+    const finishReason = normalizeFinishReason(info.finishReason);
+    const usage = normalizeUsage(info.usage);
+
     await dispatcher.onLanguageModelCallEnd?.(
       cast<'onLanguageModelCallEnd'>({
         callId,
-        finishReason: info.finishReason,
+        finishReason,
         responseId: callId,
-        usage: info.usage,
+        usage,
         content: info.content,
+        performance: {
+          responseTimeMs: undefined,
+          timeToFirstOutputMs: undefined,
+          timeBetweenOutputChunksMs: undefined,
+        },
       }),
     );
   };
 
+  const recordOutputContent = (content: TurnContentPart[]): void => {
+    finalStepText = '';
+    finalStepReasoning = [];
+
+    for (const part of content) {
+      if (part.type === 'text') {
+        finalStepText += part.text;
+      } else if (part.type === 'reasoning') {
+        finalStepReasoning.push({ text: part.text });
+      } else if (part.type === 'tool-call') {
+        outputToolCalls.push(part);
+      }
+    }
+  };
+
   const closeOpenTools = async (): Promise<void> => {
     for (const call of openTools.values()) {
       await dispatcher.onToolExecutionEnd?.(
@@ -240,18 +335,22 @@ export function createTurnTelemetry(opts: {
     async stepFinish(info) {
       if (!stepOpen) return;
       const content = info.content ?? [];
+      const finishReason = normalizeFinishReason(info.finishReason);
+      const usage = normalizeUsage(info.usage);
+      recordOutputContent(content);
+      finalStepProviderMetadata = info.providerMetadata;
       await closeOpenTools();
       await inferenceEnd({
-        finishReason: info.finishReason,
-        usage: info.usage,
+        finishReason,
+        usage,
         content,
       });
       await dispatcher.onStepEnd?.(
         cast<'onStepEnd'>({
           callId,
           stepNumber,
-          finishReason: info.finishReason,
-          usage: info.usage,
+          finishReason,
+          usage,
           providerMetadata: info.providerMetadata,
           content,
           response: {
@@ -293,6 +392,9 @@ export function createTurnTelemetry(opts: {
 
     async toolEnd(toolCallId, output) {
       const call = openTools.get(toolCallId);
+      const normalizedOutput = output.ok
+        ? { type: 'tool-result' as const, output: output.output }
+        : { type: 'error' as const, error: output.error };
       if (call == null) return;
       openTools.delete(toolCallId);
       await dispatcher.onToolExecutionEnd?.(
@@ -308,29 +410,29 @@ export function createTurnTelemetry(opts: {
             dynamic: true,
           },
           toolContext: undefined,
-          toolOutput: output.ok
-            ? { type: 'tool-result', output: output.output }
-            : { type: 'error', error: output.error },
+          toolOutput: normalizedOutput,
         }),
       );
     },
 
     async end(info) {
       if (ended) return;
+      const finishReason = normalizeFinishReason(info.finishReason);
+      const usage = normalizeUsage(info.usage);
       if (!started) await fireStart();
       if (stepOpen) {
         await closeOpenTools();
         await inferenceEnd({
-          finishReason: info.finishReason,
-          usage: info.usage,
+          finishReason,
+          usage,
           content: [],
         });
         await dispatcher.onStepEnd?.(
           cast<'onStepEnd'>({
             callId,
             stepNumber,
-            finishReason: info.finishReason,
-            usage: info.usage,
+            finishReason,
+            usage,
             providerMetadata: undefined,
             content: [],
             response: {
@@ -348,10 +450,17 @@ export function createTurnTelemetry(opts: {
         cast<'onEnd'>({
           callId,
           operationId: 'ai.harness',
-          finishReason: info.finishReason,
-          usage: info.usage,
-          totalUsage: info.usage,
+          finishReason,
+          usage,
+          totalUsage: usage,
           content: [],
+          text: finalStepText,
+          finalStep: {
+            reasoning: finalStepReasoning,
+            providerMetadata: finalStepProviderMetadata,
+          },
+          toolCalls: outputToolCalls,
+          files: [],
           steps: new Array(stepNumber),
           response: {
             id: callId,

package/src/bridge/index.ts

@@ -120,13 +120,6 @@ export interface BridgeTurn {
   /** Aborts when the host sends `abort`. */
   readonly abortSignal: AbortSignal;
 
-  /**
-   * Register the runtime-specific interrupt hook for this active turn. The
-   * shared bridge invokes it when the host sends `interrupt`, then acknowledges
-   * only after the hook settles.
-   */
-  onInterrupt(handler: () => void | Promise<void>): void;
-
   /** True for the first turn since this bridge process started. */
   readonly firstTurn: boolean;
 
@@ -191,7 +184,6 @@ type InboundControl =
     }
   | { type: 'user-message'; text: string }
   | { type: 'abort' }
-  | { type: 'interrupt' }
   | { type: 'shutdown' }
   | { type: 'detach' }
   | { type: 'resume'; lastSeenEventId: number };
@@ -238,7 +230,6 @@ export async function runBridge<TStart extends { type: 'start' }>(
   let isFirstTurn = true;
   let turnAbort: AbortController | undefined;
   let currentUserMessages: string[] | undefined;
-  let currentInterruptHandler: (() => void | Promise<void>) | undefined;
 
   // Diagnostics. Resolved per turn from `start.debug` with a sandbox-side
   // env fallback; gates console capture + structured `debug-event`s.
@@ -259,7 +250,7 @@ export async function runBridge<TStart extends { type: 'start' }>(
    * Disk mirror of the in-memory replay log. The in-memory log is lost when the
    * bridge process dies; the on-disk `event-log.ndjson` survives in the sandbox
    * filesystem so a respawned bridge (started with `BRIDGE_REPLAY_FROM_DISK=1`)
-   * can reload the just-interrupted turn and serve a host's resume cursor —
+   * can reload the in-flight turn and serve a host's resume cursor —
    * `replay` recovery. Writes are batched on `setImmediate` (single-flight via
    * `flushPromise`) to keep `emit` off the disk hot path.
    */
@@ -537,7 +528,6 @@ export async function runBridge<TStart extends { type: 'start' }>(
         void writeFile(eventLogPath, '').catch(() => {});
         turnAbort = new AbortController();
         currentTurnState = 'running';
-        currentInterruptHandler = undefined;
         void writeStartConfig(msg);
         void writeBridgeMeta('running');
         const startDebug = (msg as { debug?: BridgeDebugConfig }).debug;
@@ -565,9 +555,6 @@ export async function runBridge<TStart extends { type: 'start' }>(
             }),
           pendingUserMessages: [],
           abortSignal: turnAbort.signal,
-          onInterrupt: handler => {
-            currentInterruptHandler = handler;
-          },
           firstTurn,
           bridgeLog: input => {
             const level = input.level ?? 'debug';
@@ -592,7 +579,6 @@ export async function runBridge<TStart extends { type: 'start' }>(
         } catch (err) {
           emitError({ error: err, message: 'bridge turn failed' });
         } finally {
-          currentInterruptHandler = undefined;
           currentTurnState = 'waiting';
           void writeBridgeMeta('waiting');
         }
@@ -620,34 +606,6 @@ export async function runBridge<TStart extends { type: 'start' }>(
       case 'abort':
         turnAbort?.abort();
         return;
-      case 'interrupt':
-        try {
-          /*
-           * A bridge waiting for a host tool result or approval is already
-           * paused at a resumable boundary. Interrupting the native runtime at
-           * that point terminates the operation that owns the pending request,
-           * so a later host process cannot satisfy it. Active turns without
-           * pending host input are interrupted before suspension as usual.
-           */
-          if (
-            pendingToolResults.size === 0 &&
-            pendingToolApprovals.size === 0
-          ) {
-            if (currentInterruptHandler) {
-              await currentInterruptHandler();
-            } else {
-              turnAbort?.abort();
-            }
-          }
-          sendControl({ type: 'bridge-interrupted', ok: true });
-        } catch (err) {
-          sendControl({
-            type: 'bridge-interrupted',
-            ok: false,
-            error: serialiseError(err),
-          });
-        }
-        return;
       case 'resume':
         if (activeSocket !== ws) return;
         replay(ws, msg.lastSeenEventId);

package/src/utils/sandbox-channel.ts

@@ -277,62 +277,6 @@ export class SandboxChannel<
     this.enqueue(() => this.finalizeClose(1000, 'closed'));
   }
 
-  interrupt(options?: { timeoutMs?: number }): Promise<void> {
-    if (this.pinnedSuspensionCursor != null) {
-      return Promise.resolve();
-    }
-    const timeoutMs = options?.timeoutMs ?? 5000;
-    return new Promise<void>((resolve, reject) => {
-      let settled = false;
-      let unsub = (): void => {};
-      const timer = setTimeout(() => {
-        complete(
-          new Error(
-            `SandboxChannel: interrupt was not acknowledged within ${timeoutMs}ms.`,
-          ),
-        );
-      }, timeoutMs);
-      timer.unref?.();
-
-      const complete = (error?: unknown): void => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        unsub();
-        if (error) {
-          reject(error);
-        } else {
-          resolve();
-        }
-      };
-
-      unsub = this.on('bridge-interrupted' as EventTypeOf<TOut>, event => {
-        const response = event as unknown as {
-          type: 'bridge-interrupted';
-          ok: boolean;
-          error?: unknown;
-        };
-        if (response.ok) {
-          complete();
-          return;
-        }
-        complete(
-          new Error(
-            `SandboxChannel: interrupt failed: ${formatControlError(
-              response.error,
-            )}`,
-          ),
-        );
-      });
-
-      try {
-        this.send({ type: 'interrupt' } as TIn);
-      } catch (err) {
-        complete(err);
-      }
-    });
-  }
-
   /**
    * Gracefully suspend at a slice boundary: stop processing inbound frames
    * (so the cursor freezes at the last delivered event), drain any frames
@@ -571,13 +515,3 @@ export class SandboxChannel<
     for (const h of this.onCloseHandlers) h(code, reason);
   }
 }
-
-function formatControlError(error: unknown): string {
-  if (error instanceof Error) return error.message;
-  if (error && typeof error === 'object') {
-    const message = (error as { message?: unknown }).message;
-    if (typeof message === 'string' && message.length > 0) return message;
-  }
-  if (typeof error === 'string' && error.length > 0) return error;
-  return 'unknown error';
-}

package/src/v1/harness-v1-bridge-protocol.ts

@@ -140,17 +140,6 @@ export const harnessV1BridgeThreadSchema = z.object({
   threadId: z.string(),
 });
 
-/**
- * Acknowledgement for an inbound `interrupt` command. The host waits for this
- * before freezing its replay cursor so the adapter-specific interrupt has
- * actually reached the underlying runtime.
- */
-export const harnessV1BridgeInterruptedSchema = z.object({
-  type: z.literal('bridge-interrupted'),
-  ok: z.boolean(),
-  error: z.unknown().optional(),
-});
-
 // --- Diagnostics frames (outbound, not consumer events) ---
 
 /**
@@ -211,7 +200,6 @@ export const harnessV1BridgeOutboundMessageSchema = z.discriminatedUnion(
     harnessV1BridgeHelloSchema,
     harnessV1BridgeDetachSchema,
     harnessV1BridgeThreadSchema,
-    harnessV1BridgeInterruptedSchema,
     harnessV1BridgeSandboxLogSchema,
     harnessV1BridgeDebugEventSchema,
   ],
@@ -289,10 +277,6 @@ export const harnessV1BridgeAbortInboundSchema = z.object({
   type: z.literal('abort'),
 });
 
-export const harnessV1BridgeInterruptInboundSchema = z.object({
-  type: z.literal('interrupt'),
-});
-
 export const harnessV1BridgeShutdownInboundSchema = z.object({
   type: z.literal('shutdown'),
 });
@@ -324,7 +308,6 @@ export const harnessV1BridgeInboundCommandSchemas = [
   harnessV1BridgeToolApprovalResponseInboundSchema,
   harnessV1BridgeUserMessageInboundSchema,
   harnessV1BridgeAbortInboundSchema,
-  harnessV1BridgeInterruptInboundSchema,
   harnessV1BridgeShutdownInboundSchema,
   harnessV1BridgeResumeInboundSchema,
   harnessV1BridgeDetachInboundSchema,

package/src/v1/harness-v1-lifecycle-state.ts

@@ -53,7 +53,7 @@ export type HarnessV1ResumeSessionState = HarnessV1LifecycleStateBase & {
 /**
  * Opaque payload returned by `doSuspendTurn` and accepted by a future
  * `HarnessV1.doStart({ continueFrom })` to reconnect to the same session before
- * continuing the interrupted turn.
+ * continuing the suspended turn.
  */
 export type HarnessV1ContinueTurnState = HarnessV1LifecycleStateBase & {
   readonly type: 'continue-turn';

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

@@ -216,7 +216,7 @@ export type HarnessV1Session = {
   /**
    * Continue the in-flight turn **without a new user prompt**, returning the
    * same control surface as `doPromptTurn`. Used to keep consuming a turn that
-   * was interrupted at a process boundary (the workflow slice loop), after the
+   * was suspended at a process boundary (the workflow slice loop), after the
    * session itself has been resumed via `doStart({ continueFrom })`:
    *
    *  - When the runtime's turn is still live and reachable (bridge `attach` /
@@ -225,7 +225,7 @@ export type HarnessV1Session = {
    *  - When the live turn is gone (bridge respawned `rerun`, or a host-resident
    *    runtime like Pi whose turn cannot survive its process), the adapter
    *    re-drives the runtime's own thread from its persisted state. Lossy: work
-   *    in flight at the interruption is recomputed.
+   *    in flight at the suspension is recomputed.
    *
    * Required on every adapter. The behaviour an adapter can guarantee follows
    * from its architecture; the contract is uniform.

package/src/v1/harness-v1.ts

@@ -87,7 +87,7 @@ export type HarnessV1<TBuiltinTools extends ToolSet = ToolSet> = {
 
   /**
    * Start a fresh session, resume a parked session via `resumeFrom`, or resume
-   * an interrupted turn via `continueFrom`. The host then issues prompts against
+   * a suspended turn via `continueFrom`. The host then issues prompts against
    * the returned session, ending with `doDetach`, `doStop`, or `doDestroy`.
    */
   doStart(options: HarnessV1StartOptions): PromiseLike<HarnessV1Session>;