@botbotgo/agent-harness 0.0.36 → 0.0.38

package/dist/contracts/types.d.ts

@@ -236,6 +236,7 @@ export type RunListeners = {
     onToolResult?: (item: {
         toolName: string;
         output: unknown;
+        isError?: boolean;
     }) => void | Promise<void>;
 };
 export type MessageContentPart = {
@@ -289,6 +290,7 @@ export type HarnessStreamItem = {
     agentId: string;
     toolName: string;
     output: unknown;
+    isError?: boolean;
 };
 export type TranscriptMessage = {
     role: "user" | "assistant";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.35";
+export declare const AGENT_HARNESS_VERSION = "0.0.37";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.35";
+export const AGENT_HARNESS_VERSION = "0.0.37";

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

@@ -32,6 +32,16 @@ function asObject(value) {
 function resolveTimeoutMs(value) {
     return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
 }
+function computeRemainingTimeoutMs(deadlineAt, fallbackTimeoutMs) {
+    if (!deadlineAt) {
+        return fallbackTimeoutMs;
+    }
+    const remaining = deadlineAt - Date.now();
+    if (remaining <= 0) {
+        return 0;
+    }
+    return fallbackTimeoutMs ? Math.min(fallbackTimeoutMs, remaining) : remaining;
+}
 function isPlaceholderApiKey(value) {
     return typeof value === "string" && value.trim().toLowerCase() === "dummy";
 }
@@ -209,11 +219,27 @@ export class AgentRuntimeAdapter {
             });
         });
     }
-    async *iterateWithTimeout(iterable, timeoutMs, operation) {
+    async *iterateWithTimeout(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs) {
         const iterator = iterable[Symbol.asyncIterator]();
         try {
             for (;;) {
-                const next = await this.withTimeout(() => iterator.next(), timeoutMs, operation, "stream");
+                const effectiveTimeoutMs = computeRemainingTimeoutMs(deadlineAt, timeoutMs);
+                if (effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0) {
+                    throw new RuntimeOperationTimeoutError(operation, deadlineTimeoutMs ?? timeoutMs ?? 0, "invoke");
+                }
+                let next;
+                try {
+                    next = await this.withTimeout(() => iterator.next(), effectiveTimeoutMs, operation, "stream");
+                }
+                catch (error) {
+                    if (error instanceof RuntimeOperationTimeoutError &&
+                        deadlineAt &&
+                        deadlineTimeoutMs &&
+                        effectiveTimeoutMs !== timeoutMs) {
+                        throw new RuntimeOperationTimeoutError(operation, deadlineTimeoutMs, "invoke");
+                    }
+                    throw error;
+                }
                 if (next.done) {
                     return;
                 }
@@ -591,6 +617,7 @@ export class AgentRuntimeAdapter {
         try {
             const invokeTimeoutMs = this.resolveBindingTimeout(binding);
             const streamIdleTimeoutMs = this.resolveStreamIdleTimeout(binding);
+            const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
             if (binding.langchainAgentParams) {
                 const langchainParams = binding.langchainAgentParams;
                 const resolvedModel = (await this.resolveModel(binding.langchainAgentParams.model));
@@ -605,8 +632,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)), invokeTimeoutMs, "model stream start", "stream");
-                    for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream")) {
+                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(langchainParams.systemPrompt, history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
+                    for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream", streamDeadlineAt, invokeTimeoutMs)) {
                         const delta = readStreamDelta(chunk);
                         if (delta) {
                             emitted = true;
@@ -626,12 +653,13 @@ 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" }), invokeTimeoutMs, "agent streamEvents start", "stream");
+                const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2" }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
                 const allowVisibleStreamDeltas = Boolean(binding.langchainAgentParams);
                 let emittedOutput = "";
+                let emittedToolError = false;
                 const seenTerminalOutputs = new Set();
                 let lastStep = "";
-                for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents")) {
+                for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents", streamDeadlineAt, invokeTimeoutMs)) {
                     const interruptPayload = extractInterruptPayload(event);
                     if (interruptPayload) {
                         yield { kind: "interrupt", content: interruptPayload };
@@ -668,7 +696,8 @@ export class AgentRuntimeAdapter {
                     }
                     const toolResult = extractToolResult(event);
                     if (toolResult) {
-                        yield { kind: "tool-result", toolName: toolResult.toolName, output: toolResult.output };
+                        emittedToolError = emittedToolError || toolResult.isError === true;
+                        yield { kind: "tool-result", toolName: toolResult.toolName, output: toolResult.output, isError: toolResult.isError };
                     }
                     const output = extractTerminalStreamOutput(event);
                     if (output) {
@@ -686,14 +715,14 @@ export class AgentRuntimeAdapter {
                         }
                     }
                 }
-                if (emittedOutput) {
+                if (emittedOutput || emittedToolError) {
                     return;
                 }
             }
             if (binding.langchainAgentParams && typeof runnable.stream === "function") {
-                const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId } }), invokeTimeoutMs, "agent stream start", "stream");
+                const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId } }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent stream start", "stream");
                 let emitted = false;
-                for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream")) {
+                for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream", streamDeadlineAt, invokeTimeoutMs)) {
                     const delta = readStreamDelta(chunk);
                     if (delta) {
                         emitted = true;

package/dist/runtime/harness.js

@@ -6,7 +6,7 @@ import { createResourceBackendResolver, createResourceToolResolver } from "../re
 import { EventBus } from "./event-bus.js";
 import { PolicyEngine } from "./policy-engine.js";
 import { getRoutingSystemPrompt } from "../workspace/support/workspace-ref-utils.js";
-import { createHarnessEvent, createPendingApproval, heuristicRoute, inferRoutingBindings, resolveDeterministicRouteIntent, renderRuntimeFailure, requiresResearchRoute, } from "./support/harness-support.js";
+import { createHarnessEvent, createPendingApproval, heuristicRoute, inferRoutingBindings, resolveDeterministicRouteIntent, renderRuntimeFailure, renderToolFailure, requiresResearchRoute, } from "./support/harness-support.js";
 import { createCheckpointerForConfig, createStoreForConfig } from "./support/runtime-factories.js";
 import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "./support/embedding-models.js";
 import { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "./support/vector-stores.js";
@@ -429,6 +429,7 @@ export class AgentHarness {
                 await this.notifyListener(listeners.onToolResult, {
                     toolName: item.toolName,
                     output: item.output,
+                    isError: item.isError,
                 });
             }
         }
@@ -543,6 +544,7 @@ export class AgentHarness {
         try {
             const priorHistory = await this.loadPriorHistory(threadId, runId);
             let assistantOutput = "";
+            const toolErrors = [];
             for await (const chunk of this.runtimeAdapter.stream(binding, options.input, threadId, priorHistory)) {
                 if (chunk) {
                     const normalizedChunk = typeof chunk === "string"
@@ -591,6 +593,9 @@ export class AgentHarness {
                         continue;
                     }
                     if (normalizedChunk.kind === "tool-result") {
+                        if (normalizedChunk.isError) {
+                            toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
+                        }
                         yield {
                             type: "tool-result",
                             threadId,
@@ -598,6 +603,7 @@ export class AgentHarness {
                             agentId: selectedAgentId,
                             toolName: normalizedChunk.toolName,
                             output: normalizedChunk.output,
+                            isError: normalizedChunk.isError,
                         };
                         continue;
                     }
@@ -606,6 +612,11 @@ export class AgentHarness {
                     yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, normalizedChunk.content);
                 }
             }
+            if (!assistantOutput && toolErrors.length > 0) {
+                assistantOutput = toolErrors.join("\n\n");
+                emitted = true;
+                yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, assistantOutput);
+            }
             if (!assistantOutput) {
                 const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
                 if (actual.output) {

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

@@ -14,6 +14,7 @@ export type RuntimeStreamChunk = {
     kind: "tool-result";
     toolName: string;
     output: unknown;
+    isError?: boolean;
 };
 export declare function extractTerminalStreamOutput(event: unknown): string;
 export declare function extractReasoningStreamOutput(event: unknown): string;
@@ -23,6 +24,7 @@ export declare function extractAgentStep(event: unknown): string | null;
 export declare function extractToolResult(event: unknown): {
     toolName: string;
     output: unknown;
+    isError?: boolean;
 } | null;
 export declare function extractInterruptPayload(event: unknown): string | null;
 export declare function normalizeTerminalOutputKey(value: string): string;

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

@@ -50,6 +50,31 @@ function summarizeStepValue(value) {
 function humanizeEventName(name) {
     return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[._-]+/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
 }
+function readToolErrorText(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value instanceof Error) {
+        return value.message;
+    }
+    if (typeof value !== "object" || !value) {
+        return "";
+    }
+    const record = value;
+    for (const candidate of [record.error, record.message, record.detail, record.details]) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate;
+        }
+    }
+    return "";
+}
+function isErrorLikeToolOutput(value) {
+    const message = readToolErrorText(value).trim();
+    if (!message) {
+        return false;
+    }
+    return /(^|\b)(error|exception|failed|failure|denied|timed out|timeout|not permitted|eperm|eacces)(\b|:)/i.test(message);
+}
 export function extractTerminalStreamOutput(event) {
     if (typeof event !== "object" || !event)
         return "";
@@ -109,6 +134,10 @@ export function extractAgentStep(event) {
         const outputSummary = formatStepValue(typed.data?.output, 80);
         return outputSummary ? `tool ${name || "tool"} done  ${outputSummary}` : `tool ${name || "tool"} done`;
     }
+    if (typed.event === "on_tool_error" || (typed.event === "on_chain_error" && typed.run_type === "tool")) {
+        const errorSummary = formatStepValue(typed.data?.error ?? typed.data?.output, 80);
+        return errorSummary ? `tool ${name || "tool"} error  ${errorSummary}` : `tool ${name || "tool"} error`;
+    }
     if (typed.event === "on_chat_model_start") {
         const inputTools = typed.data?.input?.tools;
         const tools = typed.invocation_params?.tools ?? inputTools ?? [];
@@ -148,14 +177,17 @@ export function extractToolResult(event) {
         return null;
     const typed = event;
     const isToolEnd = typed.event === "on_tool_end" || (typed.event === "on_chain_end" && typed.run_type === "tool");
+    const isToolError = typed.event === "on_tool_error" || (typed.event === "on_chain_error" && typed.run_type === "tool");
     const toolName = typeof typed.name === "string" ? typed.name : "";
-    if (!isToolEnd || !toolName) {
+    if ((!isToolEnd && !isToolError) || !toolName) {
         return null;
     }
-    const rawOutput = typed.data?.output;
+    const rawOutput = isToolError ? typed.data?.error ?? typed.data?.output : typed.data?.output;
+    const normalizedOutput = typeof rawOutput === "string" ? parseMaybeJson(rawOutput) : rawOutput;
     return {
         toolName,
-        output: typeof rawOutput === "string" ? parseMaybeJson(rawOutput) : rawOutput,
+        output: normalizedOutput,
+        isError: isToolError || isErrorLikeToolOutput(normalizedOutput),
     };
 }
 export function extractInterruptPayload(event) {

package/dist/runtime/support/harness-support.d.ts

@@ -1,5 +1,6 @@
 import type { ApprovalRecord, HarnessEvent, WorkspaceBundle } from "../../contracts/types.js";
 export declare function renderRuntimeFailure(error: unknown): string;
+export declare function renderToolFailure(toolName: string, output: unknown): string;
 export declare function parseInterruptContent(content: string): {
     toolName?: string;
     toolId?: string;

package/dist/runtime/support/harness-support.js

@@ -3,6 +3,33 @@ export function renderRuntimeFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return `runtime_error=${message}`.trim();
 }
+function readToolErrorMessage(output) {
+    if (typeof output === "string" && output.trim()) {
+        return output.trim();
+    }
+    if (output instanceof Error) {
+        return output.message;
+    }
+    if (typeof output !== "object" || !output) {
+        return "";
+    }
+    const record = output;
+    for (const candidate of [record.error, record.message, record.detail, record.details]) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    try {
+        return JSON.stringify(output);
+    }
+    catch {
+        return String(output);
+    }
+}
+export function renderToolFailure(toolName, output) {
+    const detail = readToolErrorMessage(output);
+    return detail ? `Tool ${toolName} failed: ${detail}` : `Tool ${toolName} failed.`;
+}
 export function parseInterruptContent(content) {
     try {
         const raw = JSON.parse(content);

package/package.json

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