@botbotgo/agent-harness 0.0.31 → 0.0.33

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.30";
+export declare const AGENT_HARNESS_VERSION = "0.0.32";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.30";
+export const AGENT_HARNESS_VERSION = "0.0.32";

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -15,6 +15,7 @@ declare class RuntimeOperationTimeoutError extends Error {
 export declare class AgentRuntimeAdapter {
     private readonly options;
     constructor(options?: RuntimeAdapterOptions);
+    private canUseSimpleDeepAgentFastPath;
     private resolveBindingTimeout;
     private resolveStreamIdleTimeout;
     private withTimeout;

package/dist/runtime/agent-runtime-adapter.js

@@ -1,12 +1,14 @@
 import { Command, MemorySaver } from "@langchain/langgraph";
+import { tool as createLangChainTool } from "@langchain/core/tools";
 import { createDeepAgent } from "deepagents";
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatGoogle } from "@langchain/google";
 import { ChatOllama } from "@langchain/ollama";
 import { ChatOpenAI } from "@langchain/openai";
 import { createAgent, humanInTheLoopMiddleware, initChatModel } from "langchain";
+import { z } from "zod";
 import { extractEmptyAssistantMessageFailure, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
+import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractVisibleStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
 import { wrapToolForExecution } from "./tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./declared-middleware.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
@@ -120,6 +122,37 @@ function wrapResolvedToolWithModelFacingName(resolvedTool, modelFacingName) {
         },
     });
 }
+function hasCallableToolHandler(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const typed = value;
+    return typeof typed.invoke === "function" || typeof typed.call === "function" || typeof typed.func === "function";
+}
+function normalizeResolvedToolSchema(resolvedTool) {
+    const schema = resolvedTool.schema;
+    if (schema && typeof schema.parse === "function" && "_def" in schema) {
+        return resolvedTool.schema;
+    }
+    if (schema && (schema.type === "object" || typeof schema.properties === "object")) {
+        return schema;
+    }
+    return z.object({}).passthrough();
+}
+function asStructuredExecutableTool(resolvedTool, modelFacingName, description) {
+    if (!hasCallableToolHandler(resolvedTool)) {
+        return resolvedTool;
+    }
+    const handler = resolvedTool.invoke ?? resolvedTool.call ?? resolvedTool.func;
+    if (typeof handler !== "function") {
+        return resolvedTool;
+    }
+    return createLangChainTool(async (input, config) => handler(input, config), {
+        name: modelFacingName,
+        description,
+        schema: normalizeResolvedToolSchema(resolvedTool),
+    });
+}
 function countConfiguredTools(binding) {
     return binding.langchainAgentParams?.tools.length ?? binding.deepAgentParams?.tools.length ?? 0;
 }
@@ -128,6 +161,25 @@ export class AgentRuntimeAdapter {
     constructor(options = {}) {
         this.options = options;
     }
+    canUseSimpleDeepAgentFastPath(binding) {
+        const params = binding.deepAgentParams;
+        if (!params) {
+            return false;
+        }
+        if ((params.subagents?.length ?? 0) > 0) {
+            return false;
+        }
+        if ((params.memory?.length ?? 0) > 0) {
+            return false;
+        }
+        if ((params.skills?.length ?? 0) > 0) {
+            return false;
+        }
+        if (params.backend || params.store) {
+            return false;
+        }
+        return true;
+    }
     resolveBindingTimeout(binding) {
         return resolveTimeoutMs(binding.langchainAgentParams?.model.init.timeout ?? binding.deepAgentParams?.model.init.timeout);
     }
@@ -317,6 +369,10 @@ export class AgentRuntimeAdapter {
             }
             const wrappedTool = wrapToolForExecution(resolvedTool, compiledTool);
             const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
+            const structuredTool = asStructuredExecutableTool(wrappedTool, modelFacingName, compiledTool.description);
+            if (structuredTool !== wrappedTool) {
+                return structuredTool;
+            }
             return modelFacingName === compiledTool.name ? wrappedTool : wrapResolvedToolWithModelFacingName(wrappedTool, modelFacingName);
         });
     }
@@ -431,6 +487,23 @@ export class AgentRuntimeAdapter {
         if (!params) {
             throw new Error(`Agent ${binding.agent.id} has no runnable params`);
         }
+        if (this.canUseSimpleDeepAgentFastPath(binding)) {
+            const interruptOn = this.resolveInterruptOn(binding);
+            const model = (await this.resolveModel(params.model));
+            const tools = this.resolveTools(params.tools, binding);
+            if (tools.length > 0 && typeof model.bindTools !== "function") {
+                throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${params.model.id} does not support tool binding.`);
+            }
+            return createAgent({
+                model: model,
+                tools: tools,
+                systemPrompt: params.systemPrompt,
+                responseFormat: params.responseFormat,
+                contextSchema: params.contextSchema,
+                middleware: (await this.resolveMiddleware(binding, interruptOn)),
+                checkpointer: this.resolveCheckpointer(binding),
+            });
+        }
         const deepAgentConfig = {
             model: (await this.resolveModel(params.model)),
             tools: this.resolveTools(params.tools, binding),
@@ -554,7 +627,8 @@ export class AgentRuntimeAdapter {
             const request = { messages: this.buildAgentMessages(history, input) };
             if (typeof runnable.streamEvents === "function") {
                 const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2" }), invokeTimeoutMs, "agent streamEvents start", "stream");
-                let terminalOutput = "";
+                const allowVisibleStreamDeltas = Boolean(binding.langchainAgentParams);
+                let emittedOutput = "";
                 const seenTerminalOutputs = new Set();
                 let lastStep = "";
                 for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents")) {
@@ -567,6 +641,26 @@ export class AgentRuntimeAdapter {
                     if (reasoning) {
                         yield { kind: "reasoning", content: reasoning };
                     }
+                    if (allowVisibleStreamDeltas) {
+                        const visibleStreamOutput = extractVisibleStreamOutput(event);
+                        if (visibleStreamOutput) {
+                            const nextOutput = computeIncrementalOutput(emittedOutput, visibleStreamOutput);
+                            emittedOutput = nextOutput.accumulated;
+                            if (nextOutput.delta) {
+                                yield { kind: "content", content: nextOutput.delta };
+                            }
+                        }
+                    }
+                    if (binding.deepAgentParams) {
+                        const stateStreamOutput = extractStateStreamOutput(event);
+                        if (stateStreamOutput) {
+                            const nextOutput = computeIncrementalOutput(emittedOutput, sanitizeVisibleText(stateStreamOutput));
+                            emittedOutput = nextOutput.accumulated;
+                            if (nextOutput.delta) {
+                                yield { kind: "content", content: nextOutput.delta };
+                            }
+                        }
+                    }
                     const agentStep = extractAgentStep(event);
                     if (agentStep && agentStep !== lastStep) {
                         lastStep = agentStep;
@@ -585,11 +679,14 @@ export class AgentRuntimeAdapter {
                         if (outputKey) {
                             seenTerminalOutputs.add(outputKey);
                         }
-                        terminalOutput += output;
+                        const nextOutput = computeIncrementalOutput(emittedOutput, sanitizeVisibleText(output));
+                        emittedOutput = nextOutput.accumulated;
+                        if (nextOutput.delta) {
+                            yield { kind: "content", content: nextOutput.delta };
+                        }
                     }
                 }
-                if (terminalOutput) {
-                    yield { kind: "content", content: sanitizeVisibleText(terminalOutput) };
+                if (emittedOutput) {
                     return;
                 }
             }

package/dist/runtime/parsing/stream-event-parsing.d.ts

@@ -17,6 +17,8 @@ export type RuntimeStreamChunk = {
 };
 export declare function extractTerminalStreamOutput(event: unknown): string;
 export declare function extractReasoningStreamOutput(event: unknown): string;
+export declare function extractVisibleStreamOutput(event: unknown): string;
+export declare function extractStateStreamOutput(event: unknown): string;
 export declare function extractAgentStep(event: unknown): string | null;
 export declare function extractToolResult(event: unknown): {
     toolName: string;
@@ -24,4 +26,8 @@ export declare function extractToolResult(event: unknown): {
 } | null;
 export declare function extractInterruptPayload(event: unknown): string | null;
 export declare function normalizeTerminalOutputKey(value: string): string;
+export declare function computeIncrementalOutput(accumulated: string, next: string): {
+    accumulated: string;
+    delta: string;
+};
 export declare function readStreamDelta(chunk: unknown): string;

package/dist/runtime/parsing/stream-event-parsing.js

@@ -73,6 +73,29 @@ export function extractReasoningStreamOutput(event) {
     const typed = event;
     return typed.event === "on_chat_model_stream" ? extractReasoningText(typed.data?.chunk) : "";
 }
+export function extractVisibleStreamOutput(event) {
+    if (typeof event !== "object" || !event)
+        return "";
+    const typed = event;
+    return typed.event === "on_chat_model_stream" ? readTextContent(typed.data?.chunk) : "";
+}
+export function extractStateStreamOutput(event) {
+    if (typeof event !== "object" || !event)
+        return "";
+    const typed = event;
+    if (typed.event !== "on_chain_stream") {
+        return "";
+    }
+    const chunk = typed.data?.chunk;
+    if (typeof chunk !== "object" || !chunk) {
+        return "";
+    }
+    const record = chunk;
+    if (!("messages" in record) && !("output" in record)) {
+        return "";
+    }
+    return extractVisibleOutput(chunk);
+}
 export function extractAgentStep(event) {
     if (typeof event !== "object" || !event)
         return null;
@@ -156,6 +179,36 @@ export function extractInterruptPayload(event) {
 export function normalizeTerminalOutputKey(value) {
     return value.trim();
 }
+export function computeIncrementalOutput(accumulated, next) {
+    if (!next) {
+        return { accumulated, delta: "" };
+    }
+    if (!accumulated) {
+        return { accumulated: next, delta: next };
+    }
+    if (next === accumulated || accumulated.endsWith(next)) {
+        return { accumulated, delta: "" };
+    }
+    if (next.startsWith(accumulated)) {
+        return {
+            accumulated: next,
+            delta: next.slice(accumulated.length),
+        };
+    }
+    const overlapLength = Math.min(accumulated.length, next.length);
+    for (let size = overlapLength; size > 0; size -= 1) {
+        if (accumulated.slice(-size) === next.slice(0, size)) {
+            return {
+                accumulated: accumulated + next.slice(size),
+                delta: next.slice(size),
+            };
+        }
+    }
+    return {
+        accumulated: accumulated + next,
+        delta: next,
+    };
+}
 export function readStreamDelta(chunk) {
     return readTextContent(chunk);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Agent Harness framework package",
   "type": "module",
   "packageManager": "npm@10.9.2",