langflower 0.0.7 → 0.0.9

package/vendor/server/dist/bridge/settings-draft-controller.js

@@ -8,6 +8,30 @@ import { applyDraftPatch, buildDraftSnapshot, providerIndexesWithBaseUrl, seedSc
 import { bridgeEmit, clientEmit } from './bridge-outbound.js';
 import { buildLangflowerConfigSnapshot } from './build-langflower-config-snapshot.js';
 const isScope = (value) => value === 'project' || value === 'global';
+/** Fill missing/empty Save keys from the session draft (write-only apiKey). */
+const mergeProviderApiKeysFromSession = (payload, sessionDraft) => {
+    if (payload.provider === undefined || sessionDraft === undefined) {
+        return payload.providerApiKeys;
+    }
+    const merged = {
+        ...(payload.providerApiKeys ?? {}),
+    };
+    for (const row of sessionDraft.providers) {
+        const id = row.id.trim();
+        if (id.length === 0) {
+            continue;
+        }
+        const fromPayload = merged[id]?.trim() ?? '';
+        if (fromPayload.length > 0) {
+            continue;
+        }
+        const pending = row.apiKey.trim();
+        if (pending.length > 0) {
+            merged[id] = pending;
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : payload.providerApiKeys;
+};
 const layerForScope = (layers, scope) => (scope === 'project' ? layers.project : layers.global);
 export const createSettingsDraftController = (bridge, context, session) => {
     const probeGeneration = new Map();
@@ -144,15 +168,14 @@ export const createSettingsDraftController = (bridge, context, session) => {
         if (payload === undefined || !isScope(payload.scope)) {
             return null;
         }
+        const providerApiKeys = mergeProviderApiKeysFromSession(payload, state?.draft);
         const layers = await context.langflowerConfigService.writeSettings({
             scope: payload.scope,
             ...(payload.model !== undefined ? { model: payload.model } : {}),
             ...(payload.provider !== undefined
                 ? { provider: payload.provider }
                 : {}),
-            ...(payload.providerApiKeys !== undefined
-                ? { providerApiKeys: payload.providerApiKeys }
-                : {}),
+            ...(providerApiKeys !== undefined ? { providerApiKeys } : {}),
             ...('serverLogs' in payload
                 ? { serverLogs: payload.serverLogs }
                 : {}),

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,11 @@
+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 { 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 +38,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 +64,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 +90,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 +118,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 +203,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 +256,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);
                 }

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, state, value] = event;
+        if (state !== 'value' || typeof portId !== 'string') {
             return false;
         }
-        if (event.state !== 'value' || typeof event.portId !== 'string') {
-            return false;
-        }
-        const jsonValue = toCheckpointJsonValue(event.value);
+        const jsonValue = toCheckpointJsonValue(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/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/schemas/langflower-config.schema.json

@@ -55,7 +55,17 @@
 					},
 					"options": {
 						"type": "object",
-						"additionalProperties": true
+						"additionalProperties": true,
+						"properties": {
+							"baseURL": {
+								"type": "string",
+								"description": "OpenAI-compatible API base URL (e.g. https://api.openai.com/v1 or http://127.0.0.1:1234/v1)."
+							},
+							"apiKey": {
+								"type": "string",
+								"description": "API key or `{env:VAR_NAME}` placeholder. Resolved on the server only; omitted from WebSocket snapshots. Prefer `{env:…}` over literals on disk."
+							}
+						}
 					}
 				}
 			}

package/vendor/server/skeleton/skills/langflower-helper/SKILL.md

@@ -13,6 +13,10 @@ provider. They are past bootstrap; do not lead with CLI start or provider setup.
 ## Role and style
 
 - Short, actionable steps. No long essays.
+- On **starter**, **Langflower Tools** is wired to you and Writer — you
+  already have **`compile_custom_nodes`**. After pack file changes, **call
+  it** (no arguments). Do not send the user to Custom → **Update** as the
+  only path.
 - Answer **only** from allowed fact sources: the **Companion docs** (via
   `read` when relevant) and the **Knowledge base** below. If a fact is
   missing, say **not in my facts** (or point at project use-case docs) —
@@ -35,8 +39,8 @@ Bootstrap and provider facts stay in the Knowledge base for when they ask.
 Example opening:
 
 > Glad you got Langflower running and a provider configured. I can explain what
-> Langflower can do and help you set up workflows and nodes for your needs.
-> What do you want to build?
+> Langflower can do, help you set up workflows and custom nodes, and compile
+> packs from this chat (`compile_custom_nodes`). What do you want to build?
 
 ## Companion docs
 
@@ -141,23 +145,28 @@ do not say coding pipelines “don’t exist” or are unavailable.
 
 ### 7. Run lifecycle
 
-| Mechanism             | Meaning                                                                                               |
-| --------------------- | ----------------------------------------------------------------------------------------------------- |
-| Hard Stop             | Cancel; does **not** by itself create checkpoint Continue                                             |
-| Soft Pause            | Per-node Steer pause of the last feed agent; siblings keep working; Send / Resume continues that node |
-| Browser close         | If `langflower start` stays up, run continues; reopen live or settled                                 |
-| Process kill / reboot | **Not** detachable resume                                                                             |
-| Checkpoint Continue   | Needs explicit boundary (`common-checkpoint` / `createCheckpoint`); **no** every-node auto Continue   |
+| Mechanism             | Meaning                                                                                                                                                                                                                                                                                                                                                                                      |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Hard Stop             | Cancel; does **not** by itself create checkpoint Continue                                                                                                                                                                                                                                                                                                                                    |
+| Soft Pause            | Per-node Steer pause of the last feed agent; siblings keep working; Send / Resume continues that node                                                                                                                                                                                                                                                                                        |
+| Provider recovery     | Idle: default **autokick** (abort, exponential backoff, full-store replay + kick). Dead-loop: abort + short `retryBaseDelayMs` wait (not idle backoff) + kick. 429/5xx/network: short transient budget, then autokick **wait** (no kick, no penalty). `'retry'` banner stays in the feed after reasoning/draft; does not open Steer. Off / cap exhausted → **Steer**. Auth/config stay fatal |
+| Browser close         | If `langflower start` stays up, run continues; reopen live or settled                                                                                                                                                                                                                                                                                                                        |
+| Process kill / reboot | **Not** detachable resume                                                                                                                                                                                                                                                                                                                                                                    |
+| Checkpoint Continue   | Needs explicit boundary (`common-checkpoint` / `createCheckpoint`); **no** every-node auto Continue                                                                                                                                                                                                                                                                                          |
 
 These four are **not** the same thing.
 
 ### 8. Tools, permissions, MCP
 
 - **Can:** Harness builtins + `permission.ask` Allow/Deny for those builtins.
-  Wired pack / MCP tools (including memory writes) do **not** ask — authoring
-  the edge is consent. Write Allow does **not** grant bash. Agents receive
-  **McpHandle**s; system MCP starts only for ids enabled on nodes in the
-  active workflow.
+  Wired pack / MCP tools (including memory writes and **Langflower Tools**)
+  do **not** ask — authoring the edge is consent. Write Allow does **not**
+  grant bash. Agents receive **McpHandle**s; system MCP starts only for ids
+  enabled on nodes in the active workflow.
+- **Can:** `compile_custom_nodes` exists only when **Langflower Tools**
+  (`common-langflower-tools`) is wired into that agent’s `tools` port
+  (starter Helper / Writer). Same intent as Custom → **Update**. Recompile
+  is unsafe — not ambient on every agent.
 - **Can:** First-run `langflower.jsonc` seeds `permission` allow-all (project
   **floor**). Inspector **Tool permissions** table (`tool` / `deny` / `ask` /
   `allow`) sets per-agent `toolPermissions` (cannot loosen past floor). Presets
@@ -217,17 +226,38 @@ When the user asks to “create a project wiki”, “build a knowledge base”,
 ### 11. Custom nodes
 
 - **Can:** **TypeScript** via `@langflower/node-sdk` — first-class language;
-  `tsc` / IDE types act as compile-time validators before Custom → **Update**.
-  Packs under `.langflower/nodes/<pack>/`; user runs `npm install` in the pack.
-  See `instructions.md` and `nodes/my-nodes/README.md`.
+  `tsc` / IDE types act as compile-time validators. After file changes call
+  **`compile_custom_nodes`** (no args) or Custom → **Update** — same
+  composer. On starter you already have the tool (Langflower Tools wired).
+  Stop is not required for already-placed custom types (hot-swap).
+  An already-wired custom tools pack can be invoked later in the **same run**
+  after compile. New types appear under **Custom**; Langflower does **not**
+  auto-place or auto-wire them mid-run.
+  Packs under `.langflower/nodes/<pack>/`; user runs `npm install` in the pack
+  when adding author deps. See `instructions.md` and `nodes/my-nodes/README.md`.
   Nodes may **intentionally keep in-memory internal state across runs**
   (Stop / done / Start) until the user loads another workflow or shuts down
   Langflower — not the same as Checkpoint resume after process kill.
 - **Cannot:** Plain JS as the authoring path, Go, Python, or other languages.
   Server auto-install. Sandboxed arbitrary user-node execution as shipped.
-  Custom-pack compiler as product-Implementable.
-  Claim that every node always resets on Stop, or that in-memory node state
-  survives process restart without Checkpoints.
+  Ambient compile without Langflower Tools wired. Canvas add/remove node or
+  edge tools (not shipped). Claim that every node always resets on Stop, or
+  that in-memory node state survives process restart without Checkpoints.
+
+### 11a. Recipe — write / reload a custom node
+
+When the user asks to add or change a custom node from this starter chat:
+
+1. Spawn Writer (or edit `.langflower/nodes/<pack>/*.ts` yourself).
+2. Call **`compile_custom_nodes`** (no args). Report `status` / `nodeTypes` /
+   `errors` from the tool text. Pack failures also write
+   `COMPILATION_ERRORS.md`.
+3. **Already on the canvas** → live now, no Stop. **New type** → user places
+   it from Custom and wires it; this tool does not drop nodes on the canvas.
+4. If a custom tools pack is already wired into this agent, you may call those
+   `toolId`s later in **this run** after compile.
+
+Do **not** treat Custom → Update as the only reload path on starter.
 
 ### 12. Status vocabulary
 

package/vendor/server/skeleton/skills/langflower-helper/architecture.md

@@ -57,11 +57,18 @@ Project product data for Langflower lives under **`.langflower/`**.
 - **HITL loops** (Review Gate, feedback ports, composer Start/Send) are normal
   **internal waiting state of nodes**, not a separate product “interrupt the
   engine” mechanism.
-- LLM provider idle/HTTP 5xx/network failures retry from the last committed
-  round, then keep the node alive for **Steer / Resume** (recovery notices on
-  the `recovery` port; suspend opens the Steer composer). Partial draft text is
-  telemetry, not committed history. Authentication/configuration failures are
-  terminal. Generic reload of any failed non-LLM node is not yet shipped.
+- LLM provider idle **aborts** the in-flight request, then default
+  **autokick** (exponential backoff, full stored messages + kick user
+  turn). Dead-loop aborts the same way but waits **`retryBaseDelayMs`**
+  (not idle backoff) before that replay. HTTP 429 / 5xx / network use the
+  short transient budget, then join the idle autokick wait **without** a
+  kick turn or penalty bump. `'retry'` notices on the `recovery` port stay
+  in the feed after reasoning/draft, tick locally on the visit tail, and
+  do **not** open Steer. Autokick off or a finite cap exhausted keep the
+  node alive for **Steer / Resume** (`'suspended'`).
+  Partial draft text is telemetry, not committed history.
+  Authentication/configuration failures are terminal. Generic reload of any
+  failed non-LLM node is not yet shipped.
 - Also on the bus: runner start / resume / interrupt intents, `permission.ask`,
   and related facts.
 
@@ -80,11 +87,17 @@ Project product data for Langflower lives under **`.langflower/`**.
 ## Extensibility
 
 - Custom nodes use the same **`@langflower/node-sdk`** path as built-ins.
-- **TypeScript** is first-class; `tsc` / IDE types act as compile-time gates
-  before Custom → **Update**.
+- **TypeScript** is first-class; `tsc` / IDE types act as compile-time gates.
+  After file changes call `compile_custom_nodes` (only if **Langflower
+  Tools** is wired — starter Helper / Writer already are) or Custom →
+  **Update**. Same composer: typecheck + bundle + hot-swap live custom
+  instances + refresh the Custom palette.
+  Stop is not required for already-placed custom types.
+  An already-wired custom tools pack can be invoked later in the same run
+  after compile. Do not auto-place or auto-wire a new type mid-run.
 - Plain JS / Go / Python are not the authoring path. Sandboxed arbitrary
-  user-node execution and a custom-pack compiler are **not** claimed as
-  shipped Implementable here.
+  user-node execution is **not** shipped. Canvas add/remove node or edge
+  tools are **not** shipped (later rows on Langflower Tools).
 
 ## What stays local
 

package/vendor/server/skeleton/skills/langflower-helper/layout.md

@@ -17,21 +17,21 @@ Facts for UI chrome and on-disk paths. Prefer this file over guessing.
 
 ## Where can I…?
 
-| Goal                                   | Where                                                                                                                                  |
-| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| Change provider / API key              | Gear → **Settings** (right aside; Global auto-opens when none configured), or edit `.langflower/langflower.jsonc` (prefer `{env:VAR}`) |
-| Start a Chat Input graph               | Composer **Start** — not plain **Run** (Run stays disabled for those graphs)                                                           |
-| See run output / stream                | Right aside **feed**                                                                                                                   |
-| Answer HITL / send into a waiting node | Composer + feed context                                                                                                                |
-| Allow or Deny `permission.ask`         | Composer permission controls                                                                                                           |
-| Soft-pause last feed agent / continue  | Composer **Pause** (per-node) / Send or Resume (soft pause ≠ Hard Stop)                                                                |
-| Hard-stop a run                        | Composer **Stop**                                                                                                                      |
-| Edit selected node params / ports      | Select node → right aside **inspector** (not Settings)                                                                                 |
-| Add or reload custom nodes             | Put pack under `.langflower/nodes/<pack>/`, then Custom → **Update**                                                                   |
-| Switch workflow                        | Topbar workflow list                                                                                                                   |
-| Open Settings without leaving canvas   | Gear — Settings in right aside                                                                                                         |
-| Find sample coding graphs              | Skeleton / demo-project workflow files — **manual copy** into project, then load → Start. No Sample workflows catalog UI.              |
-| Project instructions for agents        | `.langflower/instructions.md`                                                                                                          |
+| Goal                                   | Where                                                                                                                                                                                                                                                                                                                |
+| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Change provider / API key              | Gear → **Settings** (right aside; Global auto-opens when none configured), or edit `.langflower/langflower.jsonc` (prefer `{env:VAR}`)                                                                                                                                                                               |
+| Start a Chat Input graph               | Composer **Start** — not plain **Run** (Run stays disabled for those graphs)                                                                                                                                                                                                                                         |
+| See run output / stream                | Right aside **feed**                                                                                                                                                                                                                                                                                                 |
+| Answer HITL / send into a waiting node | Composer + feed context                                                                                                                                                                                                                                                                                              |
+| Allow or Deny `permission.ask`         | Composer permission controls                                                                                                                                                                                                                                                                                         |
+| Soft-pause last feed agent / continue  | Composer **Pause** (per-node) / Send or Resume (soft pause ≠ Hard Stop)                                                                                                                                                                                                                                              |
+| Hard-stop a run                        | Composer **Stop**                                                                                                                                                                                                                                                                                                    |
+| Edit selected node params / ports      | Select node → right aside **inspector** (not Settings)                                                                                                                                                                                                                                                               |
+| Add or reload custom nodes             | Pack under `.langflower/nodes/<pack>/`. On starter, Helper / Writer call `compile_custom_nodes` (Langflower Tools is wired). Else Custom → **Update**. Hot-swap already-placed types; already-wired custom tools work later in the same run. New types: user places from Custom (no auto-place / auto-wire mid-run). |
+| Switch workflow                        | Topbar workflow list                                                                                                                                                                                                                                                                                                 |
+| Open Settings without leaving canvas   | Gear — Settings in right aside                                                                                                                                                                                                                                                                                       |
+| Find sample coding graphs              | Skeleton / demo-project workflow files — **manual copy** into project, then load → Start. No Sample workflows catalog UI.                                                                                                                                                                                            |
+| Project instructions for agents        | `.langflower/instructions.md`                                                                                                                                                                                                                                                                                        |
 
 ## On-disk `.langflower/` map
 

package/vendor/server/skeleton/skills/langflower-node-writer/SKILL.md

@@ -3,7 +3,7 @@ name: Langflower node writer
 description: >-
     Guides authors writing project custom nodes under .langflower/nodes packs
     (defineNode / defineToolRegistrations / defineReactiveNode, ADR-030 layout,
-    reload via Custom Update).
+    reload via compile_custom_nodes or Custom Update).
 ---
 
 # Langflower node writer
@@ -16,10 +16,14 @@ You help the user write **custom nodes** for Langflower.
   language; `tsc` / IDE types are the compile-time validators. **Not** plain JS
   as the authoring path, Go, Python, Rust, or other runtimes.
 - Do **not** claim sandboxed execution of arbitrary user-node code is shipped.
-- Do **not** claim a custom-pack compiler epic is product-Implementable unless
-  the user’s docs say so — packs reload via Custom → **Update** /
-  `COMPILATION_ERRORS.md` today.
+- After file changes **call `compile_custom_nodes` yourself** (no args) — on
+  starter, Writer has it because **Langflower Tools** is wired. Custom →
+  **Update** is the same composer. Failures land in `COMPILATION_ERRORS.md`.
+  Do **not** only remind the user to click Update.
 - Langflower does **not** auto-`npm install` pack dependencies.
+- Do **not** claim you can place a newly compiled type on the canvas or wire
+  it mid-run. Already-placed types hot-swap; already-wired custom tools can
+  be invoked later in the **same run**.
 
 ## Contract (do not invent forks)
 
@@ -34,8 +38,12 @@ You help the user write **custom nodes** for Langflower.
   Skip `*.test.ts`, `*.d.ts`, `dist/`, `node_modules/`.
 - Peer deps on the host SDK / RxJS are supplied by Langflower; author libs go
   in pack `dependencies`. The user runs `npm install` in the pack.
-- After file changes: Custom section → **Update**. Failures land in
-  `COMPILATION_ERRORS.md` in that pack.
+- After file changes: call **`compile_custom_nodes`** (wired on starter
+  Helper / Writer via **Langflower Tools** — not ambient on every agent) or
+  Custom section → **Update**. Stop is not required for already-placed
+  custom types. An already-wired custom tools pack can be invoked later in
+  the **same run** after compile. Failures land in `COMPILATION_ERRORS.md`
+  in that pack.
 
 ## When drafting a node
 
@@ -44,9 +52,11 @@ You help the user write **custom nodes** for Langflower.
    (`defineToolRegistrations` owns a `tools` output — no custom inputs).
 3. Implement `execute` (`defineNode`), `tools` handlers
    (`defineToolRegistrations`), or `bind` (`defineReactiveNode`).
-4. Show the full file the user can paste into `my-nodes/`.
-5. Remind them to Update Custom and fix compile errors from
-   `COMPILATION_ERRORS.md` if present.
+4. Show the full file the user can paste into `my-nodes/` **or write it**
+   under `.langflower/nodes/<pack>/`.
+5. Call **`compile_custom_nodes`**. If the snapshot lists errors, `read`
+   that pack’s `COMPILATION_ERRORS.md`, fix, and compile again. Tell the
+   user to place **new** types from Custom; already-placed types are live.
 
 ## References in the project