@ai-sdk/harness-deepagents 1.0.39 → 1.0.40

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @ai-sdk/harness-deepagents
 
+## 1.0.40
+
+### Patch Changes
+
+- 07c977a: chore(harness): refactor bridge code to break out stream event emission from launcher to make it testable
+- 8c96d41: fix(harness-deepagents): fix Deep Agents missing model ID in telemetry
+- 5c1a6af: fix(harness-deepagents): fix overly limiting override of Deep Agents recursion limit default
+- Updated dependencies [a94425b]
+- Updated dependencies [2de0611]
+  - @ai-sdk/harness@1.0.41
+
 ## 1.0.39
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -1,5 +1,5 @@
 // src/bridge/index.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { argv, env as procEnv2 } from "process";
 
 // ../harness/dist/bridge/index.js
@@ -548,6 +548,222 @@ function collectActionRequests(interrupts) {
   return out;
 }
 
+// src/bridge/create-emit-stream-event.ts
+import { randomUUID } from "crypto";
+function createDeepAgentsStreamEventState() {
+  return {
+    streamStarted: false,
+    textBlockId: void 0,
+    reasoningBlockId: void 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    streamedStepInput: 0,
+    streamedStepOutput: 0,
+    pendingStep: void 0,
+    approvedToolQueue: /* @__PURE__ */ new Map(),
+    approvedRunIds: /* @__PURE__ */ new Map()
+  };
+}
+var NATIVE_TO_COMMON2 = {
+  read_file: "read",
+  write_file: "write",
+  edit_file: "edit",
+  execute: "bash"
+};
+function toCommonName2(nativeName) {
+  return NATIVE_TO_COMMON2[nativeName] ?? nativeName;
+}
+function createEmitStreamEvent({
+  state,
+  configuredModel,
+  hostToolNames,
+  emit
+}) {
+  return (event) => {
+    const kind = event.event;
+    const data = event.data ?? {};
+    const ns = event.metadata?.langgraph_checkpoint_ns ?? "";
+    const nested = ns.includes("|");
+    if (kind === "on_chat_model_start") {
+      if (!nested) {
+        if (!state.streamStarted) {
+          state.streamStarted = true;
+          const modelId = resolveDeepAgentsModelId({
+            configuredModel,
+            metadata: event.metadata
+          });
+          emit({
+            type: "stream-start",
+            ...modelId ? { modelId } : {}
+          });
+        }
+        flushStep({ state, emit });
+      }
+    } else if (kind === "on_chat_model_stream") {
+      if (nested) return;
+      const chunk = data.chunk;
+      if (!chunk) return;
+      const content = chunk.content;
+      if (typeof content === "string" && content) {
+        emitText({ state, emit, delta: content });
+      } else if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block && typeof block === "object") {
+            const value = block;
+            if (value.type === "text" && value.text) {
+              emitText({ state, emit, delta: value.text });
+            } else if (value.type === "thinking" && value.thinking) {
+              emitReasoning({ state, emit, delta: value.thinking });
+            }
+          }
+        }
+      }
+      const usage = chunk.usage_metadata;
+      if (usage) {
+        state.streamedStepInput = Math.max(
+          state.streamedStepInput,
+          usage.input_tokens ?? 0
+        );
+        state.streamedStepOutput = Math.max(
+          state.streamedStepOutput,
+          usage.output_tokens ?? 0
+        );
+      }
+    } else if (kind === "on_chat_model_end") {
+      const output = data.output;
+      const usage = output?.usage_metadata;
+      const stepInput = usage?.input_tokens ?? state.streamedStepInput;
+      const stepOutput = usage?.output_tokens ?? state.streamedStepOutput;
+      state.inputTokens += stepInput;
+      state.outputTokens += stepOutput;
+      state.streamedStepInput = 0;
+      state.streamedStepOutput = 0;
+      if (!nested) {
+        endTextBlock({ state, emit });
+        endReasoningBlock({ state, emit });
+        state.pendingStep = { input: stepInput, output: stepOutput };
+      }
+    } else if (kind === "on_tool_start") {
+      const toolName = event.name ?? "unknown";
+      const runId = event.run_id ?? "";
+      if (!nested && !hostToolNames.has(toolName)) {
+        const queued = state.approvedToolQueue.get(toolName);
+        if (queued && queued.length > 0) {
+          const approvalId = queued.shift();
+          if (runId) state.approvedRunIds.set(runId, approvalId);
+        } else {
+          endTextBlock({ state, emit });
+          endReasoningBlock({ state, emit });
+          emit({
+            type: "tool-call",
+            toolCallId: runId,
+            toolName: toCommonName2(toolName),
+            input: toToolCallInput(data.input),
+            providerExecuted: true,
+            nativeName: toolName
+          });
+        }
+      }
+    } else if (kind === "on_tool_end") {
+      const toolName = event.name ?? "unknown";
+      const runId = event.run_id ?? "";
+      if (!nested && !hostToolNames.has(toolName)) {
+        let output = data.output ?? "";
+        if (output && typeof output === "object" && "content" in output) {
+          output = output.content;
+        }
+        emit({
+          type: "tool-result",
+          toolCallId: state.approvedRunIds.get(runId) ?? runId,
+          toolName: toCommonName2(toolName),
+          result: output ?? null
+        });
+        state.approvedRunIds.delete(runId);
+      }
+    }
+  };
+}
+function endTextBlock({
+  state,
+  emit
+}) {
+  if (state.textBlockId) {
+    emit({ type: "text-end", id: state.textBlockId });
+    state.textBlockId = void 0;
+  }
+}
+function endReasoningBlock({
+  state,
+  emit
+}) {
+  if (state.reasoningBlockId) {
+    emit({ type: "reasoning-end", id: state.reasoningBlockId });
+    state.reasoningBlockId = void 0;
+  }
+}
+function flushStep({
+  state,
+  emit
+}) {
+  if (!state.pendingStep) return;
+  emit({
+    type: "finish-step",
+    finishReason: { unified: "stop" },
+    usage: {
+      inputTokens: { total: state.pendingStep.input },
+      outputTokens: { total: state.pendingStep.output }
+    }
+  });
+  state.pendingStep = void 0;
+}
+function ensureTextBlock({
+  state,
+  emit
+}) {
+  if (!state.textBlockId) {
+    state.textBlockId = `text-${randomUUID()}`;
+    emit({ type: "text-start", id: state.textBlockId });
+  }
+  return state.textBlockId;
+}
+function emitText({
+  state,
+  emit,
+  delta
+}) {
+  endReasoningBlock({ state, emit });
+  emit({ type: "text-delta", id: ensureTextBlock({ state, emit }), delta });
+}
+function emitReasoning({
+  state,
+  emit,
+  delta
+}) {
+  endTextBlock({ state, emit });
+  if (!state.reasoningBlockId) {
+    state.reasoningBlockId = `reasoning-${randomUUID()}`;
+    emit({ type: "reasoning-start", id: state.reasoningBlockId });
+  }
+  emit({ type: "reasoning-delta", id: state.reasoningBlockId, delta });
+}
+function resolveDeepAgentsModelId({
+  configuredModel,
+  metadata
+}) {
+  if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+    const modelId = metadata.ls_model_name;
+    if (typeof modelId === "string" && modelId.length > 0) return modelId;
+  }
+  return configuredModel;
+}
+function toToolCallInput(raw) {
+  if (raw && typeof raw === "object" && !Array.isArray(raw) && Object.keys(raw).length === 1 && typeof raw.input === "string") {
+    const inner = raw.input;
+    if (/^\s*[[{]/.test(inner)) return inner;
+  }
+  return JSON.stringify(raw ?? {});
+}
+
 // src/bridge/json-schema-to-zod.ts
 import { z } from "zod/v4";
 function jsonSchemaToZodObject(input) {
@@ -692,16 +908,7 @@ function createBuiltinToolFilteringMiddleware(input) {
 }
 
 // src/bridge/index.ts
-var NATIVE_TO_COMMON2 = {
-  read_file: "read",
-  write_file: "write",
-  edit_file: "edit",
-  execute: "bash"
-};
 var HARNESS_CLIENT_APP = procEnv2.AI_SDK_HARNESS_CLIENT_APP;
-function toCommonName2(nativeName) {
-  return NATIVE_TO_COMMON2[nativeName] ?? nativeName;
-}
 function parseArgs(rawArgs) {
   const out = {};
   for (let i = 0; i < rawArgs.length; i++) {
@@ -732,13 +939,6 @@ function buildModel(rawModel) {
     } : {}
   });
 }
-function toToolCallInput(raw) {
-  if (raw && typeof raw === "object" && !Array.isArray(raw) && Object.keys(raw).length === 1 && typeof raw.input === "string") {
-    const inner = raw.input;
-    if (/^\s*[[{]/.test(inner)) return inner;
-  }
-  return JSON.stringify(raw ?? {});
-}
 var args = parseArgs(argv.slice(2));
 var workdir = args.workdir;
 var bridgeStateDir = args.bridgeStateDir;
@@ -754,7 +954,7 @@ function buildHostTools(toolSchemas) {
       async (input) => {
         const turn = currentTurn;
         if (!turn) throw new Error("no active turn");
-        const toolCallId = `${schema.name}-${randomUUID()}`;
+        const toolCallId = `${schema.name}-${randomUUID2()}`;
         turn.emit({
           type: "tool-call",
           toolCallId,
@@ -807,67 +1007,18 @@ async function runTurn(start, turn) {
       checkpointer: new MemorySaver()
     });
   }
-  emit({
-    type: "stream-start",
-    ...start.model ? { modelId: start.model } : {}
-  });
   const hostToolNames = new Set((start.tools ?? []).map((t) => t.name));
-  let textBlockId;
-  let reasoningBlockId;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let streamedStepInput = 0;
-  let streamedStepOutput = 0;
-  let pendingStep;
-  const approvedToolQueue = /* @__PURE__ */ new Map();
-  const approvedRunIds = /* @__PURE__ */ new Map();
-  const ensureTextBlock = () => {
-    if (!textBlockId) {
-      textBlockId = `text-${randomUUID()}`;
-      emit({ type: "text-start", id: textBlockId });
-    }
-    return textBlockId;
-  };
-  const endTextBlock = () => {
-    if (textBlockId) {
-      emit({ type: "text-end", id: textBlockId });
-      textBlockId = void 0;
-    }
-  };
-  const endReasoningBlock = () => {
-    if (reasoningBlockId) {
-      emit({ type: "reasoning-end", id: reasoningBlockId });
-      reasoningBlockId = void 0;
-    }
-  };
-  const emitText = (delta) => {
-    endReasoningBlock();
-    emit({ type: "text-delta", id: ensureTextBlock(), delta });
-  };
-  const emitReasoning = (delta) => {
-    endTextBlock();
-    if (!reasoningBlockId) {
-      reasoningBlockId = `reasoning-${randomUUID()}`;
-      emit({ type: "reasoning-start", id: reasoningBlockId });
-    }
-    emit({ type: "reasoning-delta", id: reasoningBlockId, delta });
-  };
-  const flushStep = () => {
-    if (!pendingStep) return;
-    emit({
-      type: "finish-step",
-      finishReason: { unified: "stop" },
-      usage: {
-        inputTokens: { total: pendingStep.input },
-        outputTokens: { total: pendingStep.output }
-      }
-    });
-    pendingStep = void 0;
-  };
+  const streamEventState = createDeepAgentsStreamEventState();
+  const emitStreamEvent = createEmitStreamEvent({
+    state: streamEventState,
+    configuredModel: start.model,
+    hostToolNames,
+    emit
+  });
   const config = {
     version: "v2",
     configurable: { thread_id: "bridge-session" },
-    recursionLimit: start.recursionLimit ?? 100,
+    ...start.recursionLimit != null ? { recursionLimit: start.recursionLimit } : {},
     signal: turn.abortSignal
   };
   const readPendingApprovals = async () => {
@@ -888,100 +1039,15 @@ async function runTurn(start, turn) {
   while (true) {
     const stream = await agent.streamEvents(resumeInput, config);
     for await (const event of stream) {
-      const kind = event.event;
-      const data = event.data ?? {};
-      const ns = event.metadata?.langgraph_checkpoint_ns ?? "";
-      const nested = ns.includes("|");
-      if (kind === "on_chat_model_start") {
-        if (!nested) flushStep();
-      } else if (kind === "on_chat_model_stream") {
-        if (nested) continue;
-        const chunk = data.chunk;
-        if (!chunk) continue;
-        const content = chunk.content;
-        if (typeof content === "string" && content) {
-          emitText(content);
-        } else if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block && typeof block === "object") {
-              const b = block;
-              if (b.type === "text" && b.text) emitText(b.text);
-              else if (b.type === "thinking" && b.thinking)
-                emitReasoning(b.thinking);
-            }
-          }
-        }
-        const usage = chunk.usage_metadata;
-        if (usage) {
-          streamedStepInput = Math.max(
-            streamedStepInput,
-            usage.input_tokens ?? 0
-          );
-          streamedStepOutput = Math.max(
-            streamedStepOutput,
-            usage.output_tokens ?? 0
-          );
-        }
-      } else if (kind === "on_chat_model_end") {
-        const output = data.output;
-        const usage = output?.usage_metadata;
-        const stepInput = usage?.input_tokens ?? streamedStepInput;
-        const stepOutput = usage?.output_tokens ?? streamedStepOutput;
-        inputTokens += stepInput;
-        outputTokens += stepOutput;
-        streamedStepInput = 0;
-        streamedStepOutput = 0;
-        if (!nested) {
-          endTextBlock();
-          endReasoningBlock();
-          pendingStep = { input: stepInput, output: stepOutput };
-        }
-      } else if (kind === "on_tool_start") {
-        const toolName = event.name ?? "unknown";
-        const runId = event.run_id ?? "";
-        if (!nested && !hostToolNames.has(toolName)) {
-          const queued = approvedToolQueue.get(toolName);
-          if (queued && queued.length > 0) {
-            const approvalId = queued.shift();
-            if (runId) approvedRunIds.set(runId, approvalId);
-          } else {
-            endTextBlock();
-            endReasoningBlock();
-            emit({
-              type: "tool-call",
-              toolCallId: runId,
-              toolName: toCommonName2(toolName),
-              input: toToolCallInput(data.input),
-              providerExecuted: true,
-              nativeName: toolName
-            });
-          }
-        }
-      } else if (kind === "on_tool_end") {
-        const toolName = event.name ?? "unknown";
-        const runId = event.run_id ?? "";
-        if (!nested && !hostToolNames.has(toolName)) {
-          let output = data.output ?? "";
-          if (output && typeof output === "object" && "content" in output) {
-            output = output.content;
-          }
-          emit({
-            type: "tool-result",
-            toolCallId: approvedRunIds.get(runId) ?? runId,
-            toolName: toCommonName2(toolName),
-            result: output ?? null
-          });
-          approvedRunIds.delete(runId);
-        }
-      }
+      emitStreamEvent(event);
     }
     const actionRequests = await readPendingApprovals();
     if (actionRequests.length === 0) break;
     const decisions = [];
     for (const action of actionRequests) {
-      const approvalId = `approval-${randomUUID()}`;
-      endTextBlock();
-      endReasoningBlock();
+      const approvalId = `approval-${randomUUID2()}`;
+      endTextBlock({ state: streamEventState, emit });
+      endReasoningBlock({ state: streamEventState, emit });
       emit({
         type: "tool-call",
         toolCallId: approvalId,
@@ -995,12 +1061,12 @@ async function runTurn(start, turn) {
         approvalId,
         toolCallId: approvalId
       });
-      flushStep();
+      flushStep({ state: streamEventState, emit });
       const decision = await turn.requestToolApproval(approvalId);
       if (decision.approved) {
-        const queue = approvedToolQueue.get(action.name) ?? [];
+        const queue = streamEventState.approvedToolQueue.get(action.name) ?? [];
         queue.push(approvalId);
-        approvedToolQueue.set(action.name, queue);
+        streamEventState.approvedToolQueue.set(action.name, queue);
         decisions.push({ type: "approve" });
       } else {
         emit({
@@ -1017,15 +1083,15 @@ async function runTurn(start, turn) {
     }
     resumeInput = new Command({ resume: { decisions } });
   }
-  endTextBlock();
-  endReasoningBlock();
-  flushStep();
+  endTextBlock({ state: streamEventState, emit });
+  endReasoningBlock({ state: streamEventState, emit });
+  flushStep({ state: streamEventState, emit });
   emit({
     type: "finish",
     finishReason: { unified: "stop" },
     totalUsage: {
-      inputTokens: { total: inputTokens },
-      outputTokens: { total: outputTokens }
+      inputTokens: { total: streamEventState.inputTokens },
+      outputTokens: { total: streamEventState.outputTokens }
     }
   });
 }