@botbotgo/agent-harness 0.0.314 → 0.0.315

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.313";
+export declare const AGENT_HARNESS_VERSION = "0.0.314";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.313";
+export const AGENT_HARNESS_VERSION = "0.0.314";

package/dist/runtime/adapter/flow/invocation-flow.d.ts

@@ -22,6 +22,7 @@ export declare function executeRequestInvocation(options: {
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         memoryContext?: string;
+        toolRuntimeContext?: Record<string, unknown>;
     }) => Promise<Map<string, ExecutableTool>>;
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
 }): Promise<RequestResult>;

package/dist/runtime/adapter/flow/invocation-flow.js

@@ -34,6 +34,7 @@ export async function executeRequestInvocation(options) {
         executableTools,
         builtinExecutableTools: builtinExecutableTools,
         callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
+        toolRuntimeContext: invokeOptions.toolRuntimeContext,
     });
     const result = localOrUpstreamInvocation.result;
     const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];

package/dist/runtime/adapter/flow/invoke-runtime.d.ts

@@ -16,6 +16,7 @@ export declare function invokeRuntimeWithLocalTools(options: {
     executableTools: Map<string, ExecutableTool>;
     builtinExecutableTools: Map<string, ExecutableTool>;
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
+    toolRuntimeContext?: Record<string, unknown>;
 }): Promise<{
     result: Record<string, unknown>;
     executedToolResults: ExecutedToolResult[];

package/dist/runtime/adapter/flow/invoke-runtime.js

@@ -14,5 +14,6 @@ export async function invokeRuntimeWithLocalTools(options) {
         executableTools: options.executableTools,
         builtinExecutableTools: options.builtinExecutableTools,
         callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
+        toolRuntimeContext: options.toolRuntimeContext,
     });
 }

package/dist/runtime/adapter/local-tool-invocation.d.ts

@@ -14,10 +14,11 @@ type LocalToolInvocationParams = {
     executableTools: Map<string, ExecutableTool>;
     builtinExecutableTools: Map<string, ExecutableTool>;
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
+    toolRuntimeContext?: Record<string, unknown>;
 };
 type LocalToolInvocationResult = {
     result: Record<string, unknown>;
     executedToolResults: ExecutedToolResult[];
 };
-export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
+export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
 export {};

package/dist/runtime/adapter/local-tool-invocation.js

@@ -3,6 +3,7 @@ import { createModelFacingToolNameLookupCandidates, resolveModelFacingToolName }
 import { canReplayToolCallsLocally } from "./tool/tool-replay.js";
 import { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./tool/tool-arguments.js";
 import { extractMemoryCandidatesFromToolOutput } from "../harness/system/runtime-memory-candidates.js";
+import { maybePersistLargeToolOutput } from "./tool/tool-output-artifacts.js";
 const TOOL_FOLLOW_UP_INSTRUCTION = "One or more tool results are already available in this conversation. Answer the user's current request directly from the existing context and tool results. Do not ask the user to repeat inputs that are already present above.";
 function extractLatestUserInput(request) {
     const typedRequest = request;
@@ -19,7 +20,7 @@ function extractLatestUserInput(request) {
     }
     return undefined;
 }
-export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }) {
+export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, }) {
     const executedToolResults = [];
     let activeRequest = request;
     let currentMessages = Array.isArray(activeRequest.messages) ? [...activeRequest.messages] : [];
@@ -74,17 +75,24 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema, toolCall.rawArgsInput, {
                 latestUserInput,
             });
-            const toolResult = await activeExecutable.invoke(normalizedArgs);
+            const toolResult = toolRuntimeContext
+                ? await activeExecutable.invoke(normalizedArgs, { toolRuntimeContext })
+                : await activeExecutable.invoke(normalizedArgs);
             const memoryCandidates = compiledTool ? extractMemoryCandidatesFromToolOutput(compiledTool, toolResult) : [];
-            executedToolResults.push({
+            const safeToolResult = await maybePersistLargeToolOutput({
                 toolName: activeExecutable.name,
                 output: toolResult,
+                toolRuntimeContext: toolRuntimeContext,
+            });
+            executedToolResults.push({
+                toolName: activeExecutable.name,
+                output: safeToolResult,
                 ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
             });
             nextMessages.push(new ToolMessage({
                 name: activeExecutable.name,
                 tool_call_id: toolCall.id ?? `tool-${iteration + 1}-${toolIndex + 1}`,
-                content: stringifyToolOutput(toolResult),
+                content: stringifyToolOutput(safeToolResult),
             }));
         }
         currentMessages = nextMessages;

package/dist/runtime/adapter/middleware-assembly.d.ts

@@ -73,16 +73,19 @@ export declare function resolveBuiltinMiddlewareTools(input: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        toolRuntimeContext?: Record<string, unknown>;
     };
     resolveBuiltinMiddlewareBackend: (binding: CompiledAgentBinding, options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        toolRuntimeContext?: Record<string, unknown>;
     }) => unknown;
     invokeBuiltinTaskTool: (binding: CompiledAgentBinding, toolInput: unknown, options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        toolRuntimeContext?: Record<string, unknown>;
     }) => Promise<unknown>;
 }): Promise<Map<string, ExecutableTool>>;
 export declare function materializeAutomaticSummarizationMiddleware(input: {

package/dist/runtime/adapter/middleware-assembly.js

@@ -182,6 +182,7 @@ export async function resolveBuiltinMiddlewareTools(input) {
     return createBuiltinMiddlewareTools(backend, {
         includeTaskTool: isDeepAgentBinding(input.binding),
         workspaceRoot: input.binding.harnessRuntime.workspaceRoot,
+        toolRuntimeContext: input.options?.toolRuntimeContext,
         invokeTaskTool: isDeepAgentBinding(input.binding)
             ? async (toolInput) => input.invokeBuiltinTaskTool(input.binding, toolInput, input.options)
             : undefined,

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -250,4 +250,5 @@ export declare function createBuiltinMiddlewareTools(backend: BuiltinMiddlewareB
     includeTaskTool: boolean;
     invokeTaskTool?: (input: unknown) => Promise<unknown>;
     workspaceRoot?: string;
+    toolRuntimeContext?: Record<string, unknown>;
 }): Promise<Map<string, BuiltinExecutableTool>>;

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { isSandboxBackend } from "deepagents";
 import { isRecord } from "../../../utils/object.js";
 import { formatBuiltinTodoSnapshot, isLowSignalTodoContent, summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
+import { maybePersistLargeToolOutput, resolveToolRuntimeContext } from "./tool-output-artifacts.js";
 export const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS = [
     { name: "write_todos", description: "Create and update the runtime todo board for multi-step work." },
     { name: "read_todos", description: "Read the current runtime todo board." },
@@ -159,6 +160,11 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             blocked: 0,
         },
     };
+    const finalizeOutput = async (toolName, output, toolConfig) => maybePersistLargeToolOutput({
+        toolName,
+        output,
+        toolRuntimeContext: resolveToolRuntimeContext(toolConfig, options.toolRuntimeContext),
+    });
     tools.set("write_todos", {
         name: "write_todos",
         description: "Create and update the runtime todo board for multi-step work.",
@@ -200,11 +206,11 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         name: "ls",
         description: "List files in a directory.",
         schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
-        invoke: async (input) => {
+        invoke: async (input, toolConfig) => {
             const targetPath = normalizeWorkspacePathOrThrow(pathScopedBackend, isRecord(input) && typeof input.path === "string" ? input.path : "/");
             const shallowListing = await tryExecuteShallowDirectoryListing(pathScopedBackend, targetPath);
             if (typeof shallowListing === "string") {
-                return shallowListing.length > 0 ? shallowListing : `No files found in ${targetPath}`;
+                return finalizeOutput("ls", shallowListing.length > 0 ? shallowListing : `No files found in ${targetPath}`, toolConfig);
             }
             const legacyInfos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
             const infos = legacyInfos.length > 0
@@ -217,14 +223,14 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             if (infos.length === 0) {
                 return `No files found in ${targetPath}`;
             }
-            return truncateLines(infos.map((info) => info.is_dir ? `${info.path} (directory)` : `${info.path}${info.size ? ` (${info.size} bytes)` : ""}`));
+            return finalizeOutput("ls", truncateLines(infos.map((info) => info.is_dir ? `${info.path} (directory)` : `${info.path}${info.size ? ` (${info.size} bytes)` : ""}`)), toolConfig);
         },
     });
     tools.set("list_files", {
         name: "list_files",
         description: "List files in a directory.",
         schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
-        invoke: async (input) => tools.get("ls").invoke(input),
+        invoke: async (input, toolConfig) => tools.get("ls").invoke(input, toolConfig),
     });
     tools.set("read_file", {
         name: "read_file",
@@ -352,7 +358,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         name: "execute",
         description: "Run a shell command in the workspace sandbox.",
         schema: z.object({ command: z.string() }).passthrough(),
-        invoke: async (input) => {
+        invoke: async (input, toolConfig) => {
             if (!isSandboxBackend(backend) || typeof backend.execute !== "function") {
                 return "Error: Execution not available. This agent's backend does not support command execution (SandboxBackendProtocol).";
             }
@@ -365,29 +371,29 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             if (result.truncated) {
                 parts.push("\n[Output was truncated due to size limits]");
             }
-            return parts.join("");
+            return finalizeOutput("execute", parts.join(""), toolConfig);
         },
     });
     tools.set("run_command", {
         name: "run_command",
         description: "Run a shell command in the workspace sandbox.",
         schema: z.object({ command: z.string() }).passthrough(),
-        invoke: async (input) => tools.get("execute").invoke(input),
+        invoke: async (input, toolConfig) => tools.get("execute").invoke(input, toolConfig),
     });
     tools.set("fetch_url", {
         name: "fetch_url",
         description: "Fetch a URL and return the response body.",
         schema: z.object({ url: z.string() }).passthrough(),
-        invoke: async (input) => {
+        invoke: async (input, toolConfig) => {
             if (typeof backend.fetchUrl !== "function") {
                 return notAvailable("fetch_url", "URL fetching");
             }
             const typed = isRecord(input) ? input : {};
             const result = await Promise.resolve(backend.fetchUrl(typeof typed.url === "string" ? typed.url : ""));
             if (typeof result === "string") {
-                return result;
+                return finalizeOutput("fetch_url", result, toolConfig);
             }
-            return formatHttpResponse(result);
+            return finalizeOutput("fetch_url", formatHttpResponse(result), toolConfig);
         },
     });
     tools.set("http_request", {
@@ -399,7 +405,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             headers: z.record(z.string(), z.string()).optional(),
             body: z.string().optional(),
         }).passthrough(),
-        invoke: async (input) => {
+        invoke: async (input, toolConfig) => {
             if (typeof backend.httpRequest !== "function") {
                 return notAvailable("http_request", "structured HTTP requests");
             }
@@ -413,9 +419,9 @@ export async function createBuiltinMiddlewareTools(backend, options) {
                 body: typeof typed.body === "string" ? typed.body : undefined,
             }));
             if (typeof result === "string") {
-                return result;
+                return finalizeOutput("http_request", result, toolConfig);
             }
-            return formatHttpResponse(result);
+            return finalizeOutput("http_request", formatHttpResponse(result), toolConfig);
         },
     });
     tools.set("send_message", {

package/dist/runtime/adapter/tool/tool-output-artifacts.d.ts

@@ -0,0 +1,35 @@
+type ArtifactCreateInput = {
+    sessionId: string;
+    requestId: string;
+    kind: string;
+    path: string;
+    content: unknown;
+    artifactId?: string;
+    createdAt?: string;
+};
+type ArtifactCreateResult = {
+    artifactId: string;
+    kind: string;
+    path: string;
+    createdAt: string;
+};
+type ToolRuntimeContext = {
+    runtime?: {
+        current?: {
+            sessionId?: string;
+            requestId?: string;
+        };
+        artifacts?: {
+            create?: (input: ArtifactCreateInput) => Promise<ArtifactCreateResult> | ArtifactCreateResult;
+        };
+    };
+};
+export declare function resolveToolRuntimeContext(toolConfig?: Record<string, unknown>, fallback?: Record<string, unknown>): ToolRuntimeContext | undefined;
+export declare function maybePersistLargeToolOutput(input: {
+    toolName: string;
+    output: unknown;
+    toolRuntimeContext?: Record<string, unknown>;
+    maxInlineChars?: number;
+    previewChars?: number;
+}): Promise<unknown>;
+export {};

package/dist/runtime/adapter/tool/tool-output-artifacts.js

@@ -0,0 +1,88 @@
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function toSerializedToolOutput(output) {
+    if (typeof output === "string") {
+        return output;
+    }
+    try {
+        return JSON.stringify(output, null, 2);
+    }
+    catch {
+        return String(output);
+    }
+}
+function truncatePreview(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxChars - 15))}\n...[truncated]`;
+}
+function sanitizeArtifactToolName(toolName) {
+    return toolName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "tool";
+}
+export function resolveToolRuntimeContext(toolConfig, fallback) {
+    const dynamic = asRecord(toolConfig?.toolRuntimeContext);
+    const configurable = asRecord(toolConfig?.configurable);
+    const fallbackRuntime = asRecord(asRecord(fallback)?.runtime);
+    const fallbackCurrent = asRecord(fallbackRuntime?.current);
+    const resolved = (dynamic ?? fallback);
+    const runtime = asRecord(resolved?.runtime);
+    if (!runtime) {
+        return resolved;
+    }
+    return {
+        ...resolved,
+        runtime: {
+            ...runtime,
+            current: {
+                ...fallbackCurrent,
+                ...asRecord(runtime.current),
+                ...(typeof configurable?.thread_id === "string" ? { sessionId: configurable.thread_id } : {}),
+                ...(typeof configurable?.request_id === "string" ? { requestId: configurable.request_id } : {}),
+            },
+        },
+    };
+}
+export async function maybePersistLargeToolOutput(input) {
+    const maxInlineChars = input.maxInlineChars ?? 12_000;
+    const previewChars = input.previewChars ?? 2_000;
+    const serialized = toSerializedToolOutput(input.output);
+    if (serialized.length <= maxInlineChars) {
+        return input.output;
+    }
+    const runtimeContext = input.toolRuntimeContext;
+    const runtime = runtimeContext?.runtime;
+    const sessionId = runtime?.current?.sessionId;
+    const requestId = runtime?.current?.requestId;
+    const createArtifact = runtime?.artifacts?.create;
+    const createdAt = new Date().toISOString();
+    const safeToolName = sanitizeArtifactToolName(input.toolName);
+    let artifact;
+    if (typeof createArtifact === "function" && typeof sessionId === "string" && typeof requestId === "string") {
+        artifact = await Promise.resolve(createArtifact({
+            sessionId,
+            requestId,
+            kind: "tool-output",
+            path: `artifacts/tool-output-${safeToolName}-${Date.now()}.json`,
+            createdAt,
+            content: {
+                toolName: input.toolName,
+                createdAt,
+                output: input.output,
+            },
+        }));
+    }
+    return {
+        truncated: true,
+        toolName: input.toolName,
+        message: artifact
+            ? "Full tool output was stored as a request artifact because it exceeded the inline size limit."
+            : "Tool output exceeded the inline size limit and was truncated for runtime stability.",
+        originalSizeChars: serialized.length,
+        preview: truncatePreview(serialized, previewChars),
+        ...(artifact ? { artifact } : {}),
+    };
+}

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

@@ -302,7 +302,12 @@ export class AgentRuntimeAdapter {
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
         const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: await this.resolveBuiltinMiddlewareTools(binding, { sessionId: options.sessionId ?? options.legacySessionId }),
+            builtinTools: await this.resolveBuiltinMiddlewareTools(binding, {
+                sessionId: options.sessionId ?? options.legacySessionId,
+                toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
+                    sessionId: options.sessionId ?? options.legacySessionId,
+                }),
+            }),
             explicitToolNames: primaryTools.map((tool) => tool.name),
         });
         const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn, { sessionId: options.sessionId ?? options.legacySessionId });
@@ -330,9 +335,9 @@ export class AgentRuntimeAdapter {
         if (isLangChainBinding(binding)) {
             return this.createLangChainRunnable(binding, { sessionId: options.sessionId ?? options.legacySessionId });
         }
-        return this.createDeepAgentRunnable(binding);
+        return this.createDeepAgentRunnable(binding, { sessionId: options.sessionId ?? options.legacySessionId });
     }
-    async createDeepAgentRunnable(binding) {
+    async createDeepAgentRunnable(binding, options = {}) {
         const executionKind = getBindingExecutionKind(binding);
         const primaryModel = getBindingPrimaryModel(binding);
         const primaryTools = getBindingPrimaryTools(binding);
@@ -342,7 +347,12 @@ export class AgentRuntimeAdapter {
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
         const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: await this.resolveBuiltinMiddlewareTools(binding),
+            builtinTools: await this.resolveBuiltinMiddlewareTools(binding, {
+                sessionId: options.sessionId ?? options.legacySessionId,
+                toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
+                    sessionId: options.sessionId ?? options.legacySessionId,
+                }),
+            }),
             explicitToolNames: primaryTools.map((tool) => tool.name),
         });
         const resolvedMiddleware = await this.resolveMiddleware(binding);

package/dist/runtime/harness.js

@@ -174,6 +174,7 @@ export class AgentHarnessRuntime {
                 artifacts: {
                     list: (sessionId, requestId) => this.listRequestArtifacts(sessionId, requestId),
                     read: (sessionId, requestId, artifactPath) => this.readRequestArtifact(sessionId, requestId, artifactPath),
+                    create: (artifact) => this.recordArtifact(artifact),
                 },
                 schedules: {
                     manage: (options) => this.manageSchedule(options),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.314",
+  "version": "0.0.315",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",