@botbotgo/agent-harness 0.0.28 → 0.0.30

package/dist/package-version.d.ts

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

package/dist/package-version.js

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

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

@@ -6,9 +6,16 @@ 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 timeoutMs: number;
+    constructor(operation: string, timeoutMs: number);
+}
 export declare class AgentRuntimeAdapter {
     private readonly options;
     constructor(options?: RuntimeAdapterOptions);
+    private resolveBindingTimeout;
+    private withTimeout;
+    private iterateWithTimeout;
     private materializeModelStream;
     private createModelFallbackRunnable;
     private applyStrictToolJsonInstruction;
@@ -32,4 +39,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,20 +12,58 @@ 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 {
+    timeoutMs;
+    constructor(operation, timeoutMs) {
+        super(`${operation} timed out after ${timeoutMs}ms`);
+        this.timeoutMs = timeoutMs;
+        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";
+}
+function buildAuthOmittingFetch(baseFetch = fetch) {
+    return async (input, init) => {
+        const sanitizedHeaders = new Headers(input instanceof Request ? input.headers : undefined);
+        const initHeaders = new Headers(init?.headers);
+        initHeaders.forEach((value, key) => {
+            sanitizedHeaders.set(key, value);
+        });
+        sanitizedHeaders.delete("authorization");
+        if (input instanceof Request) {
+            return baseFetch(new Request(input, {
+                ...init,
+                headers: sanitizedHeaders,
+            }));
+        }
+        return baseFetch(input, {
+            ...init,
+            headers: sanitizedHeaders,
+        });
+    };
+}
 function normalizeOpenAICompatibleInit(init) {
     const normalized = { ...init };
     const configuration = asObject(init.configuration) ?? {};
     const baseUrl = typeof init.baseUrl === "string" && init.baseUrl.trim() ? init.baseUrl.trim() : undefined;
-    if (baseUrl && typeof configuration.baseURL !== "string") {
-        normalized.configuration = {
-            ...configuration,
-            baseURL: baseUrl,
-        };
+    const omitAuthHeader = init.omitAuthHeader === true || isPlaceholderApiKey(init.apiKey);
+    const nextConfiguration = { ...configuration };
+    if (baseUrl && typeof nextConfiguration.baseURL !== "string") {
+        nextConfiguration.baseURL = baseUrl;
+    }
+    if (omitAuthHeader) {
+        nextConfiguration.fetch = buildAuthOmittingFetch(typeof configuration.fetch === "function" ? configuration.fetch : fetch);
     }
+    normalized.configuration = nextConfiguration;
     delete normalized.baseUrl;
+    delete normalized.omitAuthHeader;
     return normalized;
 }
 function sanitizeToolNameForModel(name) {
@@ -86,6 +124,44 @@ export class AgentRuntimeAdapter {
     constructor(options = {}) {
         this.options = options;
     }
+    resolveBindingTimeout(binding) {
+        return resolveTimeoutMs(binding.langchainAgentParams?.model.init.timeout ?? binding.deepAgentParams?.model.init.timeout);
+    }
+    async withTimeout(producer, timeoutMs, operation) {
+        if (!timeoutMs) {
+            return Promise.resolve(producer());
+        }
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new RuntimeOperationTimeoutError(operation, timeoutMs)), 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);
+                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 = "";
@@ -166,7 +242,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.",
@@ -175,7 +251,7 @@ export class AgentRuntimeAdapter {
                 role: "user",
                 content: `Original user request:\n${extractMessageText(input)}\n\nTool results:\n${toolContext}`,
             },
-        ]);
+        ]), this.resolveBindingTimeout(binding), "deepagent synthesis invoke");
         return sanitizeVisibleText(extractVisibleOutput(synthesized));
     }
     async resolveModel(model) {
@@ -394,7 +470,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"));
         }
         catch (error) {
             if (resumePayload !== undefined || !isToolCallParseFailure(error)) {
@@ -402,7 +478,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"));
         }
         const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
         const extractedOutput = extractVisibleOutput(result);
@@ -425,9 +501,11 @@ export class AgentRuntimeAdapter {
     }
     async *stream(binding, input, threadId, history = []) {
         try {
+            const timeoutMs = this.resolveBindingTimeout(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
@@ -438,8 +516,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)), timeoutMs, "model stream start");
+                    for await (const chunk of this.iterateWithTimeout(stream, timeoutMs, "model stream")) {
                         const delta = readStreamDelta(chunk);
                         if (delta) {
                             emitted = true;
@@ -459,11 +537,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" }), timeoutMs, "agent streamEvents start");
                 let terminalOutput = "";
                 const seenTerminalOutputs = new Set();
                 let lastStep = "";
-                for await (const event of events) {
+                for await (const event of this.iterateWithTimeout(events, timeoutMs, "agent streamEvents")) {
                     const interruptPayload = extractInterruptPayload(event);
                     if (interruptPayload) {
                         yield { kind: "interrupt", content: interruptPayload };
@@ -500,9 +578,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 } }), timeoutMs, "agent stream start");
                 let emitted = false;
-                for await (const chunk of stream) {
+                for await (const chunk of this.iterateWithTimeout(stream, timeoutMs, "agent stream")) {
                     const delta = readStreamDelta(chunk);
                     if (delta) {
                         emitted = true;
@@ -539,4 +617,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) {
+                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.28",
+  "version": "0.0.30",
   "description": "Agent Harness framework package",
   "type": "module",
   "packageManager": "npm@10.9.2",