langflower 0.0.9 → 0.0.10

package/vendor/common-nodes/dist/ai/nodes/sub-agent/node.js

@@ -1,13 +1,13 @@
 import { defineLlmNode, isSteerControlPayload, toLlmRecoveryPortValue, } from '@langflower/node-sdk/llm';
-import { concat, EMPTY, filter, mergeMap, Observable, of, } from 'rxjs';
+import { TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
+import { randomUUID } from 'node:crypto';
+import { catchError, concat, filter, firstValueFrom, map, mergeMap, of, Subject, switchMap, take, tap, timeout, TimeoutError, } from 'rxjs';
 import { llmPanelUiSchema } from '../../features/ui-schema/llm-panel-ui-schema.js';
 import { llmCompactionUiSchema } from '../../features/ui-schema/llm-compaction-ui-schema.js';
 import { llmRecoveryUiSchema } from '../../features/ui-schema/llm-recovery-ui-schema.js';
 import { AGENT_MAX_ITERATIONS_CAP, DEFAULT_AGENT_MAX_ITERATIONS, normalizeMaxIterations, } from '../../features/prompt/normalize-max-iterations.js';
-import { appendToolInventory, createLlmSessionCycle$, demuxByKind, } from '../../features/llm-session/llm-session-shell.js';
+import { appendToolInventory, demuxByKind, } from '../../features/llm-session/llm-session-shell.js';
 import { runAgentLoop, } from '../../features/llm-loop/run-agent-loop.js';
-import { waitForSubagentResult } from '../../features/wait-for-subagent-result.js';
-import { flattenSubAgentRegistrations, isSubAgentSpawnPayload, SUBAGENT_REGISTRATION_WIRE_TYPE, SUBAGENT_RESULT_WIRE_TYPE, SUBAGENT_SPAWN_WIRE_TYPE, } from '../../features/sub-agent-protocol.js';
 import { collectAgentToolHandles } from '../../../tools/collect-agent-tool-handles.js';
 import { parseLlmRolePreset, resolveEffectiveSkillId, } from '../../features/llm-role-preset.js';
 import { resolveChatProviderModel } from '../../features/prompt/resolve-chat-provider-model.js';
@@ -24,23 +24,59 @@ const normalizeSkillIds = (raw) => {
         .map((entry) => String(entry ?? '').trim())
         .filter((entry) => entry.length > 0);
 };
-const acceptSpawn = (raw, nodeId, skillIds) => {
-    if (!isSubAgentSpawnPayload(raw)) {
-        return null;
+const formatSpecialistHandleName = (displayName) => `${displayName}(subagent)`;
+const slugToolId = (name, nodeId) => {
+    const slug = (raw) => raw
+        .replace(/[^a-zA-Z0-9_-]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .slice(0, 64);
+    const fromName = slug(name.trim());
+    if (fromName.length > 0) {
+        return fromName;
     }
-    if (raw.nodeId !== nodeId) {
-        return null;
+    const fromNode = slug(nodeId);
+    return fromNode.length > 0 ? fromNode : 'subagent';
+};
+const formatSpawnUserContent = (task, skillId) => {
+    if (skillId.length === 0) {
+        return task;
+    }
+    return `[skill:${skillId}]\n${task}`;
+};
+const buildSpecialistDescription = (name, description, skillIds) => {
+    const parts = [
+        `${name} is a canvas Sub-Agent — a separate specialist agent, not a regular tool (not files, shell, or MCP).`,
+        'Call this tool to delegate a task; the specialist runs its own model and tools and returns a text result.',
+        'Do not try to do this specialist work yourself when this tool is the right owner.',
+    ];
+    if (description.trim().length > 0) {
+        parts.push(description.trim());
     }
-    if (raw.skillId.length > 0 && !skillIds.includes(raw.skillId)) {
-        return null;
+    if (skillIds.length > 0) {
+        parts.push(`Skills: ${skillIds.join(', ')}.`);
     }
-    return raw;
+    parts.push('Required argument: task — the assignment for this Sub-Agent.');
+    return parts.join(' ');
 };
-const formatSpawnUserContent = (spawn) => {
-    if (spawn.skillId.length === 0) {
-        return spawn.task;
+const buildSpecialistInputSchema = (skillIds) => {
+    const properties = {
+        task: {
+            type: 'string',
+            description: 'Task to delegate to this Sub-Agent specialist',
+        },
+    };
+    if (skillIds.length > 0) {
+        properties.skillId = {
+            type: 'string',
+            enum: [...skillIds],
+            description: 'Optional skill announced by this Sub-Agent Inspector selector',
+        };
     }
-    return `[skill:${spawn.skillId}]\n${spawn.task}`;
+    return {
+        type: 'object',
+        properties,
+        required: ['task'],
+    };
 };
 const resolveTurnFactory = (context) => {
     if (context.scriptedTurns !== undefined) {
@@ -48,33 +84,78 @@ const resolveTurnFactory = (context) => {
     }
     return context.factory;
 };
-const requireChatConfig = (providerId, model, scripted) => {
+const chatConfigError = (providerId, model, scripted) => {
     if (scripted) {
-        return;
+        return undefined;
     }
     if (providerId.trim().length === 0) {
-        throw new Error('Provider is required for Sub-Agent chat');
+        return 'Error: Provider is required for Sub-Agent chat';
     }
     if (model.trim().length === 0) {
-        throw new Error('Model is required for Sub-Agent chat');
+        return 'Error: Model is required for Sub-Agent chat';
     }
+    return undefined;
 };
-const runSubAgentTurn = (context, spawn, history, subagentResult$) => {
+const EMPTY_INVOKE_RESULT = 'Error: Sub-Agent returned no content';
+const finalizeInvokeText = (responseText, lastDraft, lastReasoning) => {
+    if (responseText.trim().length > 0) {
+        return responseText;
+    }
+    if (lastDraft.trim().length > 0) {
+        return lastDraft;
+    }
+    if (lastReasoning.trim().length > 0) {
+        return lastReasoning;
+    }
+    return EMPTY_INVOKE_RESULT;
+};
+const seedInvokeHistory = (history, context) => {
+    const system = {
+        role: 'system',
+        content: appendToolInventory(context.effectiveSystemPrompt, context.tools),
+    };
+    if (history.length === 0) {
+        return [system];
+    }
+    if (history[0]?.role === 'system') {
+        return [system, ...history.slice(1)];
+    }
+    return [system, ...history];
+};
+const reduceInvokeHistory = (history, chunk) => {
+    if (chunk.kind === 'historySync') {
+        return [...chunk.messages];
+    }
+    if (chunk.kind === 'invokeDone' && chunk.text.trim().length > 0) {
+        return [...history, { role: 'assistant', content: chunk.text }];
+    }
+    return history;
+};
+const runSubAgentTurn = (context, turn, history) => {
+    const fail = (text) => of({ kind: 'response', text }, {
+        kind: 'invokeDone',
+        requestId: turn.requestId,
+        text,
+    });
     const scripted = context.scriptedTurns !== undefined;
     const factory = resolveTurnFactory(context);
     if (factory === undefined) {
-        return new Observable((subscriber) => {
-            subscriber.error(new Error('Sub-Agent chat is only available during server workflow runs'));
-        });
+        return fail('Error: Sub-Agent chat is only available during server workflow runs');
+    }
+    const configError = chatConfigError(context.providerId, context.model, scripted);
+    if (configError !== undefined) {
+        return fail(configError);
     }
-    requireChatConfig(context.providerId, context.model, scripted);
+    const userContent = formatSpawnUserContent(turn.task, turn.skillId);
+    let lastDraft = '';
+    let lastReasoning = '';
     return concat(of({
         kind: 'historySync',
         messages: [
             ...history,
             {
                 role: 'user',
-                content: formatSpawnUserContent(spawn),
+                content: userContent,
             },
         ],
     }), runAgentLoop({
@@ -85,50 +166,78 @@ const runSubAgentTurn = (context, spawn, history, subagentResult$) => {
         model: scripted
             ? context.model.trim() || 'scripted'
             : context.model,
-        messages: [
-            ...history,
-            { role: 'user', content: formatSpawnUserContent(spawn) },
-        ],
+        messages: [...history, { role: 'user', content: userContent }],
         tools: context.tools,
         toolCtx: context.toolCtx,
         maxIterations: context.maxIterations,
         compaction: context.compaction,
         recovery: context.recovery,
-        subagentRegistrations: context.subagentRegistrations,
         ...(context.requestPermission !== undefined
             ? { requestPermission: context.requestPermission }
             : {}),
         ...(context.steerControl$ !== undefined
             ? { steerControl$: context.steerControl$ }
             : {}),
-        ...(context.subagentRegistrations.length > 0
-            ? {
-                waitForSubagentResult: (callId, signal) => waitForSubagentResult(subagentResult$, callId, signal, context.recovery.subagentTimeoutMs),
-            }
-            : {}),
     }).pipe(mergeMap((chunk) => {
+        if (chunk.kind === 'reasoning' && chunk.text.length > 0) {
+            lastReasoning += chunk.text;
+        }
+        if (chunk.kind === 'draftResponse' && chunk.text.length > 0) {
+            lastDraft += chunk.text;
+        }
         if (chunk.kind !== 'response') {
             return of(chunk);
         }
-        return of(chunk, {
-            kind: 'subagentResult',
-            payload: {
-                callId: spawn.callId,
-                result: chunk.text,
-            },
+        const text = finalizeInvokeText(chunk.text, lastDraft, lastReasoning);
+        return of({ kind: 'response', text }, {
+            kind: 'invokeDone',
+            requestId: turn.requestId,
+            text,
         });
+    }), catchError((error) => {
+        const text = error instanceof Error
+            ? `Error: ${error.message}`
+            : 'Error: Sub-Agent turn failed.';
+        return fail(text);
     })));
 };
+const parseInvokeTurn = (raw, skillIds) => {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return {
+            ok: false,
+            text: 'Error: Sub-Agent invoke payload is invalid.',
+        };
+    }
+    const record = raw;
+    const requestId = typeof record.requestId === 'string' && record.requestId.length > 0
+        ? record.requestId
+        : randomUUID();
+    const task = typeof record.task === 'string' ? record.task.trim() : '';
+    const skillId = typeof record.skillId === 'string' ? record.skillId.trim() : '';
+    if (task.length === 0) {
+        return {
+            ok: false,
+            text: 'Error: Sub-Agent requires a non-empty task.',
+        };
+    }
+    if (skillId.length > 0 && !skillIds.includes(skillId)) {
+        return {
+            ok: false,
+            text: `Error: Skill «${skillId}» is not announced by this Sub-Agent.`,
+        };
+    }
+    return { ok: true, turn: { requestId, task, skillId } };
+};
 /**
- * Sub-Agent: ordinary OpenAI-compatible agent plus `registration` announce.
- * Parent spawn arrives on `task`; final text returns on `result` with callId.
+ * Sub-Agent: ordinary OpenAI-compatible agent that announces one ToolHandle
+ * on `subagent-registration`. Parent invoke runs this node's in-node loop.
  * @see docs/ADR.md ADR-021
  */
 export const subAgentNode = defineLlmNode({
     type: 'common-sub-agent',
     displayName: 'Sub-Agent',
     category: 'AI',
-    description: 'OpenAI-compatible specialist agent that announces via registration and answers parent spawns on task → result.',
+    description: 'OpenAI-compatible specialist agent. Wire `tools` into a parent agent; invoke runs this node in-graph.',
     uiSchema: [
         {
             field: 'name',
@@ -153,47 +262,31 @@ export const subAgentNode = defineLlmNode({
         ...llmRecoveryUiSchema,
     ],
     bind(ctx, { makeInput, configureOutput, combineInputs }, inventory) {
-        const { tools, mcp, subagentRegistration, subagentResult, steerControl, } = inventory;
+        const { tools, steerControl } = inventory;
         const systemPrompt = makeInput('systemPrompt', {
             name: 'systemPrompt',
             wireType: 'string',
             inline: 'text-multiline',
             defaultValue: '',
         });
-        const task = makeInput('task', {
-            name: 'task',
-            wireType: SUBAGENT_SPAWN_WIRE_TYPE,
-            required: true,
-        });
-        const registration$ = combineInputs([ctx], ([ec]) => {
-            const skillIds = normalizeSkillIds(ec.params.skillIds);
-            const name = String(ec.params.name ?? 'Sub-Agent').trim();
-            const description = String(ec.params.description ?? '');
-            return {
-                targetNodeId: ec.nodeId,
-                name: name.length > 0 ? name : 'Sub-Agent',
-                description,
-                skills: skillIds.map((skillId) => ({
-                    skillId,
-                    description: skillId,
-                })),
-            };
-        });
-        const context$ = combineInputs([systemPrompt, tools, subagentRegistration, mcp, ctx], ([systemPromptValue, toolList, subagentList, mcpList, ec]) => {
+        const chunks$ = new Subject();
+        let latestContext;
+        let history = [];
+        let invokeTail = Promise.resolve();
+        const context$ = combineInputs([systemPrompt, tools, ctx], ([systemPromptValue, toolList, ec]) => {
             const rolePreset = parseLlmRolePreset(ec.params.rolePreset);
             const skillId = resolveEffectiveSkillId(rolePreset, ec.params.skillId);
             const hostServices = getRunHostServices(ec);
             const skillMarkdown = hostServices?.skillMarkdown ?? '';
             const agentsMarkdown = hostServices?.agentsMarkdown ?? '';
+            const name = String(ec.params.name ?? 'Sub-Agent').trim();
+            const inspectorDescription = String(ec.params.description ?? '');
             return {
                 prompt: '',
                 tools: collectAgentToolHandles({
                     toolHandles: ec.toolHandles,
                     toolsPort: toolList,
-                    mcpHandles: ec.mcpHandles,
-                    mcpPort: mcpList,
                 }),
-                subagentRegistrations: flattenSubAgentRegistrations(subagentList),
                 ...resolveChatProviderModel(ec.params, hostServices),
                 skillId,
                 rolePreset,
@@ -234,26 +327,56 @@ export const subAgentNode = defineLlmNode({
                 factory: hostServices?.createChatCompletionStream,
                 scriptedTurns: parseScriptedTurns(ec.params['scriptedToolTurns']),
                 nodeId: ec.nodeId,
+                displayName: name.length > 0 ? name : 'Sub-Agent',
+                inspectorDescription,
                 skillIds: normalizeSkillIds(ec.params.skillIds),
             };
         });
-        const cycle$ = createLlmSessionCycle$(context$, task.value$, (context) => ({
-            history: [
+        // Inner chunks stay values. `statefulObservable({ input: chunks$ })`
+        // re-emits loading on every token; pipeValue fans it to all demux ports.
+        const cycle$ = context$.pipeValue(switchMap(() => chunks$));
+        const enqueueInvoke = (announced, args, _toolCtx) => {
+            const context = latestContext ?? announced;
+            const parsed = parseInvokeTurn({ ...args, requestId: randomUUID() }, announced.skillIds);
+            if (!parsed.ok) {
+                return Promise.resolve(parsed.text);
+            }
+            const run = () => {
+                history = seedInvokeHistory(history, context);
+                const timeoutMs = context.recovery.subagentTimeoutMs;
+                let done$ = runSubAgentTurn(context, parsed.turn, history).pipe(tap((chunk) => {
+                    history = reduceInvokeHistory(history, chunk);
+                    chunks$.next(chunk);
+                }), filter((chunk) => chunk.kind === 'invokeDone'), map((chunk) => chunk.text), take(1));
+                if (timeoutMs > 0) {
+                    done$ = done$.pipe(timeout({ first: timeoutMs }), catchError((error) => of(error instanceof TimeoutError
+                        ? `Error: Sub-Agent timed out after ${timeoutMs}ms.`
+                        : error instanceof Error
+                            ? `Error: ${error.message}`
+                            : 'Error: Sub-Agent turn failed.')));
+                }
+                return firstValueFrom(done$, {
+                    defaultValue: EMPTY_INVOKE_RESULT,
+                });
+            };
+            const next = invokeTail.then(run, run);
+            invokeTail = next.then(() => undefined, () => undefined);
+            return next;
+        };
+        const specialistTools$ = context$.pipeValue(tap((context) => {
+            latestContext = context;
+        }), map((context) => {
+            const handleName = formatSpecialistHandleName(context.displayName);
+            return [
                 {
-                    role: 'system',
-                    content: appendToolInventory(context.effectiveSystemPrompt, context.tools),
+                    toolId: slugToolId(handleName, context.nodeId),
+                    name: handleName,
+                    description: buildSpecialistDescription(handleName, context.inspectorDescription, context.skillIds),
+                    inputSchema: buildSpecialistInputSchema(context.skillIds),
+                    invoke: (args, toolCtx) => enqueueInvoke(context, args, toolCtx),
                 },
-            ],
-            trackAssistantHistory: true,
-            appendUserFeedbackToHistory: false,
-            session: undefined,
-        }), (context, turnPayload, history, _session) => {
-            const spawn = acceptSpawn(turnPayload, context.nodeId, context.skillIds);
-            if (spawn === null) {
-                return EMPTY;
-            }
-            return runSubAgentTurn(context, spawn, history, subagentResult.value$);
-        }, { primeTurn0: false });
+            ];
+        }));
         const reasoning$ = cycle$.pipeValue(demuxByKind('reasoning', (chunk) => chunk
             .text));
         const draftResponse$ = cycle$.pipeValue(demuxByKind('draftResponse', (chunk) => chunk
@@ -265,14 +388,12 @@ export const subAgentNode = defineLlmNode({
         }));
         const response$ = cycle$.pipeValue(demuxByKind('response', (chunk) => chunk
             .text));
-        const result$ = cycle$.pipeValue(demuxByKind('subagentResult', (chunk) => chunk.payload));
-        const nestedSubagent$ = cycle$.pipeValue(demuxByKind('subagentSpawn', (chunk) => chunk
-            .payload));
         return {
-            inputs: [systemPrompt, task],
+            inputs: [systemPrompt],
             outputs: [
-                configureOutput('registration', registration$, {
-                    wireType: SUBAGENT_REGISTRATION_WIRE_TYPE,
+                configureOutput('subagent-registration', specialistTools$, {
+                    name: 'subagent-registration',
+                    wireType: TOOL_HANDLE_WIRE_TYPE,
                 }),
                 configureOutput('reasoning', reasoning$, {
                     wireType: 'string',
@@ -286,16 +407,10 @@ export const subAgentNode = defineLlmNode({
                     wireType: 'string',
                     feed: { role: 'result' },
                 }),
-                configureOutput('result', result$, {
-                    wireType: SUBAGENT_RESULT_WIRE_TYPE,
-                    // Protocol payload for parent wiring — not work-log content.
-                    feed: { role: 'none' },
-                }),
             ],
             inventoryOutputs: {
                 toolLog$,
                 recovery$,
-                subagent$: nestedSubagent$,
             },
         };
     },

package/vendor/common-nodes/dist/catalog.js

@@ -34,6 +34,7 @@ import { fetchUrlNode } from './crawl/fetch-url/node.js';
 import { savePageNode } from './crawl/save-page/node.js';
 import { memoryToolsNode } from './memory/memory-tools/node.js';
 import { langflowerToolsNode } from './langflower-tools/node.js';
+import { toolCollectionNode } from './tools/tool-collection/node.js';
 const COMMON_REACTIVE_NODES = [
     booleanNode,
     numberNode,
@@ -66,6 +67,7 @@ const COMMON_REACTIVE_NODES = [
     switchNode,
     memoryToolsNode,
     langflowerToolsNode,
+    toolCollectionNode,
     fetchUrlNode,
     extractLinksNode,
     savePageNode,

package/vendor/common-nodes/dist/mcp/mcp-http/node.d.ts

@@ -1,8 +1,8 @@
 /**
- * Owns HTTP MCP connect/close (optional local launch); emits live {@link McpHandle}.
- * Handle id = graph nodeId; server name and tools come from MCP initialize /
- * tools/list. Connect/initialize/build failure → output port **error** (not
- * silent EMPTY).
+ * Owns HTTP MCP connect/close (optional local launch); emits live
+ * {@link ToolHandle}[] for LLM `tools`. Server name and tools come from MCP
+ * initialize / tools/list. Session stays in invoke closures.
+ * Connect/initialize/build failure → output port **error** (not silent EMPTY).
  */
 export declare const mcpHttpNode: {
     readonly emitOncePerActivation: boolean;

package/vendor/common-nodes/dist/mcp/mcp-http/node.js

@@ -1,5 +1,4 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
-import { MCP_HANDLE_WIRE_TYPE } from '@langflower/node-sdk/mcp';
+import { defineReactiveNode, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
 import { buildMcpHandle } from '@langflower/tools/build-mcp-handle';
 import { formatMcpConnectError } from '@langflower/tools/format-mcp-connect-error';
 import { connectMcpHttpWithOptionalLaunch } from '@langflower/tools/mcp-http-client';
@@ -11,16 +10,16 @@ const paramsKey = (params) => JSON.stringify({
     command: params.command,
 });
 /**
- * Owns HTTP MCP connect/close (optional local launch); emits live {@link McpHandle}.
- * Handle id = graph nodeId; server name and tools come from MCP initialize /
- * tools/list. Connect/initialize/build failure → output port **error** (not
- * silent EMPTY).
+ * Owns HTTP MCP connect/close (optional local launch); emits live
+ * {@link ToolHandle}[] for LLM `tools`. Server name and tools come from MCP
+ * initialize / tools/list. Session stays in invoke closures.
+ * Connect/initialize/build failure → output port **error** (not silent EMPTY).
  */
 export const mcpHttpNode = defineReactiveNode({
     type: 'common-mcp-http',
     displayName: 'MCP http',
     category: 'Tools',
-    description: 'Connects to an MCP server over Streamable HTTP. Optional shell command launches a local process first; URL alone targets an already-running server.',
+    description: 'Connects to an MCP server over Streamable HTTP and emits its tools for LLM `tools` ports. Optional shell command launches a local process first; URL alone targets an already-running server.',
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const url = makeInput('url', {
@@ -82,7 +81,7 @@ export const mcpHttpNode = defineReactiveNode({
                         await session.close();
                         return;
                     }
-                    subscriber.next(handle);
+                    subscriber.next(handle.tools);
                 };
                 void run().catch(fail);
                 return () => {
@@ -94,8 +93,8 @@ export const mcpHttpNode = defineReactiveNode({
         return {
             inputs: [url, command],
             outputs: [
-                configureOutput('mcpTransport', handle$, {
-                    wireType: MCP_HANDLE_WIRE_TYPE,
+                configureOutput('tools', handle$, {
+                    wireType: TOOL_HANDLE_WIRE_TYPE,
                 }),
             ],
         };

package/vendor/common-nodes/dist/mcp/mcp-stdio/node.d.ts

@@ -1,8 +1,8 @@
 /**
- * Owns stdio MCP connect/close; emits live {@link McpHandle} for LLM `mcp`.
- * Handle id = graph nodeId; server name and tools come from MCP initialize /
- * tools/list. Connect/initialize/build failure → output port **error** (not
- * silent EMPTY).
+ * Owns stdio MCP connect/close; emits live {@link ToolHandle}[] for LLM `tools`.
+ * Server name and tools come from MCP initialize / tools/list. Session stays
+ * in invoke closures. Connect/initialize/build failure → output port **error**
+ * (not silent EMPTY).
  */
 export declare const mcpStdioNode: {
     readonly emitOncePerActivation: boolean;

package/vendor/common-nodes/dist/mcp/mcp-stdio/node.js

@@ -1,5 +1,4 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
-import { MCP_HANDLE_WIRE_TYPE } from '@langflower/node-sdk/mcp';
+import { defineReactiveNode, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
 import { buildMcpHandle } from '@langflower/tools/build-mcp-handle';
 import { formatMcpConnectError } from '@langflower/tools/format-mcp-connect-error';
 import { connectMcpStdioFromCli } from '@langflower/tools/mcp-stdio-client';
@@ -10,16 +9,16 @@ const paramsKey = (params) => JSON.stringify({
     command: params.command,
 });
 /**
- * Owns stdio MCP connect/close; emits live {@link McpHandle} for LLM `mcp`.
- * Handle id = graph nodeId; server name and tools come from MCP initialize /
- * tools/list. Connect/initialize/build failure → output port **error** (not
- * silent EMPTY).
+ * Owns stdio MCP connect/close; emits live {@link ToolHandle}[] for LLM `tools`.
+ * Server name and tools come from MCP initialize / tools/list. Session stays
+ * in invoke closures. Connect/initialize/build failure → output port **error**
+ * (not silent EMPTY).
  */
 export const mcpStdioNode = defineReactiveNode({
     type: 'common-mcp-stdio',
     displayName: 'MCP stdio',
     category: 'Tools',
-    description: 'Launches an MCP server over stdio from a shell command line and emits a live handle for LLM `mcp` ports.',
+    description: 'Launches an MCP server over stdio from a shell command line and emits its tools for LLM `tools` ports.',
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const command = makeInput('command', {
@@ -71,7 +70,7 @@ export const mcpStdioNode = defineReactiveNode({
                         await client.close();
                         return;
                     }
-                    subscriber.next(handle);
+                    subscriber.next(handle.tools);
                 };
                 void run().catch(fail);
                 return () => {
@@ -83,8 +82,8 @@ export const mcpStdioNode = defineReactiveNode({
         return {
             inputs: [command],
             outputs: [
-                configureOutput('mcpTransport', handle$, {
-                    wireType: MCP_HANDLE_WIRE_TYPE,
+                configureOutput('tools', handle$, {
+                    wireType: TOOL_HANDLE_WIRE_TYPE,
                 }),
             ],
         };

package/vendor/common-nodes/dist/tools/collect-agent-tool-handles.d.ts

@@ -1,12 +1,12 @@
 import type { ToolHandle } from '@langflower/node-sdk';
-import type { McpHandle } from '@langflower/node-sdk/mcp';
+/** Flatten multi-wire values that may be single handles or arrays (packs). */
+export declare const flattenToolHandles: (wired: readonly unknown[]) => readonly ToolHandle[];
 /**
- * Agent inventory: EC ∪ port for tools and MCP (flatten MCP → ToolHandle).
+ * Agent inventory: EC ∪ port for tools.
  * No catalog list, no enabledToolIds filter (server already filtered EC).
+ * Later `toolHandles` last-wins on `toolId` (jsonc MCP after builtins).
  */
 export declare const collectAgentToolHandles: (options: {
     readonly toolHandles: readonly ToolHandle[] | undefined;
     readonly toolsPort: unknown;
-    readonly mcpHandles: readonly McpHandle[] | undefined;
-    readonly mcpPort: unknown;
 }) => readonly ToolHandle[];

package/vendor/common-nodes/dist/tools/collect-agent-tool-handles.js

@@ -1,4 +1,3 @@
-import { flattenMcpHandles } from '../mcp/flatten-mcp-handles.js';
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const isToolHandle = (value) => {
     if (!isRecord(value)) {
@@ -12,7 +11,7 @@ const isToolHandle = (value) => {
         typeof value.invoke === 'function');
 };
 /** Flatten multi-wire values that may be single handles or arrays (packs). */
-const flattenToolHandles = (wired) => wired.flatMap((item) => {
+export const flattenToolHandles = (wired) => wired.flatMap((item) => {
     if (Array.isArray(item)) {
         return item.filter(isToolHandle);
     }
@@ -22,8 +21,9 @@ const flattenToolHandles = (wired) => wired.flatMap((item) => {
     return [];
 });
 /**
- * Agent inventory: EC ∪ port for tools and MCP (flatten MCP → ToolHandle).
+ * Agent inventory: EC ∪ port for tools.
  * No catalog list, no enabledToolIds filter (server already filtered EC).
+ * Later `toolHandles` last-wins on `toolId` (jsonc MCP after builtins).
  */
 export const collectAgentToolHandles = (options) => {
     const portTools = Array.isArray(options.toolsPort)
@@ -38,13 +38,5 @@ export const collectAgentToolHandles = (options) => {
     for (const handle of options.toolHandles ?? []) {
         byId.set(handle.toolId, handle);
     }
-    for (const mcp of [
-        ...(options.mcpHandles ?? []),
-        ...flattenMcpHandles(options.mcpPort),
-    ]) {
-        for (const handle of mcp.tools) {
-            byId.set(handle.toolId, handle);
-        }
-    }
     return [...byId.values()];
 };

package/vendor/common-nodes/dist/tools/inventory-tool-round.d.ts

@@ -2,8 +2,6 @@ import type { ToolHandle } from '@langflower/node-sdk';
 import { type Harness } from '@langflower/tools/create-project-harness';
 import type { ToolHandlerContext } from '@langflower/tools/domain-tool-configs';
 import type { ChatCompletionToolCall, ChatCompletionToolDefinition } from '../ai/features/chat-completion-stream.js';
-import type { SubAgentRegistration, SubAgentSpawnPayload } from '../ai/features/sub-agent-protocol.js';
-export declare const SPAWN_SUBAGENT_TOOL = "spawn_subagent";
 export declare const previewToolLogText: (text: string) => string;
 export declare const toChatToolDefinitions: (tools: readonly ToolHandle[]) => readonly ChatCompletionToolDefinition[];
 export declare const parseToolArgs: (raw: string) => Readonly<Record<string, unknown>>;
@@ -20,11 +18,3 @@ export declare const invokeInventoryTool: (harness: Harness | undefined, tools:
     readonly ok: boolean;
     readonly text: string;
 }>;
-export declare const buildSpawnSubagentChatTool: (registrations: readonly SubAgentRegistration[]) => ChatCompletionToolDefinition;
-export declare const resolveSpawnPayload: (call: ChatCompletionToolCall, registrations: readonly SubAgentRegistration[], openCallId: string | undefined) => {
-    readonly ok: true;
-    readonly payload: SubAgentSpawnPayload;
-} | {
-    readonly ok: false;
-    readonly text: string;
-};