langflower 0.0.9 → 0.1.0

package/vendor/common-nodes/dist/memory/memory-tools/node.js

@@ -8,6 +8,10 @@ export const memoryToolsNode = defineToolRegistrations({
     type: 'common-memory-tools',
     displayName: 'Memory Tools',
     category: 'Tools',
-    description: 'Emits get_memory_tree / read_memory_section / search_memory_grep / append_memory_log / update_memory_section / create_memory_file for agent inventory.',
+    description: `
+Give an agent tools to read and write the project wiki (tree, search, append, update, create).
+
+Wire **tools** into an LLM. Notes live under the project's memory folder.
+`.trim(),
     tools: MEMORY_TOOL_CONFIGS,
 });

package/vendor/common-nodes/dist/output/finish/node.js

@@ -1,20 +1,32 @@
 import { defineReactiveNode } from '@langflower/node-sdk';
+import { map } from 'rxjs';
 /** Passthrough sink — first output emission stops the run. */
 export const finishNode = defineReactiveNode({
     type: 'common-finish',
     displayName: 'Finish',
     category: 'Output',
-    description: 'Passthrough sink — the first output emission **stops the run**.',
+    description: `
+Last step of a run. When this node outputs, the run **stops**.
+
+Wire the final result here so Start/Stop settle instead of hanging on open work.
+`.trim(),
     stopsRun: true,
     emitOncePerActivation: true,
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value = makeInput('value', { name: 'value', required: true });
+        const done$ = value.pipeValue(map(() => 'done'));
         return {
             inputs: [value],
             outputs: [
+                configureOutput('done', done$, {
+                    wireType: 'string',
+                    hidden: true,
+                    feed: { role: 'result' },
+                }),
                 configureOutput('value', value, {
                     inferTypeFrom: value,
+                    feed: { role: 'none' },
                 }),
             ],
         };

package/vendor/common-nodes/dist/output/preview/node.js

@@ -19,14 +19,20 @@ export const previewNode = defineReactiveNode({
     type: 'common-preview',
     displayName: 'Preview',
     category: 'Output',
-    description: 'Displays wired **text** in a read-only preview area on the canvas.',
+    description: `
+Show a wired value on the canvas and in the work log so you can inspect it.
+
+Typical uses:
+- Debug a mid-pipeline value
+- A human-readable end of a small graph
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const text = makeInput('text', {
             name: 'text',
             wireType: 'string',
             required: true,
-            inline: 'preview',
+            inline: 'preview-markdown',
         });
         const output$ = text.pipeValue(map(formatPreviewText));
         return {
@@ -34,6 +40,7 @@ export const previewNode = defineReactiveNode({
             outputs: [
                 configureOutput('text', output$, {
                     inferTypeFrom: text,
+                    feed: { role: 'result' },
                 }),
             ],
         };

package/vendor/common-nodes/dist/primitives/boolean/node.js

@@ -4,7 +4,13 @@ export const booleanNode = defineReactiveNode({
     type: 'common-boolean',
     displayName: 'Boolean',
     category: 'Primitives',
-    description: 'Emits a **boolean literal** from the inline `value` field.',
+    description: `
+Put a constant true/false on the canvas.
+
+Typical uses:
+- Drive IF, Gate, or Assert without another node
+- A toggle you can flip while authoring
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value$ = makeInput('value', {

package/vendor/common-nodes/dist/primitives/number/node.js

@@ -4,7 +4,13 @@ export const numberNode = defineReactiveNode({
     type: 'common-number',
     displayName: 'Number',
     category: 'Primitives',
-    description: 'Emits a **number literal** from the inline `value` field.',
+    description: `
+Put a constant number on the canvas and wire it onward.
+
+Typical uses:
+- A Repeat **count** or Delay milliseconds
+- A threshold for Compare or Loop
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value$ = makeInput('value', {

package/vendor/common-nodes/dist/primitives/string/node.js

@@ -4,7 +4,13 @@ export const stringNode = defineReactiveNode({
     type: 'common-string',
     displayName: 'String',
     category: 'Primitives',
-    description: 'Emits a **string literal** from the inline `value` field.',
+    description: `
+Put a short constant string on the canvas and wire it onward.
+
+Typical uses:
+- A file path for Read File
+- A short label or prompt fragment
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput }) {
         const value$ = makeInput('value', {

package/vendor/common-nodes/dist/primitives/string-multiline/node.d.ts

@@ -0,0 +1,17 @@
+/** Multiline string literal — inline `value` textarea, no wire required. */
+export declare const stringMultilineNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [], Record<string, never>>;
+    readonly paletteSecondary?: true;
+    readonly description?: string;
+    readonly type: string;
+    readonly displayName: string;
+    readonly category: string | undefined;
+    readonly icon: string | undefined;
+};

package/vendor/common-nodes/dist/primitives/string-multiline/node.js

@@ -0,0 +1,31 @@
+import { defineReactiveNode } from '@langflower/node-sdk';
+/** Multiline string literal — inline `value` textarea, no wire required. */
+export const stringMultilineNode = defineReactiveNode({
+    type: 'common-string-multiline',
+    displayName: 'String (multiline)',
+    category: 'Primitives',
+    description: `
+Paste longer text on the node — several lines, not a single field.
+
+Typical uses:
+- A prompt or email draft
+- CSV or log text to feed into Split (paced)
+`.trim(),
+    uiSchema: [],
+    bind(_ctx, { makeInput, configureOutput }) {
+        const value$ = makeInput('value', {
+            name: 'value',
+            wireType: 'string',
+            inline: 'text-multiline',
+            defaultValue: '',
+        });
+        return {
+            inputs: [value$],
+            outputs: [
+                configureOutput('value', value$, {
+                    wireType: 'string',
+                }),
+            ],
+        };
+    },
+});

package/vendor/common-nodes/dist/text/append-file/node.js

@@ -1,4 +1,4 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
+import { defineReactiveNode, withLoading } from '@langflower/node-sdk';
 import { createProjectFilesContext } from '@langflower/tools/create-project-files-context';
 import { from, map, mergeMap, throwError } from 'rxjs';
 import { getRunHostServices } from '../../ai/features/run-host-services.js';
@@ -10,7 +10,13 @@ export const appendFileNode = defineReactiveNode({
     type: 'common-append-file',
     displayName: 'Append File',
     category: 'Text',
-    description: 'Appends `content` to a project-relative file. When the file is non-empty, inserts `delimiter` before the new content.',
+    description: `
+Add **content** to the end of a project file. If the file already has text, **delimiter** is inserted first.
+
+Typical uses:
+- Append a log line
+- Grow a notes file across loop iterations
+`.trim(),
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const pathInput = makeInput('path', {
@@ -37,7 +43,9 @@ export const appendFileNode = defineReactiveNode({
             delimiter: String(rawDelimiter ?? ''),
             content: String(rawContent ?? ''),
             ec,
-        })).pipeValue(mergeMap(({ path: filePath, delimiter: fileDelimiter, content: fileContent, ec, }) => {
+        }))
+            .pipe(withLoading())
+            .pipeValue(mergeMap(({ path: filePath, delimiter: fileDelimiter, content: fileContent, ec, }) => {
             if (filePath.length === 0) {
                 return throwError(() => new Error('Append File requires a non-empty path.'));
             }

package/vendor/common-nodes/dist/text/concat/node.js

@@ -4,7 +4,11 @@ export const concatNode = defineReactiveNode({
     type: 'common-concat',
     displayName: 'Concat',
     category: 'Text',
-    description: 'Joins wired string `value` slots with a `separator` into one string. Emits only when every wired `value` slot has a new event (`multi: zip`). In `separator`, `\\n` is replaced with a line break.',
+    description: `
+Join several strings with a **separator**. Emits only when every wired string has a fresh value.
+
+Type \`\\n\` in the separator for a line break.
+`.trim(),
     uiSchema: [],
     bind(_ctx, { makeInput, configureOutput, combineInputs }) {
         const separator$ = makeInput('separator', {

package/vendor/common-nodes/dist/text/read-file/node.js

@@ -1,4 +1,4 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
+import { defineReactiveNode, withLoading } from '@langflower/node-sdk';
 import { createProjectFilesContext } from '@langflower/tools/create-project-files-context';
 import { from, mergeMap, throwError } from 'rxjs';
 import { getRunHostServices } from '../../ai/features/run-host-services.js';
@@ -10,7 +10,11 @@ export const readFileNode = defineReactiveNode({
     type: 'common-read-file',
     displayName: 'Read File',
     category: 'Text',
-    description: 'Reads a project-relative file into `content`. Absolute paths are rejected. Emit on `update` to re-read.',
+    description: `
+Read a file inside the project into **content**. Absolute paths are refused.
+
+Pulse **update** to read the same path again after it changes on disk.
+`.trim(),
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const pathInput = makeInput('path', {
@@ -28,7 +32,9 @@ export const readFileNode = defineReactiveNode({
         const content$ = combineInputs([pathInput, update, ctx], ([rawPath, _update, ec]) => ({
             path: String(rawPath ?? '').trim(),
             ec,
-        })).pipeValue(mergeMap(({ path: filePath, ec }) => {
+        }))
+            .pipe(withLoading())
+            .pipeValue(mergeMap(({ path: filePath, ec }) => {
             if (filePath.length === 0) {
                 return throwError(() => new Error('Read File requires a non-empty path.'));
             }

package/vendor/common-nodes/dist/text/split-paced/node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Splits `text` on `divider` and emits one non-empty chunk per pace slot:
+ * first ASAP, later on `trigger`. After the last chunk, the next slot emits
+ * `finish: true`. Use for CSV / logs line-by-line; not the one-shot Split array.
+ */
+export declare const splitPacedNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [], Record<string, never>>;
+    readonly paletteSecondary?: true;
+    readonly description?: string;
+    readonly type: string;
+    readonly displayName: string;
+    readonly category: string | undefined;
+    readonly icon: string | undefined;
+};

package/vendor/common-nodes/dist/text/split-paced/node.js

@@ -0,0 +1,93 @@
+import { defineReactiveNode } from '@langflower/node-sdk';
+import { asapScheduler, filter, map, observeOn, of, startWith, switchMap, take, } from 'rxjs';
+const remainingChunks = (text, divider, startFrom) => {
+    const splitDivider = divider.replaceAll('\\n', '\n');
+    const from = Math.max(0, Math.floor(Number(startFrom) || 0));
+    const pieces = String(text)
+        .split(splitDivider)
+        .map((piece) => piece.replace(/\r$/, ''))
+        .filter((piece) => piece.length > 0);
+    return pieces.slice(from).map((chunk, offset) => ({
+        text: chunk,
+        index: from + offset,
+    }));
+};
+/**
+ * Splits `text` on `divider` and emits one non-empty chunk per pace slot:
+ * first ASAP, later on `trigger`. After the last chunk, the next slot emits
+ * `finish: true`. Use for CSV / logs line-by-line; not the one-shot Split array.
+ */
+export const splitPacedNode = defineReactiveNode({
+    type: 'common-split-paced',
+    displayName: 'Split (paced)',
+    category: 'Text',
+    description: `
+Walk a large text one piece at a time — CSV rows, log lines, paragraphs.
+
+The first piece starts immediately. Pulse **trigger** for the next. After the last piece, **finish** fires so you can stop the loop.
+
+Skip ahead with **start from**. Empty pieces are ignored. In **divider**, type \`\\n\` for a line break.
+`.trim(),
+    uiSchema: [],
+    bind(_ctx, { makeInput, configureOutput, combineInputs }) {
+        const text = makeInput('text', {
+            name: 'text',
+            wireType: 'string',
+            inline: 'text-multiline',
+            required: true,
+            defaultValue: '',
+        });
+        const divider = makeInput('divider', {
+            name: 'divider',
+            wireType: 'string',
+            inline: 'text',
+            defaultValue: '\\n',
+            description: '`\\n` is replaced with a line break.',
+        });
+        const startFrom = makeInput('startFrom', {
+            name: 'start from',
+            wireType: 'number',
+            inline: { type: 'number', min: 0, step: 1 },
+            defaultValue: 0,
+        });
+        const trigger = makeInput('trigger', {
+            name: 'trigger',
+            dynamic: true,
+            required: true,
+        });
+        const session$ = combineInputs([text, divider, startFrom], ([rawText, rawDivider, rawStart]) => remainingChunks(String(rawText ?? ''), String(rawDivider ?? ''), Number(rawStart))).pipeValue(switchMap((chunks) => {
+            const n = chunks.length;
+            if (n <= 0) {
+                return of({ kind: 'finish' });
+            }
+            return trigger.value$.pipe(startWith(undefined), take(n + 1), observeOn(asapScheduler), map((_, slot) => {
+                const chunk = chunks[slot];
+                return slot < n && chunk !== undefined
+                    ? {
+                        kind: 'chunk',
+                        text: chunk.text,
+                        index: chunk.index,
+                    }
+                    : { kind: 'finish' };
+            }));
+        }));
+        const textOut$ = session$.pipeValue(filter((e) => e.kind === 'chunk'), map((e) => e.text));
+        const indexOut$ = session$.pipeValue(filter((e) => e.kind === 'chunk'), map((e) => e.index));
+        const finishOut$ = session$.pipeValue(filter((e) => e.kind === 'finish'), map(() => true));
+        return {
+            inputs: [text, divider, startFrom, trigger],
+            outputs: [
+                configureOutput('text', textOut$, {
+                    wireType: 'string',
+                }),
+                configureOutput('index', indexOut$, {
+                    wireType: 'number',
+                }),
+                configureOutput('finish', finishOut$, {
+                    wireType: 'boolean',
+                    feed: { role: 'none' },
+                }),
+            ],
+        };
+    },
+});

package/vendor/common-nodes/dist/text/write-file/node.js

@@ -1,4 +1,4 @@
-import { defineReactiveNode } from '@langflower/node-sdk';
+import { defineReactiveNode, withLoading } from '@langflower/node-sdk';
 import { createProjectFilesContext } from '@langflower/tools/create-project-files-context';
 import { from, map, mergeMap, throwError } from 'rxjs';
 import { getRunHostServices } from '../../ai/features/run-host-services.js';
@@ -9,7 +9,13 @@ export const writeFileNode = defineReactiveNode({
     type: 'common-write-file',
     displayName: 'Write File',
     category: 'Text',
-    description: 'Writes `content` to a project-relative `path` (creates parents). Absolute paths are rejected.',
+    description: `
+Write **content** to a file inside the project (creates folders if needed). Absolute paths are refused.
+
+Typical uses:
+- Save an LLM draft
+- Persist a generated config
+`.trim(),
     uiSchema: [],
     bind(ctx, { makeInput, configureOutput, combineInputs }) {
         const pathInput = makeInput('path', {
@@ -29,7 +35,9 @@ export const writeFileNode = defineReactiveNode({
             path: String(rawPath ?? '').trim(),
             content: String(rawContent ?? ''),
             ec,
-        })).pipeValue(mergeMap(({ path: filePath, content: fileContent, ec }) => {
+        }))
+            .pipe(withLoading())
+            .pipeValue(mergeMap(({ path: filePath, content: fileContent, ec }) => {
             if (filePath.length === 0) {
                 return throwError(() => new Error('Write File requires a non-empty path.'));
             }

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;
-};

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

@@ -1,6 +1,5 @@
 import { isBuiltinToolId, } from '@langflower/tools/create-project-harness';
 import { formatPermissionDeniedText } from '@langflower/tools/permission';
-export const SPAWN_SUBAGENT_TOOL = 'spawn_subagent';
 const TOOL_LOG_PREVIEW = 400;
 export const previewToolLogText = (text) => {
     const trimmed = text.trim();
@@ -90,86 +89,3 @@ export const invokeInventoryTool = async (harness, tools, call, toolCtx, options
         };
     }
 };
-export const buildSpawnSubagentChatTool = (registrations) => {
-    const catalog = registrations
-        .map((reg) => {
-        const skills = reg.skills.length === 0
-            ? 'none'
-            : reg.skills
-                .map((skill) => `${skill.skillId}${skill.description.length > 0 ? ` (${skill.description})` : ''}`)
-                .join(', ');
-        return `- nodeId=${reg.targetNodeId} name=${reg.name}: ${reg.description} skills=[${skills}]`;
-    })
-        .join('\n');
-    return {
-        type: 'function',
-        function: {
-            name: SPAWN_SUBAGENT_TOOL,
-            description: [
-                'Spawn one Sub-Agent on the canvas (sequential — wait for its result before another spawn).',
-                'Pick nodeId from the catalog. skillId may be empty if unused.',
-                'Catalog:',
-                catalog.length > 0 ? catalog : '(no Sub-Agents registered)',
-            ].join('\n'),
-            parameters: {
-                type: 'object',
-                properties: {
-                    nodeId: {
-                        type: 'string',
-                        description: 'targetNodeId of the Sub-Agent to spawn',
-                    },
-                    skillId: {
-                        type: 'string',
-                        description: 'Optional skill id announced by that Sub-Agent; empty if none',
-                    },
-                    task: {
-                        type: 'string',
-                        description: 'Task text for the Sub-Agent body',
-                    },
-                },
-                required: ['nodeId', 'task'],
-            },
-        },
-    };
-};
-export const resolveSpawnPayload = (call, registrations, openCallId) => {
-    if (openCallId !== undefined) {
-        return {
-            ok: false,
-            text: `Serial spawn only: already waiting for callId=${openCallId}.`,
-        };
-    }
-    const args = parseToolArgs(call.arguments);
-    const nodeId = typeof args.nodeId === 'string' ? args.nodeId.trim() : '';
-    const task = typeof args.task === 'string' ? args.task : '';
-    const skillId = typeof args.skillId === 'string' ? args.skillId.trim() : '';
-    if (nodeId.length === 0) {
-        return { ok: false, text: 'spawn_subagent requires nodeId.' };
-    }
-    if (task.trim().length === 0) {
-        return { ok: false, text: 'spawn_subagent requires a non-empty task.' };
-    }
-    const target = registrations.find((reg) => reg.targetNodeId === nodeId);
-    if (target === undefined) {
-        return {
-            ok: false,
-            text: `Unknown Sub-Agent nodeId «${nodeId}» (not in subagentRegistration).`,
-        };
-    }
-    if (skillId.length > 0 &&
-        !target.skills.some((skill) => skill.skillId === skillId)) {
-        return {
-            ok: false,
-            text: `Skill «${skillId}» is not announced by Sub-Agent «${nodeId}».`,
-        };
-    }
-    return {
-        ok: true,
-        payload: {
-            callId: call.id,
-            nodeId,
-            skillId,
-            task,
-        },
-    };
-};

package/vendor/common-nodes/dist/tools/tool-collection/node.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Optional hub: combine many `tools` wires into one `ToolHandle[]`.
+ * Duplicate `toolId` last-wins (later slot). Empty / unwired → `[]`.
+ */
+export declare const toolCollectionNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [], Record<string, never>>;
+    readonly paletteSecondary?: true;
+    readonly description?: string;
+    readonly type: string;
+    readonly displayName: string;
+    readonly category: string | undefined;
+    readonly icon: string | undefined;
+};

package/vendor/common-nodes/dist/tools/tool-collection/node.js

@@ -0,0 +1,45 @@
+import { defineReactiveNode, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
+import { map } from 'rxjs';
+import { flattenToolHandles } from '../collect-agent-tool-handles.js';
+const mergeToolHandlesLastWins = (wired) => {
+    const flattened = Array.isArray(wired)
+        ? flattenToolHandles(wired)
+        : flattenToolHandles(wired === undefined || wired === null ? [] : [wired]);
+    const byId = new Map();
+    for (const handle of flattened) {
+        byId.set(handle.toolId, handle);
+    }
+    return [...byId.values()];
+};
+/**
+ * Optional hub: combine many `tools` wires into one `ToolHandle[]`.
+ * Duplicate `toolId` last-wins (later slot). Empty / unwired → `[]`.
+ */
+export const toolCollectionNode = defineReactiveNode({
+    type: 'common-tool-collection',
+    displayName: 'Tool collection',
+    category: 'Tools',
+    description: `
+Combine several tool wires into one before an agent. Duplicate names: the last wire wins.
+
+Optional — you can still plug many tool packs straight into the agent.
+`.trim(),
+    uiSchema: [],
+    bind(_ctx, { makeInput, configureOutput }) {
+        const tools = makeInput('tools', {
+            name: 'tools',
+            wireType: TOOL_HANDLE_WIRE_TYPE,
+            multi: 'combine',
+            defaultValue: [],
+        });
+        const merged$ = tools.pipeValue(map((wired) => mergeToolHandlesLastWins(wired)));
+        return {
+            inputs: [tools],
+            outputs: [
+                configureOutput('tools', merged$, {
+                    wireType: TOOL_HANDLE_WIRE_TYPE,
+                }),
+            ],
+        };
+    },
+});