@ai-sdk/harness 1.0.42 → 1.0.44

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @ai-sdk/harness
 
+## 1.0.44
+
+### Patch Changes
+
+- Updated dependencies [7bd6bdd]
+- Updated dependencies [1e2f324]
+  - ai@7.0.38
+  - @ai-sdk/provider@4.0.4
+  - @ai-sdk/provider-utils@5.0.13
+
+## 1.0.43
+
+### Patch Changes
+
+- a9a22e1: fix(harness): fix telemetry end events to report `final-step` text and reasoning for multi-step turns
+- 9e4e816: fix(harness): avoid emitting `onTurnFinished` / `onTurnFailed` when turn is suspended mid-flight
+- ea3063f: fix(harness): remove broken bridge `channel.interrupt()` layer and its usage
+
 ## 1.0.42
 
 ### Patch Changes

package/dist/agent/index.d.ts

@@ -403,7 +403,7 @@ 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.
  */
 type HarnessV1ContinueTurnState = HarnessV1LifecycleStateBase & {
     readonly type: 'continue-turn';
@@ -783,7 +783,7 @@ 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` /
@@ -792,7 +792,7 @@ 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.
@@ -915,7 +915,7 @@ type HarnessV1<TBuiltinTools extends ToolSet = ToolSet> = {
     }) => PromiseLike<HarnessV1Bootstrap>;
     /**
      * 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>;

package/dist/agent/index.js

@@ -937,6 +937,42 @@ var NOOP = {
   async error() {
   }
 };
+function normalizeFinishReason(finishReason) {
+  if (finishReason != null && typeof finishReason === "object" && "unified" in finishReason) {
+    return finishReason.unified;
+  }
+  return finishReason;
+}
+function addTokenCounts(tokenCount1, tokenCount2) {
+  return tokenCount1 == null && tokenCount2 == null ? void 0 : (tokenCount1 != null ? tokenCount1 : 0) + (tokenCount2 != null ? tokenCount2 : 0);
+}
+function normalizeUsage(usage) {
+  if (usage == null || typeof usage !== "object" || !("inputTokens" in usage) || !("outputTokens" in usage)) {
+    return usage;
+  }
+  const inputTokens = usage.inputTokens;
+  const outputTokens = usage.outputTokens;
+  if (inputTokens == null || typeof inputTokens !== "object" || outputTokens == null || typeof outputTokens !== "object") {
+    return usage;
+  }
+  const input = inputTokens;
+  const output = outputTokens;
+  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.raw
+  };
+}
 function createTurnTelemetry(opts) {
   var _a3;
   if (opts.telemetry == null) return NOOP;
@@ -952,6 +988,10 @@ function createTurnTelemetry(opts) {
   let stepOpen = false;
   let stepNumber = 0;
   let ended = false;
+  let finalStepText = "";
+  let finalStepReasoning = [];
+  let finalStepProviderMetadata;
+  let outputToolCalls = [];
   const openTools = /* @__PURE__ */ new Map();
   const cast = (event) => event;
   const fireStart = async () => {
@@ -1020,17 +1060,37 @@ function createTurnTelemetry(opts) {
   };
   const inferenceEnd = async (info) => {
     var _a4;
+    const finishReason = normalizeFinishReason(info.finishReason);
+    const usage = normalizeUsage(info.usage);
     await ((_a4 = dispatcher.onLanguageModelCallEnd) == null ? void 0 : _a4.call(
       dispatcher,
       cast({
         callId,
-        finishReason: info.finishReason,
+        finishReason,
         responseId: callId,
-        usage: info.usage,
-        content: info.content
+        usage,
+        content: info.content,
+        performance: {
+          responseTimeMs: void 0,
+          timeToFirstOutputMs: void 0,
+          timeBetweenOutputChunksMs: void 0
+        }
       })
     ));
   };
+  const recordOutputContent = (content) => {
+    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 () => {
     var _a4;
     for (const call of openTools.values()) {
@@ -1061,10 +1121,14 @@ function createTurnTelemetry(opts) {
       var _a4, _b3;
       if (!stepOpen) return;
       const content = (_a4 = info.content) != null ? _a4 : [];
+      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 ((_b3 = dispatcher.onStepEnd) == null ? void 0 : _b3.call(
@@ -1072,8 +1136,8 @@ function createTurnTelemetry(opts) {
         cast({
           callId,
           stepNumber,
-          finishReason: info.finishReason,
-          usage: info.usage,
+          finishReason,
+          usage,
           providerMetadata: info.providerMetadata,
           content,
           response: {
@@ -1115,6 +1179,7 @@ function createTurnTelemetry(opts) {
     async toolEnd(toolCallId, output) {
       var _a4;
       const call = openTools.get(toolCallId);
+      const normalizedOutput = output.ok ? { type: "tool-result", output: output.output } : { type: "error", error: output.error };
       if (call == null) return;
       openTools.delete(toolCallId);
       await ((_a4 = dispatcher.onToolExecutionEnd) == null ? void 0 : _a4.call(
@@ -1131,19 +1196,21 @@ function createTurnTelemetry(opts) {
             dynamic: true
           },
           toolContext: void 0,
-          toolOutput: output.ok ? { type: "tool-result", output: output.output } : { type: "error", error: output.error }
+          toolOutput: normalizedOutput
         })
       ));
     },
     async end(info) {
       var _a4, _b3;
       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 ((_a4 = dispatcher.onStepEnd) == null ? void 0 : _a4.call(
@@ -1151,8 +1218,8 @@ function createTurnTelemetry(opts) {
           cast({
             callId,
             stepNumber,
-            finishReason: info.finishReason,
-            usage: info.usage,
+            finishReason,
+            usage,
             providerMetadata: void 0,
             content: [],
             response: {
@@ -1171,10 +1238,17 @@ function createTurnTelemetry(opts) {
         cast({
           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,
@@ -1317,9 +1391,11 @@ function runPrompt(input) {
     runtimeContext: input.runtimeContext
   });
   const settleFailure = (err) => {
-    var _a4, _b4;
-    (_a4 = input.onTurnFailed) == null ? void 0 : _a4.call(input);
-    if ((_b4 = input.abortSignal) == null ? void 0 : _b4.aborted) {
+    var _a4, _b4, _c2;
+    if (!((_a4 = input.isTurnSuspending) == null ? void 0 : _a4.call(input))) {
+      (_b4 = input.onTurnFailed) == null ? void 0 : _b4.call(input);
+    }
+    if ((_c2 = input.abortSignal) == null ? void 0 : _c2.aborted) {
       result.abort({
         error: err,
         ...input.abortSignal.reason !== void 0 ? { reason: getErrorMessage(input.abortSignal.reason) } : {}
@@ -1329,7 +1405,7 @@ function runPrompt(input) {
     result.fail(err);
   };
   const done = (async () => {
-    var _a4, _b4, _c2, _d2, _e2, _f2, _g2, _h, _i, _j, _k;
+    var _a4, _b4, _c2, _d2, _e2, _f2, _g2, _h, _i, _j, _k, _l;
     let bridge;
     try {
       bridge = await toHarnessStream({
@@ -1932,10 +2008,15 @@ function runPrompt(input) {
           await telemetry.toolEnd(toolCall.toolCallId, execution.outcome);
         }
       }
-      if (finalFinish != null) {
-        (_j = input.onTurnFinished) == null ? void 0 : _j.call(input);
+      const isTurnSuspending = ((_j = input.isTurnSuspending) == null ? void 0 : _j.call(input)) === true;
+      if (isTurnSuspending) {
+        if (finalFinish == null) {
+          result.discardCurrentStepContent();
+        }
+      } else if (finalFinish != null) {
+        (_k = input.onTurnFinished) == null ? void 0 : _k.call(input);
       } else {
-        (_k = input.onTurnFailed) == null ? void 0 : _k.call(input);
+        (_l = input.onTurnFailed) == null ? void 0 : _l.call(input);
       }
       await result.finish(
         finalFinish ? {
@@ -2146,6 +2227,7 @@ var HarnessAgentSession = class {
         onTurnFailed: () => {
           this.finishTrackedTurn({ turnId });
         },
+        isTurnSuspending: () => this.activeTurnSequence === turnId && this.suspendedTurnState != null,
         onStopConditionMet: () => this.captureStopConditionBoundary({ session, turnId })
       });
       return turn;
@@ -2200,6 +2282,7 @@ var HarnessAgentSession = class {
         onTurnFailed: () => {
           this.finishTrackedTurn({ turnId });
         },
+        isTurnSuspending: () => this.activeTurnSequence === turnId && this.suspendedTurnState != null,
         onStopConditionMet: () => this.captureStopConditionBoundary({ session, turnId })
       });
       return turn;