langflower 0.0.4 → 0.0.6

package/vendor/node-sdk/dist/node-factory/define-reactive-node/io-helpers.d.ts

@@ -1,4 +1,5 @@
-import type { MetaFromStatefulObservable, PortMeta } from './port-meta.js';
+import type { FeedPortMeta, MetaFromStatefulObservable, PortMeta } from './port-meta.js';
+export type { FeedPortMeta, FeedRole } from './port-meta.js';
 import { StatefulObservable } from '@rx-evo/stateful-observable';
 import type { HitlInputConfig } from './hitl-config.js';
 /** One choice for the `select` / `multiselect` / `radio` inline kinds. */
@@ -65,6 +66,8 @@ export type InputParams<T> = {
     readonly hidden?: boolean;
     readonly dynamic?: boolean;
     readonly hitl?: HitlInputConfig;
+    /** Feed metadata for terminal input facts such as approve / deny. */
+    readonly feed?: FeedPortMeta;
 };
 /** Port metadata for an input — `InputParams` merged with `PortMeta`. */
 export type InputPortMeta<T> = InputParams<T> & PortMeta;
@@ -85,8 +88,6 @@ export type InputPortMeta<T> = InputParams<T> & PortMeta;
  */
 export declare function makeInput<T>(portId: string, meta: InputParams<T>): import("@rx-evo/stateful-observable").StatefulConnection<T, unknown, InputPortMeta<T>>;
 export type InputConfig = ReturnType<typeof makeInput>;
-/** Authoring `configureOutput(..., { feed: { role } })` — work-log density. */
-export type FeedRole = 'none' | 'reasoning' | 'draft' | 'tool' | 'shell' | 'result' | 'recovery';
 export type OutputParams = {
     /**
      * display name
@@ -113,14 +114,7 @@ export type OutputParams = {
     /**
      * if set - output will be connected to feed at sidebar
      */
-    readonly feed?: {
-        readonly role?: FeedRole;
-        /**
-         * Output being emitted in chunks.
-         * Feed should add these chunks to feed node.
-         */
-        readonly streaming?: boolean;
-    };
+    readonly feed?: FeedPortMeta;
 };
 type WithWireType = {
     readonly wireType: string;
@@ -133,4 +127,3 @@ export declare function configureOutput<T>(portId: string, stream: StatefulObser
 export type OutputConfig = ReturnType<typeof configureOutput>;
 /** Serializable descriptor for one output port — `OutputConfig['meta']`. */
 export type OutputPortMeta = MetaFromStatefulObservable<OutputConfig>;
-export {};

package/vendor/node-sdk/dist/node-factory/define-reactive-node/port-meta.d.ts

@@ -12,6 +12,18 @@ export type WireType = string & {
     __brand: 'RuntimeWireType';
 };
 export type InputPortMode = 'single' | 'merge' | 'combine' | 'zip' | 'bypass';
+export type FeedRole = 'none' | 'reasoning' | 'draft' | 'tool' | 'shell' | 'result' | 'recovery';
+/**
+ * Feed projection metadata shared by input and output port contracts.
+ *
+ * `streaming: true` keeps the visit open (chunks / interleaved streams).
+ * Omit it so the frame closes the visit; same-node frames while last still
+ * append to that visit.
+ */
+export type FeedPortMeta = {
+    readonly role?: FeedRole;
+    readonly streaming?: boolean;
+};
 /**
  * Typed metadata on every `statefulConnection` / `statefulObservable` `meta`.
  * Must stay structurally identical to runtime `PortMeta`.
@@ -23,6 +35,7 @@ export type PortMeta = {
     readonly mode?: InputPortMode;
     readonly fromInput?: string;
     readonly defaultValue?: unknown;
+    readonly feed?: FeedPortMeta;
 };
 /** Extract the `meta` type carried by a {@link StatefulObservable}. */
 export type MetaFromStatefulObservable<T extends StatefulObservable<unknown, unknown, unknown>> = T extends StatefulObservable<unknown, unknown, infer Meta> ? Meta : never;

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

@@ -239,7 +239,7 @@ export class RuntimeRunner {
         }
         this.eventsSubject.next(event);
     }
-    emitPortEvent(runId, kind, nodeId, portId, portIdx, state, value, edgeIds) {
+    emitPortEvent(runId, kind, nodeId, portId, portIdx, state, value, edgeIds, feed) {
         this.emitRunnerEvent({
             kind,
             runId,
@@ -249,6 +249,7 @@ export class RuntimeRunner {
             edgeIds,
             state,
             value,
+            ...(feed !== undefined ? { feed } : {}),
         });
     }
     canPreparePushedInput(node, portId) {
@@ -278,8 +279,10 @@ export class RuntimeRunner {
         const key = slotKey(cfg.nodeId, cfg.portId, 0);
         const existing = run.pushedInputSources.get(key);
         if (existing !== undefined) {
-            existing.source.next(cfg.payload);
+            // Telemetry before deliver so HITL input-received precedes cascade
+            // (output-emitted / downstream input-received) in the event log.
             this.emitPortEvent(run.runId, 'input-received', cfg.nodeId, cfg.portId, 0, 'value', cfg.payload, []);
+            existing.source.next(cfg.payload);
             return run.runId;
         }
         if (run.wiredSlotKeys.has(key)) {
@@ -297,8 +300,8 @@ export class RuntimeRunner {
             connection,
         });
         run.pushedInputSources.set(key, { source });
-        source.next(cfg.payload);
         this.emitPortEvent(run.runId, 'input-received', cfg.nodeId, cfg.portId, 0, 'value', cfg.payload, []);
+        source.next(cfg.payload);
         return run.runId;
     }
     /**
@@ -323,7 +326,7 @@ export class RuntimeRunner {
                 if (resolved === null) {
                     return;
                 }
-                this.emitPortEvent(run.runId, 'output-emitted', nodeId, portId, 0, resolved.state, resolved.value, edgeIds);
+                this.emitPortEvent(run.runId, 'output-emitted', nodeId, portId, 0, resolved.state, resolved.value, edgeIds, output.meta.feed);
                 if (resolved.state === 'value' &&
                     node !== false &&
                     node.stopsRun === true) {

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

@@ -6,7 +6,7 @@ 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, RuntimeInputReceivedEvent, RuntimeNode, RuntimeOutputEmittedEvent, RuntimePortSignalState, RuntimeResumeOptions, RuntimeRunnerApi, RuntimeRunnerEvent, RuntimeRunnerStatus, RuntimeSeedPortValue, RuntimeWireType, } from './types.js';
+export type { MetaFromStatefulObservable, NodeId, EdgeId, RunId, PortMeta, RuntimeEdge, RuntimeEditorApi, RuntimeFeedPortMeta, RuntimeFeedRole, RuntimeInputReceivedEvent, RuntimeNode, RuntimeOutputEmittedEvent, RuntimePortSignalState, RuntimeResumeOptions, RuntimeRunnerApi, RuntimeRunnerEvent, RuntimeRunnerStatus, RuntimeSeedPortValue, RuntimeWireType, } from './types.js';
 export type { RuntimeOptions };
 export declare class RuntimeFacade {
     readonly editor: RuntimeEditor;

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

@@ -14,6 +14,12 @@ export type RunId = string & {
     readonly __brand: 'RunId';
 };
 type RuntimeInputPortMode = 'single' | 'merge' | 'combine' | 'zip' | 'bypass';
+export type RuntimeFeedRole = 'none' | 'reasoning' | 'draft' | 'tool' | 'shell' | 'result' | 'recovery';
+export type RuntimeFeedPortMeta = {
+    readonly role?: RuntimeFeedRole;
+    /** When true, feed visit stays open for chunks / interleaved streams. */
+    readonly streaming?: boolean;
+};
 /**
  * Typed metadata attached to every `statefulConnection` / `statefulObservable`
  * via the `meta` field. Replaces the old string-encoding scheme.
@@ -35,6 +41,8 @@ export type PortMeta = {
      * `node.inputs` for the canvas.
      */
     readonly defaultValue?: unknown;
+    /** Author-supplied feed role / streaming hint for the work log. */
+    readonly feed?: RuntimeFeedPortMeta;
 };
 /**
  * Extract the `meta` type carried by a {@link StatefulObservable} /
@@ -120,6 +128,8 @@ export type RuntimeOutputEmittedEvent = {
     readonly edgeIds: EdgeId[];
     readonly state: RuntimePortSignalState;
     readonly value: unknown;
+    /** Resolved author feed contract carried with the runtime fact. */
+    readonly feed?: RuntimeFeedPortMeta;
 };
 export type RuntimeInputReceivedEvent = {
     readonly kind: 'input-received';
@@ -130,6 +140,8 @@ export type RuntimeInputReceivedEvent = {
     readonly edgeIds: EdgeId[];
     readonly state: RuntimePortSignalState;
     readonly value: unknown;
+    /** Resolved author feed contract carried with the runtime fact. */
+    readonly feed?: RuntimeFeedPortMeta;
 };
 export type RuntimeRunnerEvent = RuntimeOutputEmittedEvent | RuntimeInputReceivedEvent | {
     /**

package/vendor/server/dist/bridge/attach-langflower-bridge.d.ts

@@ -4,13 +4,16 @@ import type { LangflowerBridge } from './langflower-bridge.types.js';
 export type { LangflowerBridge } from './langflower-bridge.types.js';
 export type AttachLangflowerBridgeOptions = {
     readonly onRunSettled?: (status: TerminalExecutionProgressStatus) => void;
+    /** Initial effective `serverLogs` gate (defaults to enabled). */
+    readonly serverLogsEnabled?: boolean;
 };
 /**
  * Wire `langflowerWsConfig` handlers onto the WS bridge.
  *
  * Call order (see also `BRIDGE.md`):
+ * 0. Diagnostic bridge JSONL log (gated by effective `serverLogs`)
  * 1. Always-on runner telemetry fan-out
  * 2. Connect / disconnect → index + bootstrap snapshots
  * 3. Intent handlers by bus namespace (workflow → palette → editor → runner)
  */
-export declare const attachLangflowerBridge: (bridge: LangflowerBridge, context: ServerContext, options?: AttachLangflowerBridgeOptions) => (() => void);
+export declare const attachLangflowerBridge: (bridge: LangflowerBridge, context: ServerContext, options?: AttachLangflowerBridgeOptions) => (() => Promise<void>);

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

@@ -3,19 +3,22 @@ import { Subscription } from 'rxjs';
 import { RunCheckpointSession } from '../checkpoint/run-checkpoint-session.js';
 import { LangflowerSession } from '../session/langflower-session.js';
 import { clearClientIndex, indexClient, unindexClient, } from './client-index.js';
+import { attachBridgeEventLog } from './bridge-event-log.js';
 import { emitBootstrap } from './emit-bootstrap.js';
 import { forwardRunnerEvent } from './forward-runner-event.js';
-import { wireConfigHandlers } from './wire-config-handlers.js';
+import { applyServerLogsGate, wireConfigHandlers, } from './wire-config-handlers.js';
 import { wireEditorHandlers } from './wire-editor-handlers.js';
 import { wireCustomPaletteHandlers } from './wire-custom-palette-handlers.js';
 import { wirePaletteHandlers } from './wire-palette-handlers.js';
 import { wireProjectBootstrapHandlers } from './wire-project-bootstrap-handlers.js';
 import { wireRunnerHandlers } from './wire-runner-handlers.js';
 import { wireWorkflowHandlers } from './wire-workflow-handlers.js';
+import { createSettingsDraftController } from './settings-draft-controller.js';
 /**
  * Wire `langflowerWsConfig` handlers onto the WS bridge.
  *
  * Call order (see also `BRIDGE.md`):
+ * 0. Diagnostic bridge JSONL log (gated by effective `serverLogs`)
  * 1. Always-on runner telemetry fan-out
  * 2. Connect / disconnect → index + bootstrap snapshots
  * 3. Intent handlers by bus namespace (workflow → palette → editor → runner)
@@ -25,6 +28,8 @@ export const attachLangflowerBridge = (bridge, context, options = {}) => {
     const checkpoints = new RunCheckpointSession(context.projectDir);
     const rootSubscription = new Subscription();
     const onRunSettled = options.onRunSettled;
+    const diagnosticLog = attachBridgeEventLog(bridge, context.projectDir, rootSubscription, { enabled: options.serverLogsEnabled !== false });
+    const draftController = createSettingsDraftController(bridge, context, session);
     // 1. Always-on telemetry: subscribe once for the whole bridge lifetime,
     // independent of clients/runs. Guarantees initial `pending` events from
     // `runner.start()` are captured — a later per-client subscription would
@@ -45,7 +50,7 @@ export const attachLangflowerBridge = (bridge, context, options = {}) => {
         indexClient(bridge, client);
         const subscriptions = new Subscription();
         rootSubscription.add(subscriptions);
-        void emitBootstrap(client, context, session, checkpoints);
+        void emitBootstrap(client, context, session, checkpoints, draftController);
         subscriptions.add(client.disconnected$.subscribe(() => {
             subscriptions.unsubscribe();
             unindexClient(bridge, client.id);
@@ -55,13 +60,19 @@ export const attachLangflowerBridge = (bridge, context, options = {}) => {
     rootSubscription.add(wireWorkflowHandlers(bridge, context, session));
     rootSubscription.add(wirePaletteHandlers(bridge, context));
     rootSubscription.add(wireCustomPaletteHandlers(bridge, context));
-    rootSubscription.add(wireConfigHandlers(bridge, context));
+    rootSubscription.add(wireConfigHandlers(bridge, context, session, draftController, {
+        onEffectiveConfig: (config) => {
+            applyServerLogsGate(diagnosticLog.setEnabled, config);
+        },
+    }));
     rootSubscription.add(wireProjectBootstrapHandlers(bridge, context, session));
-    rootSubscription.add(wireEditorHandlers(bridge, context, session));
+    rootSubscription.add(wireEditorHandlers(bridge, context, session, draftController));
     rootSubscription.add(wireRunnerHandlers(bridge, context, session, checkpoints));
-    return () => {
+    return async () => {
+        diagnosticLog.writeServerClosing();
         rootSubscription.unsubscribe();
         clearClientIndex(bridge);
         session.dispose();
+        await diagnosticLog.flush();
     };
 };

package/vendor/server/dist/bridge/bridge-event-log.d.ts

@@ -0,0 +1,12 @@
+import { Subscription } from 'rxjs';
+import type { LangflowerBridge } from './langflower-bridge.types.js';
+export type BridgeEventLog = {
+    readonly filePath: string;
+    setEnabled(enabled: boolean): void;
+    writeServerClosing(): void;
+    flush(): Promise<void>;
+};
+export type AttachBridgeEventLogOptions = {
+    readonly enabled?: boolean;
+};
+export declare const attachBridgeEventLog: (bridge: LangflowerBridge, projectDir: string, subscriptions: Subscription, options?: AttachBridgeEventLogOptions) => BridgeEventLog;

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

@@ -0,0 +1,199 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { langflowerWsConfig } from '@langflower/shared/langflower.js';
+import { Subscription } from 'rxjs';
+const REDACTED = '[REDACTED]';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isSecretKey = (key) => {
+    const normalized = key.toLowerCase();
+    return (normalized.includes('apikey') ||
+        normalized.includes('authorization') ||
+        normalized.includes('cookie') ||
+        normalized.includes('token') ||
+        normalized.includes('password') ||
+        normalized.includes('secret') ||
+        normalized.includes('credential'));
+};
+const sanitize = (value, seen = new WeakSet()) => {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'bigint') {
+        return `${value}n`;
+    }
+    if (typeof value === 'undefined') {
+        return '[undefined]';
+    }
+    if (typeof value === 'symbol' || typeof value === 'function') {
+        return `[${typeof value}]`;
+    }
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+        };
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === 'object') {
+        if (seen.has(value)) {
+            return '[circular]';
+        }
+        seen.add(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => sanitize(entry, seen));
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            isSecretKey(key) ? REDACTED : sanitize(entry, seen),
+        ]));
+    }
+    return String(value);
+};
+const toSafeTimestamp = (date) => date.toISOString().replaceAll(':', '-').replaceAll('.', '-');
+const asObservable = (value) => isRecord(value) && typeof value.subscribe === 'function'
+    ? value
+    : undefined;
+const asInboundEvent = (value) => isRecord(value) && typeof value.clientId === 'string' && 'payload' in value
+    ? { clientId: value.clientId, payload: value.payload }
+    : undefined;
+const logPath = (projectDir) => path.join(projectDir, '.langflower', 'logs', `${toSafeTimestamp(new Date())}-${process.pid}-${randomUUID()}.log`);
+export const attachBridgeEventLog = (bridge, projectDir, subscriptions, options = {}) => {
+    const filePath = logPath(projectDir);
+    let enabled = options.enabled !== false;
+    let acceptingWrites = true;
+    let closed = false;
+    let reportedFailure = false;
+    let directoryReady = false;
+    let writeQueue = Promise.resolve();
+    const reportFailure = (error) => {
+        if (reportedFailure) {
+            return;
+        }
+        reportedFailure = true;
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Langflower diagnostic logging disabled: ${message}\n`);
+    };
+    const write = (record) => {
+        if (!enabled || !acceptingWrites || closed) {
+            return;
+        }
+        const line = `${JSON.stringify(sanitize({
+            schemaVersion: 1,
+            timestamp: new Date().toISOString(),
+            ...record,
+        }))}\n`;
+        writeQueue = writeQueue.then(async () => {
+            if (!enabled || !acceptingWrites) {
+                return;
+            }
+            try {
+                if (!directoryReady) {
+                    await fs.mkdir(path.dirname(filePath), { recursive: true });
+                    directoryReady = true;
+                }
+                await fs.appendFile(filePath, line, 'utf8');
+            }
+            catch (error) {
+                acceptingWrites = false;
+                reportFailure(error);
+            }
+        });
+    };
+    const bridgeChannels = bridge;
+    const inboundKeys = Object.keys(langflowerWsConfig.fromClientToServer);
+    const outboundKeys = Object.keys(langflowerWsConfig.fromServerToClient);
+    for (const type of inboundKeys) {
+        const channel = asObservable(bridgeChannels[type]);
+        if (channel === undefined) {
+            continue;
+        }
+        subscriptions.add(channel.subscribe((value) => {
+            const event = asInboundEvent(value);
+            if (event !== undefined) {
+                write({
+                    kind: 'frame',
+                    direction: 'inbound',
+                    clientId: event.clientId,
+                    type,
+                    payload: event.payload,
+                });
+            }
+        }));
+    }
+    for (const type of outboundKeys) {
+        const channel = asObservable(bridgeChannels[type]);
+        if (channel === undefined) {
+            continue;
+        }
+        subscriptions.add(channel.subscribe((payload) => {
+            write({
+                kind: 'frame',
+                direction: 'outbound',
+                scope: 'broadcast',
+                type,
+                payload,
+            });
+        }));
+    }
+    subscriptions.add(bridge.status$.subscribe((status) => {
+        write({ kind: 'status', status });
+    }));
+    subscriptions.add(bridge.errors$.subscribe((error) => {
+        write({
+            kind: 'error',
+            error: {
+                code: error.code,
+                message: error.message,
+                ...('cause' in error ? { cause: error.cause } : {}),
+            },
+        });
+    }));
+    subscriptions.add(bridge.connections$.subscribe((client) => {
+        write({ kind: 'connection', clientId: client.id });
+        const clientSubscriptions = new Subscription();
+        subscriptions.add(clientSubscriptions);
+        const clientChannels = client;
+        for (const type of outboundKeys) {
+            const channel = asObservable(clientChannels[type]);
+            if (channel === undefined) {
+                continue;
+            }
+            clientSubscriptions.add(channel.subscribe((payload) => {
+                write({
+                    kind: 'frame',
+                    direction: 'outbound',
+                    scope: 'client',
+                    clientId: client.id,
+                    type,
+                    payload,
+                });
+            }));
+        }
+        clientSubscriptions.add(client.disconnected$.subscribe(() => {
+            write({ kind: 'disconnection', clientId: client.id });
+            clientSubscriptions.unsubscribe();
+        }));
+    }));
+    write({ kind: 'server-started' });
+    return {
+        filePath,
+        setEnabled: (nextEnabled) => {
+            enabled = nextEnabled;
+        },
+        writeServerClosing: () => {
+            write({ kind: 'server-closing' });
+            closed = true;
+        },
+        flush: async () => {
+            await writeQueue;
+        },
+    };
+};

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

@@ -2,7 +2,7 @@ import { type ExecutionContext } from '@langflower/node-sdk';
 import type { LlmExecutionCaps } from '@langflower/node-sdk/llm';
 import type { McpHandle } from '@langflower/node-sdk/mcp';
 import type { RuntimeSeedPortValue } from '@langflower/runtime';
-import type { LangflowerConfig, RunnerPermissionAskPayload } from '@langflower/shared/langflower.js';
+import { type LangflowerConfig, type RunnerPermissionAskPayload } from '@langflower/shared/langflower.js';
 import type { ServerContext } from '../server-context.js';
 import type { LangflowerSession } from '../session/langflower-session.js';
 type WorkflowGraphNode = {

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

@@ -1,6 +1,7 @@
 import { parseLlmRolePreset, resolveEffectiveSkillId, resolveEffectiveToolPermissions, toolPermissionsToEnabledIds, } from '@langflower/common-nodes/ai/llm-role-preset';
 import { attachRunHostServices } from '@langflower/common-nodes/ai/run-host-services';
 import { contextSymbol, } from '@langflower/node-sdk';
+import { parseDefaultChatModel, } from '@langflower/shared/langflower.js';
 import { collectEnabledMcpIdsFromNodes, createSystemMcpHandles, filterMcpFailuresForNode, filterMcpHandlesByIds, parseEnabledMcpIds, } from '@langflower/tools/create-system-mcp-handles';
 import { createProjectHarness, } from '@langflower/tools/create-project-harness';
 import { createWebFetch } from '@langflower/tools/create-web-fetch';
@@ -79,12 +80,14 @@ export const buildExecutionContext = async (context, runId, node, hooks, preload
         ...(toolHandles.length > 0 ? { toolHandles } : {}),
         ...(mcpHandles.length > 0 ? { mcpHandles } : {}),
     };
+    const defaultChat = parseDefaultChatModel(config.model);
     return attachRunHostServices(base, {
         ...(node.type !== 'common-fake-llm'
             ? {
                 createChatCompletionStream: bindCreateChatCompletionStream(context.langflowerConfigService),
             }
             : {}),
+        ...(defaultChat !== null ? { defaultChat } : {}),
         ...(skillMarkdown.length > 0 ? { skillMarkdown } : {}),
         ...(agentsMarkdown.length > 0 ? { agentsMarkdown } : {}),
         ...(toolHarness.authorize !== undefined

package/vendor/server/dist/bridge/emit-bootstrap.d.ts

@@ -2,13 +2,15 @@ import type { RunCheckpointSession } from '../checkpoint/run-checkpoint-session.
 import type { ServerContext } from '../server-context.js';
 import { LangflowerSession } from '../session/langflower-session.js';
 import type { LangflowerClient } from './langflower-bridge.types.js';
+import type { SettingsDraftController } from './settings-draft-controller.js';
 /**
  * Connect / reconnect bootstrap emit order (authoritative for docs):
  * session.state.snapshot → runner.snapshot → executionFeed.snapshot →
  * runner.checkpoints.snapshot → toolConfig.snapshot →
  * workflow.list/current.snapshot → session.ready →
- * langflower.config.snapshot → (async) langflower.models.catalog.snapshot →
+ * langflower.config.snapshot → langflower.config.draft.snapshot →
+ * (async) langflower.models.catalog.snapshot →
  * permission.ask replay → palette.snapshot → customPalette.snapshot
  * (custom snapshot is warm from createServer — emit only, no compile).
  */
-export declare const emitBootstrap: (client: LangflowerClient, context: ServerContext, session: LangflowerSession, checkpoints: RunCheckpointSession) => Promise<void>;
+export declare const emitBootstrap: (client: LangflowerClient, context: ServerContext, session: LangflowerSession, checkpoints: RunCheckpointSession, draftController?: SettingsDraftController) => Promise<void>;

package/vendor/server/dist/bridge/emit-bootstrap.js

@@ -11,11 +11,12 @@ import { pushModelsCatalogToClient } from './push-models-catalog.js';
  * session.state.snapshot → runner.snapshot → executionFeed.snapshot →
  * runner.checkpoints.snapshot → toolConfig.snapshot →
  * workflow.list/current.snapshot → session.ready →
- * langflower.config.snapshot → (async) langflower.models.catalog.snapshot →
+ * langflower.config.snapshot → langflower.config.draft.snapshot →
+ * (async) langflower.models.catalog.snapshot →
  * permission.ask replay → palette.snapshot → customPalette.snapshot
  * (custom snapshot is warm from createServer — emit only, no compile).
  */
-export const emitBootstrap = async (client, context, session, checkpoints) => {
+export const emitBootstrap = async (client, context, session, checkpoints, draftController) => {
     const langflowerConfig = await context.langflowerConfigService.read();
     if (langflowerConfig.currentWorkflowId !== undefined &&
         session.activeWorkflow === null) {
@@ -56,6 +57,9 @@ export const emitBootstrap = async (client, context, session, checkpoints) => {
         version: LangflowerSession.sessionReadyVersion,
     });
     clientEmit(client, 'langflower.config.snapshot', await buildLangflowerConfigSnapshot(context));
+    if (draftController !== undefined) {
+        await draftController.pushToClient(client, session.settings.scope);
+    }
     // Live model catalogs — do not block palette / connect on models.list().
     void pushModelsCatalogToClient(client, context);
     // Re-surface in-flight permission asks after reconnect (tool loop still waiting).

package/vendor/server/dist/bridge/settings-draft-controller.d.ts

@@ -0,0 +1,14 @@
+import type { LangflowerConfig, LangflowerConfigDraftSnapshotPayload, LangflowerConfigSaveRequestedPayload, LangflowerConfigScope, SettingsDraft } from '@langflower/shared/langflower.js';
+import type { ServerContext } from '../server-context.js';
+import type { LangflowerSession } from '../session/langflower-session.js';
+import type { LangflowerBridge, LangflowerClient } from './langflower-bridge.types.js';
+export type SettingsDraftController = {
+    readonly ensureSeeded: (scope: LangflowerConfigScope) => Promise<void>;
+    readonly snapshotFor: (scope: LangflowerConfigScope) => Promise<LangflowerConfigDraftSnapshotPayload | null>;
+    readonly broadcast: (scope: LangflowerConfigScope) => Promise<void>;
+    readonly pushToClient: (client: LangflowerClient, scope: LangflowerConfigScope) => Promise<void>;
+    readonly patch: (scope: LangflowerConfigScope, draft: SettingsDraft) => Promise<void>;
+    readonly discard: (scope: LangflowerConfigScope) => Promise<void>;
+    readonly commitSave: (scope: LangflowerConfigScope, fallback?: LangflowerConfigSaveRequestedPayload) => Promise<LangflowerConfig | null>;
+};
+export declare const createSettingsDraftController: (bridge: LangflowerBridge, context: ServerContext, session: LangflowerSession) => SettingsDraftController;