@botbotgo/agent-harness 0.0.66 → 0.0.67

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.65";
+export declare const AGENT_HARNESS_VERSION = "0.0.66";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.65";
+export const AGENT_HARNESS_VERSION = "0.0.66";

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

@@ -42,6 +42,9 @@ export declare class AgentRuntimeAdapter {
     private compileInterruptOn;
     private resolveInterruptOn;
     private resolveFilesystemBackend;
+    private resolveBuiltinMiddlewareBackend;
+    private invokeBuiltinTaskTool;
+    private resolveBuiltinMiddlewareTools;
     private resolveLangChainAutomaticMiddleware;
     private resolveMiddleware;
     private resolveCheckpointer;

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

@@ -3,7 +3,8 @@ import { existsSync, statSync } from "node:fs";
 import { cp, mkdir, rm } from "node:fs/promises";
 import { Command, MemorySaver } from "@langchain/langgraph";
 import { tool as createLangChainTool } from "@langchain/core/tools";
-import { createDeepAgent, createMemoryMiddleware, createSkillsMiddleware, createSubAgentMiddleware, FilesystemBackend, } from "deepagents";
+import { HumanMessage, ToolMessage } from "@langchain/core/messages";
+import { DEFAULT_SUBAGENT_PROMPT, createDeepAgent, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, isSandboxBackend, } from "deepagents";
 import { ChatAnthropic } from "@langchain/anthropic";
 import { tools as anthropicProviderTools } from "@langchain/anthropic";
 import { ChatGoogle } from "@langchain/google";
@@ -12,7 +13,7 @@ import { ChatOpenAI } from "@langchain/openai";
 import { tools as openAIProviderTools } from "@langchain/openai";
 import { createAgent, humanInTheLoopMiddleware, initChatModel } from "langchain";
 import { z } from "zod";
-import { extractEmptyAssistantMessageFailure, extractContentBlocks, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { extractEmptyAssistantMessageFailure, extractContentBlocks, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, salvageToolArgs, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractVisibleStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
 import { wrapToolForExecution } from "./tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./declared-middleware.js";
@@ -24,6 +25,17 @@ function countConfiguredTools(binding) {
 }
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
+    "write_todos",
+    "ls",
+    "read_file",
+    "write_file",
+    "edit_file",
+    "glob",
+    "grep",
+    "execute",
+    "task",
+]);
 class RuntimeOperationTimeoutError extends Error {
     operation;
     timeoutMs;
@@ -152,7 +164,8 @@ function normalizeOpenAICompatibleInit(init) {
     return normalized;
 }
 function sanitizeToolNameForModel(name) {
-    const sanitized = name
+    const withoutNamespace = name.includes(".") ? name.split(".").at(-1) ?? name : name;
+    const sanitized = withoutNamespace
         .replaceAll(".", "__")
         .replace(/[^a-zA-Z0-9_-]+/g, "_")
         .replace(/^_+|_+$/g, "");
@@ -252,6 +265,193 @@ function normalizeResolvedToolSchema(resolvedTool) {
     }
     return z.object({}).passthrough();
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isObject(value) {
+    return isRecord(value);
+}
+function stringifyToolOutput(output) {
+    if (typeof output === "string") {
+        return output;
+    }
+    try {
+        return JSON.stringify(output);
+    }
+    catch {
+        return `${String(output)}`;
+    }
+}
+function normalizeToolArgsForSchema(args, schema) {
+    const schemaDef = isObject(schema) ? schema._def : undefined;
+    const shape = schemaDef
+        ? isRecord(schemaDef.shape)
+            ? schemaDef.shape
+            : typeof schemaDef.shape === "function"
+                ? schemaDef.shape()
+                : undefined
+        : undefined;
+    if (!shape || !isRecord(shape)) {
+        return args;
+    }
+    const keys = Object.keys(shape);
+    if (keys.length !== 1) {
+        return args;
+    }
+    const [expectedKey] = keys;
+    if (expectedKey in args) {
+        return args;
+    }
+    const aliasesByExpected = {
+        city: ["location", "locality", "place"],
+        location: ["city", "city_name"],
+    };
+    const aliases = aliasesByExpected[expectedKey] ?? [];
+    const aliasKey = aliases.find((candidate) => candidate in args);
+    if (!aliasKey || !(aliasKey in args)) {
+        return args;
+    }
+    return {
+        ...args,
+        [expectedKey]: args[aliasKey],
+    };
+}
+function extractToolCallsFromResult(result) {
+    const messages = isRecord(result) && Array.isArray(result.messages) ? result.messages : [];
+    const lastMessage = messages.at(-1);
+    if (!isObject(lastMessage)) {
+        return [];
+    }
+    const messageKwargs = isObject(lastMessage.kwargs) ? lastMessage.kwargs : undefined;
+    const rawToolCalls = Array.isArray(lastMessage.tool_calls)
+        ? (lastMessage.tool_calls ?? [])
+        : Array.isArray(messageKwargs?.tool_calls)
+            ? messageKwargs.tool_calls
+            : [];
+    return rawToolCalls
+        .map((toolCall) => {
+        if (!isObject(toolCall)) {
+            return null;
+        }
+        const functionPayload = isObject(toolCall.function) ? toolCall.function : undefined;
+        const name = typeof toolCall.name === "string"
+            ? toolCall.name
+            : typeof functionPayload?.name === "string"
+                ? functionPayload.name
+                : null;
+        if (!name) {
+            return null;
+        }
+        const rawArgs = salvageToolArgs(toolCall.args ?? functionPayload?.arguments) ?? {};
+        if (!isObject(rawArgs)) {
+            return null;
+        }
+        const id = typeof toolCall.id === "string" ? toolCall.id : undefined;
+        return { id, name, args: rawArgs };
+    })
+        .filter((item) => item !== null);
+}
+function truncateLines(lines, maxChars = 12_000) {
+    const joined = lines.join("\n");
+    if (joined.length <= maxChars) {
+        return joined;
+    }
+    return `${joined.slice(0, maxChars - 18)}\n...[truncated]`;
+}
+function summarizeBuiltinWriteTodosArgs(args) {
+    const todos = Array.isArray(args.todos) ? args.todos : [];
+    const items = todos.flatMap((todo) => {
+        if (!isObject(todo)) {
+            return [];
+        }
+        const content = typeof todo.content === "string" && todo.content.trim().length > 0
+            ? todo.content.trim()
+            : typeof todo.description === "string" && todo.description.trim().length > 0
+                ? todo.description.trim()
+                : "";
+        const status = typeof todo.status === "string" && todo.status.trim().length > 0 ? todo.status.trim() : "pending";
+        return content ? [{ content, status }] : [];
+    });
+    return {
+        total: items.length,
+        pending: items.filter((item) => item.status !== "completed").length,
+        completed: items.filter((item) => item.status === "completed").length,
+        items,
+    };
+}
+function createModelFacingToolNameCandidates(toolName) {
+    const trimmed = toolName.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const lastSegment = trimmed.split(".").at(-1) ?? "";
+    const candidates = new Set([
+        trimmed,
+        sanitizeToolNameForModel(trimmed),
+        lastSegment,
+        lastSegment.trim() ? sanitizeToolNameForModel(lastSegment) : "",
+        trimmed.replace(/[^a-zA-Z0-9_]+/g, ""),
+    ]);
+    candidates.delete("");
+    return [...candidates];
+}
+function createModelFacingToolNameLookupCandidates(toolName) {
+    const trimmed = toolName.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const candidates = new Set();
+    const add = (value) => {
+        for (const candidate of createModelFacingToolNameCandidates(value)) {
+            candidates.add(candidate);
+        }
+    };
+    const addSuffixStripped = (value) => {
+        const stripped = value.includes(".") ? value.split(".").at(-1) ?? value : value;
+        if (stripped !== value) {
+            add(stripped);
+        }
+    };
+    add(trimmed);
+    if (trimmed.startsWith("functions.")) {
+        const stripped = trimmed.substring("functions.".length);
+        add(stripped);
+        addSuffixStripped(stripped);
+    }
+    else if (trimmed.startsWith("function.")) {
+        const stripped = trimmed.substring("function.".length);
+        add(stripped);
+        addSuffixStripped(stripped);
+    }
+    else {
+        addSuffixStripped(trimmed);
+    }
+    return [...candidates];
+}
+function resolveModelFacingToolName(toolName, mapping, tools) {
+    const candidateNames = createModelFacingToolNameLookupCandidates(toolName);
+    const candidateSet = new Set(candidateNames);
+    for (const candidate of candidateNames) {
+        const mappedToolName = mapping.modelFacingToOriginal.get(candidate);
+        if (mappedToolName) {
+            return mappedToolName;
+        }
+    }
+    for (const candidate of candidateNames) {
+        const directMatch = tools.find((tool) => tool.name === candidate);
+        if (directMatch) {
+            return directMatch.name;
+        }
+    }
+    const candidateMatches = tools.filter((tool) => {
+        const modelFacingCandidates = createModelFacingToolNameCandidates(tool.name);
+        return modelFacingCandidates.some((candidate) => candidateSet.has(candidate));
+    });
+    if (candidateMatches.length === 1) {
+        return candidateMatches[0].name;
+    }
+    return toolName;
+}
 function asStructuredExecutableTool(resolvedTool, modelFacingName, description) {
     if (!hasCallableToolHandler(resolvedTool)) {
         return resolvedTool;
@@ -589,6 +789,228 @@ export class AgentRuntimeAdapter {
                 : 10,
         });
     }
+    resolveBuiltinMiddlewareBackend(binding, options = {}) {
+        const runtimeState = {
+            ...(options.state ?? {}),
+            ...(isRecord(options.files) ? { files: options.files } : {}),
+        };
+        const runtimeLike = {
+            state: runtimeState,
+            store: this.options.storeResolver?.(binding),
+        };
+        const configuredBackend = isDeepAgentBinding(binding)
+            ? this.options.backendResolver?.(binding)
+            : this.resolveFilesystemBackend(binding);
+        if (typeof configuredBackend === "function") {
+            return configuredBackend(runtimeLike);
+        }
+        if (configuredBackend) {
+            return configuredBackend;
+        }
+        return new StateBackend(runtimeLike);
+    }
+    async invokeBuiltinTaskTool(binding, input, options = {}) {
+        if (!isDeepAgentBinding(binding)) {
+            throw new Error("The built-in task tool is only available for deepagent bindings.");
+        }
+        const params = getBindingDeepAgentParams(binding);
+        if (!params) {
+            throw new Error(`Agent ${binding.agent.id} has no deepagent params`);
+        }
+        const typedInput = isObject(input) ? input : {};
+        const description = typeof typedInput.description === "string" ? typedInput.description : "";
+        const subagentType = typeof typedInput.subagent_type === "string" ? typedInput.subagent_type : "";
+        const builtinBackend = this.resolveBuiltinMiddlewareBackend(binding, options);
+        const resolvedSubagents = await this.resolveSubagents(params.subagents, binding);
+        const selectedSubagent = resolvedSubagents.find((subagent) => subagent.name === subagentType);
+        if (!selectedSubagent) {
+            const allowed = [
+                ...resolvedSubagents.map((subagent) => subagent.name),
+                ...(params.generalPurposeAgent ? ["general-purpose"] : []),
+            ];
+            throw new Error(`Error: invoked agent of type ${subagentType}, the only allowed types are ${allowed.map((name) => `\`${name}\``).join(", ")}`);
+        }
+        const summarizationModel = selectedSubagent.model
+            ? await this.resolveModel(selectedSubagent.model)
+            : await this.resolveModel(params.model);
+        const middleware = [
+            ...(selectedSubagent.skills?.length
+                ? [createSkillsMiddleware({ backend: builtinBackend, sources: selectedSubagent.skills })]
+                : []),
+            ...(selectedSubagent.memory?.length
+                ? [createMemoryMiddleware({ backend: builtinBackend, sources: selectedSubagent.memory })]
+                : []),
+            ...(selectedSubagent.middleware ??
+                [
+                    createPatchToolCallsMiddleware(),
+                    createSummarizationMiddleware({
+                        model: summarizationModel,
+                        backend: builtinBackend,
+                    }),
+                ]),
+            ...(selectedSubagent.interruptOn
+                ? [humanInTheLoopMiddleware({
+                        interruptOn: this.compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
+                    })]
+                : []),
+        ];
+        const runnable = createAgent({
+            model: (selectedSubagent.model ?? (await this.resolveModel(params.model))),
+            tools: (selectedSubagent.tools ?? this.resolveTools(params.tools, binding)),
+            systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
+            middleware: middleware,
+            responseFormat: selectedSubagent.responseFormat,
+            contextSchema: selectedSubagent.contextSchema,
+            name: selectedSubagent.name,
+            description: selectedSubagent.description,
+        });
+        const result = await runnable.invoke({ messages: [new HumanMessage({ content: description })] }, { configurable: { thread_id: `${binding.agent.id}:builtin-task` }, ...(options.context ? { context: options.context } : {}) });
+        const visibleOutput = extractVisibleOutput(result);
+        const fallbackOutput = extractToolFallbackContext(result);
+        return visibleOutput || fallbackOutput || JSON.stringify(result);
+    }
+    async resolveBuiltinMiddlewareTools(binding, options = {}) {
+        const tools = new Map();
+        const backend = this.resolveBuiltinMiddlewareBackend(binding, options);
+        tools.set("write_todos", {
+            name: "write_todos",
+            schema: z.object({
+                todos: z.array(z.object({}).passthrough()).optional(),
+            }).passthrough(),
+            invoke: async (input) => {
+                const args = isObject(input) ? input : {};
+                const summary = summarizeBuiltinWriteTodosArgs(args);
+                return {
+                    ok: true,
+                    tool: "write_todos",
+                    message: `Tracked ${summary.total} todo item(s).`,
+                    summary,
+                };
+            },
+        });
+        tools.set("ls", {
+            name: "ls",
+            schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
+            invoke: async (input) => {
+                const targetPath = isObject(input) && typeof input.path === "string" ? input.path : "/";
+                const infos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
+                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)` : ""}`));
+            },
+        });
+        tools.set("read_file", {
+            name: "read_file",
+            schema: z.object({
+                file_path: z.string(),
+                offset: z.number().optional(),
+                limit: z.number().optional(),
+            }).passthrough(),
+            invoke: async (input) => {
+                const typed = isObject(input) ? input : {};
+                const filePath = 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;
+                return Promise.resolve(backend.read?.(filePath, offset, limit)) ?? "";
+            },
+        });
+        tools.set("write_file", {
+            name: "write_file",
+            schema: z.object({ file_path: z.string(), content: z.string().optional() }).passthrough(),
+            invoke: async (input) => {
+                const typed = isObject(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 ?? "")}'`;
+            },
+        });
+        tools.set("edit_file", {
+            name: "edit_file",
+            schema: z.object({
+                file_path: z.string(),
+                old_string: z.string(),
+                new_string: z.string(),
+                replace_all: z.boolean().optional(),
+            }).passthrough(),
+            invoke: async (input) => {
+                const typed = isObject(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 ?? "")}'`;
+            },
+        });
+        tools.set("glob", {
+            name: "glob",
+            schema: z.object({ pattern: z.string(), path: z.string().optional().default("/") }).passthrough(),
+            invoke: async (input) => {
+                const typed = isObject(input) ? input : {};
+                const pattern = typeof typed.pattern === "string" ? typed.pattern : "";
+                const targetPath = typeof typed.path === "string" ? typed.path : "/";
+                const infos = (await Promise.resolve(backend.globInfo?.(pattern, targetPath))) ?? [];
+                if (infos.length === 0) {
+                    return `No files found matching pattern '${pattern}'`;
+                }
+                return truncateLines(infos.map((info) => info.path));
+            },
+        });
+        tools.set("grep", {
+            name: "grep",
+            schema: z.object({
+                pattern: z.string(),
+                path: z.string().optional().default("/"),
+                glob: z.string().nullable().optional(),
+            }).passthrough(),
+            invoke: async (input) => {
+                const typed = isObject(input) ? input : {};
+                const result = await Promise.resolve(backend.grepRaw?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
+                if (typeof result === "string") {
+                    return result;
+                }
+                if (!result || result.length === 0) {
+                    return `No matches found for pattern '${typeof typed.pattern === "string" ? typed.pattern : ""}'`;
+                }
+                const lines = [];
+                let currentFile = "";
+                for (const match of result) {
+                    if (match.path !== currentFile) {
+                        currentFile = match.path;
+                        lines.push(`\n${currentFile}:`);
+                    }
+                    lines.push(`  ${match.line}: ${match.text}`);
+                }
+                return truncateLines(lines);
+            },
+        });
+        tools.set("execute", {
+            name: "execute",
+            schema: z.object({ command: z.string() }).passthrough(),
+            invoke: async (input) => {
+                if (!isSandboxBackend(backend) || typeof backend.execute !== "function") {
+                    return "Error: Execution not available. This agent's backend does not support command execution (SandboxBackendProtocol).";
+                }
+                const typed = isObject(input) ? input : {};
+                const result = await Promise.resolve(backend.execute(typeof typed.command === "string" ? typed.command : ""));
+                const parts = [result.output];
+                if (result.exitCode !== null) {
+                    parts.push(`\n[Command ${result.exitCode === 0 ? "succeeded" : "failed"} with exit code ${result.exitCode}]`);
+                }
+                if (result.truncated) {
+                    parts.push("\n[Output was truncated due to size limits]");
+                }
+                return parts.join("");
+            },
+        });
+        if (isDeepAgentBinding(binding)) {
+            tools.set("task", {
+                name: "task",
+                schema: z.object({
+                    description: z.string(),
+                    subagent_type: z.string(),
+                }).passthrough(),
+                invoke: async (input) => this.invokeBuiltinTaskTool(binding, input, options),
+            });
+        }
+        return tools;
+    }
     async resolveLangChainAutomaticMiddleware(binding) {
         const params = getBindingLangChainParams(binding);
         if (!params) {
@@ -781,17 +1203,117 @@ export class AgentRuntimeAdapter {
             ? this.buildInvocationRequest(binding, history, input, options)
             : new Command({ resume: resumePayload });
         let result;
-        try {
-            const runnable = await this.create(binding);
-            result = (await this.withTimeout(() => runnable.invoke(request, { configurable: { thread_id: threadId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(binding), "agent invoke", "invoke"));
+        const callRuntime = async (activeBinding, activeRequest) => {
+            const runnable = await this.create(activeBinding);
+            return (await this.withTimeout(() => runnable.invoke(activeRequest, { configurable: { thread_id: threadId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(activeBinding), "agent invoke", "invoke"));
+        };
+        const callRuntimeWithToolParseRecovery = async (activeRequest) => {
+            try {
+                return await callRuntime(binding, activeRequest);
+            }
+            catch (error) {
+                if (resumePayload !== undefined || !isToolCallParseFailure(error)) {
+                    throw error;
+                }
+                return callRuntime(this.applyStrictToolJsonInstruction(binding), activeRequest);
+            }
+        };
+        const executedToolResults = [];
+        if (resumePayload !== undefined) {
+            result = await callRuntimeWithToolParseRecovery(request);
         }
-        catch (error) {
-            if (resumePayload !== undefined || !isToolCallParseFailure(error)) {
-                throw error;
+        else {
+            const primaryTools = getBindingPrimaryTools(binding);
+            const defersToUpstreamHitlExecution = primaryTools.some((tool) => tool.hitl?.enabled === true);
+            if (defersToUpstreamHitlExecution) {
+                result = await callRuntimeWithToolParseRecovery(request);
+            }
+            else {
+                const resolvedTools = this.resolveTools(primaryTools, binding);
+                const toolNameMapping = this.buildToolNameMapping(primaryTools);
+                const executableTools = new Map();
+                const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
+                for (let index = 0; index < primaryTools.length; index += 1) {
+                    const compiledTool = primaryTools[index];
+                    const resolvedTool = resolvedTools[index];
+                    if (!compiledTool || !resolvedTool || !hasCallableToolHandler(resolvedTool)) {
+                        continue;
+                    }
+                    const handler = async (toolInput) => {
+                        const callable = typeof resolvedTool.invoke === "function"
+                            ? resolvedTool.invoke
+                            : typeof resolvedTool.call === "function"
+                                ? resolvedTool.call
+                                : resolvedTool.func;
+                        if (!callable) {
+                            throw new Error(`Tool ${compiledTool.name} has no callable handler.`);
+                        }
+                        return Promise.resolve(callable.call(resolvedTool, toolInput, options.context ? { context: options.context } : undefined));
+                    };
+                    const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
+                    const normalizedSchema = normalizeResolvedToolSchema(resolvedTool);
+                    executableTools.set(modelFacingName, {
+                        name: compiledTool.name,
+                        schema: normalizedSchema,
+                        invoke: handler,
+                    });
+                    executableTools.set(compiledTool.name, {
+                        name: compiledTool.name,
+                        schema: normalizedSchema,
+                        invoke: handler,
+                    });
+                }
+                let activeRequest = request;
+                let currentMessages = Array.isArray(activeRequest.messages) ? [...activeRequest.messages] : [];
+                const maxToolIterations = 8;
+                for (let iteration = 0; iteration < maxToolIterations; iteration += 1) {
+                    result = await callRuntimeWithToolParseRecovery(activeRequest);
+                    const toolCalls = extractToolCallsFromResult(result);
+                    if (toolCalls.length === 0) {
+                        break;
+                    }
+                    if (iteration + 1 === maxToolIterations) {
+                        throw new Error(`Tool-calling loop exceeded the maximum of ${maxToolIterations} iterations`);
+                    }
+                    const resultMessages = result.messages;
+                    const nextMessages = Array.isArray(resultMessages)
+                        ? [...resultMessages]
+                        : [...currentMessages];
+                    for (let toolIndex = 0; toolIndex < toolCalls.length; toolIndex += 1) {
+                        const toolCall = toolCalls[toolIndex];
+                        const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
+                        const executable = executableTools.get(toolCall.name) ?? executableTools.get(resolvedToolName);
+                        const builtinExecutable = builtinExecutableTools.get(toolCall.name) ??
+                            builtinExecutableTools.get(resolvedToolName) ??
+                            createModelFacingToolNameLookupCandidates(toolCall.name)
+                                .map((candidate) => builtinExecutableTools.get(candidate))
+                                .find((candidate) => candidate !== undefined);
+                        const activeExecutable = executable ?? builtinExecutable;
+                        if (!activeExecutable) {
+                            throw new Error(`Tool ${toolCall.name} is not configured for this agent.`);
+                        }
+                        const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema);
+                        const toolResult = await activeExecutable.invoke(normalizedArgs);
+                        executedToolResults.push({
+                            toolName: activeExecutable.name,
+                            output: toolResult,
+                        });
+                        nextMessages.push(new ToolMessage({
+                            name: activeExecutable.name,
+                            tool_call_id: toolCall.id ?? `tool-${iteration + 1}-${toolIndex + 1}`,
+                            content: stringifyToolOutput(toolResult),
+                        }));
+                    }
+                    currentMessages = nextMessages;
+                    activeRequest = {
+                        ...activeRequest,
+                        messages: currentMessages,
+                    };
+                }
             }
-            const retriedBinding = this.applyStrictToolJsonInstruction(binding);
-            const runnable = await this.create(retriedBinding);
-            result = (await this.withTimeout(() => runnable.invoke(this.buildInvocationRequest(retriedBinding, history, input, options), { configurable: { thread_id: threadId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(retriedBinding), "agent invoke", "invoke"));
+        }
+        if (!result) {
+            throw new Error("Agent invocation returned no result");
         }
         const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
         const extractedOutput = extractVisibleOutput(result);
@@ -819,6 +1341,7 @@ export class AgentRuntimeAdapter {
             ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
             ...(structuredResponse !== undefined ? { structuredResponse } : {}),
             metadata: {
+                ...(executedToolResults.length > 0 ? { executedToolResults } : {}),
                 ...(structuredResponse !== undefined ? { structuredResponse } : {}),
                 ...(outputContent !== undefined ? { outputContent } : {}),
                 ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
@@ -833,6 +1356,12 @@ export class AgentRuntimeAdapter {
             const invokeTimeoutMs = this.resolveBindingTimeout(binding);
             const streamIdleTimeoutMs = this.resolveStreamIdleTimeout(binding);
             const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
+            const primaryTools = getBindingPrimaryTools(binding);
+            const toolNameMapping = this.buildToolNameMapping(primaryTools);
+            const primaryModel = getBindingPrimaryModel(binding);
+            const forceInvokeFallback = isLangChainBinding(binding) &&
+                primaryTools.length > 0 &&
+                primaryModel?.provider === "openai-compatible";
             if (isLangChainBinding(binding)) {
                 const langchainParams = getBindingLangChainParams(binding);
                 const resolvedModel = (await this.resolveModel(langchainParams.model));
@@ -867,7 +1396,7 @@ export class AgentRuntimeAdapter {
             }
             const runnable = await this.create(binding);
             const request = this.buildInvocationRequest(binding, history, input, options);
-            if (typeof runnable.streamEvents === "function") {
+            if (!forceInvokeFallback && typeof runnable.streamEvents === "function") {
                 const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2", ...(options.context ? { context: options.context } : {}) }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
                 const allowVisibleStreamDeltas = isLangChainBinding(binding);
                 let emittedOutput = "";
@@ -912,7 +1441,13 @@ export class AgentRuntimeAdapter {
                     const toolResult = extractToolResult(event);
                     if (toolResult) {
                         emittedToolError = emittedToolError || toolResult.isError === true;
-                        yield { kind: "tool-result", toolName: toolResult.toolName, output: toolResult.output, isError: toolResult.isError };
+                        const resolvedToolName = resolveModelFacingToolName(toolResult.toolName, toolNameMapping, primaryTools);
+                        yield {
+                            kind: "tool-result",
+                            toolName: resolvedToolName,
+                            output: toolResult.output,
+                            isError: toolResult.isError,
+                        };
                     }
                     const output = extractTerminalStreamOutput(event);
                     if (output) {
@@ -934,7 +1469,7 @@ export class AgentRuntimeAdapter {
                     return;
                 }
             }
-            if (isLangChainBinding(binding) && typeof runnable.stream === "function") {
+            if (!forceInvokeFallback && isLangChainBinding(binding) && typeof runnable.stream === "function") {
                 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", streamDeadlineAt, invokeTimeoutMs)) {
@@ -954,6 +1489,17 @@ export class AgentRuntimeAdapter {
                 }
             }
             const result = await this.invoke(binding, input, threadId, threadId);
+            const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
+                ? result.metadata.executedToolResults
+                : [];
+            for (const toolResult of executedToolResults) {
+                yield {
+                    kind: "tool-result",
+                    toolName: toolResult.toolName,
+                    output: toolResult.output,
+                    isError: toolResult.isError,
+                };
+            }
             if (result.output) {
                 yield { kind: "content", content: sanitizeVisibleText(result.output) };
             }

package/dist/runtime/harness.d.ts

@@ -100,6 +100,7 @@ export declare class AgentHarnessRuntime {
     run(options: RunOptions): Promise<RunResult>;
     streamEvents(options: RunStartOptions): AsyncGenerator<HarnessStreamItem>;
     resume(options: ResumeOptions): Promise<RunResult>;
+    private buildResumePayload;
     restartConversation(options: RestartConversationOptions): Promise<RunResult & {
         restart: Record<string, string>;
     }>;

package/dist/runtime/harness.js

@@ -15,7 +15,7 @@ import { FileBackedStore } from "./store.js";
 import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
-import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig, isDeepAgentBinding } from "./support/compiled-binding.js";
 import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./inventory.js";
 export class AgentHarnessRuntime {
     workspace;
@@ -401,6 +401,9 @@ export class AgentHarnessRuntime {
         const event = createHarnessEvent(threadId, runId, sequence, eventType, payload, source);
         await this.persistence.appendEvent(event);
         this.eventBus.publish(event);
+        if (this.threadMemorySync.shouldHandle(event)) {
+            await this.threadMemorySync.handleEvent(event);
+        }
         return event;
     }
     async ensureThreadStarted(selectedAgentId, binding, input, existingThreadId) {
@@ -1066,6 +1069,7 @@ export class AgentHarnessRuntime {
         if (!binding) {
             throw new Error(`Unknown agent ${thread.agentId}`);
         }
+        const resumePayload = this.buildResumePayload(binding, approval, options);
         await this.persistence.setRunState(threadId, runId, "resuming", `checkpoints/${threadId}/${runId}/cp-1`);
         const releaseRunSlot = await this.acquireRunSlot(threadId, runId, "resuming");
         try {
@@ -1073,9 +1077,7 @@ export class AgentHarnessRuntime {
                 kind: "approval-decision",
                 savedAt: new Date().toISOString(),
                 checkpointRef: `checkpoints/${threadId}/${runId}/cp-1`,
-                resumePayload: options.decision === "edit" && options.editedInput
-                    ? { decision: "edit", editedInput: options.editedInput }
-                    : (options.decision ?? "approve"),
+                resumePayload,
                 attempts: 0,
             });
             await this.emit(threadId, runId, 5, "run.resumed", {
@@ -1095,11 +1097,8 @@ export class AgentHarnessRuntime {
             const history = await this.persistence.listThreadMessages(threadId);
             const priorHistory = history.filter((message) => message.runId !== runId);
             const runInput = await this.loadRunInput(threadId, runId);
-            const resumeDecision = options.decision === "edit" && options.editedInput
-                ? { decision: "edit", editedInput: options.editedInput }
-                : (options.decision ?? "approve");
             try {
-                const actual = await this.runtimeAdapter.invoke(binding, "", threadId, runId, resumeDecision, priorHistory);
+                const actual = await this.runtimeAdapter.invoke(binding, "", threadId, runId, resumePayload, priorHistory);
                 await this.persistence.clearRecoveryIntent(threadId, runId);
                 const finalized = await this.finalizeContinuedRun(threadId, runId, runInput, actual, {
                     previousState: "resuming",
@@ -1120,6 +1119,43 @@ export class AgentHarnessRuntime {
             releaseRunSlot();
         }
     }
+    buildResumePayload(binding, approval, options) {
+        if (!isDeepAgentBinding(binding)) {
+            return options.decision === "edit" && options.editedInput
+                ? { decision: "edit", editedInput: options.editedInput }
+                : (options.decision ?? "approve");
+        }
+        const decisionType = options.decision ?? "approve";
+        if (decisionType === "edit" && options.editedInput) {
+            return {
+                decisions: [
+                    {
+                        type: "edit",
+                        editedAction: {
+                            name: approval.toolName,
+                            args: options.editedInput,
+                        },
+                    },
+                ],
+            };
+        }
+        if (decisionType === "reject") {
+            return {
+                decisions: [
+                    {
+                        type: "reject",
+                    },
+                ],
+            };
+        }
+        return {
+            decisions: [
+                {
+                    type: "approve",
+                },
+            ],
+        };
+    }
     async restartConversation(options) {
         const thread = await this.getSession(options.threadId);
         if (!thread) {

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

@@ -130,23 +130,26 @@ export function createPendingApproval(threadId, runId, checkpointRef, input, int
 }
 export function inferRoutingBindings(workspace) {
     const hostBindings = Array.from(workspace.bindings.values()).filter((binding) => binding.harnessRuntime.hostFacing);
-    const researchBinding = hostBindings.find((binding) => binding.agent.id === "research-lite" || binding.agent.id === "research");
-    const directBinding = hostBindings.find((binding) => binding.agent.id === "direct");
-    const delegationHosts = hostBindings.filter((binding) => isDelegationCapableBinding(binding));
-    const lightweightHosts = hostBindings.filter((binding) => !isDelegationCapableBinding(binding));
-    const defaultOrchestratingHost = hostBindings.find((binding) => binding.agent.id === "orchestra") ??
+    const deepAgentHosts = hostBindings.filter((binding) => binding.agent.executionMode === "deepagent" || Boolean(binding.deepAgentParams));
+    const routingHosts = deepAgentHosts.length > 0 ? deepAgentHosts : hostBindings;
+    const researchBinding = routingHosts.find((binding) => binding.agent.id === "research-lite" || binding.agent.id === "research");
+    const directBinding = routingHosts.find((binding) => binding.agent.id === "direct");
+    const delegationHosts = routingHosts.filter((binding) => isDelegationCapableBinding(binding));
+    const lightweightHosts = routingHosts.filter((binding) => !isDelegationCapableBinding(binding));
+    const defaultOrchestratingHost = routingHosts.find((binding) => binding.agent.id === "orchestra") ??
         delegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
         delegationHosts[0];
     const delegationPreferredSecondary = delegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
         delegationHosts[0];
     const genericLightweightHost = lightweightHosts.find((binding) => binding.agent.id !== researchBinding?.agent.id);
-    const primaryBinding = defaultOrchestratingHost ?? directBinding ?? genericLightweightHost ?? hostBindings[0];
+    const primaryBinding = defaultOrchestratingHost ?? directBinding ?? genericLightweightHost ?? routingHosts[0] ?? hostBindings[0];
     const secondaryBinding = genericLightweightHost && genericLightweightHost.agent.id !== primaryBinding?.agent.id
         ? genericLightweightHost
         : directBinding && directBinding.agent.id !== primaryBinding?.agent.id
             ? directBinding
             : delegationPreferredSecondary && delegationPreferredSecondary.agent.id !== primaryBinding?.agent.id
                 ? delegationPreferredSecondary
-                : hostBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id);
+                : routingHosts.find((binding) => binding.agent.id !== primaryBinding?.agent.id) ??
+                    (deepAgentHosts.length > 0 ? undefined : hostBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id));
     return { primaryBinding, secondaryBinding, researchBinding, hostBindings };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.66",
+  "version": "0.0.67",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",