@botbotgo/agent-harness 0.0.102 → 0.0.103

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.101";
+export declare const AGENT_HARNESS_VERSION = "0.0.102";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.101";
+export const AGENT_HARNESS_VERSION = "0.0.102";

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

@@ -0,0 +1,75 @@
+import { FilesystemBackend } from "deepagents";
+import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, DeepAgentParams, RuntimeAdapterOptions } from "../../contracts/types.js";
+import type { ExecutableTool } from "./invoke-runtime.js";
+export declare function resolveBuiltinMiddlewareBackend(input: {
+    binding: CompiledAgentBinding;
+    runtimeAdapterOptions: RuntimeAdapterOptions;
+    resolveFilesystemBackend: (binding: CompiledAgentBinding) => FilesystemBackend;
+    options?: {
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    };
+}): unknown;
+export declare function resolveSubagents(input: {
+    subagents: CompiledSubAgent[];
+    binding?: CompiledAgentBinding;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
+    createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
+}): Promise<CompiledSubAgent[]>;
+export declare function invokeBuiltinTaskTool(input: {
+    binding: CompiledAgentBinding;
+    toolInput: unknown;
+    options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    };
+    resolveBuiltinMiddlewareBackend: (binding: CompiledAgentBinding, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => unknown;
+    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<CompiledSubAgent[]>;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
+}): Promise<unknown>;
+export declare function resolveBuiltinMiddlewareTools(input: {
+    binding: CompiledAgentBinding;
+    options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    };
+    resolveBuiltinMiddlewareBackend: (binding: CompiledAgentBinding, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => unknown;
+    invokeBuiltinTaskTool: (binding: CompiledAgentBinding, toolInput: unknown, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => Promise<unknown>;
+}): Promise<Map<string, ExecutableTool>>;
+export declare function resolveAutomaticSummarizationMiddleware(input: {
+    binding: CompiledAgentBinding;
+    createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
+}): Promise<unknown[]>;
+export declare function resolveLangChainAutomaticMiddleware(input: {
+    binding: CompiledAgentBinding;
+    resolveAutomaticSummarizationMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
+    resolveFilesystemBackend: (binding: CompiledAgentBinding) => FilesystemBackend;
+    resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
+    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<CompiledSubAgent[]>;
+}): Promise<unknown[]>;
+export declare function resolveMiddleware(input: {
+    binding: CompiledAgentBinding;
+    interruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>;
+    runtimeAdapterOptions: RuntimeAdapterOptions;
+    createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
+    resolveLangChainAutomaticMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
+}): Promise<unknown[]>;

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

@@ -0,0 +1,175 @@
+import { HumanMessage } from "@langchain/core/messages";
+import { DEFAULT_SUBAGENT_PROMPT, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, StateBackend, } from "deepagents";
+import { createAgent, humanInTheLoopMiddleware } from "langchain";
+import { createBuiltinMiddlewareTools } from "./tool/builtin-middleware-tools.js";
+import { compileInterruptOn } from "./tool/interrupt-policy.js";
+import { extractToolFallbackContext, extractVisibleOutput } from "../parsing/output-parsing.js";
+import { hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord } from "./runtime-adapter-support.js";
+import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
+import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
+import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
+export function resolveBuiltinMiddlewareBackend(input) {
+    const runtimeState = {
+        ...(input.options?.state ?? {}),
+        ...(isRecord(input.options?.files) ? { files: input.options?.files } : {}),
+    };
+    const runtimeLike = {
+        state: runtimeState,
+        store: input.runtimeAdapterOptions.storeResolver?.(input.binding),
+    };
+    const configuredBackend = isDeepAgentBinding(input.binding)
+        ? input.runtimeAdapterOptions.backendResolver?.(input.binding)
+        : input.resolveFilesystemBackend(input.binding);
+    if (typeof configuredBackend === "function") {
+        return configuredBackend(runtimeLike);
+    }
+    if (configuredBackend) {
+        return configuredBackend;
+    }
+    return new StateBackend(runtimeLike);
+}
+export async function resolveSubagents(input) {
+    return Promise.all(input.subagents.map(async (subagent) => ({
+        ...subagent,
+        ...(subagent.passthrough ?? {}),
+        model: subagent.model ? (await input.resolveModel(subagent.model)) : undefined,
+        tools: subagent.tools ? input.resolveTools(subagent.tools, input.binding) : undefined,
+        skills: await materializeDeepAgentSkillSourcePaths({
+            workspaceRoot: input.binding?.harnessRuntime.workspaceRoot,
+            runRoot: input.binding?.harnessRuntime.runRoot,
+            ownerId: `${input.binding?.agent.id ?? "agent"}-${subagent.name}`,
+            skillPaths: subagent.skills,
+        }),
+        interruptOn: compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
+        responseFormat: subagent.responseFormat,
+        contextSchema: subagent.contextSchema,
+        middleware: (await resolveDeclaredMiddleware(subagent.middleware, input.createDeclaredMiddlewareResolverOptions(input.binding))),
+    })));
+}
+export async function invokeBuiltinTaskTool(input) {
+    if (!isDeepAgentBinding(input.binding)) {
+        throw new Error("The built-in task tool is only available for deepagent bindings.");
+    }
+    const params = getBindingDeepAgentParams(input.binding);
+    if (!params) {
+        throw new Error(`Agent ${input.binding.agent.id} has no deepagent params`);
+    }
+    const typedInput = isObject(input.toolInput) ? input.toolInput : {};
+    const description = typeof typedInput.description === "string" ? typedInput.description : "";
+    const subagentType = typeof typedInput.subagent_type === "string" ? typedInput.subagent_type : "";
+    const builtinBackend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
+    const resolvedSubagents = await input.resolveSubagents(params.subagents, input.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 input.resolveModel(selectedSubagent.model)
+        : await input.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: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
+                })]
+            : []),
+    ];
+    const runnable = createAgent({
+        model: (selectedSubagent.model ?? (await input.resolveModel(params.model))),
+        tools: (selectedSubagent.tools ?? input.resolveTools(params.tools, input.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: `${input.binding.agent.id}:builtin-task` }, ...(input.options?.context ? { context: input.options.context } : {}) });
+    const visibleOutput = extractVisibleOutput(result);
+    const fallbackOutput = extractToolFallbackContext(result);
+    return visibleOutput || fallbackOutput || JSON.stringify(result);
+}
+export async function resolveBuiltinMiddlewareTools(input) {
+    const backend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
+    return createBuiltinMiddlewareTools(backend, {
+        includeTaskTool: isDeepAgentBinding(input.binding),
+        invokeTaskTool: isDeepAgentBinding(input.binding)
+            ? async (toolInput) => input.invokeBuiltinTaskTool(input.binding, toolInput, input.options)
+            : undefined,
+    });
+}
+export async function resolveAutomaticSummarizationMiddleware(input) {
+    if (hasConfiguredMiddlewareKind(input.binding, "summarization")) {
+        return [];
+    }
+    const primaryModel = getBindingPrimaryModel(input.binding);
+    if (!primaryModel) {
+        return [];
+    }
+    return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], input.createDeclaredMiddlewareResolverOptions(input.binding));
+}
+export async function resolveLangChainAutomaticMiddleware(input) {
+    const params = getBindingLangChainParams(input.binding);
+    if (!params) {
+        return [];
+    }
+    const compatibleParams = applyDeepAgentDelegationPromptCompatibility(params.model, params);
+    const automaticMiddleware = [];
+    automaticMiddleware.push(createPatchToolCallsMiddleware());
+    automaticMiddleware.push(...(await input.resolveAutomaticSummarizationMiddleware(input.binding)));
+    if ((compatibleParams.skills?.length ?? 0) > 0) {
+        automaticMiddleware.push(createSkillsMiddleware({
+            backend: input.resolveFilesystemBackend(input.binding),
+            sources: compatibleParams.skills,
+        }));
+    }
+    if ((compatibleParams.memory?.length ?? 0) > 0) {
+        automaticMiddleware.push(createMemoryMiddleware({
+            backend: input.resolveFilesystemBackend(input.binding),
+            sources: compatibleParams.memory,
+        }));
+    }
+    if (hasConfiguredSubagentSupport(input.binding)) {
+        automaticMiddleware.push(createSubAgentMiddleware({
+            defaultModel: (await input.resolveModel(compatibleParams.model)),
+            defaultTools: input.resolveTools(compatibleParams.tools, input.binding),
+            defaultInterruptOn: getBindingInterruptCompatibilityRules(input.binding),
+            subagents: (await input.resolveSubagents(compatibleParams.subagents ?? [], input.binding)),
+            generalPurposeAgent: compatibleParams.generalPurposeAgent,
+            taskDescription: compatibleParams.taskDescription ?? null,
+        }));
+    }
+    return automaticMiddleware;
+}
+export async function resolveMiddleware(input) {
+    const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(input.binding), input.createDeclaredMiddlewareResolverOptions(input.binding));
+    const automaticMiddleware = isLangChainBinding(input.binding)
+        ? await input.resolveLangChainAutomaticMiddleware(input.binding)
+        : [];
+    const middleware = [
+        ...declarativeMiddleware,
+        ...automaticMiddleware,
+        ...(input.runtimeAdapterOptions.middlewareResolver ? input.runtimeAdapterOptions.middlewareResolver(input.binding) : []),
+    ];
+    if (input.interruptOn && Object.keys(input.interruptOn).length > 0) {
+        middleware.push(humanInTheLoopMiddleware({ interruptOn: input.interruptOn }));
+    }
+    return middleware;
+}

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

@@ -0,0 +1,27 @@
+import type { CompiledAgentBinding } from "../../contracts/types.js";
+export declare class RuntimeOperationTimeoutError extends Error {
+    readonly operation: string;
+    readonly timeoutMs: number;
+    readonly stage: "stream" | "invoke";
+    constructor(operation: string, timeoutMs: number, stage?: "stream" | "invoke");
+}
+export declare function invokeWithProviderRetry<T>(binding: CompiledAgentBinding, operation: () => Promise<T>): Promise<T>;
+export declare function withRuntimeTimeout<T>(producer: () => T | Promise<T>, timeoutMs: number | undefined, operation: string, stage?: "stream" | "invoke"): Promise<T>;
+export declare function iterateWithTimeout<T>(iterable: AsyncIterable<T>, timeoutMs: number | undefined, operation: string, deadlineAt?: number, deadlineTimeoutMs?: number): AsyncGenerator<T>;
+export declare function materializeModelStream(streamFactory: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>, input: unknown, config?: Record<string, unknown>): Promise<{
+    content: string;
+}>;
+export declare function createModelFallbackRunnable(model: {
+    invoke?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown>;
+    stream?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
+}): {
+    invoke: (input: unknown, config?: Record<string, unknown>) => Promise<unknown>;
+    stream: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
+};
+export declare function applyStrictToolJsonInstruction(binding: CompiledAgentBinding): CompiledAgentBinding;
+export declare function callRuntimeWithToolParseRecovery(input: {
+    binding: CompiledAgentBinding;
+    request: unknown;
+    resumePayload?: unknown;
+    callRuntime: (binding: CompiledAgentBinding, request: unknown) => Promise<Record<string, unknown>>;
+}): Promise<Record<string, unknown>>;

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

@@ -0,0 +1,168 @@
+import { extractVisibleOutput, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION } from "../parsing/output-parsing.js";
+import { readStreamDelta } from "../parsing/stream-event-parsing.js";
+import { computeRemainingTimeoutMs, isRetryableProviderError, resolveProviderRetryPolicy } from "./resilience.js";
+import { sleep } from "./runtime-adapter-support.js";
+import { getBindingDeepAgentParams, getBindingLangChainParams, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
+export class RuntimeOperationTimeoutError extends Error {
+    operation;
+    timeoutMs;
+    stage;
+    constructor(operation, timeoutMs, stage = operation.includes("stream") ? "stream" : "invoke") {
+        super(`${operation} timed out after ${timeoutMs}ms`);
+        this.operation = operation;
+        this.timeoutMs = timeoutMs;
+        this.stage = stage;
+        this.name = "RuntimeOperationTimeoutError";
+    }
+}
+export async function invokeWithProviderRetry(binding, operation) {
+    const retryPolicy = resolveProviderRetryPolicy(binding);
+    let lastError;
+    for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= retryPolicy.maxAttempts || !isRetryableProviderError(binding, error)) {
+                throw error;
+            }
+            if (retryPolicy.backoffMs > 0) {
+                await sleep(retryPolicy.backoffMs);
+            }
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+export async function withRuntimeTimeout(producer, timeoutMs, operation, stage = operation.includes("stream") ? "stream" : "invoke") {
+    if (!timeoutMs) {
+        return Promise.resolve(producer());
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new RuntimeOperationTimeoutError(operation, timeoutMs, stage)), timeoutMs);
+        Promise.resolve(producer()).then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+export async function* iterateWithTimeout(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    try {
+        for (;;) {
+            const effectiveTimeoutMs = computeRemainingTimeoutMs(deadlineAt, timeoutMs);
+            if (effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0) {
+                throw new RuntimeOperationTimeoutError(operation, deadlineTimeoutMs ?? timeoutMs ?? 0, "invoke");
+            }
+            let next;
+            try {
+                next = await withRuntimeTimeout(() => iterator.next(), effectiveTimeoutMs, operation, "stream");
+            }
+            catch (error) {
+                if (error instanceof RuntimeOperationTimeoutError &&
+                    deadlineAt &&
+                    deadlineTimeoutMs &&
+                    effectiveTimeoutMs !== timeoutMs) {
+                    throw new RuntimeOperationTimeoutError(operation, deadlineTimeoutMs, "invoke");
+                }
+                throw error;
+            }
+            if (next.done) {
+                return;
+            }
+            yield next.value;
+        }
+    }
+    finally {
+        if (typeof iterator.return === "function") {
+            const returnResult = iterator.return();
+            if (returnResult && typeof returnResult.then === "function") {
+                void returnResult.catch(() => undefined);
+            }
+        }
+    }
+}
+export async function materializeModelStream(streamFactory, input, config) {
+    const stream = await streamFactory(input, config);
+    let content = "";
+    for await (const chunk of stream) {
+        const delta = readStreamDelta(chunk) || extractVisibleOutput(chunk);
+        if (delta) {
+            content += delta;
+        }
+    }
+    return { content };
+}
+export function createModelFallbackRunnable(model) {
+    return {
+        invoke: async (input, config) => {
+            const request = typeof input === "object" && input !== null && "messages" in input
+                ? input.messages
+                : input;
+            if (typeof model.invoke === "function") {
+                return model.invoke(request, config);
+            }
+            if (typeof model.stream === "function") {
+                return materializeModelStream(model.stream.bind(model), request, config);
+            }
+            throw new Error("Resolved model must define invoke or stream.");
+        },
+        stream: async (input, config) => {
+            if (typeof model.stream === "function") {
+                const request = typeof input === "object" && input !== null && "messages" in input
+                    ? input.messages
+                    : input;
+                return model.stream(request, config);
+            }
+            if (typeof model.invoke === "function") {
+                const request = typeof input === "object" && input !== null && "messages" in input
+                    ? input.messages
+                    : input;
+                const result = await model.invoke(request, config);
+                const text = extractVisibleOutput(result);
+                async function* singleChunk() {
+                    yield { content: text };
+                }
+                return singleChunk();
+            }
+            throw new Error("Resolved model must define invoke or stream.");
+        },
+    };
+}
+export function applyStrictToolJsonInstruction(binding) {
+    if (isLangChainBinding(binding)) {
+        const params = getBindingLangChainParams(binding);
+        return {
+            ...binding,
+            langchainAgentParams: {
+                ...params,
+                systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+            },
+        };
+    }
+    if (isDeepAgentBinding(binding)) {
+        const params = getBindingDeepAgentParams(binding);
+        return {
+            ...binding,
+            deepAgentParams: {
+                ...params,
+                systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+            },
+        };
+    }
+    return binding;
+}
+export async function callRuntimeWithToolParseRecovery(input) {
+    try {
+        return await input.callRuntime(input.binding, input.request);
+    }
+    catch (error) {
+        if (input.resumePayload !== undefined || !isToolCallParseFailure(error)) {
+            throw error;
+        }
+        return input.callRuntime(applyStrictToolJsonInstruction(input.binding), input.request);
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
+import { type ToolNameMapping } from "./tool/tool-name-mapping.js";
+import type { ExecutableTool } from "./invoke-runtime.js";
+export declare function resolveAdapterTools(input: {
+    tools: Array<CompiledTool>;
+    binding?: CompiledAgentBinding;
+    resolveToolValues?: (toolIds: string[], binding?: CompiledAgentBinding) => unknown[];
+}): unknown[];
+export declare function buildExecutableToolMap(input: {
+    primaryTools: CompiledTool[];
+    resolvedTools: unknown[];
+    toolNameMapping?: ToolNameMapping;
+    context?: Record<string, unknown>;
+}): Map<string, ExecutableTool>;

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

@@ -0,0 +1,57 @@
+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 { wrapToolForExecution } from "./tool/tool-hitl.js";
+export function resolveAdapterTools(input) {
+    const resolved = input.resolveToolValues ? input.resolveToolValues(input.tools.map((tool) => tool.id), input.binding) : [];
+    const toolNameMapping = buildToolNameMapping(input.tools);
+    return input.tools.flatMap((compiledTool, index) => {
+        const resolvedTool = resolved[index] ?? (compiledTool.type === "provider" ? instantiateProviderTool(compiledTool) : undefined);
+        if (resolvedTool === undefined) {
+            return [];
+        }
+        const wrappedTool = wrapToolForExecution(resolvedTool, compiledTool, input.binding);
+        const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
+        const structuredTool = asStructuredExecutableTool(wrappedTool, modelFacingName, compiledTool.description);
+        if (structuredTool !== wrappedTool) {
+            return structuredTool;
+        }
+        return modelFacingName === compiledTool.name ? wrappedTool : wrapResolvedToolWithModelFacingName(wrappedTool, modelFacingName);
+    });
+}
+export function buildExecutableToolMap(input) {
+    const executableTools = new Map();
+    const toolNameMapping = input.toolNameMapping ?? buildToolNameMapping(input.primaryTools);
+    for (let index = 0; index < input.primaryTools.length; index += 1) {
+        const compiledTool = input.primaryTools[index];
+        const resolvedTool = input.resolvedTools[index];
+        if (!compiledTool || !resolvedTool || !hasCallableToolHandler(resolvedTool)) {
+            continue;
+        }
+        const callableTool = resolvedTool;
+        const handler = async (toolInput) => {
+            const callable = typeof callableTool.invoke === "function"
+                ? callableTool.invoke
+                : typeof callableTool.call === "function"
+                    ? callableTool.call
+                    : callableTool.func;
+            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));
+        };
+        const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
+        const schema = normalizeResolvedToolSchema(callableTool);
+        executableTools.set(modelFacingName, {
+            name: compiledTool.name,
+            schema,
+            invoke: handler,
+        });
+        executableTools.set(compiledTool.name, {
+            name: compiledTool.name,
+            schema,
+            invoke: handler,
+        });
+    }
+    return executableTools;
+}

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

@@ -1,5 +1,6 @@
 import type { CompiledAgentBinding, MessageContent, RunResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
+import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
 export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
@@ -10,12 +11,6 @@ type RunnableLike = {
     streamEvents?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
 };
 declare const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
-declare class RuntimeOperationTimeoutError extends Error {
-    readonly operation: string;
-    readonly timeoutMs: number;
-    readonly stage: "stream" | "invoke";
-    constructor(operation: string, timeoutMs: number, stage?: "stream" | "invoke");
-}
 export declare class AgentRuntimeAdapter {
     private readonly options;
     private readonly modelCache;