@botbotgo/agent-harness 0.0.92 → 0.0.94

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

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { Command, MemorySaver } from "@langchain/langgraph";
 import { tool as createLangChainTool } from "@langchain/core/tools";
 import { HumanMessage, ToolMessage } from "@langchain/core/messages";
@@ -16,8 +17,11 @@ import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, ex
 import { wrapToolForExecution } from "./tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./declared-middleware.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
-import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingModelInit, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingAdapterConfig, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingLangGraphPreset, getBindingLangGraphWorkflow, getBindingMiddlewareConfigs, getBindingModelInit, getBindingPrimaryModel, getBindingRuntimeModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 import { readSkillMetadata } from "./support/skill-metadata.js";
+import { resolveLangGraphProfileWorkflow } from "./langgraph-profiles.js";
+import { resolveLangGraphPresetWorkflow } from "./langgraph-presets.js";
+const SUPPORTED_LANGGRAPH_WORKFLOW_NODE_KINDS = new Set(["llm", "agent", "tool", "approval", "condition"]);
 function countConfiguredTools(binding) {
     return getBindingPrimaryTools(binding).length;
 }
@@ -161,6 +165,28 @@ function hasConfiguredSubagentSupport(binding) {
     }
     return (params.subagents?.length ?? 0) > 0 || params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
 }
+function isOpenAICompatibleGptOssModel(model) {
+    return model?.provider === "openai-compatible" && model.model.trim().toLowerCase().startsWith("gpt-oss");
+}
+export function shouldRelaxDeepAgentDelegationPrompt(model, params) {
+    if (!isOpenAICompatibleGptOssModel(model)) {
+        return false;
+    }
+    if ((params.subagents?.length ?? 0) === 0) {
+        return false;
+    }
+    return params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
+}
+function applyDeepAgentDelegationPromptCompatibility(model, params) {
+    if (!shouldRelaxDeepAgentDelegationPrompt(model, params)) {
+        return params;
+    }
+    return {
+        ...params,
+        generalPurposeAgent: undefined,
+        taskDescription: undefined,
+    };
+}
 function hasConfiguredMiddlewareKind(binding, kind) {
     return getBindingMiddlewareConfigs(binding)?.some((entry) => entry.kind === kind) ?? false;
 }
@@ -437,6 +463,7 @@ export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
     runnableCache = new WeakMap();
+    langGraphSessions = new Map();
     constructor(options = {}) {
         this.options = options;
     }
@@ -1038,6 +1065,9 @@ export class AgentRuntimeAdapter {
         }
         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;
@@ -1071,29 +1101,30 @@ export class AgentRuntimeAdapter {
         if (!params) {
             return [];
         }
+        const compatibleParams = applyDeepAgentDelegationPromptCompatibility(params.model, params);
         const automaticMiddleware = [];
         automaticMiddleware.push(createPatchToolCallsMiddleware());
         automaticMiddleware.push(...(await this.resolveAutomaticSummarizationMiddleware(binding)));
-        if ((params.skills?.length ?? 0) > 0) {
+        if ((compatibleParams.skills?.length ?? 0) > 0) {
             automaticMiddleware.push(createSkillsMiddleware({
                 backend: this.resolveFilesystemBackend(binding),
-                sources: params.skills,
+                sources: compatibleParams.skills,
             }));
         }
-        if ((params.memory?.length ?? 0) > 0) {
+        if ((compatibleParams.memory?.length ?? 0) > 0) {
             automaticMiddleware.push(createMemoryMiddleware({
                 backend: this.resolveFilesystemBackend(binding),
-                sources: params.memory,
+                sources: compatibleParams.memory,
             }));
         }
         if (hasConfiguredSubagentSupport(binding)) {
             automaticMiddleware.push(createSubAgentMiddleware({
-                defaultModel: (await this.resolveModel(params.model)),
-                defaultTools: this.resolveTools(params.tools, binding),
+                defaultModel: (await this.resolveModel(compatibleParams.model)),
+                defaultTools: this.resolveTools(compatibleParams.tools, binding),
                 defaultInterruptOn: getBindingInterruptCompatibilityRules(binding),
-                subagents: (await this.resolveSubagents(params.subagents ?? [], binding)),
-                generalPurposeAgent: params.generalPurposeAgent,
-                taskDescription: params.taskDescription ?? null,
+                subagents: (await this.resolveSubagents(compatibleParams.subagents ?? [], binding)),
+                generalPurposeAgent: compatibleParams.generalPurposeAgent,
+                taskDescription: compatibleParams.taskDescription ?? null,
             }));
         }
         return automaticMiddleware;
@@ -1128,6 +1159,12 @@ export class AgentRuntimeAdapter {
     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 ` +
@@ -1178,59 +1215,987 @@ export class AgentRuntimeAdapter {
             })),
         })));
     }
+    async createLangChainRunnable(binding, options = {}) {
+        const params = getBindingLangChainParams(binding);
+        const interruptOn = this.resolveInterruptOn(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, executorResult) {
+        const condition = edge.when?.toLowerCase().trim();
+        if (!condition || condition === "always") {
+            return true;
+        }
+        const review = state.review?.toLowerCase() ?? "";
+        const hasResult = Boolean(executorResult);
+        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, executorResult) {
+        return this.listLangGraphWorkflowEdges(workflow)
+            .filter((edge) => edge.from === nodeId && this.shouldFollowLangGraphEdge(edge, state, executorResult))
+            .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 executor 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}`,
+                                "",
+                                `Executor 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}`,
+                        "",
+                        `Executor 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 };
+        }
+    }
     async createRunnable(binding) {
+        if (getBindingAdapterKind(binding) === "langgraph") {
+            return this.createLangGraphRunnable(binding);
+        }
         if (isLangChainBinding(binding)) {
-            const params = getBindingLangChainParams(binding);
-            const interruptOn = this.resolveInterruptOn(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({
-                ...(params.passthrough ?? {}),
-                model: model,
-                tools: tools,
-                systemPrompt: 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,
-            });
+            return this.createLangChainRunnable(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 = {
-            ...(params.passthrough ?? {}),
-            model: (await this.resolveModel(params.model)),
-            tools: this.resolveTools(params.tools, binding),
-            systemPrompt: params.systemPrompt,
-            responseFormat: params.responseFormat,
-            contextSchema: params.contextSchema,
+            ...(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(params.subagents, 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: params.name,
-            memory: params.memory,
+            name: compatibleParams.name,
+            memory: compatibleParams.memory,
             skills: await materializeDeepAgentSkillSourcePaths({
                 workspaceRoot: binding.harnessRuntime.workspaceRoot,
                 runRoot: binding.harnessRuntime.runRoot,
                 ownerId: binding.agent.id,
-                skillPaths: params.skills,
+                skillPaths: compatibleParams.skills,
             }),
-            generalPurposeAgent: params.generalPurposeAgent,
-            taskDescription: params.taskDescription,
+            generalPurposeAgent: compatibleParams.generalPurposeAgent,
+            taskDescription: compatibleParams.taskDescription,
         };
         return createDeepAgent(deepAgentConfig);
     }
@@ -1250,7 +2215,9 @@ export class AgentRuntimeAdapter {
         }
     }
     async route(input, primaryBinding, secondaryBinding, options = {}) {
-        const routeModelConfig = getBindingPrimaryModel(primaryBinding) ??
+        const routeModelConfig = getBindingRuntimeModel(primaryBinding, "routing") ??
+            getBindingRuntimeModel(secondaryBinding, "routing") ??
+            getBindingPrimaryModel(primaryBinding) ??
             getBindingPrimaryModel(secondaryBinding);
         if (!routeModelConfig) {
             throw new Error("No router model configuration available");
@@ -1276,6 +2243,84 @@ export class AgentRuntimeAdapter {
             ? 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)
@@ -1284,7 +2329,7 @@ export class AgentRuntimeAdapter {
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding);
-                return (await this.withTimeout(() => runnable.invoke(activeRequest, { configurable: { thread_id: threadId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(activeBinding), "agent invoke", "invoke"));
+                return (await this.withTimeout(() => runnable.invoke(activeRequest, { configurable: { thread_id: threadId, run_id: runId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(activeBinding), "agent invoke", "invoke"));
             });
         };
         const callRuntimeWithToolParseRecovery = async (activeRequest) => {
@@ -1437,15 +2482,23 @@ export class AgentRuntimeAdapter {
     }
     async *stream(binding, input, threadId, history = [], options = {}) {
         try {
+            const adapterKind = getBindingAdapterKind(binding);
             const invokeTimeoutMs = this.resolveBindingTimeout(binding);
             const streamIdleTimeoutMs = this.resolveStreamIdleTimeout(binding);
             const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
             const primaryTools = getBindingPrimaryTools(binding);
             const toolNameMapping = this.buildToolNameMapping(primaryTools);
             const primaryModel = getBindingPrimaryModel(binding);
-            const forceInvokeFallback = isLangChainBinding(binding) &&
+            const forceInvokeFallback = adapterKind !== "langgraph" &&
+                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));
@@ -1481,7 +2534,7 @@ export class AgentRuntimeAdapter {
             const runnable = await this.create(binding);
             const request = this.buildInvocationRequest(binding, history, input, options);
             if (!forceInvokeFallback && typeof runnable.streamEvents === "function") {
-                const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2", ...(options.context ? { context: options.context } : {}) }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
+                const 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;
@@ -1554,7 +2607,7 @@ export class AgentRuntimeAdapter {
                 }
             }
             if (!forceInvokeFallback && isLangChainBinding(binding) && typeof runnable.stream === "function") {
-                const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId } }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent stream start", "stream");
+                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);