@botbotgo/agent-harness 0.0.30 → 0.0.32

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.29";
+export declare const AGENT_HARNESS_VERSION = "0.0.31";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.29";
+export const AGENT_HARNESS_VERSION = "0.0.31";

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

@@ -7,13 +7,16 @@ type RunnableLike = {
 };
 declare const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 declare class RuntimeOperationTimeoutError extends Error {
+    readonly operation: string;
     readonly timeoutMs: number;
-    constructor(operation: string, timeoutMs: number);
+    readonly stage: "stream" | "invoke";
+    constructor(operation: string, timeoutMs: number, stage?: "stream" | "invoke");
 }
 export declare class AgentRuntimeAdapter {
     private readonly options;
     constructor(options?: RuntimeAdapterOptions);
     private resolveBindingTimeout;
+    private resolveStreamIdleTimeout;
     private withTimeout;
     private iterateWithTimeout;
     private materializeModelStream;

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

@@ -1,10 +1,12 @@
 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 { wrapToolForExecution } from "./tool-hitl.js";
@@ -13,10 +15,14 @@ import { extractMessageText, normalizeMessageContent } from "../utils/message-co
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 class RuntimeOperationTimeoutError extends Error {
+    operation;
     timeoutMs;
-    constructor(operation, timeoutMs) {
+    stage;
+    constructor(operation, timeoutMs, stage = operation.includes("stream") ? "stream" : "invoke") {
         super(`${operation} timed out after ${timeoutMs}ms`);
+        this.operation = operation;
         this.timeoutMs = timeoutMs;
+        this.stage = stage;
         this.name = "RuntimeOperationTimeoutError";
     }
 }
@@ -116,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;
 }
@@ -127,12 +164,23 @@ export class AgentRuntimeAdapter {
     resolveBindingTimeout(binding) {
         return resolveTimeoutMs(binding.langchainAgentParams?.model.init.timeout ?? binding.deepAgentParams?.model.init.timeout);
     }
-    async withTimeout(producer, timeoutMs, operation) {
+    resolveStreamIdleTimeout(binding) {
+        const configuredIdleTimeout = resolveTimeoutMs(binding.langchainAgentParams?.model.init.streamIdleTimeout ?? binding.deepAgentParams?.model.init.streamIdleTimeout);
+        if (configuredIdleTimeout) {
+            return configuredIdleTimeout;
+        }
+        const invokeTimeout = this.resolveBindingTimeout(binding);
+        if (invokeTimeout) {
+            return Math.min(invokeTimeout, 15_000);
+        }
+        return 15_000;
+    }
+    async withTimeout(producer, timeoutMs, operation, stage = operation.includes("stream") ? "stream" : "invoke") {
         if (!timeoutMs) {
             return Promise.resolve(producer());
         }
         return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => reject(new RuntimeOperationTimeoutError(operation, timeoutMs)), timeoutMs);
+            const timer = setTimeout(() => reject(new RuntimeOperationTimeoutError(operation, timeoutMs, stage)), timeoutMs);
             Promise.resolve(producer()).then((value) => {
                 clearTimeout(timer);
                 resolve(value);
@@ -146,7 +194,7 @@ export class AgentRuntimeAdapter {
         const iterator = iterable[Symbol.asyncIterator]();
         try {
             for (;;) {
-                const next = await this.withTimeout(() => iterator.next(), timeoutMs, operation);
+                const next = await this.withTimeout(() => iterator.next(), timeoutMs, operation, "stream");
                 if (next.done) {
                     return;
                 }
@@ -251,7 +299,7 @@ export class AgentRuntimeAdapter {
                 role: "user",
                 content: `Original user request:\n${extractMessageText(input)}\n\nTool results:\n${toolContext}`,
             },
-        ]), this.resolveBindingTimeout(binding), "deepagent synthesis invoke");
+        ]), this.resolveBindingTimeout(binding), "deepagent synthesis invoke", "invoke");
         return sanitizeVisibleText(extractVisibleOutput(synthesized));
     }
     async resolveModel(model) {
@@ -302,6 +350,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);
         });
     }
@@ -470,7 +522,7 @@ export class AgentRuntimeAdapter {
         let result;
         try {
             const runnable = await this.create(binding);
-            result = (await this.withTimeout(() => runnable.invoke(request, { configurable: { thread_id: threadId } }), this.resolveBindingTimeout(binding), "agent invoke"));
+            result = (await this.withTimeout(() => runnable.invoke(request, { configurable: { thread_id: threadId } }), this.resolveBindingTimeout(binding), "agent invoke", "invoke"));
         }
         catch (error) {
             if (resumePayload !== undefined || !isToolCallParseFailure(error)) {
@@ -478,7 +530,7 @@ export class AgentRuntimeAdapter {
             }
             const retriedBinding = this.applyStrictToolJsonInstruction(binding);
             const runnable = await this.create(retriedBinding);
-            result = (await this.withTimeout(() => runnable.invoke({ messages: this.buildAgentMessages(history, input) }, { configurable: { thread_id: threadId } }), this.resolveBindingTimeout(retriedBinding), "agent invoke"));
+            result = (await this.withTimeout(() => runnable.invoke({ messages: this.buildAgentMessages(history, input) }, { configurable: { thread_id: threadId } }), this.resolveBindingTimeout(retriedBinding), "agent invoke", "invoke"));
         }
         const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
         const extractedOutput = extractVisibleOutput(result);
@@ -501,7 +553,8 @@ export class AgentRuntimeAdapter {
     }
     async *stream(binding, input, threadId, history = []) {
         try {
-            const timeoutMs = this.resolveBindingTimeout(binding);
+            const invokeTimeoutMs = this.resolveBindingTimeout(binding);
+            const streamIdleTimeoutMs = this.resolveStreamIdleTimeout(binding);
             if (binding.langchainAgentParams) {
                 const langchainParams = binding.langchainAgentParams;
                 const resolvedModel = (await this.resolveModel(binding.langchainAgentParams.model));
@@ -516,8 +569,8 @@ export class AgentRuntimeAdapter {
                 // agent loop and only adds an extra model round-trip before the runnable path.
                 if (canUseDirectModelStream && typeof model.stream === "function") {
                     let emitted = false;
-                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(langchainParams.systemPrompt, history, input)), timeoutMs, "model stream start");
-                    for await (const chunk of this.iterateWithTimeout(stream, timeoutMs, "model stream")) {
+                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(langchainParams.systemPrompt, history, input)), invokeTimeoutMs, "model stream start", "stream");
+                    for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream")) {
                         const delta = readStreamDelta(chunk);
                         if (delta) {
                             emitted = true;
@@ -537,11 +590,11 @@ export class AgentRuntimeAdapter {
             const runnable = await this.create(binding);
             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" }), timeoutMs, "agent streamEvents start");
+                const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2" }), invokeTimeoutMs, "agent streamEvents start", "stream");
                 let terminalOutput = "";
                 const seenTerminalOutputs = new Set();
                 let lastStep = "";
-                for await (const event of this.iterateWithTimeout(events, timeoutMs, "agent streamEvents")) {
+                for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents")) {
                     const interruptPayload = extractInterruptPayload(event);
                     if (interruptPayload) {
                         yield { kind: "interrupt", content: interruptPayload };
@@ -578,9 +631,9 @@ export class AgentRuntimeAdapter {
                 }
             }
             if (binding.langchainAgentParams && typeof runnable.stream === "function") {
-                const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId } }), timeoutMs, "agent stream start");
+                const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId } }), invokeTimeoutMs, "agent stream start", "stream");
                 let emitted = false;
-                for await (const chunk of this.iterateWithTimeout(stream, timeoutMs, "agent stream")) {
+                for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream")) {
                     const delta = readStreamDelta(chunk);
                     if (delta) {
                         emitted = true;

package/dist/runtime/harness.js

@@ -628,7 +628,7 @@ export class AgentHarness {
                     }) };
                 return;
             }
-            if (error instanceof RuntimeOperationTimeoutError) {
+            if (error instanceof RuntimeOperationTimeoutError && error.stage === "invoke") {
                 yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
                         previousState: null,
                         error: error.message,

package/package.json

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