langflower 0.0.3 → 0.0.5

package/vendor/server/dist/bridge/client-index.d.ts

@@ -3,4 +3,3 @@ export declare const indexClient: (bridge: LangflowerBridge, client: LangflowerC
 export declare const unindexClient: (bridge: LangflowerBridge, clientId: string) => void;
 export declare const findClientById: (bridge: LangflowerBridge, clientId: string) => LangflowerClient | undefined;
 export declare const clearClientIndex: (bridge: LangflowerBridge) => void;
-//# sourceMappingURL=client-index.d.ts.map

package/vendor/server/dist/bridge/client-index.js

@@ -14,4 +14,3 @@ export const findClientById = (bridge, clientId) => clientIndex.get(bridge)?.get
 export const clearClientIndex = (bridge) => {
     clientIndex.delete(bridge);
 };
-//# sourceMappingURL=client-index.js.map

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>;
-//# sourceMappingURL=emit-bootstrap.d.ts.map
+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,10 +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) {
@@ -55,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).
@@ -63,13 +68,12 @@ export const emitBootstrap = async (client, context, session, checkpoints) => {
     }
     const paletteResult = await context.paletteService.reload(context.projectDir);
     clientEmit(client, 'palette.snapshot', paletteResult.payload);
-    if (await hasCustomNodePacks(context.projectDir)) {
-        clientEmit(client, 'customPalette.snapshot', context.customPaletteService.compilingSnapshot());
-        const customSnapshot = await context.customPaletteService.update(context.projectDir);
-        clientEmit(client, 'customPalette.snapshot', customSnapshot);
+    const customSnapshot = context.customPaletteService.getSnapshot();
+    if (customSnapshot.status === 'not_compiled' &&
+        !(await hasCustomNodePacks(context.projectDir))) {
+        clientEmit(client, 'customPalette.snapshot', context.customPaletteService.applyEmptyOk());
     }
     else {
-        clientEmit(client, 'customPalette.snapshot', context.customPaletteService.applyEmptyOk());
+        clientEmit(client, 'customPalette.snapshot', customSnapshot);
     }
 };
-//# sourceMappingURL=emit-bootstrap.js.map

package/vendor/server/dist/bridge/forward-runner-event.d.ts

@@ -2,4 +2,3 @@ import type { RuntimeRunnerEvent } from '@langflower/runtime';
 import type { LangflowerBridge } from './langflower-bridge.types.js';
 /** Fan-out runner telemetry to every connected tab (session-shared). */
 export declare const forwardRunnerEvent: (bridge: LangflowerBridge, event: RuntimeRunnerEvent) => void;
-//# sourceMappingURL=forward-runner-event.d.ts.map

package/vendor/server/dist/bridge/forward-runner-event.js

@@ -15,4 +15,3 @@ export const forwardRunnerEvent = (bridge, event) => {
             break;
     }
 };
-//# sourceMappingURL=forward-runner-event.js.map

package/vendor/server/dist/bridge/inbound-guards.d.ts

@@ -1,3 +1,2 @@
 import type { WsBridgeServerInboundEvent } from '@langflower/websocket-bridge';
 export declare const isInboundEvent: <TPayload>(value: unknown) => value is WsBridgeServerInboundEvent<TPayload>;
-//# sourceMappingURL=inbound-guards.d.ts.map

package/vendor/server/dist/bridge/inbound-guards.js

@@ -2,4 +2,3 @@ export const isInboundEvent = (value) => typeof value === 'object' &&
     value !== null &&
     'clientId' in value &&
     'payload' in value;
-//# sourceMappingURL=inbound-guards.js.map

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

@@ -2,4 +2,3 @@ import { createServer as createWsBridge } from '@langflower/websocket-bridge/cre
 import { langflowerWsConfig } from '@langflower/shared/langflower.js';
 export type LangflowerBridge = ReturnType<typeof createWsBridge<typeof langflowerWsConfig>>;
 export type LangflowerClient = LangflowerBridge['connections$'] extends import('rxjs').Observable<infer Client> ? Client : never;
-//# sourceMappingURL=langflower-bridge.types.d.ts.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=langflower-bridge.types.js.map

package/vendor/server/dist/bridge/push-models-catalog.d.ts

@@ -10,4 +10,3 @@ export declare const buildModelsCatalogSnapshot: (context: ServerContext) => Pro
 export declare const pushModelsCatalogToClient: (client: LangflowerClient, context: ServerContext) => Promise<void>;
 /** Broadcast catalog to all tabs (after Settings Save). */
 export declare const broadcastModelsCatalog: (bridge: LangflowerBridge, context: ServerContext) => Promise<void>;
-//# sourceMappingURL=push-models-catalog.d.ts.map

package/vendor/server/dist/bridge/push-models-catalog.js

@@ -29,4 +29,3 @@ export const pushModelsCatalogToClient = async (client, context) => {
 export const broadcastModelsCatalog = async (bridge, context) => {
     bridgeEmit(bridge, 'langflower.models.catalog.snapshot', await buildModelsCatalogSnapshot(context));
 };
-//# sourceMappingURL=push-models-catalog.js.map

package/vendor/server/dist/bridge/same-canvas-viewport.d.ts

@@ -1,4 +1,3 @@
 import type { CanvasViewport } from '@langflower/shared/langflower.js';
 /** Epsilon compare — skip no-op viewport writes that would markDirty. */
 export declare const sameCanvasViewport: (left: CanvasViewport, right: CanvasViewport) => boolean;
-//# sourceMappingURL=same-canvas-viewport.d.ts.map

package/vendor/server/dist/bridge/same-canvas-viewport.js

@@ -3,4 +3,3 @@ const VIEWPORT_COORD_EPSILON = 0.01;
 export const sameCanvasViewport = (left, right) => Math.abs(left.x - right.x) < VIEWPORT_COORD_EPSILON &&
     Math.abs(left.y - right.y) < VIEWPORT_COORD_EPSILON &&
     Math.abs(left.scale - right.scale) < VIEWPORT_COORD_EPSILON;
-//# sourceMappingURL=same-canvas-viewport.js.map

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;

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

@@ -0,0 +1,178 @@
+/**
+ * Session Settings draft: seed, patch, discard, save commit, connection probe.
+ */
+import { listProviderModels as listOpenAiProviderModels } from '@langflower/common-nodes/ai/openai/list-provider-models';
+import { draftToSavePayload, mergeLangflowerConfigLayers, } from '@langflower/shared/langflower.js';
+import { resolveDraftProviderCredentials } from '../config/resolve-draft-provider-credentials.js';
+import { applyDraftPatch, buildDraftSnapshot, providerIndexesWithBaseUrl, seedScopeDraft, setConnectionStatus, } from '../session/settings-draft-session.js';
+import { bridgeEmit, clientEmit } from './bridge-outbound.js';
+import { buildLangflowerConfigSnapshot } from './build-langflower-config-snapshot.js';
+const isScope = (value) => value === 'project' || value === 'global';
+const layerForScope = (layers, scope) => (scope === 'project' ? layers.project : layers.global);
+export const createSettingsDraftController = (bridge, context, session) => {
+    const probeGeneration = new Map();
+    const getState = (scope) => scope === 'project'
+        ? session.settingsDraft.project
+        : session.settingsDraft.global;
+    const setState = (scope, state) => {
+        if (scope === 'project') {
+            session.settingsDraft.project = state;
+        }
+        else {
+            session.settingsDraft.global = state;
+        }
+    };
+    /** Emit current session draft — never re-enters ensureSeeded/probe. */
+    const emitCurrent = (scope) => {
+        const state = getState(scope);
+        if (state === undefined) {
+            return;
+        }
+        bridgeEmit(bridge, 'langflower.config.draft.snapshot', buildDraftSnapshot(scope, state));
+    };
+    const runProbe = async (scope, index) => {
+        const key = `${scope}:${index}`;
+        const generation = (probeGeneration.get(key) ?? 0) + 1;
+        probeGeneration.set(key, generation);
+        const state = getState(scope);
+        const row = state?.draft.providers[index];
+        if (state === undefined || row === undefined) {
+            return;
+        }
+        const baseURL = row.baseURL.trim();
+        if (baseURL.length === 0) {
+            setState(scope, setConnectionStatus(state, index, { state: 'idle' }));
+            emitCurrent(scope);
+            return;
+        }
+        setState(scope, setConnectionStatus(state, index, { state: 'checking' }));
+        emitCurrent(scope);
+        const layers = await context.langflowerConfigService.readLayers();
+        const savedLayer = layerForScope(layers, scope);
+        const resolved = resolveDraftProviderCredentials(row, savedLayer);
+        let status;
+        if (!resolved.ok) {
+            status = { state: 'error', message: resolved.message };
+        }
+        else {
+            const listed = await listOpenAiProviderModels(resolved.credentials);
+            status =
+                listed.error !== undefined
+                    ? { state: 'error', message: listed.error }
+                    : { state: 'ok', modelCount: listed.models.length };
+        }
+        if (probeGeneration.get(key) !== generation) {
+            return;
+        }
+        const latest = getState(scope);
+        if (latest === undefined ||
+            latest.draft.providers[index] === undefined) {
+            return;
+        }
+        setState(scope, setConnectionStatus(latest, index, status));
+        emitCurrent(scope);
+    };
+    const probeProvidersWithUrl = (scope, draft) => {
+        for (const index of providerIndexesWithBaseUrl(draft)) {
+            void runProbe(scope, index);
+        }
+    };
+    const ensureSeeded = async (scope) => {
+        if (getState(scope) !== undefined) {
+            return;
+        }
+        const layers = await context.langflowerConfigService.readLayers();
+        const seeded = seedScopeDraft(layerForScope(layers, scope));
+        setState(scope, seeded);
+        // Seed leaves URL rows as `checking`; kick probes so launch shows
+        // Connected/error without requiring an edit first.
+        probeProvidersWithUrl(scope, seeded.draft);
+    };
+    const snapshotFor = async (scope) => {
+        await ensureSeeded(scope);
+        const state = getState(scope);
+        if (state === undefined) {
+            return null;
+        }
+        return buildDraftSnapshot(scope, state);
+    };
+    const broadcast = async (scope) => {
+        await ensureSeeded(scope);
+        emitCurrent(scope);
+    };
+    const pushToClient = async (client, scope) => {
+        const snapshot = await snapshotFor(scope);
+        if (snapshot === null) {
+            return;
+        }
+        clientEmit(client, 'langflower.config.draft.snapshot', snapshot);
+    };
+    const patch = async (scope, draft) => {
+        await ensureSeeded(scope);
+        const previous = getState(scope);
+        if (previous === undefined) {
+            return;
+        }
+        const { next, probeIndexes } = applyDraftPatch(previous, draft);
+        setState(scope, next);
+        emitCurrent(scope);
+        for (const index of probeIndexes) {
+            void runProbe(scope, index);
+        }
+    };
+    const discard = async (scope) => {
+        const layers = await context.langflowerConfigService.readLayers();
+        const seeded = seedScopeDraft(layerForScope(layers, scope));
+        setState(scope, seeded);
+        emitCurrent(scope);
+        probeProvidersWithUrl(scope, seeded.draft);
+    };
+    const commitSave = async (scope, fallback) => {
+        await ensureSeeded(scope);
+        const state = getState(scope);
+        // Prefer an explicit Save payload (provider/model/serverLogs) so a
+        // trailing draft.patch cannot race past commit. Otherwise persist the
+        // session draft (`{ scope }` only).
+        const payload = fallback !== undefined &&
+            (fallback.provider !== undefined ||
+                fallback.model !== undefined ||
+                'serverLogs' in fallback)
+            ? fallback
+            : state !== undefined
+                ? draftToSavePayload(scope, state.draft)
+                : fallback;
+        if (payload === undefined || !isScope(payload.scope)) {
+            return null;
+        }
+        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 }
+                : {}),
+            ...('serverLogs' in payload
+                ? { serverLogs: payload.serverLogs }
+                : {}),
+        });
+        const layer = layerForScope(layers, scope);
+        const seeded = seedScopeDraft(layer);
+        setState(scope, seeded);
+        const snapshot = await buildLangflowerConfigSnapshot(context);
+        bridgeEmit(bridge, 'langflower.config.snapshot', snapshot);
+        emitCurrent(scope);
+        probeProvidersWithUrl(scope, seeded.draft);
+        return mergeLangflowerConfigLayers(layers.global, layers.project);
+    };
+    return {
+        ensureSeeded,
+        snapshotFor,
+        broadcast,
+        pushToClient,
+        patch,
+        discard,
+        commitSave,
+    };
+};

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

@@ -1,5 +1,11 @@
 import type { Subscription } from 'rxjs';
+import type { LangflowerConfig } from '@langflower/shared/langflower.js';
 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 wireConfigHandlers: (bridge: LangflowerBridge, context: ServerContext) => Subscription;
-//# sourceMappingURL=wire-config-handlers.d.ts.map
+import type { SettingsDraftController } from './settings-draft-controller.js';
+export type WireConfigHandlersOptions = {
+    readonly onEffectiveConfig?: (config: LangflowerConfig) => void;
+};
+export declare const wireConfigHandlers: (bridge: LangflowerBridge, context: ServerContext, _session: LangflowerSession, draftController: SettingsDraftController, options?: WireConfigHandlersOptions) => Subscription;
+export declare const applyServerLogsGate: (setEnabled: (enabled: boolean) => void, config: LangflowerConfig) => void;

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

@@ -1,22 +1,49 @@
-import { bridgeEmit } from './bridge-outbound.js';
-import { buildLangflowerConfigSnapshot } from './build-langflower-config-snapshot.js';
+import { resolveServerLogsEnabled } from '@langflower/shared/langflower.js';
 import { isInboundEvent } from './inbound-guards.js';
 import { broadcastModelsCatalog } from './push-models-catalog.js';
 const isConfigScope = (value) => value === 'project' || value === 'global';
-export const wireConfigHandlers = (bridge, context) => bridge['langflower.config.save.requested'].subscribe(async (raw) => {
-    if (!isInboundEvent(raw) ||
-        !isConfigScope(raw.payload.scope)) {
-        return;
+const isSettingsDraft = (value) => {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
     }
-    const { scope, model, provider, providerApiKeys } = raw.payload;
-    await context.langflowerConfigService.writeSettings({
-        scope,
-        ...(model !== undefined ? { model } : {}),
-        ...(provider !== undefined ? { provider } : {}),
-        ...(providerApiKeys !== undefined ? { providerApiKeys } : {}),
+    const draft = value;
+    return (typeof draft['defaultProviderId'] === 'string' &&
+        typeof draft['defaultModelId'] === 'string' &&
+        Array.isArray(draft['providers']) &&
+        (draft['serverLogs'] === 'off' ||
+            draft['serverLogs'] === 'default' ||
+            draft['serverLogs'] === 'on'));
+};
+export const wireConfigHandlers = (bridge, context, _session, draftController, options = {}) => {
+    const subscription = bridge['langflower.config.save.requested'].subscribe(async (raw) => {
+        if (!isInboundEvent(raw) ||
+            !isConfigScope(raw.payload.scope)) {
+            return;
+        }
+        const effective = await draftController.commitSave(raw.payload.scope, raw.payload);
+        if (effective === null) {
+            return;
+        }
+        options.onEffectiveConfig?.(effective);
+        await broadcastModelsCatalog(bridge, context);
     });
-    const snapshot = await buildLangflowerConfigSnapshot(context);
-    bridgeEmit(bridge, 'langflower.config.snapshot', snapshot);
-    await broadcastModelsCatalog(bridge, context);
-});
-//# sourceMappingURL=wire-config-handlers.js.map
+    subscription.add(bridge['langflower.config.draft.patch.requested'].subscribe(async (raw) => {
+        if (!isInboundEvent(raw) ||
+            !isConfigScope(raw.payload.scope) ||
+            !isSettingsDraft(raw.payload.draft)) {
+            return;
+        }
+        await draftController.patch(raw.payload.scope, raw.payload.draft);
+    }));
+    subscription.add(bridge['langflower.config.draft.discard.requested'].subscribe(async (raw) => {
+        if (!isInboundEvent(raw) ||
+            !isConfigScope(raw.payload.scope)) {
+            return;
+        }
+        await draftController.discard(raw.payload.scope);
+    }));
+    return subscription;
+};
+export const applyServerLogsGate = (setEnabled, config) => {
+    setEnabled(resolveServerLogsEnabled(config));
+};

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

@@ -2,4 +2,3 @@ import type { Subscription } from 'rxjs';
 import type { ServerContext } from '../server-context.js';
 import type { LangflowerBridge } from './langflower-bridge.types.js';
 export declare const wireCustomPaletteHandlers: (bridge: LangflowerBridge, context: ServerContext) => Subscription;
-//# sourceMappingURL=wire-custom-palette-handlers.d.ts.map

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

@@ -8,4 +8,3 @@ export const wireCustomPaletteHandlers = (bridge, context) => bridge['customPale
     const snapshot = await context.customPaletteService.update(context.projectDir);
     bridgeEmit(bridge, 'customPalette.snapshot', snapshot);
 });
-//# sourceMappingURL=wire-custom-palette-handlers.js.map

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

@@ -1,6 +1,12 @@
+import { type EditorSettingsRequestedPayload, type EditorSettingsSnapshotPayload } from '@langflower/shared/langflower.js';
 import { 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 wireEditorHandlers: (bridge: LangflowerBridge, context: ServerContext, session: LangflowerSession) => Subscription;
-//# sourceMappingURL=wire-editor-handlers.d.ts.map
+import type { SettingsDraftController } from './settings-draft-controller.js';
+export declare const wireEditorHandlers: (bridge: LangflowerBridge, context: ServerContext, session: LangflowerSession, draftController?: SettingsDraftController) => Subscription;
+/**
+ * Apply a Settings aside intent. Returns `null` when the payload is invalid
+ * (`open: true` without a valid `scope`).
+ */
+export declare const applySettingsRequested: (current: EditorSettingsSnapshotPayload, payload: EditorSettingsRequestedPayload) => EditorSettingsSnapshotPayload | null;

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

@@ -19,7 +19,7 @@ const isValidCanvasViewport = (value) => {
         Number.isFinite(viewport.scale) &&
         viewport.scale > 0);
 };
-export const wireEditorHandlers = (bridge, context, session) => {
+export const wireEditorHandlers = (bridge, context, session, draftController) => {
     const subscription = new Subscription();
     subscription.add(bridge['editor.addNode.requested'].subscribe((raw) => {
         if (!isInboundEvent(raw)) {
@@ -182,6 +182,23 @@ export const wireEditorHandlers = (bridge, context, session) => {
         bridgeEmit(bridge, 'editor.dividers.snapshot', clamped);
         void context.langflowerConfigService.setDividerPositions(clamped);
     }));
+    subscription.add(bridge['editor.settings.requested'].subscribe((raw) => {
+        if (!isInboundEvent(raw)) {
+            return;
+        }
+        if (findClientById(bridge, raw.clientId) === undefined) {
+            return;
+        }
+        const next = applySettingsRequested(session.settings, raw.payload);
+        if (next === null) {
+            return;
+        }
+        session.settings = next;
+        bridgeEmit(bridge, 'editor.settings.snapshot', next);
+        if (next.open && draftController !== undefined) {
+            void draftController.broadcast(next.scope);
+        }
+    }));
     subscription.add(bridge['editor.selectNode.requested'].subscribe((raw) => {
         if (!isInboundEvent(raw)) {
             return;
@@ -194,9 +211,30 @@ export const wireEditorHandlers = (bridge, context, session) => {
             !session.activeWorkflow?.graph.nodes.some((node) => node.id === nodeId)) {
             return;
         }
+        if (nodeId !== null && session.settings.open) {
+            const closed = {
+                open: false,
+                scope: session.settings.scope,
+            };
+            session.settings = closed;
+            bridgeEmit(bridge, 'editor.settings.snapshot', closed);
+        }
         session.selectedNodeId = nodeId;
         bridgeEmit(bridge, 'editor.nodeSelected', buildSelectedNodePayload(session, context.resolveDefinition));
     }));
     return subscription;
 };
-//# sourceMappingURL=wire-editor-handlers.js.map
+const isConfigScope = (value) => value === 'project' || value === 'global';
+/**
+ * Apply a Settings aside intent. Returns `null` when the payload is invalid
+ * (`open: true` without a valid `scope`).
+ */
+export const applySettingsRequested = (current, payload) => {
+    if (payload.open) {
+        if (!isConfigScope(payload.scope)) {
+            return null;
+        }
+        return { open: true, scope: payload.scope };
+    }
+    return { open: false, scope: current.scope };
+};

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

@@ -2,4 +2,3 @@ import type { Subscription } from 'rxjs';
 import type { ServerContext } from '../server-context.js';
 import type { LangflowerBridge } from './langflower-bridge.types.js';
 export declare const wirePaletteHandlers: (bridge: LangflowerBridge, context: ServerContext) => Subscription;
-//# sourceMappingURL=wire-palette-handlers.d.ts.map

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

@@ -7,4 +7,3 @@ export const wirePaletteHandlers = (bridge, context) => bridge['palette.reload.r
     const result = await context.paletteService.reload(context.projectDir);
     bridgeEmit(bridge, 'palette.snapshot', result.payload);
 });
-//# sourceMappingURL=wire-palette-handlers.js.map

package/vendor/server/dist/bridge/wire-project-bootstrap-handlers.d.ts

@@ -7,4 +7,3 @@ import type { LangflowerBridge } from './langflower-bridge.types.js';
  * Rejects while a run is active. Never rewrites `langflower.jsonc`.
  */
 export declare const wireProjectBootstrapHandlers: (bridge: LangflowerBridge, context: ServerContext, session: LangflowerSession) => Subscription;
-//# sourceMappingURL=wire-project-bootstrap-handlers.d.ts.map

package/vendor/server/dist/bridge/wire-project-bootstrap-handlers.js

@@ -61,4 +61,3 @@ export const wireProjectBootstrapHandlers = (bridge, context, session) => bridge
         emitResult(failResult(message));
     }
 });
-//# sourceMappingURL=wire-project-bootstrap-handlers.js.map

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

@@ -8,4 +8,3 @@ import type { LangflowerBridge } from './langflower-bridge.types.js';
  * terminal node) ends the run; no `output-emitted` "complete" signal is needed.
  */
 export declare const wireRunnerHandlers: (bridge: LangflowerBridge, context: ServerContext, session: LangflowerSession, checkpoints: RunCheckpointSession) => Subscription;
-//# sourceMappingURL=wire-runner-handlers.d.ts.map

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

@@ -273,7 +273,9 @@ export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
         if (connected === undefined) {
             return;
         }
-        session.permissionAsks.reply(raw.payload);
+        if (session.permissionAsks.reply(raw.payload)) {
+            bridgeEmit(bridge, 'runner.permission.accepted', raw.payload);
+        }
     }));
     subscription.add(bridge['runner.executionFeed.clear.requested'].subscribe((raw) => {
         if (!isInboundEvent(raw)) {
@@ -291,4 +293,3 @@ export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
     }));
     return subscription;
 };
-//# sourceMappingURL=wire-runner-handlers.js.map

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

@@ -3,4 +3,3 @@ 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 wireWorkflowHandlers: (bridge: LangflowerBridge, context: ServerContext, session: LangflowerSession) => Subscription;
-//# sourceMappingURL=wire-workflow-handlers.d.ts.map

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

@@ -73,6 +73,16 @@ export const wireWorkflowHandlers = (bridge, context, session) => {
             // 2. Persist current-workflow id when load succeeded
             if (loaded.ok) {
                 await context.langflowerConfigService.setCurrentWorkflowId(raw.payload.workflowId);
+                if (loaded.repaired) {
+                    const nodeCount = loaded.droppedNodeIds.length;
+                    const edgeCount = loaded.droppedEdgeIds.length;
+                    clientEmit(connected, 'workflow.load.repaired', {
+                        workflowId: raw.payload.workflowId,
+                        droppedNodeIds: loaded.droppedNodeIds,
+                        droppedEdgeIds: loaded.droppedEdgeIds,
+                        message: `Loaded with ${nodeCount} node(s) / ${edgeCount} edge(s) removed (invalid). Save to keep.`,
+                    });
+                }
             }
             else {
                 clientEmit(connected, 'workflow.load.failed', {
@@ -219,4 +229,3 @@ export const wireWorkflowHandlers = (bridge, context, session) => {
     }));
     return subscription;
 };
-//# sourceMappingURL=wire-workflow-handlers.js.map

package/vendor/server/dist/bridge/wrap-builtin-tool-handles.d.ts

@@ -1,8 +1,10 @@
 import type { ToolHandle } from '@langflower/node-sdk';
 import type { Harness } from '@langflower/tools/create-project-harness';
+import { type PermissionConfig } from '@langflower/tools/permission';
 /**
  * Wrap harness builtins as {@link ToolHandle}[] and apply author allowlist.
  * `enabledToolIds === undefined` → all; `[]` → none.
+ * Builtins that are always-deny under {@link permission} are omitted so the
+ * model cannot call tools that the gate would refuse without ask.
  */
-export declare const wrapBuiltinToolHandles: (harness: Harness, enabledToolIds: readonly string[] | undefined) => readonly ToolHandle[];
-//# sourceMappingURL=wrap-builtin-tool-handles.d.ts.map
+export declare const wrapBuiltinToolHandles: (harness: Harness, enabledToolIds: readonly string[] | undefined, permission?: PermissionConfig) => readonly ToolHandle[];

package/vendor/server/dist/bridge/wrap-builtin-tool-handles.js

@@ -1,3 +1,4 @@
+import { isToolAlwaysDenied, } from '@langflower/tools/permission';
 const filterEnabledBuiltins = (builtins, enabledToolIds) => {
     if (enabledToolIds === undefined) {
         return builtins;
@@ -8,12 +9,15 @@ const filterEnabledBuiltins = (builtins, enabledToolIds) => {
     const allowed = new Set(enabledToolIds);
     return builtins.filter((reg) => allowed.has(reg.toolId));
 };
+const filterAlwaysDeniedBuiltins = (builtins, permission) => builtins.filter((reg) => !isToolAlwaysDenied(permission, reg.toolId));
 /**
  * Wrap harness builtins as {@link ToolHandle}[] and apply author allowlist.
  * `enabledToolIds === undefined` → all; `[]` → none.
+ * Builtins that are always-deny under {@link permission} are omitted so the
+ * model cannot call tools that the gate would refuse without ask.
  */
-export const wrapBuiltinToolHandles = (harness, enabledToolIds) => {
-    const filtered = filterEnabledBuiltins(harness.listBuiltinRegistrations(), enabledToolIds);
+export const wrapBuiltinToolHandles = (harness, enabledToolIds, permission) => {
+    const filtered = filterAlwaysDeniedBuiltins(filterEnabledBuiltins(harness.listBuiltinRegistrations(), enabledToolIds), permission);
     return filtered.map((reg) => ({
         toolId: reg.toolId,
         name: reg.name,
@@ -31,4 +35,3 @@ export const wrapBuiltinToolHandles = (harness, enabledToolIds) => {
         },
     }));
 };
-//# sourceMappingURL=wrap-builtin-tool-handles.js.map

package/vendor/server/dist/checkpoint/list-resumable-checkpoints.d.ts

@@ -2,4 +2,3 @@ import { type WorkflowCheckpointSummary, type WorkflowLoadedPayload } from '@lan
 import type { WorkflowCheckpointStore } from './workflow-checkpoint-store.js';
 /** List resumable checkpoints, marking fingerprint mismatches as stale. */
 export declare const listResumableCheckpoints: (store: WorkflowCheckpointStore, workflowId: string | null, workflow: WorkflowLoadedPayload | null) => Promise<readonly WorkflowCheckpointSummary[]>;
-//# sourceMappingURL=list-resumable-checkpoints.d.ts.map