@botbotgo/agent-harness 0.0.29 → 0.0.31

package/dist/package-version.d.ts

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

package/dist/package-version.js

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

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

@@ -6,9 +6,19 @@ type RunnableLike = {
     streamEvents?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
 };
 declare const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+declare class RuntimeOperationTimeoutError extends Error {
+    readonly operation: string;
+    readonly 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;
     private createModelFallbackRunnable;
     private applyStrictToolJsonInstruction;
@@ -32,4 +42,4 @@ export declare class AgentRuntimeAdapter {
     invoke(binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string, resumePayload?: unknown, history?: TranscriptMessage[]): Promise<RunResult>;
     stream(binding: CompiledAgentBinding, input: MessageContent, threadId: string, history?: TranscriptMessage[]): AsyncGenerator<RuntimeStreamChunk | string>;
 }
-export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError, };

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

@@ -12,9 +12,24 @@ import { resolveDeclaredMiddleware } from "./declared-middleware.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+class RuntimeOperationTimeoutError extends Error {
+    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";
+    }
+}
 function asObject(value) {
     return typeof value === "object" && value ? value : undefined;
 }
+function resolveTimeoutMs(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
 function isPlaceholderApiKey(value) {
     return typeof value === "string" && value.trim().toLowerCase() === "dummy";
 }
@@ -113,6 +128,55 @@ export class AgentRuntimeAdapter {
     constructor(options = {}) {
         this.options = options;
     }
+    resolveBindingTimeout(binding) {
+        return resolveTimeoutMs(binding.langchainAgentParams?.model.init.timeout ?? binding.deepAgentParams?.model.init.timeout);
+    }
+    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, stage)), timeoutMs);
+            Promise.resolve(producer()).then((value) => {
+                clearTimeout(timer);
+                resolve(value);
+            }, (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    async *iterateWithTimeout(iterable, timeoutMs, operation) {
+        const iterator = iterable[Symbol.asyncIterator]();
+        try {
+            for (;;) {
+                const next = await this.withTimeout(() => iterator.next(), timeoutMs, operation, "stream");
+                if (next.done) {
+                    return;
+                }
+                yield next.value;
+            }
+        }
+        finally {
+            if (typeof iterator.return === "function") {
+                const returnResult = iterator.return();
+                if (returnResult && typeof returnResult.then === "function") {
+                    void returnResult.catch(() => undefined);
+                }
+            }
+        }
+    }
     async materializeModelStream(streamFactory, input, config) {
         const stream = await streamFactory(input, config);
         let content = "";
@@ -193,7 +257,7 @@ export class AgentRuntimeAdapter {
         if (!model?.invoke) {
             return "";
         }
-        const synthesized = await model.invoke([
+        const synthesized = await this.withTimeout(() => model.invoke([
             {
                 role: "system",
                 content: "The previous agent run completed tool work but did not produce a final user-facing answer. Write the final answer now using the tool results provided. Do not expose internal state, tools, or reasoning.",
@@ -202,7 +266,7 @@ export class AgentRuntimeAdapter {
                 role: "user",
                 content: `Original user request:\n${extractMessageText(input)}\n\nTool results:\n${toolContext}`,
             },
-        ]);
+        ]), this.resolveBindingTimeout(binding), "deepagent synthesis invoke", "invoke");
         return sanitizeVisibleText(extractVisibleOutput(synthesized));
     }
     async resolveModel(model) {
@@ -421,7 +485,7 @@ export class AgentRuntimeAdapter {
         let result;
         try {
             const runnable = await this.create(binding);
-            result = (await runnable.invoke(request, { configurable: { thread_id: threadId } }));
+            result = (await this.withTimeout(() => runnable.invoke(request, { configurable: { thread_id: threadId } }), this.resolveBindingTimeout(binding), "agent invoke", "invoke"));
         }
         catch (error) {
             if (resumePayload !== undefined || !isToolCallParseFailure(error)) {
@@ -429,7 +493,7 @@ export class AgentRuntimeAdapter {
             }
             const retriedBinding = this.applyStrictToolJsonInstruction(binding);
             const runnable = await this.create(retriedBinding);
-            result = (await runnable.invoke({ messages: this.buildAgentMessages(history, input) }, { configurable: { thread_id: threadId } }));
+            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);
@@ -452,9 +516,12 @@ export class AgentRuntimeAdapter {
     }
     async *stream(binding, input, threadId, history = []) {
         try {
+            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));
-                const tools = this.resolveTools(binding.langchainAgentParams.tools, binding);
+                const tools = this.resolveTools(langchainParams.tools, binding);
                 const canUseDirectModelStream = tools.length === 0 || typeof resolvedModel.bindTools !== "function";
                 const model = canUseDirectModelStream
                     ? resolvedModel
@@ -465,8 +532,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 model.stream(this.buildRawModelMessages(binding.langchainAgentParams.systemPrompt, history, input));
-                    for await (const chunk of 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;
@@ -486,11 +553,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 runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2" });
+                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 events) {
+                for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents")) {
                     const interruptPayload = extractInterruptPayload(event);
                     if (interruptPayload) {
                         yield { kind: "interrupt", content: interruptPayload };
@@ -527,9 +594,9 @@ export class AgentRuntimeAdapter {
                 }
             }
             if (binding.langchainAgentParams && typeof runnable.stream === "function") {
-                const stream = await runnable.stream(request, { configurable: { thread_id: threadId } });
+                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 stream) {
+                for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream")) {
                     const delta = readStreamDelta(chunk);
                     if (delta) {
                         emitted = true;
@@ -566,4 +633,4 @@ export class AgentRuntimeAdapter {
         }
     }
 }
-export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError, };

package/dist/runtime/harness.js

@@ -1,7 +1,7 @@
 import { AUTO_AGENT_ID } from "../contracts/types.js";
 import { FilePersistence } from "../persistence/file-store.js";
 import { createPersistentId } from "../utils/id.js";
-import { AGENT_INTERRUPT_SENTINEL_PREFIX, AgentRuntimeAdapter } from "./agent-runtime-adapter.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, AgentRuntimeAdapter, RuntimeOperationTimeoutError } from "./agent-runtime-adapter.js";
 import { createResourceBackendResolver, createResourceToolResolver } from "../resource/resource.js";
 import { EventBus } from "./event-bus.js";
 import { PolicyEngine } from "./policy-engine.js";
@@ -628,6 +628,20 @@ export class AgentHarness {
                     }) };
                 return;
             }
+            if (error instanceof RuntimeOperationTimeoutError && error.stage === "invoke") {
+                yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 4, "failed", {
+                        previousState: null,
+                        error: error.message,
+                    }) };
+                yield {
+                    type: "content",
+                    threadId,
+                    runId,
+                    agentId: selectedAgentId,
+                    content: renderRuntimeFailure(error),
+                };
+                return;
+            }
             try {
                 const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
                 await this.appendAssistantMessage(threadId, runId, actual.output);

package/package.json

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