langflower 0.0.8 → 0.0.10

package/vendor/runtime/dist/runtime.js

@@ -4,6 +4,7 @@ export { bypassOutputPortId, parseBypassOutputPortId } from './bypass-ports.js';
 export { RuntimeEditor } from './runtime-editor.js';
 export { graphHasCycle } from './runtime-helpers.js';
 export { RuntimeRunner } from './runtime-runner.js';
+export { isPortErrorTelemetry, isPortPendingTelemetry, isPortTelemetry, isPortValueTelemetry, isRuntimeDone, } from './types.js';
 export class RuntimeFacade {
     editor;
     runner;

package/vendor/runtime/dist/testing/workflows/workflow-events.d.ts

@@ -1,20 +1,24 @@
+import { type EdgeId, type PortTelemetry, type RunId, type RuntimeEdge, type RuntimeRunnerEvent } from '../../types.js';
 import { RuntimeEditor } from '../../runtime-editor.js';
 import { RuntimeRunner } from '../../runtime-runner.js';
 import { type RuntimeOptions } from '../../runtime.js';
-import type { RunId, RuntimeEdge, RuntimeRunnerEvent } from '../../types.js';
 export type RuntimeHarness = {
     readonly editor: RuntimeEditor;
     readonly runner: RuntimeRunner;
 };
 export declare function createRuntimeHarness(options?: RuntimeOptions): RuntimeHarness;
 export declare function wireEdge(editor: RuntimeEditor, edge: Omit<RuntimeEdge, 'edgeId'>): void;
-export type OutputEmittedEvent = Extract<RuntimeRunnerEvent, {
-    kind: 'output-emitted';
-}>;
-export declare function outputValues(events: readonly RuntimeRunnerEvent[], nodeId: string, portId: string, runId?: string): unknown[];
-export declare function waitForOutput(runtime: RuntimeRunner | RuntimeHarness, nodeId: string, portId: string, runId?: string): Promise<OutputEmittedEvent>;
+export type OutputEmittedEvent = PortTelemetry & {
+    readonly 0: 'out';
+};
+export declare function outputValues(events: readonly RuntimeRunnerEvent[], nodeId: string, portId: string, _runId?: string): unknown[];
+export declare function waitForOutput(runtime: RuntimeRunner | RuntimeHarness, nodeId: string, portId: string, _runId?: string): Promise<OutputEmittedEvent>;
 export declare function runAndCollectEvents(runtime: RuntimeRunner | RuntimeHarness, startRun: () => string, settleMs?: number): Promise<{
     readonly runId: string;
     readonly events: readonly RuntimeRunnerEvent[];
 }>;
 export declare function noDoneWithin(runtime: RuntimeRunner | RuntimeHarness, ms: number, runId?: RunId): Promise<boolean>;
+export declare const edgeIdsFromPortEvent: (event: PortTelemetry) => readonly EdgeId[];
+export declare const portDirLabel: (event: PortTelemetry) => "input-received" | "output-emitted";
+export declare const dtoHas: (dtos: readonly unknown[], key: "pending" | "value" | "error" | "inactive") => boolean;
+export declare const dtoIndex: (dtos: readonly unknown[], key: "pending" | "value" | "error" | "inactive") => number;

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

@@ -1,4 +1,5 @@
 import { filter, firstValueFrom } from 'rxjs';
+import { isPortValueTelemetry, 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) => isPortValueTelemetry(event) && event[0] === 'out';
+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[3].value);
 }
-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[3].value))));
 }
 export async function runAndCollectEvents(runtime, startRun, settleMs = 50) {
     const events = [];
@@ -52,26 +49,19 @@ 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[5];
+export const portDirLabel = (event) => event[0] === 'out' ? 'output-emitted' : 'input-received';
+export const dtoHas = (dtos, key) => dtos.some((dto) => typeof dto === 'object' && dto !== null && key in dto);
+export const dtoIndex = (dtos, key) => dtos.findIndex((dto) => typeof dto === 'object' && dto !== null && key in dto);

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

@@ -1,4 +1,4 @@
-import type { StatefulConnection, StatefulObservable } from '@rx-evo/stateful-observable';
+import type { ResponseDto, StatefulConnection, StatefulObservable } from '@rx-evo/stateful-observable';
 import type { Observable } from 'rxjs';
 import type { GraphCluster } from './runtime-helpers.js';
 export type RuntimeWireType = string & {
@@ -83,7 +83,7 @@ export type MetaFromStatefulObservable<T extends StatefulObservable<unknown, unk
  *
  * ## Errors
  * Node handlers surface failures via RxJS / `StatefulObservable` (`catchError`,
- * port `error$`). Runner telemetry emits `output-emitted` with `state: 'error'`
+ * port `error$`). Runner telemetry emits `ResponseDto` `{ error }`
  * on the source; wiring then drops `ResponseError` so edges do not cascade
  * error chrome to downstream nodes.
  *
@@ -118,45 +118,41 @@ export type MetaFromStatefulObservable<T extends StatefulObservable<unknown, unk
  * optional {@link RuntimeNode.stopsRun} completion.
  */
 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;
+/**
+ * Port signal tuple — `portDir` `'out'` = output emitted, `'in'` = input received.
+ * Slot 3 is `@rx-evo` {@link ResponseDto} (JSON-safe pending / inactive / error /
+ * value). No per-frame `runId`; session snapshots own run correlation.
+ */
+export type PortTelemetry = readonly [
+    portDir: 'in' | 'out',
+    nodeId: NodeId,
+    portId: string,
+    response: ResponseDto<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 isPortValueTelemetry: (event: RuntimeRunnerEvent) => event is PortTelemetry & {
+    readonly 3: Extract<ResponseDto<unknown>, {
+        value: unknown;
+    }>;
 };
-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 declare const isPortErrorTelemetry: (event: RuntimeRunnerEvent) => event is PortTelemetry & {
+    readonly 3: Extract<ResponseDto<unknown>, {
+        error: unknown;
+    }>;
 };
-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;
+export declare const isPortPendingTelemetry: (event: RuntimeRunnerEvent) => event is PortTelemetry & {
+    readonly 3: {
+        readonly pending: true;
+    };
 };
+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 +251,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 +288,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
@@ -314,7 +323,9 @@ export type RuntimeEditorApi = {
 export type RuntimeRunnerApi = {
     /**
      * Wire every cluster that does not contain a {@link RuntimeNode.chatEntry}
-     * node, seed source inputs, set status to `'running'`.
+     * node. Assigns `runId` and sets `'running'` **synchronously**, then wires
+     * ports on a microtask so callers (WS `runner.started`) can fence before
+     * any `runner.port` telemetry.
      *
      * Chat-entry clusters are omitted — start them via
      * {@link RuntimeRunnerApi.pushIntoInput}. When every cluster is chat-entry
@@ -331,7 +342,8 @@ export type RuntimeRunnerApi = {
     start(initialPayload?: Readonly<Record<string, ReadonlyArray<RuntimeSeedPortValue>>>, runId?: RunId): RunId | false;
     /**
      * Run-from-node: wire the weakly connected cluster containing `nodeId`
-     * (orphan nodes elsewhere on the canvas are not wired).
+     * (orphan nodes elsewhere on the canvas are not wired). Same runId /
+     * `'running'` sync + microtask wiring as {@link RuntimeRunnerApi.start}.
      *
      * Run stays `'running'` until {@link RuntimeRunnerApi.interrupt} or a
      * {@link RuntimeNode.stopsRun} node in scope emits.

package/vendor/runtime/dist/types.js

@@ -1 +1,5 @@
-export {};
+export const isPortTelemetry = (event) => Array.isArray(event) && (event[0] === 'in' || event[0] === 'out');
+export const isPortValueTelemetry = (event) => isPortTelemetry(event) && 'value' in event[3];
+export const isPortErrorTelemetry = (event) => isPortTelemetry(event) && 'error' in event[3];
+export const isPortPendingTelemetry = (event) => isPortTelemetry(event) && 'pending' in event[3];
+export const isRuntimeDone = (event) => Array.isArray(event) && event[0] === 'done';

package/vendor/runtime/package.json

@@ -15,7 +15,7 @@
 		}
 	},
 	"dependencies": {
-		"@rx-evo/stateful-observable": "^0.5.2",
+		"@rx-evo/stateful-observable": "^0.6.0",
 		"rxjs": "^7.8.1"
 	},
 	"files": [

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);
@@ -66,8 +73,9 @@ export const buildExecutionContext = async (context, runId, node, hooks, preload
         webFetch,
     };
     const enabledToolIds = toolPermissionsToEnabledIds(toolPermissions);
-    const toolHandles = wrapBuiltinToolHandles(harness, enabledToolIds, permission);
-    const mcpHandles = filterMcpHandlesByIds(runMcpHandles ?? [], parseEnabledMcpIds(node.params.enabledMcpIds));
+    const builtinHandles = wrapBuiltinToolHandles(harness, enabledToolIds, permission);
+    const mcpTools = filterMcpHandlesByIds(runMcpHandles ?? [], parseEnabledMcpIds(node.params.enabledMcpIds)).flatMap((handle) => handle.tools);
+    const toolHandles = [...builtinHandles, ...mcpTools];
     const base = {
         projectDir: context.projectDir,
         runId,
@@ -78,7 +86,6 @@ export const buildExecutionContext = async (context, runId, node, hooks, preload
             params: node.params,
         })?.uiSchema ?? []),
         ...(toolHandles.length > 0 ? { toolHandles } : {}),
-        ...(mcpHandles.length > 0 ? { mcpHandles } : {}),
     };
     const defaultChat = parseDefaultChatModel(config.model);
     return attachRunHostServices(base, {
@@ -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);
     }
 };