@ai-sdk/harness-deepagents 1.0.39 → 1.0.40

package/src/bridge/index.ts

@@ -13,23 +13,21 @@ import { Command, MemorySaver } from '@langchain/langgraph';
 import { createDeepAgent } from 'deepagents';
 import type { StartMessage } from '../deepagents-bridge-protocol';
 import { buildInterruptOn, collectActionRequests } from './approvals';
+import {
+  createDeepAgentsStreamEventState,
+  createEmitStreamEvent,
+  endReasoningBlock,
+  endTextBlock,
+  flushStep,
+  toCommonName,
+  type DeepAgentsStreamEvent,
+} from './create-emit-stream-event';
 import { jsonSchemaToZodObject } from './json-schema-to-zod';
 import { createLocalShellBackend } from './local-shell-backend';
 import { createBuiltinToolFilteringMiddleware } from './tool-filtering';
 
-// Native Deep Agents tool name -> harness-v1 common name (renames only; grep/glob/ls/task/write_todos forward unchanged).
-const NATIVE_TO_COMMON: Readonly<Record<string, string>> = {
-  read_file: 'read',
-  write_file: 'write',
-  edit_file: 'edit',
-  execute: 'bash',
-};
 const HARNESS_CLIENT_APP = procEnv.AI_SDK_HARNESS_CLIENT_APP;
 
-function toCommonName(nativeName: string): string {
-  return NATIVE_TO_COMMON[nativeName] ?? nativeName;
-}
-
 function parseArgs(rawArgs: string[]): Record<string, string> {
   const out: Record<string, string> = {};
   for (let i = 0; i < rawArgs.length; i++) {
@@ -68,21 +66,6 @@ function buildModel(rawModel: string | undefined) {
   });
 }
 
-// LangChain reports some built-in tool args wrapped as `{ input: "<json>" }`; unwrap to the inner JSON so AI SDK validates the real shape.
-function toToolCallInput(raw: unknown): string {
-  if (
-    raw &&
-    typeof raw === 'object' &&
-    !Array.isArray(raw) &&
-    Object.keys(raw).length === 1 &&
-    typeof (raw as { input?: unknown }).input === 'string'
-  ) {
-    const inner = (raw as { input: string }).input;
-    if (/^\s*[[{]/.test(inner)) return inner;
-  }
-  return JSON.stringify(raw ?? {});
-}
-
 const args = parseArgs(argv.slice(2));
 const workdir = args.workdir;
 const bridgeStateDir = args.bridgeStateDir;
@@ -162,75 +145,21 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     });
   }
 
-  emit({
-    type: 'stream-start',
-    ...(start.model ? { modelId: start.model } : {}),
-  });
-
   const hostToolNames = new Set((start.tools ?? []).map(t => t.name));
-  let textBlockId: string | undefined;
-  let reasoningBlockId: string | undefined;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  // Per-call streamed-usage fallback (max over chunks), used only when model-end carries no usage.
-  let streamedStepInput = 0;
-  let streamedStepOutput = 0;
-  // Top-level step usage is buffered at model-end and flushed as finish-step only after the step's tools run.
-  let pendingStep: { input: number; output: number } | undefined;
-  // Approval-gated tools are announced before execution; these tie the later run back to the approval id and dedup the call.
-  const approvedToolQueue = new Map<string, string[]>();
-  const approvedRunIds = new Map<string, string>();
-
-  const ensureTextBlock = (): string => {
-    if (!textBlockId) {
-      textBlockId = `text-${randomUUID()}`;
-      emit({ type: 'text-start', id: textBlockId });
-    }
-    return textBlockId;
-  };
-  const endTextBlock = () => {
-    if (textBlockId) {
-      emit({ type: 'text-end', id: textBlockId });
-      textBlockId = undefined;
-    }
-  };
-  const endReasoningBlock = () => {
-    if (reasoningBlockId) {
-      emit({ type: 'reasoning-end', id: reasoningBlockId });
-      reasoningBlockId = undefined;
-    }
-  };
-  // Text and reasoning are mutually exclusive open blocks: starting one closes the other.
-  const emitText = (delta: string) => {
-    endReasoningBlock();
-    emit({ type: 'text-delta', id: ensureTextBlock(), delta });
-  };
-  const emitReasoning = (delta: string) => {
-    endTextBlock();
-    if (!reasoningBlockId) {
-      reasoningBlockId = `reasoning-${randomUUID()}`;
-      emit({ type: 'reasoning-start', id: reasoningBlockId });
-    }
-    emit({ type: 'reasoning-delta', id: reasoningBlockId, delta });
-  };
-  // Close the buffered top-level step; called when the next step starts and at turn end so finish-step lands after the step's tools.
-  const flushStep = () => {
-    if (!pendingStep) return;
-    emit({
-      type: 'finish-step',
-      finishReason: { unified: 'stop' },
-      usage: {
-        inputTokens: { total: pendingStep.input },
-        outputTokens: { total: pendingStep.output },
-      },
-    });
-    pendingStep = undefined;
-  };
+  const streamEventState = createDeepAgentsStreamEventState();
+  const emitStreamEvent = createEmitStreamEvent({
+    state: streamEventState,
+    configuredModel: start.model,
+    hostToolNames,
+    emit,
+  });
 
   const config = {
     version: 'v2' as const,
     configurable: { thread_id: 'bridge-session' },
-    recursionLimit: start.recursionLimit ?? 100,
+    ...(start.recursionLimit != null
+      ? { recursionLimit: start.recursionLimit }
+      : {}),
     signal: turn.abortSignal,
   };
 
@@ -256,122 +185,7 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     const stream = await agent.streamEvents(resumeInput as never, config);
 
     for await (const event of stream) {
-      const kind = event.event;
-      const data = (event.data ?? {}) as Record<string, unknown>;
-      // Subagent (e.g. `task`) events carry a `|`-delimited checkpoint namespace; keep their internals out of the top-level stream.
-      const ns =
-        (event as { metadata?: { langgraph_checkpoint_ns?: string } }).metadata
-          ?.langgraph_checkpoint_ns ?? '';
-      const nested = ns.includes('|');
-
-      if (kind === 'on_chat_model_start') {
-        // A new top-level model call means the previous step's tools have run; close it now.
-        if (!nested) flushStep();
-      } else if (kind === 'on_chat_model_stream') {
-        if (nested) continue;
-        const chunk = data.chunk as
-          | {
-              content?: unknown;
-              usage_metadata?: {
-                input_tokens?: number;
-                output_tokens?: number;
-              };
-            }
-          | undefined;
-        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 as {
-                type?: string;
-                text?: string;
-                thinking?: string;
-              };
-              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') {
-        // Final usage lands on model-end, not the chunks; each model call is one step.
-        const output = data.output as
-          | {
-              usage_metadata?: {
-                input_tokens?: number;
-                output_tokens?: number;
-              };
-            }
-          | undefined;
-        const usage = output?.usage_metadata;
-        // One model call = one step; count its usage exactly once (model-end usage, else the streamed max).
-        const stepInput = usage?.input_tokens ?? streamedStepInput;
-        const stepOutput = usage?.output_tokens ?? streamedStepOutput;
-        inputTokens += stepInput;
-        outputTokens += stepOutput;
-        streamedStepInput = 0;
-        streamedStepOutput = 0;
-        // Nested (subagent) calls still count toward total usage, but only top-level calls bound a visible step.
-        if (!nested) {
-          endTextBlock();
-          endReasoningBlock();
-          // Buffer the step; flushStep emits finish-step after this step's tools run (next start / turn end).
-          pendingStep = { input: stepInput, output: stepOutput };
-        }
-      } else if (kind === 'on_tool_start') {
-        const toolName = (event.name as string) ?? 'unknown';
-        const runId = (event.run_id as string) ?? '';
-        // Host tools emit their own tool-call; surface only top-level builtin (providerExecuted) tools.
-        if (!nested && !hostToolNames.has(toolName)) {
-          const queued = approvedToolQueue.get(toolName);
-          if (queued && queued.length > 0) {
-            // Already announced at approval time; tie this run to that id and don't re-emit the call.
-            const approvalId = queued.shift()!;
-            if (runId) approvedRunIds.set(runId, approvalId);
-          } else {
-            endTextBlock();
-            endReasoningBlock();
-            emit({
-              type: 'tool-call',
-              toolCallId: runId,
-              toolName: toCommonName(toolName),
-              input: toToolCallInput(data.input),
-              providerExecuted: true,
-              nativeName: toolName,
-            });
-          }
-        }
-      } else if (kind === 'on_tool_end') {
-        const toolName = (event.name as string) ?? 'unknown';
-        const runId = (event.run_id as string) ?? '';
-        if (!nested && !hostToolNames.has(toolName)) {
-          let output: unknown = data.output ?? '';
-          if (output && typeof output === 'object' && 'content' in output) {
-            output = (output as { content: unknown }).content;
-          }
-          emit({
-            type: 'tool-result',
-            toolCallId: approvedRunIds.get(runId) ?? runId,
-            toolName: toCommonName(toolName),
-            result: output ?? null,
-          });
-          approvedRunIds.delete(runId);
-        }
-      }
+      emitStreamEvent(event as DeepAgentsStreamEvent);
     }
 
     const actionRequests = await readPendingApprovals();
@@ -383,8 +197,8 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     > = [];
     for (const action of actionRequests) {
       const approvalId = `approval-${randomUUID()}`;
-      endTextBlock();
-      endReasoningBlock();
+      endTextBlock({ state: streamEventState, emit });
+      endReasoningBlock({ state: streamEventState, emit });
       emit({
         type: 'tool-call',
         toolCallId: approvalId,
@@ -398,12 +212,12 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
         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 {
         // Rejected tools never execute, so surface the outcome as the result now.
@@ -423,15 +237,15 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     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 },
     },
   });
 }

package/src/deepagents-harness.ts

@@ -91,7 +91,10 @@ export type DeepAgentsHarnessSettings = {
   readonly port?: number;
   /** Maximum milliseconds to wait for the bridge to advertise its port. Defaults to 120000. */
   readonly startupTimeoutMs?: number;
-  /** Max LangGraph super-steps per turn before it errors. Defaults to 100; raise for long multi-step tasks. */
+  /**
+   * Maximum LangGraph super-steps per turn before it errors.
+   * When omitted, the Deep Agents default applies.
+   */
   readonly recursionLimit?: number;
 };