@botbotgo/agent-harness 0.0.99 → 0.0.101

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

@@ -1,36 +1,34 @@
 import path from "node:path";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { Command, MemorySaver } from "@langchain/langgraph";
-import { HumanMessage, ToolMessage } from "@langchain/core/messages";
-import { DEFAULT_SUBAGENT_PROMPT, createDeepAgent, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, isSandboxBackend, } from "deepagents";
+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 { z } from "zod";
-import { extractEmptyAssistantMessageFailure, extractContentBlocks, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, normalizeUpstreamRuntimeEvent, extractReasoningStreamOutput, extractStateStreamOutput, extractVisibleStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
+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 { extractMessageText } from "../utils/message-content.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
-import { buildToolNameMapping, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, } from "./adapter/tool/tool-name-mapping.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 { 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 { createResolvedModel } from "./adapter/model/model-providers.js";
-import { buildInvocationRequest, buildSlashCommandSkillInstruction, } from "./adapter/model/invocation-request.js";
+import { buildInvocationRequest, } from "./adapter/model/invocation-request.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
-import { buildRawModelMessages, buildStateSnapshot } from "./adapter/model/message-assembly.js";
-import { asRecord, asStructuredExecutableTool, hasCallableToolHandler, normalizeResolvedToolSchema, wrapResolvedToolWithModelFacingName, } from "./adapter/tool/resolved-tool.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 { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./adapter/tool/tool-arguments.js";
+import { countConfiguredTools, hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord, sleep, } from "./adapter/runtime-adapter-support.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, getBindingAdapterConfig, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingLangGraphPreset, getBindingLangGraphWorkflow, getBindingMiddlewareConfigs, getBindingPrimaryModel, getBindingRuntimeModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
-import { resolveLangGraphProfileWorkflow } from "./adapter/langgraph/profiles.js";
-import { resolveLangGraphPresetWorkflow } from "./adapter/langgraph/presets.js";
-const SUPPORTED_LANGGRAPH_WORKFLOW_NODE_KINDS = new Set(["llm", "agent", "tool", "approval", "condition"]);
-function countConfiguredTools(binding) {
-    return getBindingPrimaryTools(binding).length;
-}
+import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, 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",
@@ -55,61 +53,10 @@ class RuntimeOperationTimeoutError extends Error {
         this.name = "RuntimeOperationTimeoutError";
     }
 }
-function asObject(value) {
-    return typeof value === "object" && value ? value : undefined;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function hasConfiguredSubagentSupport(binding) {
-    const params = getBindingLangChainParams(binding);
-    if (!params) {
-        return false;
-    }
-    return (params.subagents?.length ?? 0) > 0 || params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
-}
-function hasConfiguredMiddlewareKind(binding, kind) {
-    return getBindingMiddlewareConfigs(binding)?.some((entry) => entry.kind === kind) ?? false;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isObject(value) {
-    return isRecord(value);
-}
-function truncateLines(lines, maxChars = 12_000) {
-    const joined = lines.join("\n");
-    if (joined.length <= maxChars) {
-        return joined;
-    }
-    return `${joined.slice(0, maxChars - 18)}\n...[truncated]`;
-}
-function summarizeBuiltinWriteTodosArgs(args) {
-    const todos = Array.isArray(args.todos) ? args.todos : [];
-    const items = todos.flatMap((todo) => {
-        if (!isObject(todo)) {
-            return [];
-        }
-        const content = typeof todo.content === "string" && todo.content.trim().length > 0
-            ? todo.content.trim()
-            : typeof todo.description === "string" && todo.description.trim().length > 0
-                ? todo.description.trim()
-                : "";
-        const status = typeof todo.status === "string" && todo.status.trim().length > 0 ? todo.status.trim() : "pending";
-        return content ? [{ content, status }] : [];
-    });
-    return {
-        total: items.length,
-        pending: items.filter((item) => item.status !== "completed").length,
-        completed: items.filter((item) => item.status === "completed").length,
-        items,
-    };
-}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
     runnableCache = new WeakMap();
-    langGraphSessions = new Map();
     constructor(options = {}) {
         this.options = options;
     }
@@ -279,21 +226,9 @@ export class AgentRuntimeAdapter {
             throw error;
         }
     }
-    buildToolNameMapping(tools) {
-        return buildToolNameMapping(tools);
-    }
-    buildSlashCommandSkillInstruction(binding, input) {
-        return buildSlashCommandSkillInstruction(binding, input);
-    }
-    buildInvocationRequest(binding, history, input, options = {}) {
-        return buildInvocationRequest(binding, history, input, options);
-    }
-    buildRawModelMessages(binding, systemPrompt, history, input) {
-        return buildRawModelMessages(binding, systemPrompt, history, input);
-    }
     resolveTools(tools, binding) {
         const resolved = this.options.toolResolver ? this.options.toolResolver(tools.map((tool) => tool.id), binding) : [];
-        const toolNameMapping = this.buildToolNameMapping(tools);
+        const toolNameMapping = buildToolNameMapping(tools);
         return tools.flatMap((compiledTool, index) => {
             const resolvedTool = resolved[index] ?? (compiledTool.type === "provider" ? instantiateProviderTool(compiledTool) : undefined);
             if (resolvedTool === undefined) {
@@ -308,12 +243,6 @@ export class AgentRuntimeAdapter {
             return modelFacingName === compiledTool.name ? wrappedTool : wrapResolvedToolWithModelFacingName(wrappedTool, modelFacingName);
         });
     }
-    compileInterruptOn(tools, compatibilityRules) {
-        return compileInterruptOn(tools, compatibilityRules);
-    }
-    resolveInterruptOn(binding) {
-        return this.compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
-    }
     resolveFilesystemBackend(binding) {
         const filesystemConfig = getBindingLangChainParams(binding)?.filesystem;
         const configuredRootDir = typeof filesystemConfig?.rootDir === "string" && filesystemConfig.rootDir.trim().length > 0
@@ -351,6 +280,21 @@ export class AgentRuntimeAdapter {
         }
         return new StateBackend(runtimeLike);
     }
+    createDeclaredMiddlewareResolverOptions(binding) {
+        return {
+            resolveModel: (model) => this.resolveModel(model),
+            resolveBackend: (resolvedBinding) => {
+                const targetBinding = resolvedBinding ?? binding;
+                return targetBinding ? this.options.backendResolver?.(targetBinding) : undefined;
+            },
+            resolveFilesystemBackend: (resolvedBinding) => {
+                const targetBinding = resolvedBinding ?? binding;
+                return targetBinding ? this.resolveFilesystemBackend(targetBinding) : undefined;
+            },
+            resolveCustom: this.options.declaredMiddlewareResolver,
+            binding,
+        };
+    }
     async invokeBuiltinTaskTool(binding, input, options = {}) {
         if (!isDeepAgentBinding(binding)) {
             throw new Error("The built-in task tool is only available for deepagent bindings.");
@@ -392,7 +336,7 @@ export class AgentRuntimeAdapter {
                 ]),
             ...(selectedSubagent.interruptOn
                 ? [humanInTheLoopMiddleware({
-                        interruptOn: this.compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
+                        interruptOn: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
                     })]
                 : []),
         ];
@@ -412,169 +356,12 @@ export class AgentRuntimeAdapter {
         return visibleOutput || fallbackOutput || JSON.stringify(result);
     }
     async resolveBuiltinMiddlewareTools(binding, options = {}) {
-        const tools = new Map();
         const backend = this.resolveBuiltinMiddlewareBackend(binding, options);
-        tools.set("write_todos", {
-            name: "write_todos",
-            schema: z.object({
-                todos: z.array(z.object({}).passthrough()).optional(),
-            }).passthrough(),
-            invoke: async (input) => {
-                const args = isObject(input) ? input : {};
-                const summary = summarizeBuiltinWriteTodosArgs(args);
-                return {
-                    ok: true,
-                    tool: "write_todos",
-                    message: `Tracked ${summary.total} todo item(s).`,
-                    summary,
-                };
-            },
-        });
-        tools.set("ls", {
-            name: "ls",
-            schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
-            invoke: async (input) => {
-                const targetPath = isObject(input) && typeof input.path === "string" ? input.path : "/";
-                const infos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
-                if (infos.length === 0) {
-                    return `No files found in ${targetPath}`;
-                }
-                return truncateLines(infos.map((info) => info.is_dir ? `${info.path} (directory)` : `${info.path}${info.size ? ` (${info.size} bytes)` : ""}`));
-            },
-        });
-        tools.set("read_file", {
-            name: "read_file",
-            schema: z.object({
-                file_path: z.string(),
-                offset: z.number().optional(),
-                limit: z.number().optional(),
-            }).passthrough(),
-            invoke: async (input) => {
-                const typed = isObject(input) ? input : {};
-                const filePath = typeof typed.file_path === "string" ? typed.file_path : "";
-                const offset = typeof typed.offset === "number" ? typed.offset : 0;
-                const limit = typeof typed.limit === "number" ? typed.limit : 500;
-                return Promise.resolve(backend.read?.(filePath, offset, limit)) ?? "";
-            },
-        });
-        tools.set("write_file", {
-            name: "write_file",
-            schema: z.object({ file_path: z.string(), content: z.string().optional() }).passthrough(),
-            invoke: async (input) => {
-                const typed = isObject(input) ? input : {};
-                const result = await Promise.resolve(backend.write?.(typeof typed.file_path === "string" ? typed.file_path : "", typeof typed.content === "string" ? typed.content : ""));
-                return result?.error ?? `Successfully wrote to '${result?.path ?? (typed.file_path ?? "")}'`;
-            },
-        });
-        tools.set("edit_file", {
-            name: "edit_file",
-            schema: z.object({
-                file_path: z.string(),
-                old_string: z.string(),
-                new_string: z.string(),
-                replace_all: z.boolean().optional(),
-            }).passthrough(),
-            invoke: async (input) => {
-                const typed = isObject(input) ? input : {};
-                const result = await Promise.resolve(backend.edit?.(typeof typed.file_path === "string" ? typed.file_path : "", typeof typed.old_string === "string" ? typed.old_string : "", typeof typed.new_string === "string" ? typed.new_string : "", typed.replace_all === true));
-                return result?.error ?? `Successfully replaced ${result?.occurrences ?? 0} occurrence(s) in '${result?.path ?? (typed.file_path ?? "")}'`;
-            },
-        });
-        tools.set("glob", {
-            name: "glob",
-            schema: z.object({ pattern: z.string(), path: z.string().optional().default("/") }).passthrough(),
-            invoke: async (input) => {
-                const typed = isObject(input) ? input : {};
-                const pattern = typeof typed.pattern === "string" ? typed.pattern : "";
-                const targetPath = typeof typed.path === "string" ? typed.path : "/";
-                const infos = (await Promise.resolve(backend.globInfo?.(pattern, targetPath))) ?? [];
-                if (infos.length === 0) {
-                    return `No files found matching pattern '${pattern}'`;
-                }
-                return truncateLines(infos.map((info) => info.path));
-            },
-        });
-        tools.set("grep", {
-            name: "grep",
-            schema: z.object({
-                pattern: z.string(),
-                path: z.string().optional().default("/"),
-                glob: z.string().nullable().optional(),
-            }).passthrough(),
-            invoke: async (input) => {
-                const typed = isObject(input) ? input : {};
-                const result = await Promise.resolve(backend.grepRaw?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
-                if (typeof result === "string") {
-                    return result;
-                }
-                if (!result || result.length === 0) {
-                    return `No matches found for pattern '${typeof typed.pattern === "string" ? typed.pattern : ""}'`;
-                }
-                const lines = [];
-                let currentFile = "";
-                for (const match of result) {
-                    if (match.path !== currentFile) {
-                        currentFile = match.path;
-                        lines.push(`\n${currentFile}:`);
-                    }
-                    lines.push(`  ${match.line}: ${match.text}`);
-                }
-                return truncateLines(lines);
-            },
-        });
-        tools.set("execute", {
-            name: "execute",
-            schema: z.object({ command: z.string() }).passthrough(),
-            invoke: async (input) => {
-                if (!isSandboxBackend(backend) || typeof backend.execute !== "function") {
-                    return "Error: Execution not available. This agent's backend does not support command execution (SandboxBackendProtocol).";
-                }
-                const typed = isObject(input) ? input : {};
-                const result = await Promise.resolve(backend.execute(typeof typed.command === "string" ? typed.command : ""));
-                const parts = [result.output];
-                if (result.exitCode !== null) {
-                    parts.push(`\n[Command ${result.exitCode === 0 ? "succeeded" : "failed"} with exit code ${result.exitCode}]`);
-                }
-                if (result.truncated) {
-                    parts.push("\n[Output was truncated due to size limits]");
-                }
-                return parts.join("");
-            },
-        });
-        if (isDeepAgentBinding(binding)) {
-            tools.set("task", {
-                name: "task",
-                schema: z.object({
-                    description: z.string(),
-                    subagent_type: z.string(),
-                }).passthrough(),
-                invoke: async (input) => this.invokeBuiltinTaskTool(binding, input, options),
-            });
-        }
-        return tools;
-    }
-    canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools) {
-        if (toolCalls.length === 0) {
-            return false;
-        }
-        if (isLangChainBinding(binding)) {
-            return true;
-        }
-        return toolCalls.every((toolCall) => {
-            const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
-            if (resolvedToolName === "task" || toolCall.name === "task") {
-                return false;
-            }
-            const executable = executableTools.get(toolCall.name) ?? executableTools.get(resolvedToolName);
-            if (executable) {
-                return false;
-            }
-            const builtinExecutable = builtinExecutableTools.get(toolCall.name) ??
-                builtinExecutableTools.get(resolvedToolName) ??
-                createModelFacingToolNameLookupCandidates(toolCall.name)
-                    .map((candidate) => builtinExecutableTools.get(candidate))
-                    .find((candidate) => candidate !== undefined);
-            return builtinExecutable !== undefined;
+        return createBuiltinMiddlewareTools(backend, {
+            includeTaskTool: isDeepAgentBinding(binding),
+            invokeTaskTool: isDeepAgentBinding(binding)
+                ? async (input) => this.invokeBuiltinTaskTool(binding, input, options)
+                : undefined,
         });
     }
     async resolveAutomaticSummarizationMiddleware(binding) {
@@ -585,13 +372,7 @@ export class AgentRuntimeAdapter {
         if (!primaryModel) {
             return [];
         }
-        return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], {
-            resolveModel: (model) => this.resolveModel(model),
-            resolveBackend: (resolvedBinding) => this.options.backendResolver?.(resolvedBinding ?? binding),
-            resolveFilesystemBackend: (resolvedBinding) => this.resolveFilesystemBackend(resolvedBinding ?? binding),
-            resolveCustom: this.options.declaredMiddlewareResolver,
-            binding,
-        });
+        return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], this.createDeclaredMiddlewareResolverOptions(binding));
     }
     async resolveLangChainAutomaticMiddleware(binding) {
         const params = getBindingLangChainParams(binding);
@@ -626,23 +407,11 @@ export class AgentRuntimeAdapter {
         }
         return automaticMiddleware;
     }
-    async resolveDeepAgentAutomaticMiddleware(binding) {
-        if (!isDeepAgentBinding(binding)) {
-            return [];
-        }
-        return [];
-    }
     async resolveMiddleware(binding, interruptOn) {
-        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), {
-            resolveModel: (model) => this.resolveModel(model),
-            resolveBackend: (resolvedBinding) => this.options.backendResolver?.(resolvedBinding ?? binding),
-            resolveFilesystemBackend: (resolvedBinding) => this.resolveFilesystemBackend(resolvedBinding ?? binding),
-            resolveCustom: this.options.declaredMiddlewareResolver,
-            binding,
-        });
+        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), this.createDeclaredMiddlewareResolverOptions(binding));
         const automaticMiddleware = isLangChainBinding(binding)
             ? await this.resolveLangChainAutomaticMiddleware(binding)
-            : await this.resolveDeepAgentAutomaticMiddleware(binding);
+            : [];
         const middleware = [
             ...declarativeMiddleware,
             ...automaticMiddleware,
@@ -653,35 +422,6 @@ export class AgentRuntimeAdapter {
         }
         return middleware;
     }
-    resolveCheckpointer(binding) {
-        return this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver();
-    }
-    resolveLangGraphWorkflowCheckpointer(binding) {
-        const checkpointer = this.resolveCheckpointer(binding);
-        return typeof checkpointer === "object" && checkpointer
-            ? checkpointer
-            : undefined;
-    }
-    buildRouteSystemPrompt(primaryBinding, secondaryBinding, overridePrompt) {
-        const defaultPrompt = `You are a routing classifier for an agent harness. Reply with exactly one agent id: ${primaryBinding.agent.id} or ${secondaryBinding.agent.id}.\n\n` +
-            `Choose ${primaryBinding.agent.id} only for lightweight conversational turns that can be answered directly in one step ` +
-            "without tool use, repository inspection, file lookup, external checkout, or orchestration.\n\n" +
-            `Choose ${secondaryBinding.agent.id} for tasks that need tools, multi-step execution, external research, repository or ` +
-            "file analysis, downloading or cloning content, codebase exploration, verification, or any task where the agent " +
-            "should inspect the workspace or another repository before answering.\n\n" +
-            `If the request asks to download, clone, fetch, inspect, analyze, trace, or locate implementation in a repo or codebase, choose ${secondaryBinding.agent.id}.\n\n` +
-            `When uncertain, prefer ${secondaryBinding.agent.id}.\n\n` +
-            `Agent ${primaryBinding.agent.id}: ${primaryBinding.agent.description}\n` +
-            `Agent ${secondaryBinding.agent.id}: ${secondaryBinding.agent.description}`;
-        if (!overridePrompt?.trim()) {
-            return defaultPrompt;
-        }
-        return overridePrompt
-            .replaceAll("{{primaryAgentId}}", primaryBinding.agent.id)
-            .replaceAll("{{primaryDescription}}", primaryBinding.agent.description)
-            .replaceAll("{{secondaryAgentId}}", secondaryBinding.agent.id)
-            .replaceAll("{{secondaryDescription}}", secondaryBinding.agent.description);
-    }
     async resolveSubagents(subagents, binding) {
         return Promise.all(subagents.map(async (subagent) => ({
             ...subagent,
@@ -694,1006 +434,63 @@ export class AgentRuntimeAdapter {
                 ownerId: `${binding?.agent.id ?? "agent"}-${subagent.name}`,
                 skillPaths: subagent.skills,
             }),
-            interruptOn: this.compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
+            interruptOn: compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
             responseFormat: subagent.responseFormat,
             contextSchema: subagent.contextSchema,
-            middleware: (await resolveDeclaredMiddleware(subagent.middleware, {
-                resolveModel: (model) => this.resolveModel(model),
-                resolveBackend: (resolvedBinding) => {
-                    const targetBinding = resolvedBinding ?? binding;
-                    return targetBinding ? this.options.backendResolver?.(targetBinding) : undefined;
-                },
-                resolveFilesystemBackend: (resolvedBinding) => {
-                    const targetBinding = resolvedBinding ?? binding;
-                    return targetBinding ? this.resolveFilesystemBackend(targetBinding) : undefined;
-                },
-                resolveCustom: this.options.declaredMiddlewareResolver,
-                binding,
-            })),
+            middleware: (await resolveDeclaredMiddleware(subagent.middleware, this.createDeclaredMiddlewareResolverOptions(binding))),
         })));
     }
     async createLangChainRunnable(binding, options = {}) {
         const params = getBindingLangChainParams(binding);
-        const interruptOn = this.resolveInterruptOn(binding);
+        const interruptOn = compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
         const model = (await this.resolveModel(params.model));
         const tools = this.resolveTools(params.tools, binding);
         if (tools.length > 0 && typeof model.bindTools !== "function") {
             throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${params.model.id} does not support tool binding.`);
         }
-        return createAgent({
-            ...(options.passthroughOverride ?? params.passthrough ?? {}),
-            model: model,
-            tools: tools,
-            systemPrompt: options.systemPromptOverride ?? params.systemPrompt,
-            stateSchema: params.stateSchema,
-            responseFormat: params.responseFormat,
-            contextSchema: params.contextSchema,
-            middleware: (await this.resolveMiddleware(binding, interruptOn)),
-            checkpointer: this.resolveCheckpointer(binding),
-            store: this.options.storeResolver?.(binding),
-            includeAgentName: params.includeAgentName,
-            version: params.version,
-            name: params.name,
-            description: params.description,
-        });
-    }
-    normalizeLangGraphWorkflowNode(raw) {
-        if (!isRecord(raw)) {
-            return null;
-        }
-        const id = typeof raw.id === "string" ? raw.id.trim() : "";
-        const rawKind = typeof raw.kind === "string" ? raw.kind.trim() : "";
-        const role = typeof raw.role === "string" && raw.role.trim() ? raw.role.trim() : undefined;
-        const agent = typeof raw.agent === "string" && raw.agent.trim() ? raw.agent.trim() : undefined;
-        const tool = typeof raw.tool === "string" && raw.tool.trim() ? raw.tool.trim() : undefined;
-        const args = isRecord(raw.args) ? { ...raw.args } : undefined;
-        if (!id || !rawKind) {
-            return null;
-        }
-        if (!SUPPORTED_LANGGRAPH_WORKFLOW_NODE_KINDS.has(rawKind)) {
-            throw new Error(`Unsupported LangGraph workflow node kind ${rawKind}. Supported node kinds: ${Array.from(SUPPORTED_LANGGRAPH_WORKFLOW_NODE_KINDS).join(", ")}`);
-        }
-        return {
-            id,
-            kind: rawKind,
-            ...(typeof raw.prompt === "string" && raw.prompt.trim() ? { prompt: raw.prompt.trim() } : {}),
-            ...(role ? { role } : {}),
-            ...(agent ? { agent } : {}),
-            ...(tool ? { tool } : {}),
-            ...(args ? { args } : {}),
-        };
-    }
-    async invokeLangGraphToolNode(binding, toolName, userInputText, config, args) {
-        const primaryTools = getBindingPrimaryTools(binding);
-        const resolvedTools = this.resolveTools(primaryTools, binding);
-        const toolNameMapping = this.buildToolNameMapping(primaryTools);
-        const resolvedToolName = resolveModelFacingToolName(toolName, toolNameMapping, primaryTools);
-        const executableTool = resolvedTools.find((candidate) => {
-            if (!hasCallableToolHandler(candidate)) {
-                return false;
-            }
-            const candidateName = typeof candidate.name === "string" ? candidate.name : undefined;
-            return candidateName === toolName || candidateName === resolvedToolName;
-        });
-        if (!executableTool) {
-            throw new Error(`LangGraph agent ${binding.agent.id} workflow references unknown tool ${toolName}`);
-        }
-        const invokeMethod = typeof executableTool.invoke === "function"
-            ? executableTool.invoke.bind(executableTool)
-            : typeof executableTool.call === "function"
-                ? executableTool.call.bind(executableTool)
-                : typeof executableTool.func === "function"
-                    ? executableTool.func.bind(executableTool)
-                    : undefined;
-        if (typeof invokeMethod !== "function") {
-            throw new Error(`LangGraph workflow tool ${toolName} is not executable`);
-        }
-        const input = args && Object.keys(args).length > 0 ? args : { input: userInputText };
-        const output = await invokeMethod(input, config);
-        const finalText = stringifyToolOutput(output);
-        return {
-            output: finalText,
-            messages: [{ role: "assistant", content: finalText }],
-            metadata: {
-                executedToolResults: [{
-                        toolName: resolvedToolName,
-                        output,
-                    }],
-            },
-        };
-    }
-    listLangGraphWorkflowNodes(workflow) {
-        return Array.isArray(workflow.nodes)
-            ? workflow.nodes.map((node) => this.normalizeLangGraphWorkflowNode(node)).filter((node) => node !== null)
-            : [];
-    }
-    normalizeLangGraphWorkflowEdge(raw) {
-        if (!isRecord(raw)) {
-            return null;
-        }
-        const from = typeof raw.from === "string" ? raw.from.trim() : "";
-        const to = typeof raw.to === "string" ? raw.to.trim() : "";
-        if (!from || !to) {
-            return null;
-        }
-        return {
-            from,
-            to,
-            ...(typeof raw.when === "string" && raw.when.trim() ? { when: raw.when.trim() } : {}),
-        };
-    }
-    listLangGraphWorkflowEdges(workflow) {
-        if (!Array.isArray(workflow.edges)) {
-            return [];
-        }
-        return workflow.edges
-            .map((edge) => this.normalizeLangGraphWorkflowEdge(edge))
-            .filter((edge) => edge !== null);
-    }
-    shouldFollowLangGraphEdge(edge, state, currentResult) {
-        const condition = edge.when?.toLowerCase().trim();
-        if (!condition || condition === "always") {
-            return true;
-        }
-        const review = state.review?.toLowerCase() ?? "";
-        const hasResult = Boolean(currentResult);
-        switch (condition) {
-            case "has_plan":
-                return Boolean(state.plan?.trim());
-            case "has_result":
-                return hasResult;
-            case "needs_review":
-                return hasResult;
-            case "review_ok":
-            case "review_sufficient":
-                return review.length > 0 && !/(incomplete|insufficient|missing|risky|risk|follow-up|followup|unclear)/i.test(review);
-            case "review_incomplete":
-            case "review_retry":
-                return /(incomplete|insufficient|missing|follow-up|followup|retry|replan|unclear)/i.test(review);
-            case "can_replan":
-                return state.replans < 4;
-            case "approval_approved":
-                return state.approvalDecision === "approve";
-            case "approval_rejected":
-                return state.approvalDecision === "reject";
-            case "approval_edited":
-                return state.approvalDecision === "edit";
-            default:
-                return false;
-        }
-    }
-    listLangGraphWorkflowNextNodes(workflow, nodeId, state, currentResult) {
-        return this.listLangGraphWorkflowEdges(workflow)
-            .filter((edge) => edge.from === nodeId && this.shouldFollowLangGraphEdge(edge, state, currentResult))
-            .map((edge) => edge.to);
-    }
-    extractInvocationRequestText(request) {
-        if (!isRecord(request) || !Array.isArray(request.messages)) {
-            return "";
-        }
-        for (let index = request.messages.length - 1; index >= 0; index -= 1) {
-            const message = request.messages[index];
-            if (!isRecord(message)) {
-                continue;
-            }
-            const role = typeof message.role === "string" ? message.role : undefined;
-            if (role !== "user") {
-                continue;
-            }
-            return extractMessageText(message.content);
-        }
-        return "";
-    }
-    prependSystemMessage(request, content) {
-        if (!content.trim() || !isRecord(request) || !Array.isArray(request.messages)) {
-            return request;
-        }
-        return {
-            ...request,
-            messages: [{ role: "system", content }, ...request.messages],
-        };
-    }
-    replaceLastUserMessage(request, content) {
-        if (!content.trim() || !isRecord(request) || !Array.isArray(request.messages)) {
-            return request;
-        }
-        const messages = [...request.messages];
-        for (let index = messages.length - 1; index >= 0; index -= 1) {
-            const message = messages[index];
-            if (!isRecord(message) || message.role !== "user") {
-                continue;
-            }
-            messages[index] = {
-                ...message,
-                content,
-            };
-            return {
-                ...request,
-                messages,
-            };
-        }
-        return {
-            ...request,
-            messages: [...messages, { role: "user", content }],
-        };
-    }
-    resolveLangGraphSessionKey(binding, config) {
-        const configurable = isRecord(config?.configurable) ? config?.configurable : undefined;
-        const threadId = typeof configurable?.thread_id === "string" ? configurable.thread_id : undefined;
-        return threadId ? `${binding.agent.id}:${threadId}` : undefined;
-    }
-    resolveLangGraphSessionIdentity(binding, config, options = {}) {
-        const configurable = isRecord(config?.configurable) ? config?.configurable : undefined;
-        const threadId = typeof configurable?.thread_id === "string" ? configurable.thread_id : undefined;
-        if (!threadId) {
-            return undefined;
-        }
-        const configuredRunId = typeof configurable?.run_id === "string" ? configurable.run_id : undefined;
-        const runId = configuredRunId ?? options.fallbackRunId ?? threadId;
-        return {
-            sessionKey: `${binding.agent.id}:${threadId}:${runId}`,
-            legacySessionKey: `${binding.agent.id}:${threadId}`,
-            threadId,
-            runId,
-        };
-    }
-    langGraphCheckpointNamespace(binding, identity) {
-        return `langgraph-workflow:${binding.agent.id}:${identity.runId}`;
-    }
-    langGraphCheckpointConfig(binding, identity, checkpointId) {
-        return {
-            configurable: {
-                thread_id: identity.threadId,
-                checkpoint_ns: this.langGraphCheckpointNamespace(binding, identity),
-                ...(checkpointId ? { checkpoint_id: checkpointId } : {}),
-            },
-        };
-    }
-    buildLangGraphWorkflowCheckpoint(session) {
-        const checkpointId = `langgraph-workflow-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-        return {
-            v: 1,
-            id: checkpointId,
-            ts: new Date().toISOString(),
-            channel_values: {
-                workflow_session: session,
-            },
-            channel_versions: {
-                workflow_session: 1,
-            },
-            versions_seen: {},
-            pending_sends: [],
-        };
-    }
-    async saveLangGraphSessionToCheckpointer(binding, identity, session) {
-        const checkpointer = this.resolveLangGraphWorkflowCheckpointer(binding);
-        if (typeof checkpointer?.put !== "function") {
-            return false;
-        }
-        await checkpointer.put(this.langGraphCheckpointConfig(binding, identity), this.buildLangGraphWorkflowCheckpoint(session), {
-            source: "agent-harness",
-            step: 0,
-            writes: {
-                workflow_session: true,
-            },
-        });
-        return true;
-    }
-    async loadLangGraphSessionFromCheckpointer(binding, identity) {
-        const checkpointer = this.resolveLangGraphWorkflowCheckpointer(binding);
-        if (typeof checkpointer?.getTuple !== "function") {
-            return undefined;
-        }
-        const tuple = await checkpointer.getTuple(this.langGraphCheckpointConfig(binding, identity));
-        const checkpoint = asObject(asObject(tuple)?.checkpoint);
-        const channelValues = asObject(checkpoint?.channel_values);
-        const session = channelValues?.workflow_session;
-        if (session === null || session === undefined) {
-            return undefined;
-        }
-        return session;
-    }
-    async clearLangGraphSessionInCheckpointer(binding, identity) {
-        const checkpointer = this.resolveLangGraphWorkflowCheckpointer(binding);
-        if (typeof checkpointer?.put !== "function") {
-            return;
-        }
-        await checkpointer.put(this.langGraphCheckpointConfig(binding, identity), {
-            v: 1,
-            id: `langgraph-workflow-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
-            ts: new Date().toISOString(),
-            channel_values: {
-                workflow_session: null,
-            },
-            channel_versions: {
-                workflow_session: 1,
-            },
-            versions_seen: {},
-            pending_sends: [],
-        }, {
-            source: "agent-harness",
-            step: 0,
-            writes: {
-                workflow_session: true,
-            },
-        });
-    }
-    langGraphSessionFilePath(binding, identity) {
-        return path.join(binding.harnessRuntime.runRoot, "threads", identity.threadId, "runs", identity.runId, "backend", "langgraph", "session.json");
-    }
-    artifactLangGraphSessionFilePath(binding, identity) {
-        return path.join(binding.harnessRuntime.runRoot, "threads", identity.threadId, "runs", identity.runId, "artifacts", "langgraph-workflow-session.json");
-    }
-    legacyLangGraphSessionFilePath(binding, sessionKey) {
-        return path.join(binding.harnessRuntime.runRoot, "langgraph-sessions", `${sessionKey.replace(/[^a-zA-Z0-9._-]+/g, "_")}.json`);
-    }
-    async saveLangGraphSession(binding, identity, session) {
-        this.langGraphSessions.set(identity.sessionKey, session);
-        const persistedToCheckpointer = await this.saveLangGraphSessionToCheckpointer(binding, identity, session);
-        if (!persistedToCheckpointer) {
-            const filePath = this.langGraphSessionFilePath(binding, identity);
-            await mkdir(path.dirname(filePath), { recursive: true });
-            await writeFile(filePath, JSON.stringify(session, null, 2), "utf8");
-        }
-    }
-    async loadLangGraphSession(binding, identity) {
-        const cached = this.langGraphSessions.get(identity.sessionKey);
-        if (cached) {
-            return cached;
-        }
-        const checkpointerSession = await this.loadLangGraphSessionFromCheckpointer(binding, identity);
-        if (checkpointerSession) {
-            this.langGraphSessions.set(identity.sessionKey, checkpointerSession);
-            return checkpointerSession;
-        }
-        try {
-            const filePath = this.langGraphSessionFilePath(binding, identity);
-            const content = await readFile(filePath, "utf8");
-            const parsed = JSON.parse(content);
-            this.langGraphSessions.set(identity.sessionKey, parsed);
-            return parsed;
-        }
-        catch {
-            try {
-                const artifactPath = this.artifactLangGraphSessionFilePath(binding, identity);
-                const content = await readFile(artifactPath, "utf8");
-                const parsed = JSON.parse(content);
-                this.langGraphSessions.set(identity.sessionKey, parsed);
-                return parsed;
-            }
-            catch {
-                try {
-                    const legacyPath = this.legacyLangGraphSessionFilePath(binding, identity.legacySessionKey);
-                    const content = await readFile(legacyPath, "utf8");
-                    const parsed = JSON.parse(content);
-                    this.langGraphSessions.set(identity.sessionKey, parsed);
-                    return parsed;
-                }
-                catch {
-                    return undefined;
-                }
-            }
-        }
-    }
-    async clearLangGraphSession(binding, identity) {
-        this.langGraphSessions.delete(identity.sessionKey);
-        await this.clearLangGraphSessionInCheckpointer(binding, identity);
-        const filePath = this.langGraphSessionFilePath(binding, identity);
-        await rm(filePath, { force: true });
-        await rm(this.artifactLangGraphSessionFilePath(binding, identity), { force: true });
-        await rm(this.legacyLangGraphSessionFilePath(binding, identity.legacySessionKey), { force: true });
-    }
-    async invokeWorkflowNodeModel(model, systemPrompt, userContent) {
-        const resolved = (await this.resolveModel(model));
-        if (!resolved.invoke) {
-            throw new Error(`Workflow model ${model.id} does not support invoke()`);
-        }
-        const result = await resolved.invoke([
-            { role: "system", content: systemPrompt },
-            { role: "user", content: userContent },
-        ]);
-        return sanitizeVisibleText(typeof result === "string"
-            ? result
-            : typeof result?.content === "string"
-                ? result.content
-                : JSON.stringify(result));
-    }
-    async invokeLangGraphAgentNode(binding, agentName, userInputText, workflowState, activeResult, config) {
-        const params = getBindingLangChainParams(binding);
-        const resolvedSubagents = await this.resolveSubagents(params.subagents ?? [], binding);
-        const delegatedAgent = resolvedSubagents.find((candidate) => candidate.name === agentName);
-        if (!delegatedAgent) {
-            throw new Error(`LangGraph agent ${binding.agent.id} workflow references unknown subagent ${agentName}`);
-        }
-        const model = (delegatedAgent.model
-            ? await this.resolveModel(delegatedAgent.model)
-            : await this.resolveModel(params.model));
-        const tools = delegatedAgent.tools ? this.resolveTools(delegatedAgent.tools, binding) : [];
-        if (tools.length > 0 && typeof model.bindTools !== "function") {
-            throw new Error(`Subagent ${delegatedAgent.name} configures ${tools.length} tool(s), but its resolved model does not support tool binding.`);
-        }
-        const delegatedRunnable = createAgent({
-            ...(delegatedAgent.passthrough ?? {}),
-            model: model,
-            tools: tools,
-            systemPrompt: delegatedAgent.systemPrompt,
-            responseFormat: delegatedAgent.responseFormat,
-            contextSchema: delegatedAgent.contextSchema,
-            middleware: (delegatedAgent.middleware ?? []),
-            includeAgentName: "inline",
-            name: delegatedAgent.name,
-            description: delegatedAgent.description,
-        });
-        const delegatedPrompt = [
-            `User request:\n${userInputText}`,
-            ...(workflowState.plan ? ["", `Workflow plan:\n${workflowState.plan}`] : []),
-            ...(workflowState.review ? ["", `Workflow review:\n${workflowState.review}`] : []),
-            ...(activeResult ? ["", `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`] : []),
-            "",
-            "Complete the delegated subagent work and return concise results.",
-        ].join("\n");
-        return delegatedRunnable.invoke({
-            messages: [{ role: "user", content: delegatedPrompt }],
-        }, config);
-    }
-    async createLangGraphRunnable(binding) {
-        const adapterConfig = getBindingAdapterConfig(binding);
-        const workflow = getBindingLangGraphWorkflow(binding) ??
-            resolveLangGraphProfileWorkflow(typeof adapterConfig.profile === "string" ? adapterConfig.profile : undefined, typeof adapterConfig.with === "object" && adapterConfig.with ? adapterConfig.with : {}) ??
-            resolveLangGraphPresetWorkflow(getBindingLangGraphPreset(binding), adapterConfig);
-        if (!workflow) {
-            throw new Error(`LangGraph agent ${binding.agent.id} requires execution.config.workflow, execution.config.profile, or execution.config.preset`);
-        }
-        const entryNode = typeof workflow.entryNode === "string" ? workflow.entryNode.trim() : "";
-        const nodes = this.listLangGraphWorkflowNodes(workflow);
-        if (!entryNode || nodes.length === 0) {
-            throw new Error(`LangGraph agent ${binding.agent.id} workflow must define entryNode and nodes`);
-        }
-        const nodeMap = new Map(nodes.map((node) => [node.id, node]));
-        if (!nodeMap.has(entryNode)) {
-            throw new Error(`LangGraph agent ${binding.agent.id} workflow entryNode ${entryNode} does not match any node id`);
-        }
-        const baseParams = getBindingLangChainParams(binding);
-        const passthroughWithoutWorkflow = {
-            ...(baseParams.passthrough ?? {}),
-        };
-        delete passthroughWithoutWorkflow.workflow;
-        delete passthroughWithoutWorkflow.langgraph;
-        const executorRunnable = await this.createLangChainRunnable(binding, {
-            passthroughOverride: passthroughWithoutWorkflow,
-        });
-        return {
-            invoke: async (request, config) => {
-                const sessionIdentity = this.resolveLangGraphSessionIdentity(binding, config);
-                const resumedSession = request instanceof Command && sessionIdentity ? await this.loadLangGraphSession(binding, sessionIdentity) : undefined;
-                const resumePayload = request instanceof Command ? request.resume : undefined;
-                const userInputText = resumedSession ? this.extractInvocationRequestText(resumedSession.request) : this.extractInvocationRequestText(request);
-                let activeRequest = resumedSession?.request ?? request;
-                let activeResult = resumedSession?.result;
-                const workflowState = resumedSession?.state
-                    ? { ...resumedSession.state }
-                    : {
-                        iterations: 0,
-                        replans: 0,
-                    };
-                const visited = new Set();
-                let currentNodeId = resumedSession?.nextNodeId ?? entryNode;
-                if (resumePayload !== undefined) {
-                    if (typeof resumePayload === "string" && (resumePayload === "approve" || resumePayload === "reject")) {
-                        workflowState.approvalDecision = resumePayload;
-                    }
-                    else if (isRecord(resumePayload) && resumePayload.decision === "edit" && resumePayload.editedInput) {
-                        workflowState.approvalDecision = "edit";
-                        activeRequest = this.replaceLastUserMessage(activeRequest, String(resumePayload.editedInput));
-                    }
-                    if (sessionIdentity) {
-                        await this.clearLangGraphSession(binding, sessionIdentity);
-                    }
-                }
-                for (let iteration = 0; currentNodeId; iteration += 1) {
-                    workflowState.iterations = iteration + 1;
-                    if (iteration >= 24) {
-                        break;
-                    }
-                    const loopKey = `${currentNodeId}:${workflowState.replans}:${Boolean(activeResult)}`;
-                    if (visited.has(loopKey)) {
-                        break;
-                    }
-                    visited.add(loopKey);
-                    const node = nodeMap.get(currentNodeId);
-                    if (!node) {
-                        break;
-                    }
-                    workflowState.lastNodeId = currentNodeId;
-                    if (node.kind === "llm") {
-                        const nodeRole = node.role?.toLowerCase() ?? "llm";
-                        if (nodeRole === "planner") {
-                            const plannerModel = getBindingRuntimeModel(binding, "planning") ?? baseParams.model;
-                            const plannerPrompt = node.prompt ?? [
-                                "You are a LangGraph workflow planner.",
-                                "Write a concise execution plan for the user request.",
-                                "Keep it brief and actionable.",
-                            ].join(" ");
-                            workflowState.plan = await this.invokeWorkflowNodeModel(plannerModel, plannerPrompt, userInputText);
-                            activeRequest = this.prependSystemMessage(activeRequest, `Workflow plan:\n${workflowState.plan}`);
-                        }
-                        else if (nodeRole === "replanner") {
-                            const replannerModel = getBindingRuntimeModel(binding, "planning") ?? baseParams.model;
-                            const replannerPrompt = node.prompt ?? [
-                                "You are a LangGraph workflow replanner.",
-                                "Refine the execution plan based on the current result and review feedback.",
-                                "Return an updated concise plan only.",
-                            ].join(" ");
-                            workflowState.plan = await this.invokeWorkflowNodeModel(replannerModel, replannerPrompt, [
-                                `User request:\n${userInputText}`,
-                                ...(workflowState.plan ? ["", `Current plan:\n${workflowState.plan}`] : []),
-                                ...(workflowState.review ? ["", `Review feedback:\n${workflowState.review}`] : []),
-                                ...(activeResult ? ["", `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`] : []),
-                            ].join("\n"));
-                            workflowState.replans += 1;
-                            activeRequest = this.prependSystemMessage(activeRequest, `Updated workflow plan:\n${workflowState.plan}`);
-                        }
-                        else if (nodeRole === "reviewer" && activeResult) {
-                            const reviewerModel = getBindingRuntimeModel(binding, "review") ?? baseParams.model;
-                            const reviewerPrompt = node.prompt ?? [
-                                "You are a LangGraph workflow reviewer.",
-                                "Review the executor result and state whether it appears sufficient.",
-                                "Call out missing verification or obvious risks briefly.",
-                            ].join(" ");
-                            workflowState.review = await this.invokeWorkflowNodeModel(reviewerModel, reviewerPrompt, [
-                                `User request:\n${userInputText}`,
-                                "",
-                                `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
-                            ].join("\n"));
-                        }
-                        else if ((nodeRole === "finalizer" || nodeRole === "final") && activeResult) {
-                            const finalModel = getBindingRuntimeModel(binding, "final") ?? baseParams.model;
-                            const finalPrompt = node.prompt ?? [
-                                "You are a LangGraph workflow finalizer.",
-                                "Rewrite the current result into a concise user-facing answer.",
-                                "Preserve facts and caveats. Do not invent work that was not completed.",
-                            ].join(" ");
-                            const finalized = await this.invokeWorkflowNodeModel(finalModel, finalPrompt, [
-                                `User request:\n${userInputText}`,
-                                ...(workflowState.plan ? ["", `Plan:\n${workflowState.plan}`] : []),
-                                ...(workflowState.review ? ["", `Review:\n${workflowState.review}`] : []),
-                                "",
-                                `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
-                            ].join("\n"));
-                            activeResult = {
-                                ...activeResult,
-                                output: finalized,
-                                messages: [{ role: "assistant", content: finalized }],
-                                workflow: {
-                                    ...workflowState,
-                                },
-                            };
-                        }
-                        else {
-                            const llmModel = getBindingRuntimeModel(binding, "execution") ?? baseParams.model;
-                            const llmPrompt = node.prompt ?? "Produce the next response for this workflow node.";
-                            const llmOutput = await this.invokeWorkflowNodeModel(llmModel, llmPrompt, userInputText);
-                            activeResult = {
-                                output: llmOutput,
-                                messages: [{ role: "assistant", content: llmOutput }],
-                            };
-                        }
-                    }
-                    else if (node.kind === "agent") {
-                        if (node.agent) {
-                            activeResult = await this.invokeLangGraphAgentNode(binding, node.agent, userInputText, workflowState, activeResult, config);
-                        }
-                        else {
-                            activeResult = await executorRunnable.invoke(activeRequest, config);
-                        }
-                    }
-                    else if (node.kind === "tool") {
-                        if (!node.tool) {
-                            throw new Error(`LangGraph agent ${binding.agent.id} tool node ${node.id} requires tool`);
-                        }
-                        activeResult = await this.invokeLangGraphToolNode(binding, node.tool, userInputText, config, node.args);
-                    }
-                    else if (node.kind === "condition") {
-                        // Condition nodes are routing-only. Edge conditions decide the next node.
-                    }
-                    else if (node.kind === "approval") {
-                        const nextNodes = this.listLangGraphWorkflowNextNodes(workflow, currentNodeId, workflowState, activeResult);
-                        const nextNodeId = nextNodes[0];
-                        if (resumePayload === undefined) {
-                            if (sessionIdentity) {
-                                await this.saveLangGraphSession(binding, sessionIdentity, {
-                                    request: activeRequest,
-                                    result: activeResult,
-                                    state: { ...workflowState },
-                                    nextNodeId,
-                                });
-                            }
-                            return {
-                                __interrupt__: [{
-                                        toolName: "workflow_approval",
-                                        toolId: `workflow-approval-${binding.agent.id}-${node.id}`,
-                                        allowedDecisions: ["approve", "edit", "reject"],
-                                        inputPreview: {
-                                            nodeId: node.id,
-                                            agentId: binding.agent.id,
-                                            ...(workflowState.plan ? { plan: workflowState.plan } : {}),
-                                            ...(workflowState.review ? { review: workflowState.review } : {}),
-                                        },
-                                    }],
-                                messages: activeResult?.messages ?? [],
-                                workflow: {
-                                    ...workflowState,
-                                    pendingApprovalNodeId: node.id,
-                                },
-                            };
-                        }
-                    }
-                    const nextNodes = this.listLangGraphWorkflowNextNodes(workflow, currentNodeId, workflowState, activeResult);
-                    currentNodeId = nextNodes[0];
-                }
-                if (!activeResult) {
-                    throw new Error(`LangGraph agent ${binding.agent.id} workflow did not execute an agent or tool node`);
-                }
-                if (sessionIdentity) {
-                    await this.clearLangGraphSession(binding, sessionIdentity);
-                }
-                if ((workflowState.plan || workflowState.review || workflowState.replans > 0) && !isRecord(activeResult.workflow)) {
-                    activeResult = {
-                        ...activeResult,
-                        workflow: {
-                            ...workflowState,
-                        },
-                    };
-                }
-                return activeResult;
-            },
-        };
-    }
-    extractExecutedToolResults(result) {
-        const metadata = asObject(result?.metadata);
-        if (Array.isArray(metadata?.executedToolResults)) {
-            return metadata.executedToolResults;
-        }
-        const messages = Array.isArray(result?.messages) ? result.messages : [];
-        return messages.flatMap((message) => {
-            const typed = asObject(message);
-            const kwargs = asObject(typed?.kwargs);
-            const typeId = Array.isArray(typed?.id) ? typed.id.at(-1) : undefined;
-            const runtimeType = typeof typed?.type === "string" ? typed.type : undefined;
-            if (typeId !== "ToolMessage" && runtimeType !== "tool") {
-                return [];
-            }
-            const toolName = typeof typed?.name === "string"
-                ? typed.name
-                : typeof kwargs?.name === "string"
-                    ? kwargs.name
-                    : "tool";
-            const output = typed?.content ??
-                kwargs?.content ??
-                "";
-            return [{
-                    toolName,
-                    output,
-                }];
-        });
-    }
-    extractLangGraphResultOutput(result) {
-        if (!result) {
-            return "";
-        }
-        return sanitizeVisibleText(extractVisibleOutput(result) ||
-            extractToolFallbackContext(result) ||
-            (typeof result.output === "string" ? result.output : ""));
-    }
-    async *streamLangGraphWorkflow(binding, input, threadId, history = [], options = {}) {
-        const adapterConfig = getBindingAdapterConfig(binding);
-        const workflow = getBindingLangGraphWorkflow(binding) ??
-            resolveLangGraphProfileWorkflow(typeof adapterConfig.profile === "string" ? adapterConfig.profile : undefined, typeof adapterConfig.with === "object" && adapterConfig.with ? adapterConfig.with : {}) ??
-            resolveLangGraphPresetWorkflow(getBindingLangGraphPreset(binding), adapterConfig);
-        if (!workflow) {
-            throw new Error(`LangGraph agent ${binding.agent.id} requires execution.config.workflow, execution.config.profile, or execution.config.preset`);
-        }
-        const entryNode = typeof workflow.entryNode === "string" ? workflow.entryNode.trim() : "";
-        const nodes = this.listLangGraphWorkflowNodes(workflow);
-        if (!entryNode || nodes.length === 0) {
-            throw new Error(`LangGraph agent ${binding.agent.id} workflow must define entryNode and nodes`);
-        }
-        const nodeMap = new Map(nodes.map((node) => [node.id, node]));
-        if (!nodeMap.has(entryNode)) {
-            throw new Error(`LangGraph agent ${binding.agent.id} workflow entryNode ${entryNode} does not match any node id`);
-        }
-        const baseParams = getBindingLangChainParams(binding);
-        const passthroughWithoutWorkflow = {
-            ...(baseParams.passthrough ?? {}),
-        };
-        delete passthroughWithoutWorkflow.workflow;
-        delete passthroughWithoutWorkflow.langgraph;
-        const executorRunnable = await this.createLangChainRunnable(binding, {
-            passthroughOverride: passthroughWithoutWorkflow,
-        });
-        const request = this.buildInvocationRequest(binding, history, input, options);
-        const sessionIdentity = this.resolveLangGraphSessionIdentity(binding, { configurable: { thread_id: threadId, run_id: options.runId } }, {
-            fallbackRunId: options.runId,
-        });
-        const userInputText = this.extractInvocationRequestText(request);
-        let activeRequest = request;
-        let activeResult;
-        const workflowState = {
-            iterations: 0,
-            replans: 0,
-        };
-        const visited = new Set();
-        let currentNodeId = entryNode;
-        let emittedOutput = "";
-        for (let iteration = 0; currentNodeId; iteration += 1) {
-            workflowState.iterations = iteration + 1;
-            if (iteration >= 24) {
-                break;
-            }
-            const loopKey = `${currentNodeId}:${workflowState.replans}:${Boolean(activeResult)}`;
-            if (visited.has(loopKey)) {
-                break;
-            }
-            visited.add(loopKey);
-            const node = nodeMap.get(currentNodeId);
-            if (!node) {
-                break;
-            }
-            workflowState.lastNodeId = currentNodeId;
-            yield { kind: "step", content: `langgraph node ${node.id} (${node.kind})` };
-            if (node.kind === "llm") {
-                const nodeRole = node.role?.toLowerCase() ?? "llm";
-                if (nodeRole === "planner") {
-                    const plannerModel = getBindingRuntimeModel(binding, "planning") ?? baseParams.model;
-                    const plannerPrompt = node.prompt ?? [
-                        "You are a LangGraph workflow planner.",
-                        "Write a concise execution plan for the user request.",
-                        "Keep it brief and actionable.",
-                    ].join(" ");
-                    workflowState.plan = await this.invokeWorkflowNodeModel(plannerModel, plannerPrompt, userInputText);
-                    activeRequest = this.prependSystemMessage(activeRequest, `Workflow plan:\n${workflowState.plan}`);
-                    if (workflowState.plan) {
-                        yield { kind: "reasoning", content: workflowState.plan };
-                    }
-                }
-                else if (nodeRole === "replanner") {
-                    const replannerModel = getBindingRuntimeModel(binding, "planning") ?? baseParams.model;
-                    const replannerPrompt = node.prompt ?? [
-                        "You are a LangGraph workflow replanner.",
-                        "Refine the execution plan based on the current result and review feedback.",
-                        "Return an updated concise plan only.",
-                    ].join(" ");
-                    workflowState.plan = await this.invokeWorkflowNodeModel(replannerModel, replannerPrompt, [
-                        `User request:\n${userInputText}`,
-                        ...(workflowState.plan ? ["", `Current plan:\n${workflowState.plan}`] : []),
-                        ...(workflowState.review ? ["", `Review feedback:\n${workflowState.review}`] : []),
-                        ...(activeResult ? ["", `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`] : []),
-                    ].join("\n"));
-                    workflowState.replans += 1;
-                    activeRequest = this.prependSystemMessage(activeRequest, `Updated workflow plan:\n${workflowState.plan}`);
-                    if (workflowState.plan) {
-                        yield { kind: "reasoning", content: workflowState.plan };
-                    }
-                }
-                else if (nodeRole === "reviewer" && activeResult) {
-                    const reviewerModel = getBindingRuntimeModel(binding, "review") ?? baseParams.model;
-                    const reviewerPrompt = node.prompt ?? [
-                        "You are a LangGraph workflow reviewer.",
-                        "Review the executor result and state whether it appears sufficient.",
-                        "Call out missing verification or obvious risks briefly.",
-                    ].join(" ");
-                    workflowState.review = await this.invokeWorkflowNodeModel(reviewerModel, reviewerPrompt, [
-                        `User request:\n${userInputText}`,
-                        "",
-                        `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
-                    ].join("\n"));
-                    if (workflowState.review) {
-                        yield { kind: "reasoning", content: workflowState.review };
-                    }
-                }
-                else if ((nodeRole === "finalizer" || nodeRole === "final") && activeResult) {
-                    const finalModel = getBindingRuntimeModel(binding, "final") ?? baseParams.model;
-                    const finalPrompt = node.prompt ?? [
-                        "You are a LangGraph workflow finalizer.",
-                        "Rewrite the current result into a concise user-facing answer.",
-                        "Preserve facts and caveats. Do not invent work that was not completed.",
-                    ].join(" ");
-                    const finalized = await this.invokeWorkflowNodeModel(finalModel, finalPrompt, [
-                        `User request:\n${userInputText}`,
-                        ...(workflowState.plan ? ["", `Plan:\n${workflowState.plan}`] : []),
-                        ...(workflowState.review ? ["", `Review:\n${workflowState.review}`] : []),
-                        "",
-                        `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
-                    ].join("\n"));
-                    activeResult = {
-                        ...activeResult,
-                        output: finalized,
-                        messages: [{ role: "assistant", content: finalized }],
-                        workflow: {
-                            ...workflowState,
-                        },
-                    };
-                    const nextOutput = computeIncrementalOutput(emittedOutput, finalized);
-                    emittedOutput = nextOutput.accumulated;
-                    if (nextOutput.delta) {
-                        yield { kind: "content", content: nextOutput.delta };
-                    }
-                }
-                else {
-                    const llmModel = getBindingRuntimeModel(binding, "execution") ?? baseParams.model;
-                    const llmPrompt = node.prompt ?? "Produce the next response for this workflow node.";
-                    const llmOutput = await this.invokeWorkflowNodeModel(llmModel, llmPrompt, userInputText);
-                    activeResult = {
-                        output: llmOutput,
-                        messages: [{ role: "assistant", content: llmOutput }],
-                    };
-                    const nextOutput = computeIncrementalOutput(emittedOutput, llmOutput);
-                    emittedOutput = nextOutput.accumulated;
-                    if (nextOutput.delta) {
-                        yield { kind: "content", content: nextOutput.delta };
-                    }
-                }
-            }
-            else if (node.kind === "agent") {
-                if (node.agent) {
-                    activeResult = await this.invokeLangGraphAgentNode(binding, node.agent, userInputText, workflowState, activeResult, { configurable: { thread_id: threadId, run_id: options.runId }, ...(options.context ? { context: options.context } : {}) });
-                }
-                else {
-                    if (typeof executorRunnable.streamEvents === "function") {
-                        const executorEvents = await executorRunnable.streamEvents(activeRequest, { configurable: { thread_id: threadId, run_id: options.runId }, version: "v2", ...(options.context ? { context: options.context } : {}) });
-                        let executorOutput = "";
-                        const seenTerminalOutputs = new Set();
-                        for await (const event of executorEvents) {
-                            const reasoning = extractReasoningStreamOutput(event);
-                            if (reasoning) {
-                                yield { kind: "reasoning", content: reasoning };
-                            }
-                            const toolResult = extractToolResult(event);
-                            if (toolResult) {
-                                yield {
-                                    kind: "tool-result",
-                                    toolName: toolResult.toolName,
-                                    output: toolResult.output,
-                                    isError: toolResult.isError,
-                                };
-                            }
-                            const visibleStreamOutput = extractVisibleStreamOutput(event);
-                            if (visibleStreamOutput) {
-                                executorOutput = computeIncrementalOutput(executorOutput, visibleStreamOutput).accumulated;
-                            }
-                            const terminalOutput = extractTerminalStreamOutput(event);
-                            if (terminalOutput) {
-                                const outputKey = normalizeTerminalOutputKey(terminalOutput);
-                                if (outputKey && seenTerminalOutputs.has(outputKey)) {
-                                    continue;
-                                }
-                                if (outputKey) {
-                                    seenTerminalOutputs.add(outputKey);
-                                }
-                                executorOutput = computeIncrementalOutput(executorOutput, sanitizeVisibleText(terminalOutput)).accumulated;
-                            }
-                        }
-                        activeResult = executorOutput
-                            ? {
-                                output: executorOutput,
-                                messages: [{ role: "assistant", content: executorOutput }],
-                            }
-                            : await executorRunnable.invoke(activeRequest, { configurable: { thread_id: threadId, run_id: options.runId }, ...(options.context ? { context: options.context } : {}) });
-                    }
-                    else {
-                        activeResult = await executorRunnable.invoke(activeRequest, { configurable: { thread_id: threadId, run_id: options.runId }, ...(options.context ? { context: options.context } : {}) });
-                    }
-                }
-                for (const toolResult of this.extractExecutedToolResults(activeResult)) {
-                    yield {
-                        kind: "tool-result",
-                        toolName: toolResult.toolName,
-                        output: toolResult.output,
-                        isError: toolResult.isError,
-                    };
-                }
-            }
-            else if (node.kind === "tool") {
-                if (!node.tool) {
-                    throw new Error(`LangGraph agent ${binding.agent.id} tool node ${node.id} requires tool`);
-                }
-                activeResult = await this.invokeLangGraphToolNode(binding, node.tool, userInputText, { configurable: { thread_id: threadId, run_id: options.runId }, ...(options.context ? { context: options.context } : {}) }, node.args);
-                for (const toolResult of this.extractExecutedToolResults(activeResult)) {
-                    yield {
-                        kind: "tool-result",
-                        toolName: toolResult.toolName,
-                        output: toolResult.output,
-                        isError: toolResult.isError,
-                    };
-                }
-            }
-            else if (node.kind === "condition") {
-                // Condition nodes are routing-only. Edge conditions decide the next node.
-            }
-            else if (node.kind === "approval") {
-                const nextNodes = this.listLangGraphWorkflowNextNodes(workflow, currentNodeId, workflowState, activeResult);
-                const nextNodeId = nextNodes[0];
-                const interruptPayload = {
-                    toolName: "workflow_approval",
-                    toolId: `workflow-approval-${binding.agent.id}-${node.id}`,
-                    allowedDecisions: ["approve", "edit", "reject"],
-                    inputPreview: {
-                        nodeId: node.id,
-                        agentId: binding.agent.id,
-                        ...(workflowState.plan ? { plan: workflowState.plan } : {}),
-                        ...(workflowState.review ? { review: workflowState.review } : {}),
-                    },
-                };
-                if (sessionIdentity) {
-                    await this.saveLangGraphSession(binding, sessionIdentity, {
-                        request: activeRequest,
-                        result: activeResult,
-                        state: { ...workflowState },
-                        nextNodeId,
-                    });
-                }
-                yield { kind: "interrupt", content: JSON.stringify([interruptPayload]) };
-                return;
-            }
-            const nextNodes = this.listLangGraphWorkflowNextNodes(workflow, currentNodeId, workflowState, activeResult);
-            currentNodeId = nextNodes[0];
-        }
-        if (!activeResult) {
-            throw new Error(`LangGraph agent ${binding.agent.id} workflow did not execute an agent or tool node`);
-        }
-        if (sessionIdentity) {
-            await this.clearLangGraphSession(binding, sessionIdentity);
-        }
-        if ((workflowState.plan || workflowState.review || workflowState.replans > 0) && !isRecord(activeResult.workflow)) {
-            activeResult = {
-                ...activeResult,
-                workflow: {
-                    ...workflowState,
-                },
-            };
-        }
-        const finalOutput = this.extractLangGraphResultOutput(activeResult);
-        const nextOutput = computeIncrementalOutput(emittedOutput, finalOutput);
-        if (nextOutput.delta) {
-            yield { kind: "content", content: nextOutput.delta };
-        }
+        return createAgent(buildLangChainRunnableConfig({
+            langchainParams: params,
+            resolvedModel: model,
+            resolvedTools: tools,
+            resolvedMiddleware: await this.resolveMiddleware(binding, interruptOn),
+            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
+            resolvedStore: this.options.storeResolver?.(binding),
+            passthroughOverride: options.passthroughOverride,
+            systemPromptOverride: options.systemPromptOverride,
+        }));
     }
     async createRunnable(binding) {
         if (getBindingAdapterKind(binding) === "langgraph") {
-            return this.createLangGraphRunnable(binding);
+            throw new Error(`Agent ${binding.agent.id} uses removed backend langgraph; use langchain-v1 or deepagent`);
         }
         if (isLangChainBinding(binding)) {
             return this.createLangChainRunnable(binding);
         }
+        return this.createDeepAgentRunnable(binding);
+    }
+    async createDeepAgentRunnable(binding) {
         const params = getBindingDeepAgentParams(binding);
         if (!params) {
             throw new Error(`Agent ${binding.agent.id} has no runnable params`);
         }
         const compatibleParams = applyDeepAgentDelegationPromptCompatibility(params.model, params);
-        const deepAgentConfig = {
-            ...(compatibleParams.passthrough ?? {}),
-            model: (await this.resolveModel(compatibleParams.model)),
-            tools: this.resolveTools(compatibleParams.tools, binding),
-            systemPrompt: compatibleParams.systemPrompt,
-            responseFormat: compatibleParams.responseFormat,
-            contextSchema: compatibleParams.contextSchema,
-            middleware: (await this.resolveMiddleware(binding)),
-            subagents: (await this.resolveSubagents(compatibleParams.subagents, binding)),
-            checkpointer: this.resolveCheckpointer(binding),
-            store: this.options.storeResolver?.(binding),
-            backend: this.options.backendResolver?.(binding),
-            interruptOn: this.resolveInterruptOn(binding),
-            name: compatibleParams.name,
-            memory: compatibleParams.memory,
-            skills: await materializeDeepAgentSkillSourcePaths({
+        const deepAgentConfig = buildDeepAgentRunnableConfig({
+            compatibleParams,
+            resolvedModel: await this.resolveModel(compatibleParams.model),
+            resolvedTools: this.resolveTools(compatibleParams.tools, binding),
+            resolvedMiddleware: await this.resolveMiddleware(binding),
+            resolvedSubagents: await this.resolveSubagents(compatibleParams.subagents, binding),
+            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
+            resolvedStore: this.options.storeResolver?.(binding),
+            resolvedBackend: this.options.backendResolver?.(binding),
+            resolvedInterruptOn: compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding)),
+            resolvedSkills: (await materializeDeepAgentSkillSourcePaths({
                 workspaceRoot: binding.harnessRuntime.workspaceRoot,
                 runRoot: binding.harnessRuntime.runRoot,
                 ownerId: binding.agent.id,
                 skillPaths: compatibleParams.skills,
-            }),
-            generalPurposeAgent: compatibleParams.generalPurposeAgent,
-            taskDescription: compatibleParams.taskDescription,
-        };
+            })) ?? [],
+        });
         return createDeepAgent(deepAgentConfig);
     }
     async create(binding) {
@@ -1711,116 +508,9 @@ export class AgentRuntimeAdapter {
             throw error;
         }
     }
-    async route(input, primaryBinding, secondaryBinding, options = {}) {
-        const routeModelConfig = getBindingRuntimeModel(primaryBinding, "routing") ??
-            getBindingRuntimeModel(secondaryBinding, "routing") ??
-            getBindingPrimaryModel(primaryBinding) ??
-            getBindingPrimaryModel(secondaryBinding);
-        if (!routeModelConfig) {
-            throw new Error("No router model configuration available");
-        }
-        const routerModel = (await this.resolveModel(routeModelConfig));
-        if (!routerModel?.invoke) {
-            throw new Error("Router model does not support invoke()");
-        }
-        const result = await routerModel.invoke([
-            {
-                role: "system",
-                content: this.buildRouteSystemPrompt(primaryBinding, secondaryBinding, options.systemPrompt),
-            },
-            { role: "user", content: extractMessageText(input) },
-        ]);
-        const content = typeof result === "string"
-            ? result
-            : typeof result?.content === "string"
-                ? result.content
-                : JSON.stringify(result);
-        const normalized = content.trim().toLowerCase();
-        return normalized === secondaryBinding.agent.id.toLowerCase() || normalized.includes(secondaryBinding.agent.id.toLowerCase())
-            ? secondaryBinding.agent.id
-            : primaryBinding.agent.id;
-    }
-    async reviewRunResult(binding, input, result) {
-        const reviewModelConfig = getBindingRuntimeModel(binding, "review");
-        if (!reviewModelConfig) {
-            return null;
-        }
-        const reviewModel = (await this.resolveModel(reviewModelConfig));
-        if (!reviewModel?.invoke) {
-            throw new Error("Review model does not support invoke()");
-        }
-        const reviewPrompt = [
-            "You are a runtime completion reviewer.",
-            "Review the completed agent result against the user request.",
-            "Respond with a concise assessment that states whether the result looks sufficient, incomplete, or risky.",
-            "Call out missing verification or likely follow-up work when relevant.",
-            "Keep the response brief and operator-readable.",
-        ].join(" ");
-        const reviewResult = await reviewModel.invoke([
-            { role: "system", content: reviewPrompt },
-            {
-                role: "user",
-                content: [
-                    `User request:\n${extractMessageText(input)}`,
-                    "",
-                    `Run state: ${result.state}`,
-                    "",
-                    `Agent result:\n${result.finalMessageText ?? result.output}`,
-                ].join("\n"),
-            },
-        ]);
-        const assessment = typeof reviewResult === "string"
-            ? reviewResult
-            : typeof reviewResult?.content === "string"
-                ? reviewResult.content
-                : JSON.stringify(reviewResult);
-        return {
-            assessment: sanitizeVisibleText(assessment),
-            modelId: reviewModelConfig.id,
-        };
-    }
-    async synthesizeFinalResult(binding, input, result) {
-        const finalModelConfig = getBindingRuntimeModel(binding, "final");
-        if (!finalModelConfig) {
-            return null;
-        }
-        const finalModel = (await this.resolveModel(finalModelConfig));
-        if (!finalModel?.invoke) {
-            throw new Error("Final synthesis model does not support invoke()");
-        }
-        const synthesisPrompt = [
-            "You are a final response synthesizer for a runtime-managed agent system.",
-            "Rewrite the agent result into a concise, user-facing final answer.",
-            "Preserve important facts and caveats.",
-            "Do not invent work that was not completed.",
-            "If the result is already concise, keep it concise.",
-        ].join(" ");
-        const synthesisResult = await finalModel.invoke([
-            { role: "system", content: synthesisPrompt },
-            {
-                role: "user",
-                content: [
-                    `User request:\n${extractMessageText(input)}`,
-                    "",
-                    `Agent result:\n${result.finalMessageText ?? result.output}`,
-                ].join("\n"),
-            },
-        ]);
-        const synthesized = typeof synthesisResult === "string"
-            ? synthesisResult
-            : typeof synthesisResult?.content === "string"
-                ? synthesisResult.content
-                : JSON.stringify(synthesisResult);
-        const finalMessageText = sanitizeVisibleText(synthesized);
-        return {
-            output: finalMessageText,
-            finalMessageText,
-            modelId: finalModelConfig.id,
-        };
-    }
     async invoke(binding, input, threadId, runId, resumePayload, history = [], options = {}) {
         const request = resumePayload === undefined
-            ? this.buildInvocationRequest(binding, history, input, options)
+            ? buildInvocationRequest(binding, history, input, options)
             : new Command({ resume: resumePayload });
         let result;
         const callRuntime = async (activeBinding, activeRequest) => {
@@ -1852,7 +542,7 @@ export class AgentRuntimeAdapter {
             }
             else {
                 const resolvedTools = this.resolveTools(primaryTools, binding);
-                const toolNameMapping = this.buildToolNameMapping(primaryTools);
+                const toolNameMapping = buildToolNameMapping(primaryTools);
                 const executableTools = new Map();
                 const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
                 for (let index = 0; index < primaryTools.length; index += 1) {
@@ -1885,117 +575,41 @@ export class AgentRuntimeAdapter {
                         invoke: handler,
                     });
                 }
-                let activeRequest = request;
-                let currentMessages = Array.isArray(activeRequest.messages) ? [...activeRequest.messages] : [];
-                const maxToolIterations = 8;
-                let pendingResult;
-                for (let iteration = 0; iteration < maxToolIterations; iteration += 1) {
-                    result = pendingResult ?? await callRuntimeWithToolParseRecovery(activeRequest);
-                    pendingResult = undefined;
-                    const toolCalls = extractToolCallsFromResult(result);
-                    if (toolCalls.length === 0) {
-                        break;
-                    }
-                    if (!this.canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools)) {
-                        break;
-                    }
-                    if (iteration + 1 === maxToolIterations) {
-                        throw new Error(`Tool-calling loop exceeded the maximum of ${maxToolIterations} iterations`);
-                    }
-                    const resultMessages = result.messages;
-                    const nextMessages = Array.isArray(resultMessages)
-                        ? [...resultMessages]
-                        : [...currentMessages];
-                    for (let toolIndex = 0; toolIndex < toolCalls.length; toolIndex += 1) {
-                        const toolCall = toolCalls[toolIndex];
-                        const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
-                        const executable = executableTools.get(toolCall.name) ?? executableTools.get(resolvedToolName);
-                        const builtinExecutable = builtinExecutableTools.get(toolCall.name) ??
-                            builtinExecutableTools.get(resolvedToolName) ??
-                            createModelFacingToolNameLookupCandidates(toolCall.name)
-                                .map((candidate) => builtinExecutableTools.get(candidate))
-                                .find((candidate) => candidate !== undefined);
-                        const activeExecutable = executable ?? builtinExecutable;
-                        if (!activeExecutable) {
-                            throw new Error(`Tool ${toolCall.name} is not configured for this agent.`);
-                        }
-                        const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema);
-                        const toolResult = await activeExecutable.invoke(normalizedArgs);
-                        executedToolResults.push({
-                            toolName: activeExecutable.name,
-                            output: toolResult,
-                        });
-                        nextMessages.push(new ToolMessage({
-                            name: activeExecutable.name,
-                            tool_call_id: toolCall.id ?? `tool-${iteration + 1}-${toolIndex + 1}`,
-                            content: stringifyToolOutput(toolResult),
-                        }));
-                    }
-                    currentMessages = nextMessages;
-                    activeRequest = {
-                        ...activeRequest,
-                        messages: currentMessages,
-                    };
-                }
+                const localInvocation = await runLocalToolInvocationLoop({
+                    binding,
+                    request,
+                    primaryTools,
+                    toolNameMapping,
+                    executableTools: executableTools,
+                    builtinExecutableTools: builtinExecutableTools,
+                    callRuntimeWithToolParseRecovery,
+                });
+                result = localInvocation.result;
+                executedToolResults.push(...localInvocation.executedToolResults);
             }
         }
         if (!result) {
             throw new Error("Agent invocation returned no result");
         }
-        const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
-        const extractedOutput = extractVisibleOutput(result);
-        const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
-        const emptyAssistantMessageFailure = extractEmptyAssistantMessageFailure(result);
-        const toolFallback = extractToolFallbackContext(result);
-        if (!visibleOutput && !toolFallback && emptyAssistantMessageFailure) {
-            throw new Error(emptyAssistantMessageFailure);
-        }
-        const output = visibleOutput || toolFallback || JSON.stringify(result, null, 2);
-        const finalMessageText = sanitizeVisibleText(output);
-        const outputContent = extractOutputContent(result);
-        const contentBlocks = extractContentBlocks(result);
-        const structuredResponse = result.structuredResponse;
-        return {
+        return finalizeInvocationResult({
+            bindingAgentId: binding.agent.id,
             threadId,
             runId,
-            agentId: binding.agent.id,
-            state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
-            interruptContent,
-            output: finalMessageText,
-            finalMessageText,
-            ...(outputContent !== undefined ? { outputContent } : {}),
-            ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
-            ...(structuredResponse !== undefined ? { structuredResponse } : {}),
-            metadata: {
-                ...(executedToolResults.length > 0 ? { executedToolResults } : {}),
-                ...(structuredResponse !== undefined ? { structuredResponse } : {}),
-                ...(outputContent !== undefined ? { outputContent } : {}),
-                ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
-                ...(asRecord(result.files) ? { files: asRecord(result.files) } : {}),
-                ...(buildStateSnapshot(result) ? { stateSnapshot: buildStateSnapshot(result) } : {}),
-                upstreamResult: result,
-            },
-        };
+            result,
+            executedToolResults,
+        });
     }
     async *stream(binding, input, threadId, history = [], options = {}) {
         try {
-            const adapterKind = getBindingAdapterKind(binding);
             const invokeTimeoutMs = resolveBindingTimeout(binding);
             const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
             const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
             const primaryTools = getBindingPrimaryTools(binding);
-            const toolNameMapping = this.buildToolNameMapping(primaryTools);
+            const toolNameMapping = buildToolNameMapping(primaryTools);
             const primaryModel = getBindingPrimaryModel(binding);
-            const forceInvokeFallback = adapterKind !== "langgraph" &&
-                isLangChainBinding(binding) &&
+            const forceInvokeFallback = isLangChainBinding(binding) &&
                 primaryTools.length > 0 &&
                 primaryModel?.provider === "openai-compatible";
-            if (adapterKind === "langgraph") {
-                for await (const chunk of this.streamLangGraphWorkflow(binding, input, threadId, history, options)) {
-                    yield chunk;
-                }
-                return;
-            }
             if (isLangChainBinding(binding)) {
                 const langchainParams = getBindingLangChainParams(binding);
                 const resolvedModel = (await this.resolveModel(langchainParams.model));
@@ -2009,121 +623,61 @@ export class AgentRuntimeAdapter {
                 // 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 stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(binding, getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
-                    for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream", streamDeadlineAt, invokeTimeoutMs)) {
-                        const delta = readStreamDelta(chunk);
-                        if (delta) {
+                    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 { kind: "content", content: delta };
-                            continue;
-                        }
-                        const reasoning = extractReasoningText(chunk);
-                        if (reasoning) {
-                            yield { kind: "reasoning", content: reasoning };
                         }
+                        yield nextChunk.value;
+                        nextChunk = await projected.next();
                     }
-                    if (emitted) {
+                    if (nextChunk.value.emittedContent || emitted) {
                         return;
                     }
                 }
             }
             const runnable = await this.create(binding);
-            const request = this.buildInvocationRequest(binding, history, input, options);
+            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 allowVisibleStreamDeltas = isLangChainBinding(binding);
-                let emittedOutput = "";
-                let emittedToolError = false;
-                const seenTerminalOutputs = new Set();
-                let lastStep = "";
+                const projectionState = createStreamEventProjectionState();
                 for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents", streamDeadlineAt, invokeTimeoutMs)) {
-                    yield { kind: "upstream-event", event: normalizeUpstreamRuntimeEvent(event) };
-                    const interruptPayload = extractInterruptPayload(event);
-                    if (interruptPayload) {
-                        yield { kind: "interrupt", content: interruptPayload };
-                        continue;
-                    }
-                    const reasoning = extractReasoningStreamOutput(event);
-                    if (reasoning) {
-                        yield { kind: "reasoning", content: reasoning };
-                    }
-                    if (allowVisibleStreamDeltas) {
-                        const visibleStreamOutput = extractVisibleStreamOutput(event);
-                        if (visibleStreamOutput) {
-                            const nextOutput = computeIncrementalOutput(emittedOutput, visibleStreamOutput);
-                            emittedOutput = nextOutput.accumulated;
-                            if (nextOutput.delta) {
-                                yield { kind: "content", content: nextOutput.delta };
-                            }
-                        }
-                    }
-                    if (isDeepAgentBinding(binding)) {
-                        const stateStreamOutput = extractStateStreamOutput(event);
-                        if (stateStreamOutput) {
-                            const nextOutput = computeIncrementalOutput(emittedOutput, sanitizeVisibleText(stateStreamOutput));
-                            emittedOutput = nextOutput.accumulated;
-                            if (nextOutput.delta) {
-                                yield { kind: "content", content: nextOutput.delta };
-                            }
-                        }
-                    }
-                    const agentStep = extractAgentStep(event);
-                    if (agentStep && agentStep !== lastStep) {
-                        lastStep = agentStep;
-                        yield { kind: "step", content: agentStep };
-                    }
-                    const toolResult = extractToolResult(event);
-                    if (toolResult) {
-                        emittedToolError = emittedToolError || toolResult.isError === true;
-                        const resolvedToolName = resolveModelFacingToolName(toolResult.toolName, toolNameMapping, primaryTools);
-                        yield {
-                            kind: "tool-result",
-                            toolName: resolvedToolName,
-                            output: toolResult.output,
-                            isError: toolResult.isError,
-                        };
-                    }
-                    const output = extractTerminalStreamOutput(event);
-                    if (output) {
-                        const outputKey = normalizeTerminalOutputKey(output);
-                        if (outputKey && seenTerminalOutputs.has(outputKey)) {
-                            continue;
-                        }
-                        if (outputKey) {
-                            seenTerminalOutputs.add(outputKey);
-                        }
-                        const nextOutput = computeIncrementalOutput(emittedOutput, sanitizeVisibleText(output));
-                        emittedOutput = nextOutput.accumulated;
-                        if (nextOutput.delta) {
-                            yield { kind: "content", content: nextOutput.delta };
-                        }
+                    const projectedChunks = projectRuntimeStreamEvent({
+                        event,
+                        allowVisibleStreamDeltas: isLangChainBinding(binding),
+                        includeStateStreamOutput: isDeepAgentBinding(binding),
+                        toolNameMapping,
+                        primaryTools,
+                        state: projectionState,
+                    });
+                    for (const chunk of projectedChunks) {
+                        yield chunk;
                     }
                 }
-                if (emittedOutput || emittedToolError) {
+                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;
-                for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream", streamDeadlineAt, invokeTimeoutMs)) {
-                    const delta = readStreamDelta(chunk);
-                    if (delta) {
+                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 { kind: "content", content: delta };
-                        continue;
-                    }
-                    const reasoning = extractReasoningText(chunk);
-                    if (reasoning) {
-                        yield { kind: "reasoning", content: reasoning };
                     }
+                    yield nextChunk.value;
+                    nextChunk = await projected.next();
                 }
-                if (emitted) {
+                if (nextChunk.value.emittedContent || emitted) {
                     return;
                 }
             }
-            const result = await this.invoke(binding, input, threadId, threadId);
+            const result = await this.invoke(binding, input, threadId, options.runId ?? threadId, undefined, history, options);
             const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
                 ? result.metadata.executedToolResults
                 : [];
@@ -2148,7 +702,7 @@ export class AgentRuntimeAdapter {
             if (!isToolCallParseFailure(error)) {
                 throw error;
             }
-            const retried = await this.invoke(this.applyStrictToolJsonInstruction(binding), input, threadId, threadId, undefined, history);
+            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) };
             }