@botbotgo/agent-harness 0.0.93 → 0.0.94

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

@@ -19,7 +19,9 @@ import { resolveDeclaredMiddleware } from "./declared-middleware.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.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;
 }
@@ -1243,15 +1245,64 @@ export class AgentRuntimeAdapter {
             return null;
         }
         const id = typeof raw.id === "string" ? raw.id.trim() : "";
-        const kind = typeof raw.kind === "string" ? raw.kind.trim() : "";
-        if (!id || !kind) {
+        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,
+            kind: rawKind,
             ...(typeof raw.prompt === "string" && raw.prompt.trim() ? { prompt: raw.prompt.trim() } : {}),
-            ...(typeof raw.specialist === "string" && raw.specialist.trim() ? { specialist: raw.specialist.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) {
@@ -1550,48 +1601,51 @@ export class AgentRuntimeAdapter {
                 ? result.content
                 : JSON.stringify(result));
     }
-    async invokeLangGraphSpecialist(binding, specialistName, userInputText, workflowState, activeResult, config) {
+    async invokeLangGraphAgentNode(binding, agentName, userInputText, workflowState, activeResult, config) {
         const params = getBindingLangChainParams(binding);
         const resolvedSubagents = await this.resolveSubagents(params.subagents ?? [], binding);
-        const specialist = resolvedSubagents.find((candidate) => candidate.name === specialistName);
-        if (!specialist) {
-            throw new Error(`LangGraph agent ${binding.agent.id} workflow references unknown specialist ${specialistName}`);
+        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 = (specialist.model
-            ? await this.resolveModel(specialist.model)
+        const model = (delegatedAgent.model
+            ? await this.resolveModel(delegatedAgent.model)
             : await this.resolveModel(params.model));
-        const tools = specialist.tools ? this.resolveTools(specialist.tools, binding) : [];
+        const tools = delegatedAgent.tools ? this.resolveTools(delegatedAgent.tools, binding) : [];
         if (tools.length > 0 && typeof model.bindTools !== "function") {
-            throw new Error(`Specialist ${specialist.name} configures ${tools.length} tool(s), but its resolved model does not support tool binding.`);
+            throw new Error(`Subagent ${delegatedAgent.name} configures ${tools.length} tool(s), but its resolved model does not support tool binding.`);
         }
-        const specialistRunnable = createAgent({
-            ...(specialist.passthrough ?? {}),
+        const delegatedRunnable = createAgent({
+            ...(delegatedAgent.passthrough ?? {}),
             model: model,
             tools: tools,
-            systemPrompt: specialist.systemPrompt,
-            responseFormat: specialist.responseFormat,
-            contextSchema: specialist.contextSchema,
-            middleware: (specialist.middleware ?? []),
+            systemPrompt: delegatedAgent.systemPrompt,
+            responseFormat: delegatedAgent.responseFormat,
+            contextSchema: delegatedAgent.contextSchema,
+            middleware: (delegatedAgent.middleware ?? []),
             includeAgentName: "inline",
-            name: specialist.name,
-            description: specialist.description,
+            name: delegatedAgent.name,
+            description: delegatedAgent.description,
         });
-        const specialistPrompt = [
+        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 specialist work and return concise results.",
+            "Complete the delegated subagent work and return concise results.",
         ].join("\n");
-        return specialistRunnable.invoke({
-            messages: [{ role: "user", content: specialistPrompt }],
+        return delegatedRunnable.invoke({
+            messages: [{ role: "user", content: delegatedPrompt }],
         }, config);
     }
     async createLangGraphRunnable(binding) {
-        const workflow = getBindingLangGraphWorkflow(binding) ?? resolveLangGraphPresetWorkflow(getBindingLangGraphPreset(binding), getBindingAdapterConfig(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 or execution.config.preset`);
+            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);
@@ -1654,53 +1708,96 @@ export class AgentRuntimeAdapter {
                         break;
                     }
                     workflowState.lastNodeId = currentNodeId;
-                    if (node.kind === "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 (node.kind === "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 (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 === "executor") {
-                        activeResult = await executorRunnable.invoke(activeRequest, config);
+                    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 === "specialist") {
-                        if (!node.specialist) {
-                            throw new Error(`LangGraph agent ${binding.agent.id} specialist node ${node.id} requires specialist`);
+                    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.invokeLangGraphSpecialist(binding, node.specialist, userInputText, workflowState, activeResult, config);
+                        activeResult = await this.invokeLangGraphToolNode(binding, node.tool, userInputText, config, node.args);
                     }
-                    else if (node.kind === "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 (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);
@@ -1734,34 +1831,11 @@ export class AgentRuntimeAdapter {
                             };
                         }
                     }
-                    else if ((node.kind === "finalizer" || node.kind === "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 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 executor node`);
+                    throw new Error(`LangGraph agent ${binding.agent.id} workflow did not execute an agent or tool node`);
                 }
                 if (sessionIdentity) {
                     await this.clearLangGraphSession(binding, sessionIdentity);
@@ -1815,9 +1889,12 @@ export class AgentRuntimeAdapter {
             (typeof result.output === "string" ? result.output : ""));
     }
     async *streamLangGraphWorkflow(binding, input, threadId, history = [], options = {}) {
-        const workflow = getBindingLangGraphWorkflow(binding) ?? resolveLangGraphPresetWorkflow(getBindingLangGraphPreset(binding), getBindingAdapterConfig(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 or execution.config.preset`);
+            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);
@@ -1867,82 +1944,148 @@ export class AgentRuntimeAdapter {
             }
             workflowState.lastNodeId = currentNodeId;
             yield { kind: "step", content: `langgraph node ${node.id} (${node.kind})` };
-            if (node.kind === "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 };
+            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 (node.kind === "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 === "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 === "executor") {
-                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;
+            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;
                             }
-                            if (outputKey) {
-                                seenTerminalOutputs.add(outputKey);
+                            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;
                             }
-                            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 } : {}) });
                     }
-                    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 {
@@ -1953,11 +2096,11 @@ export class AgentRuntimeAdapter {
                     };
                 }
             }
-            else if (node.kind === "specialist") {
-                if (!node.specialist) {
-                    throw new Error(`LangGraph agent ${binding.agent.id} specialist node ${node.id} requires specialist`);
+            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.invokeLangGraphSpecialist(binding, node.specialist, userInputText, workflowState, activeResult, { configurable: { thread_id: threadId, run_id: options.runId }, ...(options.context ? { context: options.context } : {}) });
+                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",
@@ -1967,21 +2110,8 @@ export class AgentRuntimeAdapter {
                     };
                 }
             }
-            else if (node.kind === "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 (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);
@@ -2008,39 +2138,11 @@ export class AgentRuntimeAdapter {
                 yield { kind: "interrupt", content: JSON.stringify([interruptPayload]) };
                 return;
             }
-            else if ((node.kind === "finalizer" || node.kind === "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 };
-                }
-            }
             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 executor node`);
+            throw new Error(`LangGraph agent ${binding.agent.id} workflow did not execute an agent or tool node`);
         }
         if (sessionIdentity) {
             await this.clearLangGraphSession(binding, sessionIdentity);