@botbotgo/agent-harness 0.0.372 → 0.0.374

package/dist/cli/chat-rendering.js

@@ -16,21 +16,18 @@ export function renderChatRequestRunning(input) {
     return `\n${parts.join(" ")}\n`;
 }
 export function summarizeChatToolResult(output, isError) {
-    if (!isError) {
-        return "completed";
-    }
-    return summarizeChatToolError(output);
+    return isError ? summarizeChatToolOutput(output, "failed") : summarizeChatToolOutput(output, "completed");
 }
-function summarizeChatToolError(output) {
+function summarizeChatToolOutput(output, fallback) {
     if (typeof output === "string") {
         const trimmed = output.trim();
-        return trimmed.length > 0 ? truncateChatToolPreview(trimmed, 240) : "failed";
+        return trimmed.length > 0 ? truncateChatToolPreview(trimmed, 240) : fallback;
     }
     if (typeof output === "number" || typeof output === "boolean") {
         return String(output);
     }
     if (!output || typeof output !== "object") {
-        return "failed";
+        return fallback;
     }
     const typed = output;
     const content = extractChatToolTextContent(output);

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.372";
+export declare const AGENT_HARNESS_VERSION = "0.0.374";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.372";
+export const AGENT_HARNESS_VERSION = "0.0.374";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";

package/dist/runtime/adapter/flow/execution-context.js

@@ -28,18 +28,19 @@ export function buildBindingToolExecutionContext(input) {
 export async function resolveLangChainStreamContext(input) {
     const primaryTools = getBindingPrimaryTools(input.binding);
     const primaryModel = getBindingPrimaryModel(input.binding);
-    const forceInvokeFallback = isLangChainBinding(input.binding) &&
-        primaryTools.length > 0 &&
-        primaryModel?.provider === "openai-compatible";
     const resolvedLangChainModel = primaryModel
         ? (await input.resolveModel(primaryModel))
         : undefined;
     const resolvedLangChainTools = primaryTools.length > 0 ? input.resolveTools(primaryTools, input.binding) : [];
+    const modelSupportsToolBinding = typeof resolvedLangChainModel?.bindTools === "function";
+    const forceInvokeFallback = isLangChainBinding(input.binding) &&
+        primaryTools.length > 0 &&
+        primaryModel?.provider === "openai-compatible";
     const canUseDirectModelStream = !!resolvedLangChainModel &&
-        (resolvedLangChainTools.length === 0 || typeof resolvedLangChainModel.bindTools !== "function");
+        primaryTools.length === 0;
     const langChainStreamModel = resolvedLangChainModel && canUseDirectModelStream
         ? resolvedLangChainModel
-        : resolvedLangChainModel && typeof resolvedLangChainModel.bindTools === "function" && resolvedLangChainTools.length > 0
+        : resolvedLangChainModel && modelSupportsToolBinding && resolvedLangChainTools.length > 0
             ? resolvedLangChainModel.bindTools(resolvedLangChainTools)
             : undefined;
     return {

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

@@ -7,7 +7,7 @@ import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../ups
 import { appendToolRecoveryInstruction, extractVisibleOutput, tryParseJson } from "../../parsing/output-parsing.js";
 import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
 import { isEmptyFinalAiMessageError } from "../resilience.js";
-import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
+import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
 const CLOSE_REQUIRED_PLAN_RECOVERY_INSTRUCTION = [
     "The current required todo board still has unfinished work.",
     "Do not broaden the investigation, restart planning, or ask the user what to do next.",
@@ -352,7 +352,7 @@ export async function executeRequestInvocation(options) {
             ? result.messages
             : undefined;
         const recoveryBase = messages ? { messages } : request;
-        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, CLOSE_REQUIRED_PLAN_RECOVERY_INSTRUCTION);
+        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION);
         const recoveredInvocation = await invokeOnce(recoveredRequest);
         localOrUpstreamInvocation = recoveredInvocation;
         result = recoveredInvocation.result;

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

@@ -1,4 +1,4 @@
-import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
+import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, appendToolRecoveryInstruction, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
 import { DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION, DELEGATION_ONLY_RECOVERY_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
@@ -19,6 +19,13 @@ const CLOSE_REQUIRED_PLAN_RECOVERY_INSTRUCTION = [
     "Your next action must be write_todos: update every remaining pending or in_progress item to completed if evidence was gathered, or failed if it cannot be completed with the available tools.",
     "After that write_todos call, provide the final answer required by the agent response format.",
 ].join("\n");
+const INITIAL_REQUIRED_PLAN_INSTRUCTION = [
+    "This agent has a required visible planning contract.",
+    "Your first action for this request must be write_todos with concrete task steps and statuses.",
+    "Do not call any domain/evidence tool and do not provide a final answer before the initial write_todos call succeeds.",
+    "Do not use placeholders like '1', '2', '3', 'step 1', or generic labels. Each todo must name the concrete work it represents.",
+    "After each evidence step, update the todo board. Before the final answer, close every todo as completed or failed.",
+].join("\n");
 function toVisibleContent(value) {
     const extracted = extractVisibleOutput(value);
     return extracted ? sanitizeVisibleText(extracted) : "";
@@ -231,7 +238,10 @@ function finishProfileStep(input) {
     });
 }
 export async function* streamRuntimeExecution(options) {
-    const request = buildInvocationRequest(options.binding, options.history, options.input, options.runtimeOptions);
+    let request = buildInvocationRequest(options.binding, options.history, options.input, options.runtimeOptions);
+    if (requiresPlanEvidence(options.binding)) {
+        request = appendToolRecoveryInstruction(request, INITIAL_REQUIRED_PLAN_INSTRUCTION);
+    }
     let emittedUnsafeStreamSideEffects = false;
     const shouldProfile = options.runtimeOptions.profiling === true;
     const shouldValidateStreamOutput = shouldValidateExecutionWithoutToolEvidence(request);

package/dist/runtime/adapter/model/model-providers.js

@@ -201,6 +201,30 @@ function hasPriorToolResultForToolName(input, toolName) {
     }
     return false;
 }
+function readBoundToolName(tool) {
+    return typeof tool === "object" && tool !== null && typeof tool.name === "string"
+        ? tool.name.trim()
+        : "";
+}
+function isTodoPlanningToolName(name) {
+    return name === "write_todos"
+        || name === "read_todos"
+        || name === "tool_call_write_todos"
+        || name === "tool_call_read_todos";
+}
+function shouldLimitPromptedJsonToolsToPlanning(input) {
+    const text = stringifyNodeLlamaCppInput(input);
+    return text.includes("required visible planning contract")
+        && !hasPriorToolResultForToolName(input, "write_todos")
+        && !hasPriorToolResultForToolName(input, "tool_call_write_todos");
+}
+function selectPromptedJsonToolsForTurn(input, boundTools) {
+    if (!shouldLimitPromptedJsonToolsToPlanning(input)) {
+        return boundTools;
+    }
+    const planningTools = boundTools.filter((tool) => isTodoPlanningToolName(readBoundToolName(tool)));
+    return planningTools.length > 0 ? planningTools : boundTools;
+}
 function normalizeReadFileToolContent(name, content) {
     if (name !== "read_file") {
         return content;
@@ -484,8 +508,9 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
             }
             if (prop === "invoke") {
                 return async (input, config) => {
-                    const rawResult = await target.invoke(boundTools.length > 0 ? withPromptedJsonToolPrompt(input, boundTools, options) : input, config);
-                    if (boundTools.length === 0) {
+                    const effectiveBoundTools = selectPromptedJsonToolsForTurn(input, boundTools);
+                    const rawResult = await target.invoke(effectiveBoundTools.length > 0 ? withPromptedJsonToolPrompt(input, effectiveBoundTools, options) : input, config);
+                    if (effectiveBoundTools.length === 0) {
                         return rawResult;
                     }
                     const text = readModelText(rawResult);

package/dist/runtime/adapter/stream-event-projection.js

@@ -1,5 +1,6 @@
 import { extractToolFallbackContext, extractVisibleOutput, readTextContent, sanitizeVisibleText } from "../parsing/output-parsing.js";
 import { salvageFunctionLikeToolCall } from "../parsing/output-tool-args.js";
+import { isLowSignalTodoContent, summarizeBuiltinWriteTodosArgs } from "./runtime-adapter-support.js";
 import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, sanitizeRetainedUpstreamEvent, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, } from "../parsing/stream-event-parsing.js";
 import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
 export function createStreamEventProjectionState() {
@@ -287,6 +288,30 @@ function updateDelegationState(state, event, countConfiguredToolsForAgentId) {
         }
     }
 }
+function extractTodoToolStart(event) {
+    if (typeof event !== "object" || event === null) {
+        return null;
+    }
+    const typed = event;
+    const eventName = typeof typed.event === "string" ? typed.event : "";
+    const runType = typeof typed.run_type === "string" ? typed.run_type : "";
+    const toolName = typeof typed.name === "string" ? typed.name : "";
+    const isToolStart = eventName === "on_tool_start" || (eventName === "on_chain_start" && runType === "tool");
+    if (!isToolStart || (toolName !== "write_todos" && toolName !== "read_todos")) {
+        return null;
+    }
+    const input = unwrapPossibleToolInput(typed.data?.input);
+    if (toolName === "write_todos" && typeof input === "object" && input !== null && !Array.isArray(input)) {
+        const summary = summarizeBuiltinWriteTodosArgs(input);
+        if (summary.summary.total === 0) {
+            throw new Error("Error invoking tool 'write_todos' with kwargs {\"todos\":[]} with error: Error: Initial write_todos call cannot use an empty todo list. Send the concrete task steps with both content and status.");
+        }
+        if (summary.items.every((item) => isLowSignalTodoContent(item.content))) {
+            throw new Error("Error invoking tool 'write_todos' with placeholder todo content with error: Error: Initial write_todos call must use descriptive task content. Do not use placeholder entries like '1', '2', or 'step 1'.");
+        }
+    }
+    return { toolName, input };
+}
 export function projectRuntimeStreamEvent(params) {
     const { event, allowVisibleStreamDeltas, includeStateStreamOutput, rootAgentId, countConfiguredToolsForAgentId, toolNameMapping, primaryTools, state, } = params;
     const chunks = [{
@@ -341,6 +366,17 @@ export function projectRuntimeStreamEvent(params) {
         }
     }
     const toolResult = extractToolResult(event);
+    const todoToolStart = toolResult ? null : extractTodoToolStart(event);
+    if (todoToolStart) {
+        state.emittedToolResult = true;
+        state.emittedSuccessfulToolResult = true;
+        chunks.push({
+            kind: "tool-result",
+            toolName: resolveModelFacingToolName(todoToolStart.toolName, toolNameMapping, primaryTools),
+            output: todoToolStart.input,
+            isError: false,
+        });
+    }
     if (toolResult) {
         const isTodoTool = toolResult.toolName === "write_todos" || toolResult.toolName === "read_todos";
         const salvagedTaskErrorFindings = toolResult.toolName === "task"

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

@@ -217,7 +217,7 @@ export function asStructuredExecutableTool(resolvedTool, modelFacingName, descri
     if (typeof handler !== "function") {
         return resolvedTool;
     }
-    return createLangChainTool(async (input, config) => handler(input, config), {
+    return createLangChainTool(async (input, config) => handler.call(resolvedTool, input, config), {
         name: modelFacingName,
         description,
         schema: normalizeModelFacingToolSchema(resolvedTool),

package/dist/runtime/adapter/tool/tool-name-mapping.d.ts

@@ -2,6 +2,8 @@ export type ToolNameMapping = {
     originalToModelFacing: Map<string, string>;
     modelFacingToOriginal: Map<string, string>;
 };
+export declare function stripProviderToolCallPrefix(toolName: string): string | null;
+export declare function createProviderToolCallAliasName(toolName: string): string;
 export declare function sanitizeToolNameForModel(name: string): string;
 export declare function buildToolNameMapping(tools: Array<{
     name: string;

package/dist/runtime/adapter/tool/tool-name-mapping.js

@@ -1,4 +1,17 @@
 const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const PROVIDER_TOOL_CALL_PREFIXES = ["tool_call_", "tool_call.", "tool_call-", "tool.call_", "tool.call.", "tool-call-"];
+export function stripProviderToolCallPrefix(toolName) {
+    const trimmed = toolName.trim();
+    for (const prefix of PROVIDER_TOOL_CALL_PREFIXES) {
+        if (trimmed.startsWith(prefix)) {
+            return trimmed.substring(prefix.length);
+        }
+    }
+    return null;
+}
+export function createProviderToolCallAliasName(toolName) {
+    return `tool_call_${sanitizeToolNameForModel(toolName)}`;
+}
 export function sanitizeToolNameForModel(name) {
     const withoutNamespace = name.includes(".") ? name.split(".").at(-1) ?? name : name;
     const sanitized = withoutNamespace
@@ -59,16 +72,26 @@ export function createModelFacingToolNameLookupCandidates(toolName) {
             add(stripped);
         }
     };
+    const addProviderPrefixStripped = (value) => {
+        const stripped = stripProviderToolCallPrefix(value);
+        if (stripped) {
+            add(stripped);
+            addSuffixStripped(stripped);
+        }
+    };
     add(trimmed);
+    addProviderPrefixStripped(trimmed);
     if (trimmed.startsWith("functions.")) {
         const stripped = trimmed.substring("functions.".length);
         add(stripped);
         addSuffixStripped(stripped);
+        addProviderPrefixStripped(stripped);
     }
     else if (trimmed.startsWith("function.")) {
         const stripped = trimmed.substring("function.".length);
         add(stripped);
         addSuffixStripped(stripped);
+        addProviderPrefixStripped(stripped);
     }
     else {
         addSuffixStripped(trimmed);
@@ -97,5 +120,9 @@ export function resolveModelFacingToolName(toolName, mapping, tools) {
     if (candidateMatches.length === 1) {
         return candidateMatches[0].name;
     }
+    const providerPrefixStripped = stripProviderToolCallPrefix(toolName);
+    if (providerPrefixStripped) {
+        return sanitizeToolNameForModel(providerPrefixStripped);
+    }
     return toolName;
 }

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

@@ -13,3 +13,4 @@ export declare function buildExecutableToolMap(input: {
     toolConfig?: Record<string, unknown>;
     context?: Record<string, unknown>;
 }): Map<string, ExecutableTool>;
+export declare function appendProviderToolCallAliasTools(tools: unknown[]): unknown[];

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

@@ -1,6 +1,6 @@
 import { instantiateProviderTool } from "./tool/provider-tool.js";
 import { asStructuredExecutableTool, hasCallableToolHandler, normalizeResolvedToolSchema, wrapResolvedToolWithModelFacingName, } from "./tool/resolved-tool.js";
-import { buildToolNameMapping } from "./tool/tool-name-mapping.js";
+import { buildToolNameMapping, createProviderToolCallAliasName } from "./tool/tool-name-mapping.js";
 import { wrapToolForExecution } from "./tool/tool-hitl.js";
 export function resolveAdapterTools(input) {
     const resolved = input.resolveToolValues ? input.resolveToolValues(input.tools.map((tool) => tool.id), input.binding) : [];
@@ -57,3 +57,30 @@ export function buildExecutableToolMap(input) {
     }
     return executableTools;
 }
+function readResolvedToolName(tool) {
+    return typeof tool === "object" && tool !== null && typeof tool.name === "string"
+        ? tool.name
+        : undefined;
+}
+function readResolvedToolDescription(tool) {
+    return typeof tool === "object" && tool !== null && typeof tool.description === "string"
+        ? tool.description
+        : "";
+}
+export function appendProviderToolCallAliasTools(tools) {
+    const existingNames = new Set(tools.map(readResolvedToolName).filter((name) => !!name));
+    const aliases = [];
+    for (const tool of tools) {
+        const name = readResolvedToolName(tool);
+        if (!name || !hasCallableToolHandler(tool)) {
+            continue;
+        }
+        const aliasName = createProviderToolCallAliasName(name);
+        if (existingNames.has(aliasName)) {
+            continue;
+        }
+        existingNames.add(aliasName);
+        aliases.push(asStructuredExecutableTool(tool, aliasName, readResolvedToolDescription(tool) || name));
+    }
+    return [...tools, ...aliases];
+}

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

@@ -37,6 +37,7 @@ export declare class AgentRuntimeAdapter {
     private createAssemblyResolvers;
     private invokeBuiltinTaskTool;
     private resolveBuiltinMiddlewareTools;
+    private materializeProviderAliasBuiltinTools;
     private materializeAutomaticSummarizationMiddleware;
     private resolveLangChainRuntimeExtensionMiddleware;
     private resolveMiddleware;

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

@@ -16,7 +16,7 @@ import { extractSubagentRequestText, invokeBuiltinTaskTool as invokeBuiltinTaskT
 import { isEmptyFinalAiMessageError, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { renderDirectWorkspaceListing, shouldDirectlyListWorkspaceFiles } from "./adapter/direct-builtin-utility.js";
-import { resolveAdapterTools } from "./adapter/tool-resolution.js";
+import { appendProviderToolCallAliasTools, resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 import { isRetryableProviderError } from "./adapter/resilience.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
@@ -418,6 +418,12 @@ export class AgentRuntimeAdapter {
             invokeBuiltinTaskTool: assembly.invokeBuiltinTaskTool,
         });
     }
+    materializeProviderAliasBuiltinTools(builtinTools) {
+        const aliasableTools = ["write_todos", "read_todos", "task"]
+            .map((name) => builtinTools.get(name))
+            .filter((tool) => tool !== undefined);
+        return appendProviderToolCallAliasTools(aliasableTools).slice(aliasableTools.length);
+    }
     async materializeAutomaticSummarizationMiddleware(binding) {
         const assembly = this.createAssemblyResolvers(binding);
         return materializeAutomaticSummarizationMiddlewareHelper({
@@ -530,16 +536,18 @@ export class AgentRuntimeAdapter {
         const interruptOn = resolveRunnableInterruptOn(binding);
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
-        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: await this.resolveBuiltinMiddlewareTools(binding, {
+        const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, {
+            sessionId: options.sessionId ?? options.legacySessionId,
+            toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
                 sessionId: options.sessionId ?? options.legacySessionId,
-                toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
-                    sessionId: options.sessionId ?? options.legacySessionId,
-                }),
             }),
+        });
+        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
+            builtinTools: builtinExecutableTools,
             explicitToolNames: primaryTools.map((tool) => tool.name),
             modelExposed: getBindingBuiltinToolsConfig(binding)?.modelExposed,
         });
+        const providerAliasBuiltinTools = this.materializeProviderAliasBuiltinTools(builtinExecutableTools);
         const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn, { sessionId: options.sessionId ?? options.legacySessionId });
         const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
         const resolvedStore = this.options.storeResolver?.(binding);
@@ -547,10 +555,14 @@ export class AgentRuntimeAdapter {
         if (resolvedTools.length + builtinMiddlewareTools.length > 0 && typeof model.bindTools !== "function") {
             throw new Error(`Agent ${binding.agent.id} configures ${resolvedTools.length + builtinMiddlewareTools.length} tool(s), but resolved model ${primaryModel.id} does not support tool binding.`);
         }
+        const modelTools = [
+            ...appendProviderToolCallAliasTools([...resolvedTools, ...builtinMiddlewareTools]),
+            ...providerAliasBuiltinTools,
+        ];
         return createAgent(buildLangChainCreateParams({
             binding,
             resolvedModel: model,
-            resolvedTools: [...resolvedTools, ...builtinMiddlewareTools],
+            resolvedTools: modelTools,
             resolvedMiddleware,
             resolvedCheckpointer,
             resolvedStore,
@@ -576,16 +588,22 @@ export class AgentRuntimeAdapter {
         }
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
-        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: await this.resolveBuiltinMiddlewareTools(binding, {
+        const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, {
+            sessionId: options.sessionId ?? options.legacySessionId,
+            toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
                 sessionId: options.sessionId ?? options.legacySessionId,
-                toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
-                    sessionId: options.sessionId ?? options.legacySessionId,
-                }),
             }),
+        });
+        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
+            builtinTools: builtinExecutableTools,
             explicitToolNames: primaryTools.map((tool) => tool.name),
             modelExposed: getBindingBuiltinToolsConfig(binding)?.modelExposed,
         });
+        const providerAliasBuiltinTools = this.materializeProviderAliasBuiltinTools(builtinExecutableTools);
+        const modelTools = [
+            ...appendProviderToolCallAliasTools([...resolvedTools, ...builtinMiddlewareTools]),
+            ...providerAliasBuiltinTools,
+        ];
         const resolvedMiddleware = await this.resolveMiddleware(binding);
         const resolvedSubagents = await this.resolveDeepAgentSubagents(getBindingDeepAgentSubagents(binding), binding, { sessionId: options.sessionId ?? options.legacySessionId });
         const resolvedInterruptOn = resolveRunnableInterruptOn(binding);
@@ -607,7 +625,7 @@ export class AgentRuntimeAdapter {
         if (shouldUseConfigurableDeepAgentAssembly(binding)) {
             return this.createConfigurableDeepAgentRunnable(binding, {
                 resolvedModel,
-                resolvedTools: [...resolvedTools, ...builtinMiddlewareTools],
+                resolvedTools: modelTools,
                 resolvedMiddleware,
                 resolvedSubagents,
                 resolvedInterruptOn,

package/package.json

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