@botbotgo/agent-harness 0.0.101 → 0.0.103

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

@@ -1,34 +1,28 @@
 import path from "node:path";
 import { Command, MemorySaver } from "@langchain/langgraph";
-import { HumanMessage } from "@langchain/core/messages";
-import { DEFAULT_SUBAGENT_PROMPT, createDeepAgent, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
-import { createAgent, humanInTheLoopMiddleware } from "langchain";
-import { extractToolFallbackContext, extractVisibleOutput, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { readStreamDelta, } from "./parsing/stream-event-parsing.js";
-import { wrapToolForExecution } from "./adapter/tool/tool-hitl.js";
-import { resolveDeclaredMiddleware } from "./adapter/tool/declared-middleware.js";
+import { createDeepAgent, FilesystemBackend, } from "deepagents";
+import { createAgent } from "langchain";
+import { wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
-import { createBuiltinMiddlewareTools } from "./adapter/tool/builtin-middleware-tools.js";
 import { finalizeInvocationResult } from "./adapter/invocation-result.js";
-import { runLocalToolInvocationLoop } from "./adapter/local-tool-invocation.js";
-import { createStreamEventProjectionState, projectRuntimeStreamEvent } from "./adapter/stream-event-projection.js";
-import { projectTextStreamChunks } from "./adapter/stream-text-consumption.js";
+import { invokeRuntimeWithLocalTools } from "./adapter/invoke-runtime.js";
+import { streamRuntimeExecution } from "./adapter/stream-runtime.js";
 import { buildDeepAgentRunnableConfig } from "./adapter/deepagent-runnable-config.js";
 import { buildLangChainRunnableConfig } from "./adapter/langchain-runnable-config.js";
-import { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
+import { applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
+import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, resolveAutomaticSummarizationMiddleware as resolveAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainAutomaticMiddleware as resolveLangChainAutomaticMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
+import { computeRemainingTimeoutMs, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { buildInvocationRequest, } from "./adapter/model/invocation-request.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
-import { buildRawModelMessages } from "./adapter/model/message-assembly.js";
-import { asStructuredExecutableTool, hasCallableToolHandler, normalizeResolvedToolSchema, wrapResolvedToolWithModelFacingName, } from "./adapter/tool/resolved-tool.js";
-import { instantiateProviderTool } from "./adapter/tool/provider-tool.js";
-import { countConfiguredTools, hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord, sleep, } from "./adapter/runtime-adapter-support.js";
+import { countConfiguredTools, } from "./adapter/runtime-adapter-support.js";
+import { buildExecutableToolMap, resolveAdapterTools } from "./adapter/tool-resolution.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";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
-import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "write_todos",
@@ -41,18 +35,6 @@ const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "execute",
     "task",
 ]);
-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 class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -69,144 +51,22 @@ export class AgentRuntimeAdapter {
         });
     }
     async 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));
+        return invokeWithProviderRetryHelper(binding, operation);
     }
     async withTimeout(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);
-            });
-        });
+        return withRuntimeTimeout(producer, timeoutMs, operation, stage);
     }
     async *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 this.withTimeout(() => 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);
-                }
-            }
-        }
+        yield* iterateWithTimeoutHelper(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs);
     }
     async 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 };
+        return materializeModelStreamHelper(streamFactory, input, config);
     }
     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 this.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.");
-            },
-        };
+        return createModelFallbackRunnableHelper(model);
     }
     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;
+        return applyStrictToolJsonInstructionHelper(binding);
     }
     async resolveModel(model) {
         const cacheKey = this.getModelCacheKey(model);
@@ -227,20 +87,10 @@ export class AgentRuntimeAdapter {
         }
     }
     resolveTools(tools, binding) {
-        const resolved = this.options.toolResolver ? this.options.toolResolver(tools.map((tool) => tool.id), binding) : [];
-        const toolNameMapping = buildToolNameMapping(tools);
-        return tools.flatMap((compiledTool, index) => {
-            const resolvedTool = resolved[index] ?? (compiledTool.type === "provider" ? instantiateProviderTool(compiledTool) : undefined);
-            if (resolvedTool === undefined) {
-                return [];
-            }
-            const wrappedTool = wrapToolForExecution(resolvedTool, compiledTool, 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);
+        return resolveAdapterTools({
+            tools,
+            binding,
+            resolveToolValues: this.options.toolResolver,
         });
     }
     resolveFilesystemBackend(binding) {
@@ -261,24 +111,12 @@ export class AgentRuntimeAdapter {
         });
     }
     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);
+        return resolveBuiltinMiddlewareBackendHelper({
+            binding,
+            runtimeAdapterOptions: this.options,
+            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
+            options,
+        });
     }
     createDeclaredMiddlewareResolverOptions(binding) {
         return {
@@ -296,149 +134,57 @@ export class AgentRuntimeAdapter {
         };
     }
     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: 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,
+        return invokeBuiltinTaskToolHelper({
+            binding,
+            toolInput: input,
+            options,
+            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
+            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
         });
-        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 backend = this.resolveBuiltinMiddlewareBackend(binding, options);
-        return createBuiltinMiddlewareTools(backend, {
-            includeTaskTool: isDeepAgentBinding(binding),
-            invokeTaskTool: isDeepAgentBinding(binding)
-                ? async (input) => this.invokeBuiltinTaskTool(binding, input, options)
-                : undefined,
+        return resolveBuiltinMiddlewareToolsHelper({
+            binding,
+            options,
+            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
+            invokeBuiltinTaskTool: (currentBinding, toolInput, currentOptions) => this.invokeBuiltinTaskTool(currentBinding, toolInput, currentOptions),
         });
     }
     async resolveAutomaticSummarizationMiddleware(binding) {
-        if (hasConfiguredMiddlewareKind(binding, "summarization")) {
-            return [];
-        }
-        const primaryModel = getBindingPrimaryModel(binding);
-        if (!primaryModel) {
-            return [];
-        }
-        return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], this.createDeclaredMiddlewareResolverOptions(binding));
+        return resolveAutomaticSummarizationMiddlewareHelper({
+            binding,
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+        });
     }
     async resolveLangChainAutomaticMiddleware(binding) {
-        const params = getBindingLangChainParams(binding);
-        if (!params) {
-            return [];
-        }
-        const compatibleParams = applyDeepAgentDelegationPromptCompatibility(params.model, params);
-        const automaticMiddleware = [];
-        automaticMiddleware.push(createPatchToolCallsMiddleware());
-        automaticMiddleware.push(...(await this.resolveAutomaticSummarizationMiddleware(binding)));
-        if ((compatibleParams.skills?.length ?? 0) > 0) {
-            automaticMiddleware.push(createSkillsMiddleware({
-                backend: this.resolveFilesystemBackend(binding),
-                sources: compatibleParams.skills,
-            }));
-        }
-        if ((compatibleParams.memory?.length ?? 0) > 0) {
-            automaticMiddleware.push(createMemoryMiddleware({
-                backend: this.resolveFilesystemBackend(binding),
-                sources: compatibleParams.memory,
-            }));
-        }
-        if (hasConfiguredSubagentSupport(binding)) {
-            automaticMiddleware.push(createSubAgentMiddleware({
-                defaultModel: (await this.resolveModel(compatibleParams.model)),
-                defaultTools: this.resolveTools(compatibleParams.tools, binding),
-                defaultInterruptOn: getBindingInterruptCompatibilityRules(binding),
-                subagents: (await this.resolveSubagents(compatibleParams.subagents ?? [], binding)),
-                generalPurposeAgent: compatibleParams.generalPurposeAgent,
-                taskDescription: compatibleParams.taskDescription ?? null,
-            }));
-        }
-        return automaticMiddleware;
+        return resolveLangChainAutomaticMiddlewareHelper({
+            binding,
+            resolveAutomaticSummarizationMiddleware: (currentBinding) => this.resolveAutomaticSummarizationMiddleware(currentBinding),
+            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+        });
     }
     async resolveMiddleware(binding, interruptOn) {
-        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), this.createDeclaredMiddlewareResolverOptions(binding));
-        const automaticMiddleware = isLangChainBinding(binding)
-            ? await this.resolveLangChainAutomaticMiddleware(binding)
-            : [];
-        const middleware = [
-            ...declarativeMiddleware,
-            ...automaticMiddleware,
-            ...(this.options.middlewareResolver ? this.options.middlewareResolver(binding) : []),
-        ];
-        if (interruptOn && Object.keys(interruptOn).length > 0) {
-            middleware.push(humanInTheLoopMiddleware({ interruptOn }));
-        }
-        return middleware;
+        return resolveMiddlewareHelper({
+            binding,
+            interruptOn,
+            runtimeAdapterOptions: this.options,
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            resolveLangChainAutomaticMiddleware: (currentBinding) => this.resolveLangChainAutomaticMiddleware(currentBinding),
+        });
     }
     async resolveSubagents(subagents, binding) {
-        return Promise.all(subagents.map(async (subagent) => ({
-            ...subagent,
-            ...(subagent.passthrough ?? {}),
-            model: subagent.model ? (await this.resolveModel(subagent.model)) : undefined,
-            tools: subagent.tools ? this.resolveTools(subagent.tools) : undefined,
-            skills: await materializeDeepAgentSkillSourcePaths({
-                workspaceRoot: binding?.harnessRuntime.workspaceRoot,
-                runRoot: binding?.harnessRuntime.runRoot,
-                ownerId: `${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, this.createDeclaredMiddlewareResolverOptions(binding))),
-        })));
+        return resolveSubagentsHelper({
+            subagents,
+            binding,
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+        });
     }
     async createLangChainRunnable(binding, options = {}) {
         const params = getBindingLangChainParams(binding);
@@ -512,7 +258,6 @@ export class AgentRuntimeAdapter {
         const request = resumePayload === undefined
             ? buildInvocationRequest(binding, history, input, options)
             : new Command({ resume: resumePayload });
-        let result;
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding);
@@ -520,74 +265,36 @@ export class AgentRuntimeAdapter {
             });
         };
         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);
-            }
+            return callRuntimeWithToolParseRecoveryHelper({
+                binding,
+                request: activeRequest,
+                resumePayload,
+                callRuntime,
+            });
         };
-        const executedToolResults = [];
-        if (resumePayload !== undefined) {
-            result = await callRuntimeWithToolParseRecovery(request);
-        }
-        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 = 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,
-                    });
-                }
-                const localInvocation = await runLocalToolInvocationLoop({
-                    binding,
-                    request,
-                    primaryTools,
-                    toolNameMapping,
-                    executableTools: executableTools,
-                    builtinExecutableTools: builtinExecutableTools,
-                    callRuntimeWithToolParseRecovery,
-                });
-                result = localInvocation.result;
-                executedToolResults.push(...localInvocation.executedToolResults);
-            }
-        }
+        const primaryTools = getBindingPrimaryTools(binding);
+        const resolvedTools = this.resolveTools(primaryTools, binding);
+        const toolNameMapping = buildToolNameMapping(primaryTools);
+        const executableTools = buildExecutableToolMap({
+            primaryTools,
+            resolvedTools,
+            toolNameMapping,
+            context: options.context,
+        });
+        const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
+        const localOrUpstreamInvocation = await invokeRuntimeWithLocalTools({
+            binding,
+            request,
+            resumePayload,
+            primaryTools,
+            defersToUpstreamHitlExecution: primaryTools.some((tool) => tool.hitl?.enabled === true),
+            toolNameMapping,
+            executableTools,
+            builtinExecutableTools: builtinExecutableTools,
+            callRuntimeWithToolParseRecovery,
+        });
+        const result = localOrUpstreamInvocation.result;
+        const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];
         if (!result) {
             throw new Error("Agent invocation returned no result");
         }
@@ -600,113 +307,51 @@ export class AgentRuntimeAdapter {
         });
     }
     async *stream(binding, input, threadId, history = [], options = {}) {
-        try {
-            const invokeTimeoutMs = resolveBindingTimeout(binding);
-            const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
-            const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-            const primaryTools = getBindingPrimaryTools(binding);
-            const toolNameMapping = 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));
-                const tools = this.resolveTools(langchainParams.tools, binding);
-                const canUseDirectModelStream = tools.length === 0 || typeof resolvedModel.bindTools !== "function";
-                const model = canUseDirectModelStream
-                    ? resolvedModel
-                    : typeof resolvedModel.bindTools === "function" && tools.length > 0
-                        ? resolvedModel.bindTools(tools)
-                        : resolvedModel;
-                // For tool-using langchain agents, a raw model.stream pass cannot execute the
-                // agent loop and only adds an extra model round-trip before the runnable path.
-                if (canUseDirectModelStream && typeof model.stream === "function") {
-                    const stream = await this.withTimeout(() => model.stream(buildRawModelMessages(binding, getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
-                    let emitted = false;
-                    const projected = projectTextStreamChunks(this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream", streamDeadlineAt, invokeTimeoutMs));
-                    let nextChunk = await projected.next();
-                    while (!nextChunk.done) {
-                        if (nextChunk.value.kind === "content") {
-                            emitted = true;
-                        }
-                        yield nextChunk.value;
-                        nextChunk = await projected.next();
-                    }
-                    if (nextChunk.value.emittedContent || emitted) {
-                        return;
-                    }
-                }
-            }
-            const runnable = await this.create(binding);
-            const request = buildInvocationRequest(binding, history, input, options);
-            if (!forceInvokeFallback && typeof runnable.streamEvents === "function") {
-                const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId, run_id: options.runId }, version: "v2", ...(options.context ? { context: options.context } : {}) }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
-                const projectionState = createStreamEventProjectionState();
-                for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents", streamDeadlineAt, invokeTimeoutMs)) {
-                    const projectedChunks = projectRuntimeStreamEvent({
-                        event,
-                        allowVisibleStreamDeltas: isLangChainBinding(binding),
-                        includeStateStreamOutput: isDeepAgentBinding(binding),
-                        toolNameMapping,
-                        primaryTools,
-                        state: projectionState,
-                    });
-                    for (const chunk of projectedChunks) {
-                        yield chunk;
-                    }
-                }
-                if (projectionState.emittedOutput || projectionState.emittedToolResult || projectionState.emittedToolError) {
-                    return;
-                }
-            }
-            if (!forceInvokeFallback && isLangChainBinding(binding) && typeof runnable.stream === "function") {
-                const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId, run_id: options.runId } }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent stream start", "stream");
-                let emitted = false;
-                const projected = projectTextStreamChunks(this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream", streamDeadlineAt, invokeTimeoutMs));
-                let nextChunk = await projected.next();
-                while (!nextChunk.done) {
-                    if (nextChunk.value.kind === "content") {
-                        emitted = true;
-                    }
-                    yield nextChunk.value;
-                    nextChunk = await projected.next();
-                }
-                if (nextChunk.value.emittedContent || emitted) {
-                    return;
-                }
-            }
-            const result = await this.invoke(binding, input, threadId, options.runId ?? threadId, undefined, history, options);
-            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) };
-            }
-        }
-        catch (error) {
-            if (countConfiguredTools(binding) > 0 &&
-                error instanceof Error &&
-                error.message.includes("does not support tool binding")) {
-                throw error;
-            }
-            if (!isToolCallParseFailure(error)) {
-                throw error;
-            }
-            const retried = await this.invoke(this.applyStrictToolJsonInstruction(binding), input, threadId, options.runId ?? threadId, undefined, history, options);
-            if (retried.output) {
-                yield { kind: "content", content: sanitizeVisibleText(retried.output) };
-            }
-        }
+        const invokeTimeoutMs = resolveBindingTimeout(binding);
+        const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
+        const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
+        const primaryTools = getBindingPrimaryTools(binding);
+        const toolNameMapping = buildToolNameMapping(primaryTools);
+        const primaryModel = getBindingPrimaryModel(binding);
+        const forceInvokeFallback = isLangChainBinding(binding) &&
+            primaryTools.length > 0 &&
+            primaryModel?.provider === "openai-compatible";
+        const langchainParams = isLangChainBinding(binding) ? getBindingLangChainParams(binding) : undefined;
+        const resolvedLangChainModel = langchainParams
+            ? (await this.resolveModel(langchainParams.model))
+            : undefined;
+        const resolvedLangChainTools = langchainParams ? this.resolveTools(langchainParams.tools, binding) : [];
+        const canUseDirectModelStream = !!resolvedLangChainModel &&
+            (resolvedLangChainTools.length === 0 || typeof resolvedLangChainModel.bindTools !== "function");
+        const langChainStreamModel = resolvedLangChainModel && canUseDirectModelStream
+            ? resolvedLangChainModel
+            : resolvedLangChainModel && typeof resolvedLangChainModel.bindTools === "function" && resolvedLangChainTools.length > 0
+                ? resolvedLangChainModel.bindTools(resolvedLangChainTools)
+                : undefined;
+        yield* streamRuntimeExecution({
+            binding,
+            input,
+            threadId,
+            history,
+            runtimeOptions: options,
+            primaryTools,
+            toolNameMapping,
+            forceInvokeFallback,
+            canUseDirectModelStream,
+            langChainStreamModel,
+            createRunnable: () => this.create(binding),
+            withTimeout: (producer, timeoutMs, operation, stage) => this.withTimeout(producer, timeoutMs, operation, stage),
+            iterateWithTimeout: (iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs) => this.iterateWithTimeout(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs),
+            invokeTimeoutMs: computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs),
+            streamIdleTimeoutMs,
+            streamDeadlineAt,
+            invoke: (activeBinding, activeInput, activeThreadId, runId, resumePayload, activeHistory, invokeOptions) => this.invoke(activeBinding, activeInput, activeThreadId, runId, resumePayload, activeHistory, invokeOptions),
+            applyStrictToolJsonInstruction: (activeBinding) => this.applyStrictToolJsonInstruction(activeBinding),
+            getSystemPrompt: (activeBinding) => getBindingSystemPrompt(activeBinding),
+            isLangChainBinding,
+            isDeepAgentBinding,
+            countConfiguredTools,
+        });
     }
 }
 export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError, };