langflower 0.0.9 → 0.0.10

package/vendor/runtime/dist/runtime-runner.js

@@ -1,60 +1,24 @@
-import { combineStatefulObservables, isError, isInactive, isLoading, isSuccess, statefulObservable, } from '@rx-evo/stateful-observable';
+import { combineStatefulObservables, serializeResponse, statefulObservable, } from '@rx-evo/stateful-observable';
 import { BehaviorSubject, filter, merge, of, Subject, Subscription, tap, zip, } from 'rxjs';
 import { checkpointPortIdForSlot, getBypassConnection, isBypassPort, } from './bypass-ports.js';
 import { normalizePortErrorValue } from './normalize-port-error-value.js';
 import { edgePortSlotKey, parseSlotKey, slotKey, } from './port-meta.js';
 import { clusterHasChatEntry, collectClusterSlotKeys, } from './runtime-helpers.js';
+const toResponseDto = (response) => {
+    if (response === null || response === undefined) {
+        return null;
+    }
+    return serializeResponse(response);
+};
 const isConnectionInactive = (connection) => {
     let inactive = true;
     const sub = connection.raw$.subscribe((raw) => {
-        // Same dual-package Symbol hazard as loading (BUG-2026-07-23 /
-        // ADR-028): CJS `isInactive` can miss an ESM inactive sentinel.
-        inactive = isInactive(raw) || isSymbolStateSentinel(raw);
+        const dto = toResponseDto(raw);
+        inactive = dto === null || 'inactive' in dto;
     });
     sub.unsubscribe();
     return inactive;
 };
-/**
- * `@rx-evo` status sentinels are `{ state: Symbol(...) }` (loading / inactive).
- * When the sentinel is created by a different module instance than the
- * `isLoading` / `isInactive` guards (CJS/ESM dual-package hazard), identity
- * checks fail and `isSuccess` may return true — telemetry then emits
- * `state:'value'` with that object (JSON → `{}`), or `applyPortDefaults`
- * skips seeding and LLM `combineInputs` stalls.
- */
-const isSymbolStateSentinel = (signal) => {
-    if (typeof signal !== 'object' ||
-        signal === null ||
-        Array.isArray(signal)) {
-        return false;
-    }
-    const keys = Object.keys(signal);
-    if (keys.length !== 1 || keys[0] !== 'state') {
-        return false;
-    }
-    const state = signal.state;
-    return typeof state === 'symbol';
-};
-const resolveSignalState = (response) => {
-    const signal = response;
-    if (isError(signal)) {
-        return {
-            state: 'error',
-            value: normalizePortErrorValue(signal.error),
-        };
-    }
-    if (isLoading(signal) || isSymbolStateSentinel(signal)) {
-        return { state: 'pending', value: undefined };
-    }
-    if (isSuccess(signal)) {
-        return { state: 'value', value: signal };
-    }
-    return null;
-};
-/** Drop errors and loading so edges only carry success values. */
-const isEdgeForwardable = (response) => !isError(response) &&
-    !isLoading(response) &&
-    !isSymbolStateSentinel(response);
 export class RuntimeRunner {
     editor;
     static EMPTY_EVENT_LOG = [];
@@ -63,6 +27,8 @@ export class RuntimeRunner {
     logEvents;
     eventLogBuffer = [];
     activeRun;
+    pendingWireRunId;
+    pendingWire;
     disposed = false;
     status$ = this.statusSubject.asObservable();
     /** Synchronous snapshot of {@link status$}. */
@@ -143,6 +109,7 @@ export class RuntimeRunner {
             this.finishRun(resolvedRunId);
             return resolvedRunId;
         }
+        this.assertResumeOutputSnapshots(completedNodeIds, outputSnapshots);
         return this.runScope(new Set(nodes.map((node) => node.nodeId)), new Set(edges.map((edge) => edge.edgeId)), options.initialPayload, resolvedRunId, {
             completedNodeIds,
             outputSnapshots,
@@ -169,6 +136,7 @@ export class RuntimeRunner {
             return false;
         }
         const runId = this.runScope(cluster.nodeIds, cluster.edgeIds);
+        this.flushPendingWire();
         const pushedRunId = this.pushIntoActiveRun(cfg);
         if (pushedRunId === false) {
             this.interrupt('cancel');
@@ -181,6 +149,7 @@ export class RuntimeRunner {
         if (this.statusSubject.value !== 'running') {
             return;
         }
+        this.cancelPendingWire();
         this.teardownRun();
         this.setStatus('stopped');
     }
@@ -206,6 +175,7 @@ export class RuntimeRunner {
             return;
         }
         if (this.statusSubject.value === 'running') {
+            this.cancelPendingWire();
             this.teardownRun();
         }
         this.disposed = true;
@@ -239,18 +209,26 @@ export class RuntimeRunner {
         }
         this.eventsSubject.next(event);
     }
-    emitPortEvent(_runId, portDir, nodeId, portId, portIdx, state, value, edgeIds, feed) {
+    emitPortEvent(_runId, portDir, nodeId, portId, portIdx, raw, edgeIds, defaultFeed) {
+        const dto = toResponseDto(raw);
+        if (dto === null) {
+            return false;
+        }
+        const response = 'error' in dto
+            ? { error: normalizePortErrorValue(dto.error) }
+            : dto;
+        const feed = defaultFeed ?? null;
         const portIdStr = typeof portId === 'string' ? portId : String(portId);
         this.emitRunnerEvent([
             portDir,
             nodeId,
             portIdStr,
-            state,
-            value,
+            response,
             portIdx,
             edgeIds,
-            feed ?? null,
+            feed,
         ]);
+        return 'value' in response;
     }
     canPreparePushedInput(node, portId) {
         const connection = node.inputs[portId];
@@ -268,6 +246,7 @@ export class RuntimeRunner {
             edge.toPort[1] === 0);
     }
     pushIntoActiveRun(cfg) {
+        this.flushPendingWire();
         const run = this.activeRun;
         if (run === undefined || !run.scopeNodeIds.has(cfg.nodeId)) {
             return false;
@@ -281,7 +260,7 @@ export class RuntimeRunner {
         if (existing !== undefined) {
             // Telemetry before deliver so HITL input-received precedes cascade
             // (output-emitted / downstream input-received) in the event log.
-            this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, 'value', cfg.payload, []);
+            this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, cfg.payload, []);
             existing.source.next(cfg.payload);
             return run.runId;
         }
@@ -300,15 +279,15 @@ export class RuntimeRunner {
             connection,
         });
         run.pushedInputSources.set(key, { source });
-        this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, 'value', cfg.payload, []);
+        this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, cfg.payload, []);
         source.next(cfg.payload);
         return run.runId;
     }
     /**
      * Returns `output` wrapped with a `tap` that emits `output-emitted`
-     * telemetry, then `filter(isEdgeForwardable)` so `ResponseError` and
-     * loading sentinels stay visible to Observability on the source node but
-     * are not forwarded on edges (loading must not appear as `{}` downstream).
+     * telemetry, then forward only success values on edges so errors and
+     * loading sentinels stay visible on the source node (loading must not
+     * appear as `{}` downstream).
      * The wrapper is the value the downstream connects to, so the event fires
      * *as part of* the dataflow delivery — there is no separate refCounted
      * subscriber, which is what previously reordered events against downstream
@@ -322,12 +301,8 @@ export class RuntimeRunner {
         return output
             .pipe(tap({
             next: (response) => {
-                const resolved = resolveSignalState(response);
-                if (resolved === null) {
-                    return;
-                }
-                this.emitPortEvent(run.runId, 'out', nodeId, portId, 0, resolved.state, resolved.value, edgeIds, output.meta.feed);
-                if (resolved.state === 'value' &&
+                const emittedValue = this.emitPortEvent(run.runId, 'out', nodeId, portId, 0, response, edgeIds, output.meta.feed);
+                if (emittedValue &&
                     node !== false &&
                     node.stopsRun === true) {
                     const finishRunId = run.runId;
@@ -338,7 +313,10 @@ export class RuntimeRunner {
                     });
                 }
             },
-        }), filter(isEdgeForwardable))
+        }), filter((response) => {
+            const dto = toResponseDto(response);
+            return dto !== null && 'value' in dto;
+        }))
             .with({ meta: output.meta });
     }
     /**
@@ -353,11 +331,7 @@ export class RuntimeRunner {
         return source
             .pipe(tap({
             next: (response) => {
-                const resolved = resolveSignalState(response);
-                if (resolved === null) {
-                    return;
-                }
-                this.emitPortEvent(run.runId, 'in', nodeId, portId, slotIndex, resolved.state, resolved.value, edgeIds);
+                this.emitPortEvent(run.runId, 'in', nodeId, portId, slotIndex, response, edgeIds);
             },
         }))
             .with({ meta: source.meta });
@@ -373,25 +347,76 @@ export class RuntimeRunner {
         this.setStatus('idle');
         this.teardownRun();
     }
+    assertResumeOutputSnapshots(completedNodeIds, outputSnapshots) {
+        const nodesById = new Map(this.editor.getNodes().map((node) => [node.nodeId, node]));
+        for (const edge of this.editor.getEdges()) {
+            if (!completedNodeIds.has(edge.fromNodeId) ||
+                completedNodeIds.has(edge.toNodeId)) {
+                continue;
+            }
+            const fromNode = nodesById.get(edge.fromNodeId);
+            if (fromNode === undefined) {
+                continue;
+            }
+            const [fromPortId, fromSlotIndex] = edge.fromPort;
+            const snapshotPortId = checkpointPortIdForSlot(fromNode, fromPortId, fromSlotIndex);
+            const snapshotValue = outputSnapshots
+                .get(edge.fromNodeId)
+                ?.get(snapshotPortId);
+            if (snapshotValue === undefined) {
+                throw new Error(`Resume missing output snapshot for ${edge.fromNodeId}.${fromPortId}`);
+            }
+        }
+    }
+    cancelPendingWire() {
+        this.pendingWire = undefined;
+        this.pendingWireRunId = undefined;
+    }
+    flushPendingWire() {
+        const wire = this.pendingWire;
+        if (wire === undefined) {
+            return;
+        }
+        this.pendingWire = undefined;
+        this.pendingWireRunId = undefined;
+        wire();
+    }
     runScope(scopeNodeIds, scopeEdgeIds, initialPayload, runId, resumeOverlay) {
         this.assertNotDisposed();
         if (this.statusSubject.value === 'running') {
             return false;
         }
         const resolvedRunId = runId ?? crypto.randomUUID();
-        this.editor.setLocked(true);
-        try {
-            this.activeRun = this.wireScope(resolvedRunId, scopeEdgeIds, scopeNodeIds, initialPayload, resumeOverlay);
-        }
-        catch (error) {
-            this.editor.setLocked(false);
-            throw error;
-        }
         this.setStatus('running');
+        this.editor.setLocked(true);
+        this.pendingWireRunId = resolvedRunId;
+        this.pendingWire = () => {
+            try {
+                this.activeRun = this.wireScope(resolvedRunId, scopeEdgeIds, scopeNodeIds, initialPayload, resumeOverlay);
+            }
+            catch (error) {
+                this.editor.setLocked(false);
+                this.setStatus('idle');
+                throw error;
+            }
+        };
+        queueMicrotask(() => {
+            if (this.pendingWireRunId !== resolvedRunId) {
+                return;
+            }
+            try {
+                this.flushPendingWire();
+            }
+            catch {
+                // Status/lock already restored in pendingWire.
+            }
+        });
         return resolvedRunId;
     }
     teardownRun() {
+        this.cancelPendingWire();
         if (this.activeRun === undefined) {
+            this.editor.setLocked(false);
             return;
         }
         for (const wired of this.activeRun.wiredSlots) {
@@ -429,7 +454,7 @@ export class RuntimeRunner {
                 connection.connect(of(seed.value).pipe(tap({
                     next: (value) => {
                         if (typeof seed.portId !== 'symbol') {
-                            this.emitPortEvent(runId, 'in', nodeId, seed.portId, seed.slotIndex, 'value', value, []);
+                            this.emitPortEvent(runId, 'in', nodeId, seed.portId, seed.slotIndex, value, []);
                         }
                     },
                 })));
@@ -467,7 +492,7 @@ export class RuntimeRunner {
                 }
                 connection.connect(of(defaultValue).pipe(tap({
                     next: (value) => {
-                        this.emitPortEvent(runId, 'in', nodeId, portId, 0, 'value', value, []);
+                        this.emitPortEvent(runId, 'in', nodeId, portId, 0, value, []);
                     },
                 })));
                 wiredSlotKeys.add(key);
@@ -701,11 +726,7 @@ export class RuntimeRunner {
                         }).with({ meta });
             group.connection.connect(combined.pipe(tap({
                 next: (response) => {
-                    const resolved = resolveSignalState(response);
-                    if (resolved === null) {
-                        return;
-                    }
-                    this.emitPortEvent(run.runId, 'in', group.nodeId, group.portId, 0, resolved.state, resolved.value, group.edges.map((entry) => entry.edge.edgeId));
+                    this.emitPortEvent(run.runId, 'in', group.nodeId, group.portId, 0, response, group.edges.map((entry) => entry.edge.edgeId));
                 },
             })));
             wiredSlots.push({

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

@@ -6,9 +6,10 @@ export { RuntimeEditor } from './runtime-editor.js';
 export { graphHasCycle } from './runtime-helpers.js';
 export type { GraphCluster } from './runtime-helpers.js';
 export { RuntimeRunner } from './runtime-runner.js';
-export type { MetaFromStatefulObservable, NodeId, EdgeId, RunId, PortMeta, RuntimeEdge, RuntimeEditorApi, RuntimeFeedPortMeta, RuntimeFeedRole, PortTelemetry, RuntimeDoneTelemetry, RuntimeNode, RuntimePortSignalState, RuntimeResumeOptions, RuntimeRunnerApi, RuntimeRunnerEvent, RuntimeRunnerStatus, RuntimeSeedPortValue, RuntimeWireType, SwapNodeResult, } from './types.js';
-export { isPortTelemetry, isRuntimeDone } from './types.js';
+export type { MetaFromStatefulObservable, NodeId, EdgeId, RunId, PortMeta, RuntimeEdge, RuntimeEditorApi, RuntimeFeedPortMeta, RuntimeFeedRole, PortTelemetry, RuntimeDoneTelemetry, RuntimeNode, RuntimeResumeOptions, RuntimeRunnerApi, RuntimeRunnerEvent, RuntimeRunnerStatus, RuntimeSeedPortValue, RuntimeWireType, SwapNodeResult, } from './types.js';
+export { isPortErrorTelemetry, isPortPendingTelemetry, isPortTelemetry, isPortValueTelemetry, isRuntimeDone, } from './types.js';
 export type { RuntimeOptions };
+export type { ResponseDto } from '@rx-evo/stateful-observable';
 export declare class RuntimeFacade {
     readonly editor: RuntimeEditor;
     readonly runner: RuntimeRunner;

package/vendor/runtime/dist/runtime.js

@@ -4,7 +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 { isPortTelemetry, isRuntimeDone } from './types.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

@@ -20,3 +20,5 @@ export declare function runAndCollectEvents(runtime: RuntimeRunner | RuntimeHarn
 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,5 +1,5 @@
 import { filter, firstValueFrom } from 'rxjs';
-import { isPortTelemetry, isRuntimeDone, } from '../../types.js';
+import { isPortValueTelemetry, isRuntimeDone, } from '../../types.js';
 import { RuntimeEditor } from '../../runtime-editor.js';
 import { RuntimeRunner } from '../../runtime-runner.js';
 export function createRuntimeHarness(options) {
@@ -18,13 +18,13 @@ export function wireEdge(editor, edge) {
         throw new Error(`Failed to wire ${edge.fromNodeId}.${edge.fromPort[0]} → ${edge.toNodeId}.${edge.toPort[0]}`);
     }
 }
-const isOutputValue = (event) => isPortTelemetry(event) && event[0] === 'out' && event[3] === 'value';
+const isOutputValue = (event) => isPortValueTelemetry(event) && event[0] === 'out';
 export function outputValues(events, nodeId, portId, _runId) {
     return events
         .filter((event) => isOutputValue(event) &&
         event[1] === nodeId &&
         event[2] === portId)
-        .map((event) => event[4]);
+        .map((event) => event[3].value);
 }
 export async function waitForOutput(runtime, nodeId, portId, _runId) {
     return waitForOutputMatching(runtime, nodeId, portId, () => true, _runId);
@@ -34,7 +34,7 @@ async function waitForOutputMatching(runtime, nodeId, portId, predicate, _runId)
     return firstValueFrom(runner.events$.pipe(filter((event) => isOutputValue(event) &&
         event[1] === nodeId &&
         event[2] === portId &&
-        predicate(event[4]))));
+        predicate(event[3].value))));
 }
 export async function runAndCollectEvents(runtime, startRun, settleMs = 50) {
     const events = [];
@@ -61,5 +61,7 @@ export async function noDoneWithin(runtime, ms, runId) {
     ]);
     return result === 'timeout';
 }
-export const edgeIdsFromPortEvent = (event) => event[6];
+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,17 +118,16 @@ 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';
 /**
  * Port signal tuple — `portDir` `'out'` = output emitted, `'in'` = input received.
- * No per-frame `runId`; session snapshots own run correlation.
+ * 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,
-    state: RuntimePortSignalState,
-    value: unknown,
+    response: ResponseDto<unknown>,
     portIdx: number,
     edgeIds: readonly EdgeId[],
     /** Absent feed meta — use `null` (never `undefined`; JSON arrays drop undefined). */
@@ -138,6 +137,21 @@ export type PortTelemetry = readonly [
 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 declare const isPortErrorTelemetry: (event: RuntimeRunnerEvent) => event is PortTelemetry & {
+    readonly 3: Extract<ResponseDto<unknown>, {
+        error: unknown;
+    }>;
+};
+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 = {
@@ -309,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
@@ -326,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,2 +1,5 @@
 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/build-execution-context.js

@@ -73,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,
@@ -85,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, {

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

@@ -1,8 +1,9 @@
 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.
+ * Activate current editor `tools` / `subagent-registration` outputs
+ * (including post-swap instances) so a later inbound peek in
+ * {@link getLiveWiredTools} sees live handles.
  */
 export declare const refreshLiveWiredToolPacks: (session: LangflowerSession) => void;
 /**

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

@@ -40,14 +40,17 @@ const peekPortValue = (port) => {
     return peeked;
 };
 /**
- * Activate current editor `tools` outputs (including post-swap instances)
- * so a later inbound peek in {@link getLiveWiredTools} sees live handles.
+ * Activate current editor `tools` / `subagent-registration` 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);
+        for (const portId of ['tools', 'subagent-registration']) {
+            const port = resolveToolsOutput(node.outputs, portId);
+            if (port !== undefined) {
+                peekPortValue(port);
+            }
         }
     }
 };

package/vendor/server/dist/bridge/wire-runner-handlers.js

@@ -3,6 +3,7 @@ import { buildWorkflowFingerprint, } from '@langflower/shared/langflower.js';
 import { Subscription } from 'rxjs';
 import { listResumableCheckpoints } from '../checkpoint/list-resumable-checkpoints.js';
 import { resolveCheckpointBoundary } from '../checkpoint/resolve-checkpoint-boundary.js';
+import { resetSessionExecutionFeed } from '../session/reset-session-execution-feed.js';
 import { buildContextSeeds, applyObservableContextSeeds, } from './build-execution-context.js';
 import { getLiveWiredTools } from './get-live-wired-tools.js';
 import { createLangflowerToolsRpc } from './langflower-tools-rpc.js';
@@ -293,8 +294,7 @@ export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
         if (session.runnerStatus === 'running') {
             return;
         }
-        session.runtime.runner.clearEventLog();
-        session.runId = undefined;
+        resetSessionExecutionFeed(session);
         // Re-broadcast the (now empty) feed to every tab.
         bridgeEmit(bridge, 'executionFeed.snapshot', session.buildExecutionFeed());
     }));