langflower 0.0.8 → 0.0.10

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

@@ -128,6 +128,88 @@ export declare const subAgentNode: {
         readonly min: 0;
         readonly max: 32;
         readonly step: 1;
+    }, {
+        readonly field: "autokickOnIdle";
+        readonly type: "boolean";
+        readonly label: "Autokick on idle and dead-loop";
+        readonly default: boolean;
+    }, {
+        readonly field: "deadLoopEnabled";
+        readonly type: "boolean";
+        readonly label: "Detect repetition dead loops";
+        readonly default: boolean;
+    }, {
+        readonly field: "maxAutokickAttempts";
+        readonly type: "number";
+        readonly label: "Max autokick reconnects (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+    }, {
+        readonly field: "autokickBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff base (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickMaxBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff clamp (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickUserMessage";
+        readonly type: "string";
+        readonly label: "Autokick kick message";
+        readonly default: string;
+    }, {
+        readonly field: "autokickPenaltyFrequency";
+        readonly type: "number";
+        readonly label: "Autokick frequency_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "autokickPenaltyPresence";
+        readonly type: "number";
+        readonly label: "Autokick presence_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "deadLoopMaxWindowTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop window (tokens)";
+        readonly default: number;
+        readonly min: 10;
+        readonly max: 8000;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopConsecutiveThreshold";
+        readonly type: "number";
+        readonly label: "Dead-loop consecutive identical deltas";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinRepetitions";
+        readonly type: "number";
+        readonly label: "Dead-loop cyclic repetitions";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinPatternTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop min pattern tokens";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
     }];
     readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
     readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [{
@@ -251,6 +333,88 @@ export declare const subAgentNode: {
         readonly min: 0;
         readonly max: 32;
         readonly step: 1;
+    }, {
+        readonly field: "autokickOnIdle";
+        readonly type: "boolean";
+        readonly label: "Autokick on idle and dead-loop";
+        readonly default: boolean;
+    }, {
+        readonly field: "deadLoopEnabled";
+        readonly type: "boolean";
+        readonly label: "Detect repetition dead loops";
+        readonly default: boolean;
+    }, {
+        readonly field: "maxAutokickAttempts";
+        readonly type: "number";
+        readonly label: "Max autokick reconnects (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+    }, {
+        readonly field: "autokickBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff base (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickMaxBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff clamp (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickUserMessage";
+        readonly type: "string";
+        readonly label: "Autokick kick message";
+        readonly default: string;
+    }, {
+        readonly field: "autokickPenaltyFrequency";
+        readonly type: "number";
+        readonly label: "Autokick frequency_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "autokickPenaltyPresence";
+        readonly type: "number";
+        readonly label: "Autokick presence_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "deadLoopMaxWindowTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop window (tokens)";
+        readonly default: number;
+        readonly min: 10;
+        readonly max: 8000;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopConsecutiveThreshold";
+        readonly type: "number";
+        readonly label: "Dead-loop consecutive identical deltas";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinRepetitions";
+        readonly type: "number";
+        readonly label: "Dead-loop cyclic repetitions";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinPatternTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop min pattern tokens";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
     }], import("@langflower/node-sdk/llm").LlmExecutionCaps>>, ...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 [{
@@ -374,6 +538,88 @@ export declare const subAgentNode: {
         readonly min: 0;
         readonly max: 32;
         readonly step: 1;
+    }, {
+        readonly field: "autokickOnIdle";
+        readonly type: "boolean";
+        readonly label: "Autokick on idle and dead-loop";
+        readonly default: boolean;
+    }, {
+        readonly field: "deadLoopEnabled";
+        readonly type: "boolean";
+        readonly label: "Detect repetition dead loops";
+        readonly default: boolean;
+    }, {
+        readonly field: "maxAutokickAttempts";
+        readonly type: "number";
+        readonly label: "Max autokick reconnects (0 = unlimited)";
+        readonly default: number;
+        readonly min: 0;
+        readonly max: 1000;
+        readonly step: 1;
+    }, {
+        readonly field: "autokickBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff base (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickMaxBackoffMs";
+        readonly type: "number";
+        readonly label: "Autokick backoff clamp (ms)";
+        readonly default: number;
+        readonly min: 1000;
+        readonly step: 1000;
+    }, {
+        readonly field: "autokickUserMessage";
+        readonly type: "string";
+        readonly label: "Autokick kick message";
+        readonly default: string;
+    }, {
+        readonly field: "autokickPenaltyFrequency";
+        readonly type: "number";
+        readonly label: "Autokick frequency_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "autokickPenaltyPresence";
+        readonly type: "number";
+        readonly label: "Autokick presence_penalty delta";
+        readonly default: number;
+        readonly min: -2;
+        readonly max: 2;
+        readonly step: 0.1;
+    }, {
+        readonly field: "deadLoopMaxWindowTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop window (tokens)";
+        readonly default: number;
+        readonly min: 10;
+        readonly max: 8000;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopConsecutiveThreshold";
+        readonly type: "number";
+        readonly label: "Dead-loop consecutive identical deltas";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinRepetitions";
+        readonly type: "number";
+        readonly label: "Dead-loop cyclic repetitions";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
+    }, {
+        readonly field: "deadLoopMinPatternTokens";
+        readonly type: "number";
+        readonly label: "Dead-loop min pattern tokens";
+        readonly default: number;
+        readonly min: 1;
+        readonly step: 1;
     }], import("@langflower/node-sdk/llm").LlmExecutionCaps>;
     readonly paletteSecondary?: true;
     readonly description?: string;

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

@@ -1,4 +1,4 @@
-import { defineLlmNode, isSteerControlPayload } from '@langflower/node-sdk/llm';
+import { defineLlmNode, isSteerControlPayload, toLlmRecoveryPortValue, } from '@langflower/node-sdk/llm';
 import { concat, EMPTY, filter, mergeMap, Observable, of, } from 'rxjs';
 import { llmPanelUiSchema } from '../llm-panel-ui-schema.js';
 import { llmCompactionUiSchema } from '../llm-compaction-ui-schema.js';
@@ -261,7 +261,7 @@ export const subAgentNode = defineLlmNode({
         const toolLog$ = cycle$.pipeValue(demuxByKind('toolLog', (chunk) => chunk.text));
         const recovery$ = cycle$.pipeValue(demuxByKind('recoveryNotice', (chunk) => {
             const notice = chunk;
-            return { code: notice.code, text: notice.text };
+            return toLlmRecoveryPortValue(notice);
         }));
         const response$ = cycle$.pipeValue(demuxByKind('response', (chunk) => chunk
             .text));

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

@@ -1,11 +1,11 @@
-import { fakeLlmNode } from './ai/fake-llm/node.js';
-import { openAiLlmNode } from './ai/openai-llm/node.js';
+import { fakeLlmNode } from './ai/nodes/fake-llm/node.js';
+import { openAiLlmNode } from './ai/nodes/openai-llm/node.js';
 import { mcpHttpNode } from './mcp/mcp-http/node.js';
 import { mcpStdioNode } from './mcp/mcp-stdio/node.js';
 import { chatInputNode } from './hitl/chat-input/node.js';
-import { reviewNode } from './ai/review/node.js';
-import { critiqueNode } from './ai/critique/node.js';
-import { subAgentNode } from './ai/sub-agent/node.js';
+import { reviewNode } from './ai/nodes/review/node.js';
+import { critiqueNode } from './ai/nodes/critique/node.js';
+import { subAgentNode } from './ai/nodes/sub-agent/node.js';
 import { checkpointNode } from './flow/checkpoint/node.js';
 import { delayNode } from './flow/delay/node.js';
 import { loopNode } from './flow/loop/node.js';
@@ -33,6 +33,8 @@ import { extractLinksNode } from './crawl/extract-links/node.js';
 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,
@@ -64,6 +66,8 @@ const COMMON_REACTIVE_NODES = [
     compareNode,
     switchNode,
     memoryToolsNode,
+    langflowerToolsNode,
+    toolCollectionNode,
     fetchUrlNode,
     extractLinksNode,
     savePageNode,

package/vendor/common-nodes/dist/compile-custom-nodes/node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Emits `compile_custom_nodes` for agent inventory. The handler calls the
+ * server-injected compile hook (same composer as Custom → Update).
+ */
+export declare const compileCustomNodesNode: {
+    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;
+};
+//# sourceMappingURL=node.d.ts.map

package/vendor/common-nodes/dist/compile-custom-nodes/node.js

@@ -0,0 +1,45 @@
+import { defineToolRegistrations } from '@langflower/node-sdk';
+import { getRunHostServices, } from '../ai/features/run-host-services.js';
+const MISSING_HOOK_TEXT = '{ ok: false }\ncompile_custom_nodes unavailable (no server hook)';
+const formatCompileCustomNodesResult = (result) => {
+    const lines = [`status: ${result.status}`];
+    if (result.nodeTypes.length > 0) {
+        lines.push(`nodeTypes: ${result.nodeTypes.join(', ')}`);
+    }
+    if (result.errors.length > 0) {
+        lines.push('errors:');
+        for (const error of result.errors) {
+            lines.push(`- ${error.packageName}: ${error.message}`);
+        }
+    }
+    return lines.join('\n');
+};
+/**
+ * Emits `compile_custom_nodes` for agent inventory. The handler calls the
+ * server-injected compile hook (same composer as Custom → Update).
+ */
+export const compileCustomNodesNode = defineToolRegistrations({
+    type: 'common-compile-custom-nodes',
+    displayName: 'Compile Custom Nodes',
+    category: 'Tools',
+    description: 'Emits compile_custom_nodes so an agent can recompile project custom packs (same path as Custom → Update).',
+    tools: [
+        {
+            toolId: 'compile_custom_nodes',
+            description: 'Recompile `.langflower/nodes/` packs, hot-swap live custom instances, and refresh the Custom palette. No arguments. Pack failures also write COMPILATION_ERRORS.md.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                additionalProperties: false,
+            },
+            handler: async (_args, ctx) => {
+                const compile = getRunHostServices(ctx)?.compileCustomNodes;
+                if (compile === undefined) {
+                    return MISSING_HOOK_TEXT;
+                }
+                return formatCompileCustomNodesResult(await compile());
+            },
+        },
+    ],
+});
+//# sourceMappingURL=node.js.map

package/vendor/common-nodes/dist/crawl/crawl/node.js

@@ -3,7 +3,7 @@ import { createCrawlContext } from '@langflower/tools/create-crawl-context';
 import { createWebFetch } from '@langflower/tools/create-web-fetch';
 import { runBfsCrawl } from '@langflower/tools/run-bfs-crawl';
 import { from, mergeMap, throwError } from 'rxjs';
-import { getRunHostServices } from '../../ai/run-host-services.js';
+import { getRunHostServices } from '../../ai/features/run-host-services.js';
 const normalizeLimit = (value, fallback, max) => {
     const n = Number(value);
     if (!Number.isFinite(n) || n < 0) {

package/vendor/common-nodes/dist/crawl/fetch-url/node.js

@@ -2,7 +2,7 @@ import { defineReactiveNode } from '@langflower/node-sdk';
 import { createWebFetch } from '@langflower/tools/create-web-fetch';
 import { from, map, mergeMap, throwError } from 'rxjs';
 import { htmlToText } from '@langflower/tools/html';
-import { getRunHostServices } from '../../ai/run-host-services.js';
+import { getRunHostServices } from '../../ai/features/run-host-services.js';
 /**
  * HTTP GET a URL via server `ctx.harness.webFetch` (SSRF guards), then extract
  * plain text from HTML.

package/vendor/common-nodes/dist/flow/repeat/node.js

@@ -36,10 +36,11 @@ export const repeatNode = defineReactiveNode({
                 return of({ kind: 'done' });
             }
             return trigger.value$.pipe(startWith(undefined), take(n + 1), observeOn(asapScheduler), map((_, index) => index < n
-                ? { kind: 'value', value: v }
+                ? { kind: 'value', value: v, index }
                 : { kind: 'done' }));
         }));
         const valueOut$ = session$.pipeValue(filter((e) => e.kind === 'value'), map((e) => e.value));
+        const indexOut$ = session$.pipeValue(filter((e) => e.kind === 'value'), map((e) => e.index));
         const doneOut$ = session$.pipeValue(filter((e) => e.kind === 'done'), map(() => true));
         return {
             inputs: [value, count, trigger],
@@ -47,8 +48,12 @@ export const repeatNode = defineReactiveNode({
                 configureOutput('value', valueOut$, {
                     inferTypeFrom: value,
                 }),
+                configureOutput('index', indexOut$, {
+                    wireType: 'number',
+                }),
                 configureOutput('done', doneOut$, {
                     wireType: 'boolean',
+                    feed: { role: 'none' },
                 }),
             ],
         };

package/vendor/common-nodes/dist/langflower-tools/emit-registration-tools.d.ts

@@ -0,0 +1,18 @@
+import { type ToolHandle, type ToolHandler } from '@langflower/node-sdk';
+import { type Observable } from 'rxjs';
+type RegistrationTool = {
+    readonly toolId: string;
+    readonly name?: string;
+    readonly description: string;
+    readonly inputSchema: object;
+    readonly handler: ToolHandler;
+};
+/**
+ * Emit a `tools` pack, peeking **this** node's EC at invoke so bus RPC
+ * stays on the pack instance (not agent `toolCtx`). Local to this folder —
+ * not the author SDK factory.
+ */
+export declare const emitRegistrationTools: (ctx: {
+    readonly value$: Observable<unknown>;
+}, tools: readonly RegistrationTool[]) => import("@rx-evo/stateful-observable").StatefulObservable<ToolHandle[], unknown, undefined>;
+export {};

package/vendor/common-nodes/dist/langflower-tools/emit-registration-tools.js

@@ -0,0 +1,29 @@
+import { statefulObservable } from '@rx-evo/stateful-observable';
+import { of } from 'rxjs';
+const peekNodeContext = (source) => {
+    let peeked;
+    const sub = source.value$.subscribe((value) => {
+        peeked = value;
+    });
+    sub.unsubscribe();
+    return typeof peeked === 'object' && peeked !== null
+        ? peeked
+        : undefined;
+};
+/**
+ * Emit a `tools` pack, peeking **this** node's EC at invoke so bus RPC
+ * stays on the pack instance (not agent `toolCtx`). Local to this folder —
+ * not the author SDK factory.
+ */
+export const emitRegistrationTools = (ctx, tools) => statefulObservable({
+    loader: () => of(tools.map((tool) => ({
+        toolId: tool.toolId,
+        name: tool.name ?? tool.toolId,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        invoke: (args, agentCtx) => {
+            const nodeCtx = peekNodeContext(ctx);
+            return tool.handler(args, nodeCtx ?? agentCtx);
+        },
+    }))),
+});

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

@@ -0,0 +1,20 @@
+/**
+ * Emits Langflower bus tools for agent inventory. Recompile is unsafe:
+ * wire this node’s `tools` into the agent (starter Helper / Writer).
+ */
+export declare const langflowerToolsNode: {
+    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/langflower-tools/node.js

@@ -0,0 +1,77 @@
+import { defineReactiveNode, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
+import { getRunHostServices } from '../ai/features/run-host-services.js';
+import { emitRegistrationTools } from './emit-registration-tools.js';
+const MISSING_RPC_TEXT = '{ ok: false }\ncompile_custom_nodes unavailable (no bus RPC)';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** Format `customPalette.snapshot` (RPC wait skips `compiling`). */
+const formatPaletteSnapshot = (value) => {
+    if (!isRecord(value)) {
+        return `{ ok: false }\nUnexpected compile result`;
+    }
+    const status = typeof value.status === 'string' ? value.status : 'error';
+    const lines = [`status: ${status}`];
+    const nodes = Array.isArray(value.nodes) ? value.nodes : [];
+    const nodeTypes = nodes.flatMap((node) => isRecord(node) && typeof node.type === 'string' ? [node.type] : []);
+    if (nodeTypes.length > 0) {
+        lines.push(`nodeTypes: ${nodeTypes.join(', ')}`);
+    }
+    const errors = Array.isArray(value.errors) ? value.errors : [];
+    if (errors.length > 0) {
+        lines.push('errors:');
+        for (const error of errors) {
+            if (!isRecord(error)) {
+                continue;
+            }
+            const pack = typeof error.packageName === 'string'
+                ? error.packageName
+                : 'unknown';
+            const message = typeof error.message === 'string' ? error.message : '';
+            lines.push(`- ${pack}: ${message}`);
+        }
+    }
+    return lines.join('\n');
+};
+const LANGFLOWER_BUS_TOOL_CONFIGS = [
+    {
+        toolId: 'compile_custom_nodes',
+        description: 'Recompile `.langflower/nodes/` packs, hot-swap live custom instances, and refresh the Custom palette (same intent as Custom → Update). No arguments. Pack failures also write COMPILATION_ERRORS.md.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+        handler: (async (_args, ctx) => {
+            const request = getRunHostServices(ctx)?.requestLangflowerBus;
+            if (request === undefined) {
+                return MISSING_RPC_TEXT;
+            }
+            try {
+                const snapshot = await request('customPalette.update.requested', {});
+                return formatPaletteSnapshot(snapshot);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return `{ ok: false }\n${message}`;
+            }
+        }),
+    },
+];
+/**
+ * Emits Langflower bus tools for agent inventory. Recompile is unsafe:
+ * wire this node’s `tools` into the agent (starter Helper / Writer).
+ */
+export const langflowerToolsNode = defineReactiveNode({
+    type: 'common-langflower-tools',
+    displayName: 'Langflower Tools',
+    category: 'Tools',
+    description: 'Emits compile_custom_nodes (Custom → Update over the bus). Wire tools to opt in; later bus actions may be added to this pack.',
+    uiSchema: [],
+    bind(ctx, { configureOutput }) {
+        return {
+            inputs: [],
+            outputs: [
+                configureOutput('tools', emitRegistrationTools(ctx, LANGFLOWER_BUS_TOOL_CONFIGS), { wireType: TOOL_HANDLE_WIRE_TYPE }),
+            ],
+        };
+    },
+});

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;