langflower 0.0.7 → 0.0.9

package/vendor/runtime/dist/testing/workflows/workflow-events.js

@@ -1,4 +1,5 @@
 import { filter, firstValueFrom } from 'rxjs';
+import { isPortTelemetry, isRuntimeDone, } from '../../types.js';
 import { RuntimeEditor } from '../../runtime-editor.js';
 import { RuntimeRunner } from '../../runtime-runner.js';
 export function createRuntimeHarness(options) {
@@ -17,27 +18,23 @@ export function wireEdge(editor, edge) {
         throw new Error(`Failed to wire ${edge.fromNodeId}.${edge.fromPort[0]} → ${edge.toNodeId}.${edge.toPort[0]}`);
     }
 }
-function isOutputEmitted(event) {
-    return event.kind === 'output-emitted' && event.state === 'value';
-}
-export function outputValues(events, nodeId, portId, runId) {
+const isOutputValue = (event) => isPortTelemetry(event) && event[0] === 'out' && event[3] === 'value';
+export function outputValues(events, nodeId, portId, _runId) {
     return events
-        .filter((event) => isOutputEmitted(event) &&
-        event.nodeId === nodeId &&
-        event.portId === portId &&
-        (runId === undefined || event.runId === runId))
-        .map((event) => event.value);
+        .filter((event) => isOutputValue(event) &&
+        event[1] === nodeId &&
+        event[2] === portId)
+        .map((event) => event[4]);
 }
-export async function waitForOutput(runtime, nodeId, portId, runId) {
-    return waitForOutputMatching(runtime, nodeId, portId, () => true, runId);
+export async function waitForOutput(runtime, nodeId, portId, _runId) {
+    return waitForOutputMatching(runtime, nodeId, portId, () => true, _runId);
 }
-async function waitForOutputMatching(runtime, nodeId, portId, predicate, runId) {
+async function waitForOutputMatching(runtime, nodeId, portId, predicate, _runId) {
     const runner = resolveRunner(runtime);
-    return firstValueFrom(runner.events$.pipe(filter((event) => isOutputEmitted(event) &&
-        event.nodeId === nodeId &&
-        event.portId === portId &&
-        (runId === undefined || event.runId === runId) &&
-        predicate(event.value))));
+    return firstValueFrom(runner.events$.pipe(filter((event) => isOutputValue(event) &&
+        event[1] === nodeId &&
+        event[2] === portId &&
+        predicate(event[4]))));
 }
 export async function runAndCollectEvents(runtime, startRun, settleMs = 50) {
     const events = [];
@@ -52,26 +49,17 @@ export async function runAndCollectEvents(runtime, startRun, settleMs = 50) {
     subscription.unsubscribe();
     return { runId, events };
 }
-async function collectEventsForMs(runtime, ms) {
-    const events = [];
-    const runner = resolveRunner(runtime);
-    const subscription = runner.events$.subscribe((event) => {
-        events.push(event);
-    });
-    await new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-    subscription.unsubscribe();
-    return events;
-}
 export async function noDoneWithin(runtime, ms, runId) {
     const runner = resolveRunner(runtime);
     const result = await Promise.race([
-        firstValueFrom(runner.events$.pipe(filter((event) => event.kind === 'done' &&
-            (runId === undefined || event.runId === runId)))).then(() => 'done'),
+        firstValueFrom(runner.events$.pipe(filter((event) => isRuntimeDone(event) &&
+            event.length === 2 &&
+            (runId === undefined || event[1] === runId)))).then(() => 'done'),
         new Promise((resolve) => {
             setTimeout(() => resolve('timeout'), ms);
         }),
     ]);
     return result === 'timeout';
 }
+export const edgeIdsFromPortEvent = (event) => event[6];
+export const portDirLabel = (event) => event[0] === 'out' ? 'output-emitted' : 'input-received';

package/vendor/runtime/dist/types.d.ts

@@ -119,44 +119,26 @@ export type MetaFromStatefulObservable<T extends StatefulObservable<unknown, unk
  */
 export type RuntimeRunnerStatus = 'idle' | 'running' | 'stopped';
 export type RuntimePortSignalState = 'pending' | 'value' | 'error';
-export type RuntimeOutputEmittedEvent = {
-    readonly kind: 'output-emitted';
-    readonly runId: RunId;
-    readonly nodeId: NodeId;
-    readonly portId: string | symbol;
-    readonly portIdx: number;
-    readonly edgeIds: EdgeId[];
-    readonly state: RuntimePortSignalState;
-    readonly value: unknown;
-    /** Resolved author feed contract carried with the runtime fact. */
-    readonly feed?: RuntimeFeedPortMeta;
-};
-export type RuntimeInputReceivedEvent = {
-    readonly kind: 'input-received';
-    readonly runId: RunId;
-    readonly nodeId: NodeId;
-    readonly portId: string | symbol;
-    readonly portIdx: number;
-    readonly edgeIds: EdgeId[];
-    readonly state: RuntimePortSignalState;
-    readonly value: unknown;
-    /** Resolved author feed contract carried with the runtime fact. */
-    readonly feed?: RuntimeFeedPortMeta;
-};
-export type RuntimeRunnerEvent = RuntimeOutputEmittedEvent | RuntimeInputReceivedEvent | {
-    /**
-     * Run ended naturally — sets {@link RuntimeRunnerStatus} to `'idle'`.
-     *
-     * Emitted when:
-     * - the graph is **empty** on {@link RuntimeRunner.start}, or
-     * - a node with {@link RuntimeNode.stopsRun} emits on a watched output.
-     *
-     * Otherwise the run stays `'running'` until
-     * {@link RuntimeRunner.interrupt}.
-     */
-    readonly kind: 'done';
-    readonly runId: RunId;
-};
+/**
+ * Port signal tuple — `portDir` `'out'` = output emitted, `'in'` = input received.
+ * No per-frame `runId`; session snapshots own run correlation.
+ */
+export type PortTelemetry = readonly [
+    portDir: 'in' | 'out',
+    nodeId: NodeId,
+    portId: string,
+    state: RuntimePortSignalState,
+    value: unknown,
+    portIdx: number,
+    edgeIds: readonly EdgeId[],
+    /** Absent feed meta — use `null` (never `undefined`; JSON arrays drop undefined). */
+    feed: RuntimeFeedPortMeta | null
+];
+/** Run ended — `runId` at index 1 when replay needs explicit correlation. */
+export type RuntimeDoneTelemetry = readonly ['done'] | readonly ['done', RunId];
+export type RuntimeRunnerEvent = PortTelemetry | RuntimeDoneTelemetry;
+export declare const isPortTelemetry: (event: RuntimeRunnerEvent) => event is PortTelemetry;
+export declare const isRuntimeDone: (event: RuntimeRunnerEvent) => event is RuntimeDoneTelemetry;
 /** Seed value pushed into an input port slot on {@link RuntimeRunner.start}. */
 export type RuntimeSeedPortValue = {
     readonly portId: string | symbol;
@@ -255,6 +237,10 @@ export type RuntimeOptions = {
      */
     readonly log?: boolean;
 };
+export type SwapNodeResult = {
+    readonly node: RuntimeNode;
+    readonly droppedEdges: readonly RuntimeEdge[];
+};
 export type RuntimeEditorApi = {
     /**
      * Register a node and its port observables (handler already bound).
@@ -288,6 +274,15 @@ export type RuntimeEditorApi = {
      * graph is locked. Does not cascade-remove other edges.
      */
     replaceEdge(edge: Omit<RuntimeEdge, 'edgeId'>): RuntimeEdge | false;
+    /**
+     * Replace the live instance at `nodeId` with `next`. Keeps `nodeId`.
+     * Drops incident edges whose ports vanished or whose wire types are no
+     * longer compatible (same rules as {@link addEdge}).
+     *
+     * Allowed while the graph is locked. Does not call {@link addNode} /
+     * {@link removeNode}. Returns `false` when disposed or `nodeId` is missing.
+     */
+    swapNode(nodeId: NodeId, next: Omit<RuntimeNode, 'nodeId'>): SwapNodeResult | false;
     /** Must fail while runner status is `'running'`.
      *
      * return false while running or node not found

package/vendor/runtime/dist/types.js

@@ -1 +1,2 @@
-export {};
+export const isPortTelemetry = (event) => Array.isArray(event) && (event[0] === 'in' || event[0] === 'out');
+export const isRuntimeDone = (event) => Array.isArray(event) && event[0] === 'done';

package/vendor/server/dist/bridge/attach-langflower-bridge.js

@@ -1,3 +1,4 @@
+import { isRuntimeDone } from '@langflower/runtime';
 import { deriveExecutionProgressStatus, terminalExecutionProgressStatus, } from '@langflower/shared/langflower.js';
 import { Subscription } from 'rxjs';
 import { RunCheckpointSession } from '../checkpoint/run-checkpoint-session.js';
@@ -36,7 +37,7 @@ export const attachLangflowerBridge = (bridge, context, options = {}) => {
     // miss them (`events$` is a non-replaying Subject). Late clients get the
     // backlog via `executionFeed.snapshot`. See FOUND_BUGS pending race.
     rootSubscription.add(session.runtime.runner.events$.subscribe((event) => {
-        if (event.kind === 'done' && onRunSettled !== undefined) {
+        if (isRuntimeDone(event) && onRunSettled !== undefined) {
             const progress = deriveExecutionProgressStatus('idle', session.runtime.runner.eventLog);
             const status = terminalExecutionProgressStatus(progress);
             if (status !== null) {
@@ -59,7 +60,7 @@ export const attachLangflowerBridge = (bridge, context, options = {}) => {
     // 3. Intent handlers (bus namespaces)
     rootSubscription.add(wireWorkflowHandlers(bridge, context, session));
     rootSubscription.add(wirePaletteHandlers(bridge, context));
-    rootSubscription.add(wireCustomPaletteHandlers(bridge, context));
+    rootSubscription.add(wireCustomPaletteHandlers(bridge, context, session));
     rootSubscription.add(wireConfigHandlers(bridge, context, session, draftController, {
         onEffectiveConfig: (config) => {
             applyServerLogsGate(diagnosticLog.setEnabled, config);

package/vendor/server/dist/bridge/bridge-event-log.js

@@ -2,67 +2,22 @@ import { randomUUID } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { langflowerWsConfig } from '@langflower/shared/langflower.js';
+import { encodeBridgeFrame } from '@langflower/websocket-bridge/bridge-codec';
 import { Subscription } from 'rxjs';
-const REDACTED = '[REDACTED]';
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const isSecretKey = (key) => {
-    const normalized = key.toLowerCase();
-    return (normalized.includes('apikey') ||
-        normalized.includes('authorization') ||
-        normalized.includes('cookie') ||
-        normalized.includes('token') ||
-        normalized.includes('password') ||
-        normalized.includes('secret') ||
-        normalized.includes('credential'));
-};
-const sanitize = (value, seen = new WeakSet()) => {
-    if (value === null ||
-        typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'boolean') {
-        return value;
-    }
-    if (typeof value === 'bigint') {
-        return `${value}n`;
-    }
-    if (typeof value === 'undefined') {
-        return '[undefined]';
-    }
-    if (typeof value === 'symbol' || typeof value === 'function') {
-        return `[${typeof value}]`;
-    }
-    if (value instanceof Error) {
-        return {
-            name: value.name,
-            message: value.message,
-        };
-    }
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    if (typeof value === 'object') {
-        if (seen.has(value)) {
-            return '[circular]';
-        }
-        seen.add(value);
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => sanitize(entry, seen));
-    }
-    if (isRecord(value)) {
-        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
-            key,
-            isSecretKey(key) ? REDACTED : sanitize(entry, seen),
-        ]));
-    }
-    return String(value);
-};
 const toSafeTimestamp = (date) => date.toISOString().replaceAll(':', '-').replaceAll('.', '-');
-const asObservable = (value) => isRecord(value) && typeof value.subscribe === 'function'
+const asObservable = (value) => typeof value === 'object' &&
+    value !== null &&
+    typeof value.subscribe === 'function'
     ? value
     : undefined;
-const asInboundEvent = (value) => isRecord(value) && typeof value.clientId === 'string' && 'payload' in value
-    ? { clientId: value.clientId, payload: value.payload }
+const asInboundEvent = (value) => typeof value === 'object' &&
+    value !== null &&
+    typeof value.clientId === 'string' &&
+    'payload' in value
+    ? {
+        clientId: value.clientId,
+        payload: value.payload,
+    }
     : undefined;
 const logPath = (projectDir) => path.join(projectDir, '.langflower', 'logs', `${toSafeTimestamp(new Date())}-${process.pid}-${randomUUID()}.log`);
 export const attachBridgeEventLog = (bridge, projectDir, subscriptions, options = {}) => {
@@ -81,15 +36,11 @@ export const attachBridgeEventLog = (bridge, projectDir, subscriptions, options
         const message = error instanceof Error ? error.message : String(error);
         process.stderr.write(`Langflower diagnostic logging disabled: ${message}\n`);
     };
-    const write = (record) => {
+    const writeFrame = (transportDir, busType, payload) => {
         if (!enabled || !acceptingWrites || closed) {
             return;
         }
-        const line = `${JSON.stringify(sanitize({
-            schemaVersion: 1,
-            timestamp: new Date().toISOString(),
-            ...record,
-        }))}\n`;
+        const line = `${encodeBridgeFrame(transportDir, busType, payload)}\n`;
         writeQueue = writeQueue.then(async () => {
             if (!enabled || !acceptingWrites) {
                 return;
@@ -118,13 +69,7 @@ export const attachBridgeEventLog = (bridge, projectDir, subscriptions, options
         subscriptions.add(channel.subscribe((value) => {
             const event = asInboundEvent(value);
             if (event !== undefined) {
-                write({
-                    kind: 'frame',
-                    direction: 'inbound',
-                    clientId: event.clientId,
-                    type,
-                    payload: event.payload,
-                });
+                writeFrame('in', type, event.payload);
             }
         }));
     }
@@ -134,30 +79,10 @@ export const attachBridgeEventLog = (bridge, projectDir, subscriptions, options
             continue;
         }
         subscriptions.add(channel.subscribe((payload) => {
-            write({
-                kind: 'frame',
-                direction: 'outbound',
-                scope: 'broadcast',
-                type,
-                payload,
-            });
+            writeFrame('out', type, payload);
         }));
     }
-    subscriptions.add(bridge.status$.subscribe((status) => {
-        write({ kind: 'status', status });
-    }));
-    subscriptions.add(bridge.errors$.subscribe((error) => {
-        write({
-            kind: 'error',
-            error: {
-                code: error.code,
-                message: error.message,
-                ...('cause' in error ? { cause: error.cause } : {}),
-            },
-        });
-    }));
     subscriptions.add(bridge.connections$.subscribe((client) => {
-        write({ kind: 'connection', clientId: client.id });
         const clientSubscriptions = new Subscription();
         subscriptions.add(clientSubscriptions);
         const clientChannels = client;
@@ -167,29 +92,19 @@ export const attachBridgeEventLog = (bridge, projectDir, subscriptions, options
                 continue;
             }
             clientSubscriptions.add(channel.subscribe((payload) => {
-                write({
-                    kind: 'frame',
-                    direction: 'outbound',
-                    scope: 'client',
-                    clientId: client.id,
-                    type,
-                    payload,
-                });
+                writeFrame('out', type, payload);
             }));
         }
         clientSubscriptions.add(client.disconnected$.subscribe(() => {
-            write({ kind: 'disconnection', clientId: client.id });
             clientSubscriptions.unsubscribe();
         }));
     }));
-    write({ kind: 'server-started' });
     return {
         filePath,
         setEnabled: (nextEnabled) => {
             enabled = nextEnabled;
         },
         writeServerClosing: () => {
-            write({ kind: 'server-closing' });
             closed = true;
         },
         flush: async () => {

package/vendor/server/dist/bridge/build-execution-context.d.ts

@@ -1,4 +1,5 @@
-import { type ExecutionContext } from '@langflower/node-sdk';
+import type { LangflowerBusRequest } from '@langflower/common-nodes/ai/run-host-services';
+import { type ExecutionContext, type ToolHandle } from '@langflower/node-sdk';
 import type { LlmExecutionCaps } from '@langflower/node-sdk/llm';
 import type { McpHandle } from '@langflower/node-sdk/mcp';
 import type { RuntimeSeedPortValue } from '@langflower/runtime';
@@ -16,6 +17,8 @@ type BuildHarnessHooks = {
     readonly nodeId: string;
     readonly requestPermission: LangflowerSession['permissionAsks']['requestPermission'];
     readonly emitPermissionAsk: (payload: RunnerPermissionAskPayload) => void;
+    readonly requestLangflowerBus?: LangflowerBusRequest;
+    readonly getLiveWiredTools?: (agentNodeId: string) => readonly ToolHandle[];
 };
 export declare const buildExecutionContext: (context: ExecutionContextDeps, runId: string, node: WorkflowGraphNode, hooks?: BuildHarnessHooks, preloadedConfig?: LangflowerConfig, runMcpHandles?: readonly McpHandle[]) => Promise<ExecutionContext<never, LlmExecutionCaps>>;
 /**
@@ -24,5 +27,5 @@ export declare const buildExecutionContext: (context: ExecutionContextDeps, runI
  * which would put the Observable in value$ instead of error$.
  */
 export declare const applyObservableContextSeeds: (session: LangflowerSession, seeds: Readonly<Record<string, ReadonlyArray<RuntimeSeedPortValue>>>) => Record<string, ReadonlyArray<RuntimeSeedPortValue>>;
-export declare const buildContextSeeds: (session: LangflowerSession, context: ExecutionContextDeps, runId: string, emitPermissionAsk: (payload: RunnerPermissionAskPayload) => void) => Promise<Record<string, ReadonlyArray<RuntimeSeedPortValue>>>;
+export declare const buildContextSeeds: (session: LangflowerSession, context: ExecutionContextDeps, runId: string, emitPermissionAsk: (payload: RunnerPermissionAskPayload) => void, requestLangflowerBus?: LangflowerBusRequest, getLiveWiredTools?: (agentNodeId: string) => readonly ToolHandle[]) => Promise<Record<string, ReadonlyArray<RuntimeSeedPortValue>>>;
 export {};

package/vendor/server/dist/bridge/build-execution-context.js

@@ -28,6 +28,13 @@ const createToolHarness = (options) => {
             : {}),
     });
 };
+const LIVE_WIRED_TOOLS_NODE_TYPES = new Set([
+    'common-openai-llm',
+    'common-fake-llm',
+    'common-review',
+    'common-critique',
+    'common-sub-agent',
+]);
 export const buildExecutionContext = async (context, runId, node, hooks, preloadedConfig, runMcpHandles) => {
     const rolePreset = parseLlmRolePreset(node.params.rolePreset);
     const skillId = resolveEffectiveSkillId(rolePreset, node.params.skillId);
@@ -104,8 +111,28 @@ export const buildExecutionContext = async (context, runId, node, hooks, preload
         ...(config.harness?.allowedHosts !== undefined
             ? { allowedHosts: config.harness.allowedHosts }
             : {}),
+        ...(hooks?.requestLangflowerBus !== undefined &&
+            node.type === 'common-langflower-tools'
+            ? { requestLangflowerBus: hooks.requestLangflowerBus }
+            : {}),
+        ...(hooks?.getLiveWiredTools !== undefined &&
+            LIVE_WIRED_TOOLS_NODE_TYPES.has(node.type)
+            ? { getLiveWiredTools: hooks.getLiveWiredTools }
+            : {}),
     });
 };
+/** Host `contextSymbol` vs compiled-pack duplicate (`file://` / Vitest alias). */
+const contextPortLabel = String(contextSymbol);
+const resolveLiveContextPortId = (session, nodeId) => {
+    const node = session.runtime.editor.getNode(nodeId);
+    if (node === false || node.inputs[contextSymbol] !== undefined) {
+        return contextSymbol;
+    }
+    const match = Object.getOwnPropertySymbols(node.inputs).find((portId) => String(portId) === contextPortLabel);
+    return match ?? contextSymbol;
+};
+const isContextSeedPort = (portId) => portId === contextSymbol ||
+    (typeof portId === 'symbol' && String(portId) === contextPortLabel);
 const ctxErrorFromFailures = (failures) => ({
     message: failures.map((failure) => failure.message).join('\n'),
 });
@@ -119,9 +146,10 @@ export const applyObservableContextSeeds = (session, seeds) => {
     for (const [nodeId, list] of Object.entries(seeds)) {
         const kept = [];
         for (const seed of list) {
-            if (seed.portId === contextSymbol && isObservable(seed.value)) {
+            if (isContextSeedPort(seed.portId) && isObservable(seed.value)) {
                 const node = session.runtime.editor.getNode(nodeId);
-                const connection = node === false ? undefined : node.inputs[contextSymbol];
+                const portId = resolveLiveContextPortId(session, nodeId);
+                const connection = node === false ? undefined : node.inputs[portId];
                 if (connection !== undefined) {
                     connection.connect(seed.value);
                 }
@@ -135,7 +163,7 @@ export const applyObservableContextSeeds = (session, seeds) => {
     }
     return valueSeeds;
 };
-export const buildContextSeeds = async (session, context, runId, emitPermissionAsk) => {
+export const buildContextSeeds = async (session, context, runId, emitPermissionAsk, requestLangflowerBus, getLiveWiredTools) => {
     const workflow = session.activeWorkflow;
     if (workflow === null) {
         return {};
@@ -160,7 +188,7 @@ export const buildContextSeeds = async (session, context, runId, emitPermissionA
             const error = ctxErrorFromFailures(nodeFailures);
             seeds[node.id] = [
                 {
-                    portId: contextSymbol,
+                    portId: resolveLiveContextPortId(session, node.id),
                     slotIndex: 0,
                     value: throwError(() => error),
                 },
@@ -172,8 +200,20 @@ export const buildContextSeeds = async (session, context, runId, emitPermissionA
             nodeId: node.id,
             requestPermission: session.permissionAsks.requestPermission,
             emitPermissionAsk,
+            ...(requestLangflowerBus !== undefined
+                ? { requestLangflowerBus }
+                : {}),
+            ...(getLiveWiredTools !== undefined
+                ? { getLiveWiredTools }
+                : {}),
         }, config, runMcp?.handles);
-        seeds[node.id] = [{ portId: contextSymbol, slotIndex: 0, value: ctx }];
+        seeds[node.id] = [
+            {
+                portId: resolveLiveContextPortId(session, node.id),
+                slotIndex: 0,
+                value: ctx,
+            },
+        ];
     }
     return seeds;
 };

package/vendor/server/dist/bridge/forward-runner-event.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeRunnerEvent } from '@langflower/runtime';
+import { type RuntimeRunnerEvent } from '@langflower/runtime';
 import type { LangflowerBridge } from './langflower-bridge.types.js';
 /** Fan-out runner telemetry to every connected tab (session-shared). */
 export declare const forwardRunnerEvent: (bridge: LangflowerBridge, event: RuntimeRunnerEvent) => void;

package/vendor/server/dist/bridge/forward-runner-event.js

@@ -1,17 +1,12 @@
+import { isPortTelemetry, isRuntimeDone, } from '@langflower/runtime';
 import { bridgeEmit } from './bridge-outbound.js';
 /** Fan-out runner telemetry to every connected tab (session-shared). */
 export const forwardRunnerEvent = (bridge, event) => {
-    switch (event.kind) {
-        case 'output-emitted':
-            bridgeEmit(bridge, 'runner.output-emitted', event);
-            break;
-        case 'input-received':
-            bridgeEmit(bridge, 'runner.input-received', event);
-            break;
-        case 'done':
-            bridgeEmit(bridge, 'runner.done', event);
-            break;
-        default:
-            break;
+    if (isPortTelemetry(event)) {
+        bridgeEmit(bridge, 'runner.port', event);
+        return;
+    }
+    if (isRuntimeDone(event)) {
+        bridgeEmit(bridge, 'runner.done', event);
     }
 };

package/vendor/server/dist/bridge/get-live-wired-tools.d.ts

@@ -0,0 +1,12 @@
+import type { ToolHandle } from '@langflower/node-sdk';
+import type { LangflowerSession } from '../session/langflower-session.js';
+/**
+ * Activate current editor `tools` outputs (including post-swap instances)
+ * so a later inbound peek in {@link getLiveWiredTools} sees live handles.
+ */
+export declare const refreshLiveWiredToolPacks: (session: LangflowerSession) => void;
+/**
+ * Walk inbound `tools` edges on **current** editor instances (post-swap).
+ * Does not emit on the LLM tools port (ADR-016 session must not reset).
+ */
+export declare const getLiveWiredTools: (session: LangflowerSession, agentNodeId: string) => readonly ToolHandle[];

package/vendor/server/dist/bridge/get-live-wired-tools.js

@@ -0,0 +1,80 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isToolHandle = (value) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (typeof value.toolId === 'string' &&
+        typeof value.name === 'string' &&
+        typeof value.description === 'string' &&
+        typeof value.inputSchema === 'object' &&
+        value.inputSchema !== null &&
+        typeof value.invoke === 'function');
+};
+/** Flatten multi-wire values that may be single handles or arrays (packs). */
+const flattenToolHandles = (wired) => wired.flatMap((item) => {
+    if (Array.isArray(item)) {
+        return item.filter(isToolHandle);
+    }
+    if (isToolHandle(item)) {
+        return [item];
+    }
+    return [];
+});
+const resolveToolsOutput = (outputs, portId) => {
+    const direct = outputs[portId];
+    if (direct !== undefined) {
+        return direct;
+    }
+    return Object.values(outputs).find((port) => port.meta.portId === portId);
+};
+/**
+ * One-shot subscribe to activate a freshly swapped instance without
+ * connecting into the LLM `tools` input.
+ */
+const peekPortValue = (port) => {
+    let peeked;
+    const sub = port.value$.subscribe((value) => {
+        peeked = value;
+    });
+    sub.unsubscribe();
+    return peeked;
+};
+/**
+ * Activate current editor `tools` outputs (including post-swap instances)
+ * so a later inbound peek in {@link getLiveWiredTools} sees live handles.
+ */
+export const refreshLiveWiredToolPacks = (session) => {
+    for (const node of session.runtime.editor.getNodes()) {
+        const port = resolveToolsOutput(node.outputs, 'tools');
+        if (port !== undefined) {
+            peekPortValue(port);
+        }
+    }
+};
+/**
+ * Walk inbound `tools` edges on **current** editor instances (post-swap).
+ * Does not emit on the LLM tools port (ADR-016 session must not reset).
+ */
+export const getLiveWiredTools = (session, agentNodeId) => {
+    const editor = session.runtime.editor;
+    const inbound = editor
+        .getEdges()
+        .filter((edge) => String(edge.toNodeId) === agentNodeId &&
+        edge.toPort[0] === 'tools');
+    const packs = [];
+    for (const edge of inbound) {
+        const source = editor.getNode(edge.fromNodeId);
+        if (source === false) {
+            continue;
+        }
+        const port = resolveToolsOutput(source.outputs, edge.fromPort[0]);
+        if (port === undefined) {
+            continue;
+        }
+        const peeked = peekPortValue(port);
+        if (peeked !== undefined) {
+            packs.push(peeked);
+        }
+    }
+    return flattenToolHandles(packs);
+};

package/vendor/server/dist/bridge/langflower-tools-rpc.d.ts

@@ -0,0 +1,7 @@
+import type { LangflowerBusRequest } from '@langflower/common-nodes/ai/run-host-services';
+import type { LangflowerBridge } from './langflower-bridge.types.js';
+/**
+ * Wait-then-emit RPC (MCP `emitAction` shape) over the **server** bridge.
+ * Does not import `@langflower/mcp`.
+ */
+export declare const createLangflowerToolsRpc: (bridge: LangflowerBridge) => LangflowerBusRequest;

package/vendor/server/dist/bridge/langflower-tools-rpc.js

@@ -0,0 +1,29 @@
+import { waitBusEvent } from '@langflower/shared/langflower-ws-waits';
+/**
+ * In-process bus intents this pack may emit. Compile only for now.
+ * Later: `editor.addNode.requested`, `editor.removeNode.requested`,
+ * `editor.addEdge.requested`, `editor.removeEdge.requested`.
+ */
+const LANGFLOWER_TOOLS_INTENTS = ['customPalette.update.requested'];
+const isAllowedIntent = (intent) => LANGFLOWER_TOOLS_INTENTS.includes(intent);
+/**
+ * Wait-then-emit RPC (MCP `emitAction` shape) over the **server** bridge.
+ * Does not import `@langflower/mcp`.
+ */
+export const createLangflowerToolsRpc = (bridge) => {
+    return async (intent, payload) => {
+        if (!isAllowedIntent(intent)) {
+            throw new Error(`Langflower Tools does not allow intent: ${intent}`);
+        }
+        const resultPromise = waitBusEvent(bridge['customPalette.snapshot'], {
+            predicate: (snapshot) => snapshot.status !== 'compiling',
+        });
+        const body = payload !== null &&
+            typeof payload === 'object' &&
+            !Array.isArray(payload)
+            ? payload
+            : {};
+        bridge.injectInbound(intent, body, 'langflower-tools');
+        return resultPromise;
+    };
+};