@botbotgo/agent-harness 0.0.298 → 0.0.299

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

@@ -1,7 +1,29 @@
+import path from "node:path";
 import { z } from "zod";
 import { isSandboxBackend } from "deepagents";
 import { isRecord } from "../../../utils/object.js";
-import { formatBuiltinTodoSnapshot, summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
+import { formatBuiltinTodoSnapshot, isLowSignalTodoContent, summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.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." },
+    { name: "ls", description: "List files in a directory." },
+    { name: "list_files", description: "List files in a directory." },
+    { name: "read_file", description: "Read a file from the workspace filesystem." },
+    { name: "write_file", description: "Write a file in the workspace filesystem." },
+    { name: "edit_file", description: "Replace exact text inside a workspace file." },
+    { name: "glob", description: "Find files matching a glob pattern." },
+    { name: "grep", description: "Search for text across workspace files." },
+    { name: "search_files", description: "Search for text across workspace files." },
+    { name: "execute", description: "Run a shell command in the workspace sandbox." },
+    { name: "run_command", description: "Run a shell command in the workspace sandbox." },
+    { name: "fetch_url", description: "Fetch a URL and return the response body." },
+    { name: "http_request", description: "Send a structured HTTP request." },
+    { name: "send_message", description: "Send a message through the configured backend." },
+    { name: "request_approval", description: "Request an approval decision from the runtime." },
+    { name: "schedule_task", description: "Create, inspect, update, list, and delete system-level scheduled tasks." },
+    { name: "task", description: "Delegate a bounded task to a subagent." },
+    { name: "delegate_task", description: "Delegate a bounded task to a subagent." },
+];
 function toDisplayContent(content) {
     if (typeof content === "string") {
         return content;
@@ -14,6 +36,34 @@ function toDisplayContent(content) {
 function notAvailable(toolName, capability) {
     return `Error: ${toolName} is not available. This backend does not support ${capability}.`;
 }
+function resolveWorkspaceRoot(backend) {
+    const typed = backend;
+    if (typeof typed.rootDir === "string" && typed.rootDir.trim().length > 0) {
+        return typed.rootDir.trim();
+    }
+    if (typeof typed.root === "string" && typed.root.trim().length > 0) {
+        return typed.root.trim();
+    }
+    if (typeof typed.cwd === "string" && typed.cwd.trim().length > 0) {
+        return typed.cwd.trim();
+    }
+    return undefined;
+}
+function normalizeWorkspacePathOrThrow(backend, inputPath) {
+    if (!inputPath) {
+        return inputPath;
+    }
+    const workspaceRoot = resolveWorkspaceRoot(backend);
+    if (!workspaceRoot || !path.isAbsolute(inputPath)) {
+        return inputPath;
+    }
+    const normalizedWorkspaceRoot = path.resolve(workspaceRoot);
+    const normalizedInputPath = path.resolve(inputPath);
+    if (normalizedInputPath === normalizedWorkspaceRoot || normalizedInputPath.startsWith(`${normalizedWorkspaceRoot}${path.sep}`)) {
+        return path.relative(normalizedWorkspaceRoot, normalizedInputPath) || ".";
+    }
+    throw new Error(`Path '${inputPath}' is outside the workspace root '${normalizedWorkspaceRoot}'. Use a workspace-relative path instead.`);
+}
 function formatHttpResponse(result) {
     if (result?.error) {
         return result.error;
@@ -28,33 +78,77 @@ function formatHttpResponse(result) {
     ];
     return lines.length > 0 ? lines.join("\n") : "Request completed.";
 }
+function parseScheduleWhen(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    const intervalMatch = /^every\s+(\d+)\s*(minute|minutes|min|mins|hour|hours|hr|hrs)$/u.exec(normalized);
+    if (intervalMatch) {
+        const quantity = Number.parseInt(intervalMatch[1], 10);
+        const unit = intervalMatch[2];
+        return {
+            type: "interval",
+            everyMinutes: unit.startsWith("h") ? quantity * 60 : quantity,
+        };
+    }
+    if (normalized === "hourly" || normalized === "every hour") {
+        return {
+            type: "interval",
+            everyMinutes: 60,
+        };
+    }
+    return {
+        type: "cron",
+        expression: value,
+    };
+}
 export async function createBuiltinMiddlewareTools(backend, options) {
     const tools = new Map();
+    const pathScopedBackend = options.workspaceRoot
+        ? { ...backend, rootDir: options.workspaceRoot }
+        : backend;
     let todoSnapshot = {
-        total: 0,
-        pending: 0,
-        completed: 0,
         items: [],
+        summary: {
+            total: 0,
+            pending: 0,
+            inProgress: 0,
+            completed: 0,
+            failed: 0,
+            cancelled: 0,
+            blocked: 0,
+        },
     };
     tools.set("write_todos", {
         name: "write_todos",
+        description: "Create and update the runtime todo board for multi-step work.",
         schema: z.object({
             todos: z.array(z.object({}).passthrough()).optional(),
         }).passthrough(),
         invoke: async (input) => {
             const args = isRecord(input) ? input : {};
             const summary = summarizeBuiltinWriteTodosArgs(args);
+            if (summary.summary.total === 0 && todoSnapshot.summary.total === 0) {
+                throw new Error("Initial write_todos call cannot use an empty todo list. Send the concrete task steps with both content and status.");
+            }
+            if (summary.summary.total > 0 &&
+                todoSnapshot.summary.total === 0 &&
+                summary.items.every((item) => isLowSignalTodoContent(item.content))) {
+                throw new Error("Initial write_todos call must use descriptive task content. Do not use placeholder entries like '1', '2', or 'step 1'.");
+            }
             todoSnapshot = summary;
             return {
                 ok: true,
                 tool: "write_todos",
-                message: `Tracked ${summary.total} todo item(s).`,
+                message: `Tracked ${summary.summary.total} todo item(s).`,
                 summary,
             };
         },
     });
     tools.set("read_todos", {
         name: "read_todos",
+        description: "Read the current runtime todo board.",
         schema: z.object({}).passthrough(),
         invoke: async () => ({
             ok: true,
@@ -65,9 +159,10 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     });
     tools.set("ls", {
         name: "ls",
+        description: "List files in a directory.",
         schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
         invoke: async (input) => {
-            const targetPath = isRecord(input) && typeof input.path === "string" ? input.path : "/";
+            const targetPath = normalizeWorkspacePathOrThrow(pathScopedBackend, isRecord(input) && typeof input.path === "string" ? input.path : "/");
             const legacyInfos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
             const infos = legacyInfos.length > 0
                 ? legacyInfos
@@ -84,11 +179,13 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     });
     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),
     });
     tools.set("read_file", {
         name: "read_file",
+        description: "Read a file from the workspace filesystem.",
         schema: z.object({
             file_path: z.string(),
             offset: z.number().optional(),
@@ -96,27 +193,30 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         }).passthrough(),
         invoke: async (input) => {
             const typed = isRecord(input) ? input : {};
-            const filePath = typeof typed.file_path === "string" ? typed.file_path : "";
+            const filePath = normalizeWorkspacePathOrThrow(pathScopedBackend, typeof typed.file_path === "string" ? typed.file_path : "");
             const offset = typeof typed.offset === "number" ? typed.offset : 0;
             const limit = typeof typed.limit === "number" ? typed.limit : 500;
             const result = await Promise.resolve(backend.read?.(filePath, offset, limit));
             if (typeof result === "string") {
                 return result;
             }
-            return toDisplayContent(result?.content);
+            return result?.error ?? toDisplayContent(result?.content);
         },
     });
     tools.set("write_file", {
         name: "write_file",
+        description: "Write a file in the workspace filesystem.",
         schema: z.object({ file_path: z.string(), content: z.string().optional() }).passthrough(),
         invoke: async (input) => {
             const typed = isRecord(input) ? input : {};
-            const result = await Promise.resolve(backend.write?.(typeof typed.file_path === "string" ? typed.file_path : "", typeof typed.content === "string" ? typed.content : ""));
-            return result?.error ?? `Successfully wrote to '${result?.path ?? (typed.file_path ?? "")}'`;
+            const filePath = normalizeWorkspacePathOrThrow(pathScopedBackend, typeof typed.file_path === "string" ? typed.file_path : "");
+            const result = await Promise.resolve(backend.write?.(filePath, typeof typed.content === "string" ? typed.content : ""));
+            return result?.error ?? `Successfully wrote to '${result?.path ?? filePath}'`;
         },
     });
     tools.set("edit_file", {
         name: "edit_file",
+        description: "Replace exact text inside a workspace file.",
         schema: z.object({
             file_path: z.string(),
             old_string: z.string(),
@@ -125,17 +225,19 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         }).passthrough(),
         invoke: async (input) => {
             const typed = isRecord(input) ? input : {};
-            const result = await Promise.resolve(backend.edit?.(typeof typed.file_path === "string" ? typed.file_path : "", typeof typed.old_string === "string" ? typed.old_string : "", typeof typed.new_string === "string" ? typed.new_string : "", typed.replace_all === true));
-            return result?.error ?? `Successfully replaced ${result?.occurrences ?? 0} occurrence(s) in '${result?.path ?? (typed.file_path ?? "")}'`;
+            const filePath = normalizeWorkspacePathOrThrow(pathScopedBackend, typeof typed.file_path === "string" ? typed.file_path : "");
+            const result = await Promise.resolve(backend.edit?.(filePath, typeof typed.old_string === "string" ? typed.old_string : "", typeof typed.new_string === "string" ? typed.new_string : "", typed.replace_all === true));
+            return result?.error ?? `Successfully replaced ${result?.occurrences ?? 0} occurrence(s) in '${result?.path ?? filePath}'`;
         },
     });
     tools.set("glob", {
         name: "glob",
+        description: "Find files matching a glob pattern.",
         schema: z.object({ pattern: z.string(), path: z.string().optional().default("/") }).passthrough(),
         invoke: async (input) => {
             const typed = isRecord(input) ? input : {};
             const pattern = typeof typed.pattern === "string" ? typed.pattern : "";
-            const targetPath = typeof typed.path === "string" ? typed.path : "/";
+            const targetPath = normalizeWorkspacePathOrThrow(pathScopedBackend, typeof typed.path === "string" ? typed.path : "/");
             const legacyInfos = (await Promise.resolve(backend.globInfo?.(pattern, targetPath))) ?? [];
             const infos = legacyInfos.length > 0
                 ? legacyInfos
@@ -148,6 +250,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     });
     tools.set("grep", {
         name: "grep",
+        description: "Search for text across workspace files.",
         schema: z.object({
             pattern: z.string(),
             path: z.string().optional().default("/"),
@@ -155,8 +258,9 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         }).passthrough(),
         invoke: async (input) => {
             const typed = isRecord(input) ? input : {};
-            const legacyResult = await Promise.resolve(backend.grepRaw?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
-            const structuredResult = await Promise.resolve(backend.grep?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
+            const targetPath = normalizeWorkspacePathOrThrow(pathScopedBackend, typeof typed.path === "string" ? typed.path : "/");
+            const legacyResult = await Promise.resolve(backend.grepRaw?.(typeof typed.pattern === "string" ? typed.pattern : "", targetPath, typeof typed.glob === "string" ? typed.glob : null));
+            const structuredResult = await Promise.resolve(backend.grep?.(typeof typed.pattern === "string" ? typed.pattern : "", targetPath, typeof typed.glob === "string" ? typed.glob : null));
             const normalizedStructuredMatches = structuredResult?.matches?.map((match) => ({
                 path: match.path,
                 line: match.lineNumber ?? match.line_number ?? match.line ?? 0,
@@ -183,6 +287,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     });
     tools.set("search_files", {
         name: "search_files",
+        description: "Search for text across workspace files.",
         schema: z.object({
             query: z.string(),
             path: z.string().optional().default("/"),
@@ -192,16 +297,17 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         invoke: async (input) => {
             const typed = isRecord(input) ? input : {};
             const query = typeof typed.query === "string" ? typed.query : "";
-            const path = typeof typed.path === "string" ? typed.path : "/";
+            const searchPath = normalizeWorkspacePathOrThrow(pathScopedBackend, typeof typed.path === "string" ? typed.path : "/");
             const globPattern = typeof typed.glob === "string" ? typed.glob : null;
             const searchType = typed.search_type === "path" ? "path" : "content";
             return searchType === "path"
-                ? tools.get("glob").invoke({ pattern: query, path })
-                : tools.get("grep").invoke({ pattern: query, path, glob: globPattern });
+                ? tools.get("glob").invoke({ pattern: query, path: searchPath })
+                : tools.get("grep").invoke({ pattern: query, path: searchPath, glob: globPattern });
         },
     });
     tools.set("execute", {
         name: "execute",
+        description: "Run a shell command in the workspace sandbox.",
         schema: z.object({ command: z.string() }).passthrough(),
         invoke: async (input) => {
             if (!isSandboxBackend(backend) || typeof backend.execute !== "function") {
@@ -221,11 +327,13 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     });
     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),
     });
     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) => {
             if (typeof backend.fetchUrl !== "function") {
@@ -241,6 +349,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     });
     tools.set("http_request", {
         name: "http_request",
+        description: "Send a structured HTTP request.",
         schema: z.object({
             url: z.string(),
             method: z.string().optional(),
@@ -268,6 +377,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     });
     tools.set("send_message", {
         name: "send_message",
+        description: "Send a message through the configured backend.",
         schema: z.object({
             destination: z.string(),
             message: z.string(),
@@ -293,6 +403,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     });
     tools.set("request_approval", {
         name: "request_approval",
+        description: "Request an approval decision from the runtime.",
         schema: z.object({
             action: z.string(),
             reason: z.string().optional(),
@@ -321,17 +432,76 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     });
     tools.set("schedule_task", {
         name: "schedule_task",
+        description: "Create, inspect, update, list, and delete system-level scheduled tasks.",
         schema: z.object({
-            instruction: z.string(),
-            when: z.string(),
+            operation: z.enum(["create", "list", "get", "update", "delete"]).optional(),
+            scheduleId: z.string().optional(),
             name: z.string().optional(),
+            instruction: z.string().optional(),
+            agentId: z.string().optional(),
+            when: z.string().optional(),
+            schedule: z.object({
+                type: z.enum(["cron", "interval", "daily", "weekly"]),
+                expression: z.string().optional(),
+                everyMinutes: z.number().int().positive().optional(),
+                time: z.string().optional(),
+                days: z.array(z.string()).optional(),
+            }).optional(),
+            filters: z.object({
+                scheduleId: z.string().optional(),
+                name: z.string().optional(),
+                agentId: z.string().optional(),
+                source: z.enum(["crontab", "schtasks"]).optional(),
+                status: z.enum(["active", "missing"]).optional(),
+                query: z.string().optional(),
+            }).optional(),
             metadata: z.record(z.string(), z.unknown()).optional(),
         }).passthrough(),
         invoke: async (input) => {
+            const typed = isRecord(input) ? input : {};
+            const operation = typeof typed.operation === "string" ? typed.operation : "create";
+            const normalizedSchedule = isRecord(typed.schedule) && typeof typed.schedule.type === "string"
+                ? {
+                    type: typed.schedule.type,
+                    ...(typeof typed.schedule.expression === "string" ? { expression: typed.schedule.expression } : {}),
+                    ...(typeof typed.schedule.everyMinutes === "number" ? { everyMinutes: typed.schedule.everyMinutes } : {}),
+                    ...(typeof typed.schedule.time === "string" ? { time: typed.schedule.time } : {}),
+                    ...(Array.isArray(typed.schedule.days)
+                        ? {
+                            days: typed.schedule.days.filter((day) => typeof day === "string"),
+                        }
+                        : {}),
+                }
+                : typeof typed.when === "string"
+                    ? parseScheduleWhen(typed.when)
+                    : undefined;
+            if (typeof backend.manageSchedule === "function") {
+                return backend.manageSchedule({
+                    operation: operation,
+                    scheduleId: typeof typed.scheduleId === "string" ? typed.scheduleId : undefined,
+                    name: typeof typed.name === "string" ? typed.name : undefined,
+                    instruction: typeof typed.instruction === "string" ? typed.instruction : undefined,
+                    agentId: typeof typed.agentId === "string" ? typed.agentId : undefined,
+                    schedule: normalizedSchedule,
+                    filters: isRecord(typed.filters)
+                        ? {
+                            ...(typeof typed.filters.scheduleId === "string" ? { scheduleId: typed.filters.scheduleId } : {}),
+                            ...(typeof typed.filters.name === "string" ? { name: typed.filters.name } : {}),
+                            ...(typeof typed.filters.agentId === "string" ? { agentId: typed.filters.agentId } : {}),
+                            ...(typed.filters.source === "crontab" || typed.filters.source === "schtasks" ? { source: typed.filters.source } : {}),
+                            ...(typed.filters.status === "active" || typed.filters.status === "missing" ? { status: typed.filters.status } : {}),
+                            ...(typeof typed.filters.query === "string" ? { query: typed.filters.query } : {}),
+                        }
+                        : undefined,
+                    metadata: isRecord(typed.metadata) ? typed.metadata : undefined,
+                });
+            }
             if (typeof backend.scheduleTask !== "function") {
                 return notAvailable("schedule_task", "task scheduling");
             }
-            const typed = isRecord(input) ? input : {};
+            if (operation !== "create") {
+                return "Error: schedule_task only supports create on this backend.";
+            }
             const result = await Promise.resolve(backend.scheduleTask({
                 instruction: typeof typed.instruction === "string" ? typed.instruction : "",
                 when: typeof typed.when === "string" ? typed.when : "",
@@ -347,6 +517,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
     if (options.includeTaskTool && options.invokeTaskTool) {
         tools.set("task", {
             name: "task",
+            description: "Delegate a bounded task to a subagent.",
             schema: z.object({
                 description: z.string(),
                 subagent_type: z.string(),
@@ -355,6 +526,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         });
         tools.set("delegate_task", {
             name: "delegate_task",
+            description: "Delegate a bounded task to a subagent.",
             schema: z.object({
                 description: z.string(),
                 subagent_type: z.string(),

package/dist/runtime/adapter/tool/tool-arguments.d.ts

@@ -1,5 +1,7 @@
 export declare function stringifyToolOutput(output: unknown): string;
-export declare function normalizeToolArgsForSchema(args: Record<string, unknown>, schema: unknown, rawArgsInput?: unknown): Record<string, unknown>;
+export declare function normalizeToolArgsForSchema(args: Record<string, unknown>, schema: unknown, rawArgsInput?: unknown, options?: {
+    latestUserInput?: string;
+}): Record<string, unknown>;
 export declare function extractToolCallsFromResult(result: unknown): Array<{
     id?: string;
     name: string;

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -1,17 +1,31 @@
 import { salvageToolArgs } from "../../parsing/output-parsing.js";
 import { isRecord } from "../../../utils/object.js";
+import { extractExplicitResourceReferences, hasExplicitResourceReference } from "../../harness/system/runtime-memory-policy.js";
 function isObject(value) {
     return isRecord(value);
 }
 export function stringifyToolOutput(output) {
+    let rendered;
     if (typeof output === "string") {
-        return output;
+        rendered = output;
+    }
+    else {
+        try {
+            rendered = JSON.stringify(output);
+        }
+        catch {
+            rendered = `${String(output)}`;
+        }
+    }
+    const maxChars = 4_000;
+    if (rendered.length <= maxChars) {
+        return rendered;
     }
     try {
-        return JSON.stringify(output);
+        return `${rendered.slice(0, maxChars - 15)}\n...[truncated]`;
     }
     catch {
-        return `${String(output)}`;
+        return rendered;
     }
 }
 function mapSingleFieldScalarArg(args, expectedKey, rawArgsInput) {
@@ -36,7 +50,27 @@ function mapSingleFieldScalarArg(args, expectedKey, rawArgsInput) {
     }
     return args;
 }
-export function normalizeToolArgsForSchema(args, schema, rawArgsInput) {
+function isScalarLikeValue(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function mapSingleRemainingScalarArg(args, expectedKey) {
+    if (expectedKey in args) {
+        return args;
+    }
+    const entries = Object.entries(args).filter(([, value]) => isScalarLikeValue(value));
+    if (entries.length !== 1) {
+        return args;
+    }
+    const [, value] = entries[0];
+    if (typeof value === "string" && value.trim().length === 0) {
+        return args;
+    }
+    return {
+        ...args,
+        [expectedKey]: value,
+    };
+}
+export function normalizeToolArgsForSchema(args, schema, rawArgsInput, options = {}) {
     const schemaDef = isObject(schema) ? schema._def : undefined;
     const zodShape = schemaDef
         ? isRecord(schemaDef.shape)
@@ -64,20 +98,21 @@ export function normalizeToolArgsForSchema(args, schema, rawArgsInput) {
     if (expectedKey in scalarMappedArgs) {
         return scalarMappedArgs;
     }
-    const aliasesByExpected = {
-        city: ["location", "locality", "place"],
-        location: ["city", "city_name"],
-        query: ["question", "prompt", "text", "request"],
-    };
-    const aliases = aliasesByExpected[expectedKey] ?? [];
-    const aliasKey = aliases.find((candidate) => candidate in scalarMappedArgs);
-    if (!aliasKey || !(aliasKey in scalarMappedArgs)) {
-        return scalarMappedArgs;
+    if (Object.keys(scalarMappedArgs).length === 0 && typeof options.latestUserInput === "string") {
+        const userInput = options.latestUserInput.trim();
+        const resourceRefs = extractExplicitResourceReferences(userInput);
+        if (resourceRefs.length === 1 && hasExplicitResourceReference(userInput)) {
+            return {
+                ...scalarMappedArgs,
+                [expectedKey]: resourceRefs[0],
+            };
+        }
     }
-    return {
-        ...scalarMappedArgs,
-        [expectedKey]: scalarMappedArgs[aliasKey],
-    };
+    const genericScalarMappedArgs = mapSingleRemainingScalarArg(scalarMappedArgs, expectedKey);
+    if (expectedKey in genericScalarMappedArgs) {
+        return genericScalarMappedArgs;
+    }
+    return genericScalarMappedArgs;
 }
 export function extractToolCallsFromResult(result) {
     const messages = isRecord(result) && Array.isArray(result.messages) ? result.messages : [];

package/dist/runtime/adapter/tool-resolution.d.ts

@@ -10,5 +10,6 @@ export declare function buildExecutableToolMap(input: {
     primaryTools: CompiledTool[];
     resolvedTools: unknown[];
     toolNameMapping?: ToolNameMapping;
+    toolConfig?: Record<string, unknown>;
     context?: Record<string, unknown>;
 }): Map<string, ExecutableTool>;

package/dist/runtime/adapter/tool-resolution.js

@@ -29,7 +29,7 @@ export function buildExecutableToolMap(input) {
             continue;
         }
         const callableTool = resolvedTool;
-        const handler = async (toolInput) => {
+        const handler = async (toolInput, toolConfig) => {
             const callable = typeof callableTool.invoke === "function"
                 ? callableTool.invoke
                 : typeof callableTool.call === "function"
@@ -38,7 +38,9 @@ export function buildExecutableToolMap(input) {
             if (!callable) {
                 throw new Error(`Tool ${compiledTool.name} has no callable handler.`);
             }
-            return Promise.resolve(callable.call(callableTool, toolInput, input.context ? { context: input.context } : undefined));
+            return Promise.resolve(callable.call(callableTool, toolInput, toolConfig
+                ?? input.toolConfig
+                ?? (input.context ? { context: input.context } : undefined)));
         };
         const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
         const schema = normalizeResolvedToolSchema(callableTool);

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

@@ -1,5 +1,6 @@
 import type { CompiledAgentBinding, CompiledAsyncSubAgent, MessageContent, RequestResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
+import type { ExecutableTool } from "./adapter/flow/invoke-runtime.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
 import { type UpstreamSubagentConfig } from "./adapter/middleware-assembly.js";
 export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
@@ -12,6 +13,10 @@ type RunnableLike = {
     streamEvents?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
 };
 declare const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+export declare function materializeModelExposedBuiltinMiddlewareTools(input: {
+    builtinTools: Map<string, ExecutableTool>;
+    explicitToolNames?: string[];
+}): unknown[];
 export declare function resolveRunnableCheckpointer(options: RuntimeAdapterOptions, binding: CompiledAgentBinding): unknown;
 export declare function resolveRunnableInterruptOn(binding: CompiledAgentBinding): Record<string, {
     allowedDecisions: import("./adapter/tool/interrupt-policy.js").InterruptDecision[];
@@ -32,6 +37,7 @@ export declare function resolveLangChainInvocationConfig(binding: CompiledAgentB
     legacySessionId?: string;
     legacyRequestId?: string;
     context?: Record<string, unknown>;
+    toolRuntimeContext?: Record<string, unknown>;
 }): Record<string, unknown>;
 export declare function buildDeepAgentCreateParams(input: {
     binding: CompiledAgentBinding;
@@ -47,6 +53,24 @@ export declare function buildDeepAgentCreateParams(input: {
     }>;
     resolvedSkills: string[];
 }): Record<string, unknown>;
+export declare function shouldUseMinimalDeepAgentAssembly(input: {
+    binding: CompiledAgentBinding;
+    resolvedMiddleware: unknown[];
+    resolvedSubagents: Array<UpstreamSubagentConfig | CompiledAsyncSubAgent>;
+    resolvedInterruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>;
+    resolvedSkills: string[];
+    resolvedBackend?: unknown;
+}): boolean;
+export declare function buildMinimalDeepAgentCreateParams(input: {
+    binding: CompiledAgentBinding;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedCheckpointer?: unknown;
+    resolvedStore?: unknown;
+    resolvedBackend: unknown;
+}): Record<string, unknown>;
 export declare class AgentRuntimeAdapter {
     private readonly options;
     private readonly modelCache;
@@ -67,6 +91,7 @@ export declare class AgentRuntimeAdapter {
     private resolveFilesystemBackend;
     private resolveFilesystemRootDir;
     private resolveBuiltinMiddlewareBackend;
+    private buildFunctionToolRuntimeContext;
     private createDeclaredMiddlewareResolverOptions;
     private createAssemblyResolvers;
     private invokeBuiltinTaskTool;
@@ -96,6 +121,8 @@ export declare class AgentRuntimeAdapter {
         files?: Record<string, unknown>;
         requestId?: string;
         memoryContext?: string;
+        profiling?: boolean;
+        toolRuntimeContext?: Record<string, unknown>;
     }): AsyncGenerator<RuntimeStreamChunk | string>;
 }
 export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError, };