langflower 0.0.8 → 0.0.10

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

@@ -0,0 +1,13 @@
+import type { ToolHandle } from '@langflower/node-sdk';
+import type { LangflowerSession } from '../session/langflower-session.js';
+/**
+ * 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;
+/**
+ * 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,83 @@
+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` / `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()) {
+        for (const portId of ['tools', 'subagent-registration']) {
+            const port = resolveToolsOutput(node.outputs, portId);
+            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;
+    };
+};

package/vendor/server/dist/bridge/wire-custom-palette-handlers.d.ts

@@ -1,4 +1,5 @@
 import type { Subscription } from 'rxjs';
 import type { ServerContext } from '../server-context.js';
+import type { LangflowerSession } from '../session/langflower-session.js';
 import type { LangflowerBridge } from './langflower-bridge.types.js';
-export declare const wireCustomPaletteHandlers: (bridge: LangflowerBridge, context: ServerContext) => Subscription;
+export declare const wireCustomPaletteHandlers: (bridge: LangflowerBridge, context: ServerContext, session: LangflowerSession) => Subscription;

package/vendor/server/dist/bridge/wire-custom-palette-handlers.js

@@ -1,10 +1,8 @@
-import { bridgeEmit } from './bridge-outbound.js';
+import { compileAndHotSwapCustomNodes } from '../palette/compile-and-hot-swap-custom-nodes.js';
 import { isInboundEvent } from './inbound-guards.js';
-export const wireCustomPaletteHandlers = (bridge, context) => bridge['customPalette.update.requested'].subscribe(async (raw) => {
+export const wireCustomPaletteHandlers = (bridge, context, session) => bridge['customPalette.update.requested'].subscribe(async (raw) => {
     if (!isInboundEvent(raw)) {
         return;
     }
-    bridgeEmit(bridge, 'customPalette.snapshot', context.customPaletteService.compilingSnapshot());
-    const snapshot = await context.customPaletteService.update(context.projectDir);
-    bridgeEmit(bridge, 'customPalette.snapshot', snapshot);
+    await compileAndHotSwapCustomNodes(session, context, bridge);
 });

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

@@ -1,8 +1,12 @@
+import { isPortTelemetry, isRuntimeDone, } from '@langflower/runtime';
 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';
 import { bridgeEmit, clientEmit } from './bridge-outbound.js';
 import { findClientById } from './client-index.js';
 import { isInboundEvent } from './inbound-guards.js';
@@ -35,11 +39,15 @@ export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
     const emitPermissionAsk = (payload) => {
         bridgeEmit(bridge, 'runner.permission.ask', payload);
     };
+    const requestLangflowerBus = createLangflowerToolsRpc(bridge);
+    const liveWiredTools = (agentNodeId) => getLiveWiredTools(session, agentNodeId);
     subscription.add(session.runtime.runner.events$.subscribe((event) => {
-        const boundary = event.kind === 'output-emitted' &&
-            typeof event.portId === 'string' &&
+        const [, nodeId, portId] = isPortTelemetry(event) ? event : [];
+        const boundary = isPortTelemetry(event) &&
+            event[0] === 'out' &&
+            typeof portId === 'string' &&
             session.activeWorkflow !== null
-            ? resolveCheckpointBoundary(session.activeWorkflow, String(event.nodeId), event.portId)
+            ? resolveCheckpointBoundary(session.activeWorkflow, String(nodeId), portId)
             : undefined;
         const shouldPersist = checkpoints.observe(event, boundary === undefined
             ? undefined
@@ -57,7 +65,7 @@ export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
             })
                 .catch(() => undefined);
         }
-        if (event.kind === 'done') {
+        if (isRuntimeDone(event)) {
             void checkpoints
                 .markCompleted()
                 .then(async (summary) => {
@@ -83,7 +91,7 @@ export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
                 crypto.randomUUID());
             // Lock before async seed build so workflow load cannot race in.
             session.runnerStatus = 'running';
-            const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, resolvedRunId, emitPermissionAsk));
+            const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, resolvedRunId, emitPermissionAsk, requestLangflowerBus, liveWiredTools));
             const initialPayload = mergeSeeds(contextSeeds, clientInitialPayload);
             if (session.activeWorkflow !== null) {
                 checkpoints.beginRun(resolvedRunId, session.activeWorkflow);
@@ -111,7 +119,7 @@ export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
             const resolvedRunId = (clientRunId ??
                 crypto.randomUUID());
             session.runnerStatus = 'running';
-            const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, resolvedRunId, emitPermissionAsk));
+            const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, resolvedRunId, emitPermissionAsk, requestLangflowerBus, liveWiredTools));
             const initialPayload = mergeSeeds(contextSeeds, clientInitialPayload);
             if (session.activeWorkflow !== null) {
                 checkpoints.beginRun(resolvedRunId, session.activeWorkflow);
@@ -196,7 +204,7 @@ export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
                 return;
             }
             session.runnerStatus = 'running';
-            const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, checkpoint.runId, emitPermissionAsk));
+            const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, checkpoint.runId, emitPermissionAsk, requestLangflowerBus, liveWiredTools));
             checkpoints.hydrateFromCheckpoint(checkpoint, workflow);
             const resumeOptions = checkpoints.resumeOptionsFromCheckpoint(checkpoint);
             const resumed = session.runtime.runner.resume({
@@ -249,7 +257,7 @@ export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
             if (wasIdle) {
                 const resolvedRunId = crypto.randomUUID();
                 session.runnerStatus = 'running';
-                const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, resolvedRunId, emitPermissionAsk));
+                const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, resolvedRunId, emitPermissionAsk, requestLangflowerBus, liveWiredTools));
                 if (session.activeWorkflow !== null) {
                     checkpoints.beginRun(resolvedRunId, session.activeWorkflow);
                 }
@@ -286,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());
     }));

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

@@ -1,6 +1,7 @@
 import { Subscription } from 'rxjs';
 import { listResumableCheckpoints } from '../checkpoint/list-resumable-checkpoints.js';
 import { WorkflowCheckpointStore } from '../checkpoint/workflow-checkpoint-store.js';
+import { resetSessionExecutionFeed } from '../session/reset-session-execution-feed.js';
 import { buildSaveCurrentPayload } from '../workflow/build-save-current-payload.js';
 import { copyWorkflowToSession } from '../workflow/copy-workflow-to-session.js';
 import { createEmptyWorkflowInSession } from '../workflow/create-empty-workflow-in-session.js';
@@ -10,11 +11,17 @@ import { bridgeEmit, clientEmit } from './bridge-outbound.js';
 import { findClientById } from './client-index.js';
 import { isInboundEvent } from './inbound-guards.js';
 /**
- * Composer: clear selection → current snapshot → optional catalog sync.
- * Sibling steps — handlers do not call these in nested order themselves.
+ * Composer: optional feed reset → clear selection → current snapshot →
+ * optional catalog sync. Sibling steps — handlers do not nest these.
  */
 const syncAfterWorkflowMutation = async (bridge, context, session, client, options) => {
-    // 1. Clear selection (and notify tabs if it was set)
+    // 1. Document switch: empty feed before the new catalog so the UI never
+    // paints the previous run under the next workflow's nodes.
+    if (options.resetFeed === true) {
+        resetSessionExecutionFeed(session);
+        bridgeEmit(bridge, 'executionFeed.snapshot', session.buildExecutionFeed());
+    }
+    // 2. Clear selection (and notify tabs if it was set)
     if (options.clearSelection) {
         const hadSelection = session.selectedNodeId !== null;
         session.selectedNodeId = null;
@@ -22,19 +29,19 @@ const syncAfterWorkflowMutation = async (bridge, context, session, client, optio
             bridgeEmit(bridge, 'editor.nodeSelected', { node: null });
         }
     }
-    // 2. Authoritative current-workflow slice (session-shared — fan out)
+    // 3. Authoritative current-workflow slice (session-shared — fan out)
     bridgeEmit(bridge, 'workflow.current.snapshot', {
         activeWorkflow: session.activeWorkflow,
         currentStatus: { status: session.currentStatus },
     });
-    // 3. Resumable checkpoints for the active workflow (explicit boundaries)
+    // 4. Resumable checkpoints for the active workflow (explicit boundaries)
     const workflowId = session.activeWorkflowId ?? null;
     const checkpoints = await listResumableCheckpoints(new WorkflowCheckpointStore(context.projectDir), workflowId, session.activeWorkflow);
     bridgeEmit(bridge, 'runner.checkpoints.snapshot', {
         workflowId,
         checkpoints,
     });
-    // 4. Catalog sync
+    // 5. Catalog sync
     if (options.catalog.kind === 'broadcast') {
         const workflows = await context.workflowService.list();
         bridgeEmit(bridge, 'workflow.list.snapshot', { workflows });
@@ -67,11 +74,13 @@ export const wireWorkflowHandlers = (bridge, context, session) => {
             return;
         }
         let clearSelection = false;
+        let resetFeed = false;
         if (!session.isGraphLocked()) {
             // 1. Load document into session
             const loaded = await loadWorkflowIntoSession(session, context.workflowService, context.projectDir, raw.payload.workflowId, context.resolveDefinition);
             // 2. Persist current-workflow id when load succeeded
             if (loaded.ok) {
+                resetFeed = true;
                 await context.langflowerConfigService.setCurrentWorkflowId(raw.payload.workflowId);
                 if (loaded.repaired) {
                     const nodeCount = loaded.droppedNodeIds.length;
@@ -101,7 +110,7 @@ export const wireWorkflowHandlers = (bridge, context, session) => {
             });
         }
         // 3. Sync outbound
-        await syncAfterWorkflowMutation(bridge, context, session, connected, { clearSelection, catalog: { kind: 'none' } });
+        await syncAfterWorkflowMutation(bridge, context, session, connected, { clearSelection, catalog: { kind: 'none' }, resetFeed });
     }));
     subscription.add(bridge['workflow.saveCurrent.requested'].subscribe(async (raw) => {
         if (!isInboundEvent(raw)) {
@@ -163,11 +172,13 @@ export const wireWorkflowHandlers = (bridge, context, session) => {
             return;
         }
         let clearSelection = false;
+        let resetFeed = false;
         if (!session.isGraphLocked()) {
-            await createEmptyWorkflowInSession(session, context.workflowService, context.projectDir, context.resolveDefinition);
+            const created = await createEmptyWorkflowInSession(session, context.workflowService, context.projectDir, context.resolveDefinition);
             clearSelection = true;
+            resetFeed = created;
         }
-        await syncAfterWorkflowMutation(bridge, context, session, connected, { clearSelection, catalog: { kind: 'none' } });
+        await syncAfterWorkflowMutation(bridge, context, session, connected, { clearSelection, catalog: { kind: 'none' }, resetFeed });
     }));
     subscription.add(bridge['workflow.copy.requested'].subscribe(async (raw) => {
         if (!isInboundEvent(raw)) {
@@ -179,16 +190,19 @@ export const wireWorkflowHandlers = (bridge, context, session) => {
         }
         let catalogChanged = false;
         let clearSelection = false;
+        let resetFeed = false;
         if (!session.isGraphLocked()) {
             const copied = await copyWorkflowToSession(session, context.workflowService, context.projectDir, raw.payload.workflowId, context.resolveDefinition);
             if (copied && session.activeWorkflowId !== undefined) {
                 catalogChanged = true;
+                resetFeed = true;
                 await context.langflowerConfigService.setCurrentWorkflowId(session.activeWorkflowId);
             }
             clearSelection = true;
         }
         await syncAfterWorkflowMutation(bridge, context, session, connected, {
             clearSelection,
+            resetFeed,
             catalog: catalogChanged
                 ? { kind: 'broadcast' }
                 : { kind: 'none' },

package/vendor/server/dist/checkpoint/run-checkpoint-session.d.ts

@@ -1,4 +1,4 @@
-import type { NodeId, RunId, RuntimeRunnerEvent } from '@langflower/runtime';
+import { type NodeId, type RunId, type RuntimeRunnerEvent } from '@langflower/runtime';
 import { type WorkflowCheckpoint, type WorkflowCheckpointSummary, type WorkflowLoadedPayload } from '@langflower/shared/langflower.js';
 import { WorkflowCheckpointStore } from './workflow-checkpoint-store.js';
 /**

package/vendor/server/dist/checkpoint/run-checkpoint-session.js

@@ -1,3 +1,4 @@
+import { isPortTelemetry, } from '@langflower/runtime';
 import { buildWorkflowFingerprint, toCheckpointJsonValue, } from '@langflower/shared/langflower.js';
 import { summarizeCheckpoint, WorkflowCheckpointStore, } from './workflow-checkpoint-store.js';
 /**
@@ -56,27 +57,27 @@ export class RunCheckpointSession {
      *          that should trigger an immediate persist.
      */
     observe(event, boundary) {
-        if (this.active === undefined || event.kind !== 'output-emitted') {
+        if (this.active === undefined ||
+            !isPortTelemetry(event) ||
+            event[0] !== 'out') {
             return false;
         }
-        if (String(event.runId) !== this.active.runId) {
+        const [, nodeIdRaw, portId, response] = event;
+        if (!('value' in response) || typeof portId !== 'string') {
             return false;
         }
-        if (event.state !== 'value' || typeof event.portId !== 'string') {
-            return false;
-        }
-        const jsonValue = toCheckpointJsonValue(event.value);
+        const jsonValue = toCheckpointJsonValue(response.value);
         if (jsonValue === undefined) {
-            this.unsupportedValue = `${event.nodeId}.${event.portId}`;
+            this.unsupportedValue = `${String(nodeIdRaw)}.${portId}`;
             return false;
         }
-        const nodeId = String(event.nodeId);
+        const nodeId = String(nodeIdRaw);
         let ports = this.active.outputSnapshots.get(nodeId);
         if (ports === undefined) {
             ports = new Map();
             this.active.outputSnapshots.set(nodeId, ports);
         }
-        ports.set(event.portId, {
+        ports.set(portId, {
             state: 'value',
             value: jsonValue,
         });

package/vendor/server/dist/palette/compile-and-hot-swap-custom-nodes.d.ts

@@ -0,0 +1,10 @@
+import type { CustomPaletteSnapshotPayload } from '@langflower/shared/langflower.js';
+import type { LangflowerBridge } from '../bridge/langflower-bridge.types.js';
+import type { ServerContext } from '../server-context.js';
+import type { LangflowerSession } from '../session/langflower-session.js';
+/**
+ * One composer for Custom → Update and `compile_custom_nodes` (via bus
+ * intent `customPalette.update.requested`): compile, registry, live swap,
+ * then palette snapshot (and deleteEdges if ports vanished).
+ */
+export declare const compileAndHotSwapCustomNodes: (session: LangflowerSession, context: ServerContext, bridge: LangflowerBridge) => Promise<CustomPaletteSnapshotPayload>;

package/vendor/server/dist/palette/compile-and-hot-swap-custom-nodes.js

@@ -0,0 +1,23 @@
+import { swapCustomNodesInEditor } from '../workflow/apply-editor-mutation.js';
+import { refreshLiveWiredToolPacks } from '../bridge/get-live-wired-tools.js';
+import { bridgeEmit } from '../bridge/bridge-outbound.js';
+/**
+ * One composer for Custom → Update and `compile_custom_nodes` (via bus
+ * intent `customPalette.update.requested`): compile, registry, live swap,
+ * then palette snapshot (and deleteEdges if ports vanished).
+ */
+export const compileAndHotSwapCustomNodes = async (session, context, bridge) => {
+    bridgeEmit(bridge, 'customPalette.snapshot', context.customPaletteService.compilingSnapshot());
+    const snapshot = await context.customPaletteService.update(context.projectDir);
+    const customTypes = new Set(snapshot.nodes.map((node) => node.type));
+    const droppedEdges = swapCustomNodesInEditor(session, context.projectDir, context.resolveDefinition, customTypes);
+    refreshLiveWiredToolPacks(session);
+    if (droppedEdges.length > 0) {
+        bridgeEmit(bridge, 'editor.deleteEdges', droppedEdges);
+        bridgeEmit(bridge, 'workflow.currentStatus.snapshot', {
+            status: session.currentStatus,
+        });
+    }
+    bridgeEmit(bridge, 'customPalette.snapshot', snapshot);
+    return snapshot;
+};

package/vendor/server/dist/session/reset-session-execution-feed.d.ts

@@ -0,0 +1,6 @@
+import type { LangflowerSession } from './langflower-session.js';
+/**
+ * Drop the session run log so `buildExecutionFeed()` returns null.
+ * Call only when the runner is idle (document switch or user Clear).
+ */
+export declare const resetSessionExecutionFeed: (session: LangflowerSession) => void;

package/vendor/server/dist/session/reset-session-execution-feed.js

@@ -0,0 +1,8 @@
+/**
+ * Drop the session run log so `buildExecutionFeed()` returns null.
+ * Call only when the runner is idle (document switch or user Clear).
+ */
+export const resetSessionExecutionFeed = (session) => {
+    session.runtime.runner.clearEventLog();
+    session.runId = undefined;
+};

package/vendor/server/dist/workflow/apply-editor-mutation.d.ts

@@ -44,6 +44,11 @@ export declare const applyEditorRemoveEdge: (session: LangflowerSession, edgeId:
  * Composer: snapshot → runtime remove → sync session topology from editor.
  */
 export declare const applyEditorRemoveNode: (session: LangflowerSession, nodeId: NodeId) => WorkflowNodePersisted[];
+/**
+ * Replace live editor instances whose persisted `type` is in `customTypes`.
+ * Types missing from the set keep the old instance. Allowed while locked.
+ */
+export declare const swapCustomNodesInEditor: (session: LangflowerSession, projectDir: string, resolveDefinition: ResolveNodeDefinition, customTypes: ReadonlySet<string>) => readonly RuntimeEdge[];
 export type BindWorkflowResult = {
     readonly ok: true;
     readonly droppedNodeIds: readonly string[];

package/vendor/server/dist/workflow/apply-editor-mutation.js

@@ -447,6 +447,38 @@ export const applyEditorRemoveNode = (session, nodeId) => {
     syncActiveWorkflowTopologyFromEditor(session);
     return nodeSnapshot !== undefined ? [nodeSnapshot] : [];
 };
+/**
+ * Replace live editor instances whose persisted `type` is in `customTypes`.
+ * Types missing from the set keep the old instance. Allowed while locked.
+ */
+export const swapCustomNodesInEditor = (session, projectDir, resolveDefinition, customTypes) => {
+    const active = session.activeWorkflow;
+    if (active === null) {
+        return [];
+    }
+    const persistedById = new Map(active.graph.nodes.map((node) => [node.id, node]));
+    const droppedEdges = [];
+    for (const runtimeNode of session.runtime.editor.getNodes()) {
+        const persisted = persistedById.get(runtimeNode.nodeId);
+        if (persisted === undefined || !customTypes.has(persisted.type)) {
+            continue;
+        }
+        const next = materializeRuntimeNode(projectDir, persisted, resolveDefinition);
+        if (next === undefined) {
+            continue;
+        }
+        const { nodeId: _nodeId, ...rest } = next;
+        const swapped = session.runtime.editor.swapNode(runtimeNode.nodeId, rest);
+        if (swapped === false) {
+            continue;
+        }
+        droppedEdges.push(...swapped.droppedEdges);
+    }
+    if (droppedEdges.length > 0) {
+        syncActiveWorkflowTopologyFromEditor(session);
+    }
+    return droppedEdges;
+};
 /**
  * Load path: document → editor (activate/rename/rebind).
  * Unsupported nodes and invalid edges are skipped (graceful degradation);

package/vendor/server/skeleton/instructions.md

@@ -27,11 +27,15 @@ contract.
 
 ## Load custom nodes
 
-In the editor Custom section, click **Update** (or reconnect). Langflower
-typechecks each pack (`tsc --noEmit` when `tsconfig.json` is present), then
-esbuild-bundles entries that passed. On success nodes appear under **Custom**.
-Failures write `COMPILATION_ERRORS.md` in the pack without dropping other
-successful custom nodes.
+Call **`compile_custom_nodes`** (no args) — on starter, Helper and Writer
+already have it because **Langflower Tools** is wired — or, in the editor
+Custom section, click **Update** (or reconnect). Same composer: typecheck
+each pack (`tsc --noEmit` when `tsconfig.json` is present), esbuild-bundle
+entries that passed, hot-swap live custom instances, refresh **Custom**.
+Stop is not required for already-placed custom types. Already-wired custom
+tools can be invoked later in the **same run**. New types are not auto-placed
+or auto-wired mid-run. Failures write `COMPILATION_ERRORS.md` in the pack
+without dropping other successful custom nodes.
 
 ## Gaps
 

package/vendor/server/skeleton/nodes/my-nodes/README.md

@@ -199,9 +199,10 @@ even though Langflower bundles with esbuild for load.
 2. `export default defineNode({ … })`, `defineToolRegistrations({ … })` for an
    LLM `tools` pack, **or** `defineReactiveNode({ … })` when exclusive `ok` /
    `fail` (or other silent-branch) ports are required.
-3. Run `npm install` in the pack if peers or deps changed.
-4. In the editor Custom section, click **Update** (or reconnect) — the node
-   appears under **Custom**.
+3. Run `npm install` in the pack if author deps changed.
+4. Call **`compile_custom_nodes`** (starter Helper / Writer) or Custom →
+   **Update**. The type appears under **Custom**. Already-placed instances
+   hot-swap (no Stop). Place **new** types on the canvas yourself.
 
 ## Second shareable pack
 

package/vendor/server/skeleton/nodes/my-nodes/package.json

@@ -5,7 +5,7 @@
 	"type": "module",
 	"peerDependencies": {
 		"@langflower/node-sdk": "0.1.0",
-		"@rx-evo/stateful-observable": "^0.5.2",
+		"@rx-evo/stateful-observable": "^0.6.0",
 		"rxjs": "^7.8.1"
 	}
 }