langflower 0.0.4 → 0.0.6

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,4 +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;
+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,21 +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);
-});
+    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-editor-handlers.d.ts

@@ -1,5 +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;
+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,8 +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;
 };
+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-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)) {

package/vendor/server/dist/config/langflower-config.service.d.ts

@@ -8,6 +8,8 @@ export type LangflowerConfigSettingsWrite = {
     readonly model?: string;
     readonly provider?: Readonly<Record<string, LangflowerProviderConfig>>;
     readonly providerApiKeys?: Readonly<Record<string, string>>;
+    /** `null` clears the scope key (Settings Default). */
+    readonly serverLogs?: boolean | null;
 };
 export declare class LangflowerConfigService {
     private readonly projectDir;

package/vendor/server/dist/config/langflower-config.service.js

@@ -147,6 +147,9 @@ function parseLangflowerConfig(raw) {
             ? { currentWorkflowId: raw.currentWorkflowId }
             : {}),
         ...(typeof raw.model === 'string' ? { model: raw.model } : {}),
+        ...(typeof raw.serverLogs === 'boolean'
+            ? { serverLogs: raw.serverLogs }
+            : {}),
         ...(providers !== undefined ? { provider: providers } : {}),
         ...(tools !== undefined ? { tools } : {}),
         ...(permission !== undefined ? { permission } : {}),
@@ -195,7 +198,20 @@ function mergeLangflowerConfig(existing, patch) {
         }
     }
     if (patch.model !== undefined) {
-        merged.model = patch.model;
+        if (patch.model.trim().length === 0) {
+            delete merged.model;
+        }
+        else {
+            merged.model = patch.model;
+        }
+    }
+    if ('serverLogs' in patch) {
+        if (patch.serverLogs === undefined) {
+            delete merged.serverLogs;
+        }
+        else {
+            merged.serverLogs = patch.serverLogs;
+        }
     }
     if (patch.provider !== undefined) {
         merged.provider = patch.provider;
@@ -315,6 +331,13 @@ export class LangflowerConfigService {
         const patch = {
             ...(input.model !== undefined ? { model: input.model } : {}),
             ...(provider !== undefined ? { provider } : {}),
+            ...('serverLogs' in input
+                ? {
+                    serverLogs: input.serverLogs === null
+                        ? undefined
+                        : input.serverLogs,
+                }
+                : {}),
         };
         const merged = mergeLangflowerConfig(existingRaw, patch);
         await this.writeRawAt(filePath, merged);

package/vendor/server/dist/config/resolve-draft-provider-credentials.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resolve OpenAI-compatible credentials for a Settings draft row probe.
+ * Prefer pending draft apiKey; else fall back to the saved layer provider.
+ */
+import type { LangflowerConfig, ProviderDraft } from '@langflower/shared/langflower.js';
+type ResolvedCredentials = {
+    readonly apiKey?: string;
+    readonly baseURL?: string;
+};
+export type ResolveDraftProviderCredentialsResult = {
+    readonly ok: true;
+    readonly credentials: ResolvedCredentials;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export declare const resolveDraftProviderCredentials: (row: ProviderDraft, savedLayer: LangflowerConfig) => ResolveDraftProviderCredentialsResult;
+export {};

package/vendor/server/dist/config/resolve-draft-provider-credentials.js

@@ -0,0 +1,60 @@
+import { resolveProviderCredentials } from './resolve-provider-credentials.js';
+const ENV_REF_PATTERN = /^\{env:([A-Za-z_][A-Za-z0-9_]*)\}$/;
+const resolveEnvRef = (value, context) => {
+    const match = ENV_REF_PATTERN.exec(value);
+    if (match === null) {
+        return { ok: true, value };
+    }
+    const varName = match[1];
+    const resolved = process.env[varName];
+    if (resolved === undefined || resolved === '') {
+        return {
+            ok: false,
+            message: `Environment variable ${varName} is not set (${context})`,
+        };
+    }
+    return { ok: true, value: resolved };
+};
+export const resolveDraftProviderCredentials = (row, savedLayer) => {
+    const baseURL = row.baseURL.trim();
+    if (baseURL.length === 0) {
+        return {
+            ok: false,
+            message: 'Base URL is empty',
+        };
+    }
+    const context = `draft provider ${row.id.trim() || '(new)'}`;
+    const pendingKey = row.apiKey.trim();
+    if (pendingKey.length > 0) {
+        const resolved = resolveEnvRef(pendingKey, context);
+        if (!resolved.ok) {
+            return resolved;
+        }
+        return {
+            ok: true,
+            credentials: {
+                apiKey: resolved.value,
+                baseURL,
+            },
+        };
+    }
+    const providerId = row.id.trim();
+    if (providerId.length > 0 &&
+        savedLayer.provider?.[providerId] !== undefined) {
+        const fromSaved = resolveProviderCredentials(savedLayer, providerId);
+        if (!fromSaved.ok) {
+            return fromSaved;
+        }
+        return {
+            ok: true,
+            credentials: {
+                ...fromSaved.credentials,
+                baseURL,
+            },
+        };
+    }
+    return {
+        ok: true,
+        credentials: { baseURL },
+    };
+};

package/vendor/server/dist/create-server.js

@@ -1,5 +1,5 @@
 import { hasCustomNodePacks } from '@langflower/compiler/compile-project-nodes';
-import { langflowerWsConfig, } from '@langflower/shared/langflower.js';
+import { langflowerWsConfig, resolveServerLogsEnabled, } from '@langflower/shared/langflower.js';
 import { createServer as createWsBridge } from '@langflower/websocket-bridge/create-server';
 import express from 'express';
 import http from 'node:http';
@@ -33,23 +33,25 @@ export async function createServer(options) {
         });
     }
     const toolConfig = await context.configService.read();
+    const langflowerConfig = await context.langflowerConfigService.read();
     const port = options.port ?? toolConfig.port;
     const httpServer = http.createServer(app);
     const bridge = createWsBridge(langflowerWsConfig, { httpServer });
     const detachBridge = attachLangflowerBridge(bridge, context, {
+        serverLogsEnabled: resolveServerLogsEnabled(langflowerConfig),
         ...(options.onRunSettled !== undefined
             ? { onRunSettled: options.onRunSettled }
             : {}),
     });
     httpServer.on('close', () => {
-        detachBridge();
+        void detachBridge();
         bridge.close();
     });
     try {
         await listenHttpServer(httpServer, port, '127.0.0.1');
     }
     catch (error) {
-        detachBridge();
+        await detachBridge();
         bridge.close();
         httpServer.close();
         throw error;

package/vendor/server/dist/session/build-session-bootstrap.d.ts

@@ -1,5 +1,7 @@
-import type { SessionStateSnapshotPayload } from '@langflower/shared/langflower.js';
+import type { EditorSettingsSnapshotPayload, SessionStateSnapshotPayload } from '@langflower/shared/langflower.js';
 import type { LangflowerConfigService } from '../config/langflower-config.service.js';
 import type { ResolveNodeDefinition } from '../workflow/workflow-document.js';
 import { LangflowerSession } from './langflower-session.js';
+/** Empty effective providers → open Global Settings for bootstrap onboarding. */
+export declare const settingsAsideForEffectiveConfig: (provider: Readonly<Record<string, unknown>> | undefined, current: EditorSettingsSnapshotPayload) => EditorSettingsSnapshotPayload;
 export declare function buildSessionBootstrap(session: LangflowerSession, langflowerConfigService: LangflowerConfigService, resolveDefinition: ResolveNodeDefinition, projectDir: string): Promise<SessionStateSnapshotPayload>;

package/vendor/server/dist/session/build-session-bootstrap.js

@@ -2,12 +2,21 @@ import { redactLangflowerConfigForBridge } from '../config/redact-langflower-con
 import { withSkillsCatalog } from '../skills/with-skills-catalog.js';
 import { buildSelectedNodePayload } from './build-selected-node-payload.js';
 import { LangflowerSession } from './langflower-session.js';
+/** Empty effective providers → open Global Settings for bootstrap onboarding. */
+export const settingsAsideForEffectiveConfig = (provider, current) => {
+    if (Object.keys(provider ?? {}).length === 0) {
+        return { open: true, scope: 'global' };
+    }
+    return current;
+};
 export async function buildSessionBootstrap(session, langflowerConfigService, resolveDefinition, projectDir) {
     const langflowerConfig = redactLangflowerConfigForBridge(await withSkillsCatalog(projectDir, await langflowerConfigService.read()));
+    session.settings = settingsAsideForEffectiveConfig(langflowerConfig.provider, session.settings);
     return {
         version: LangflowerSession.snapshotVersion,
         langflowerConfig,
         dividerPositions: session.dividerPositions,
         selectedNode: buildSelectedNodePayload(session, resolveDefinition).node,
+        settings: session.settings,
     };
 }

package/vendor/server/dist/session/langflower-session.d.ts

@@ -1,7 +1,8 @@
 import type { RunId, RuntimeRunnerStatus } from '@langflower/runtime';
 import { RuntimeFacade } from '@langflower/runtime';
-import type { DividerPositions, ExecutionFeedSnapshotPayload, WorkflowCurrentStatus, WorkflowLoadedPayload } from '@langflower/shared/langflower.js';
+import type { DividerPositions, EditorSettingsSnapshotPayload, ExecutionFeedSnapshotPayload, WorkflowCurrentStatus, WorkflowLoadedPayload } from '@langflower/shared/langflower.js';
 import { PendingPermissionAsks } from '../harness/pending-permission-asks.js';
+import { type SettingsDraftStore } from './settings-draft-session.js';
 export declare class LangflowerSession {
     readonly runtime: RuntimeFacade;
     /** Feed permission.ask pause/resume for the internal tool loop. */
@@ -15,6 +16,10 @@ export declare class LangflowerSession {
     dividerPositions: DividerPositions;
     /** In-memory canvas selection, shared across tabs. `null` = nothing selected. */
     selectedNodeId: string | null;
+    /** Settings aside chrome — session memory only (not persisted to disk). */
+    settings: EditorSettingsSnapshotPayload;
+    /** Unsaved Settings form draft per scope (session memory). */
+    settingsDraft: SettingsDraftStore;
     private readonly subscriptions;
     private mcpDispose;
     constructor();
@@ -27,5 +32,5 @@ export declare class LangflowerSession {
     markPristine(): void;
     buildExecutionFeed(): ExecutionFeedSnapshotPayload | null;
     static readonly sessionReadyVersion = 1;
-    static readonly snapshotVersion = 5;
+    static readonly snapshotVersion = 6;
 }

package/vendor/server/dist/session/langflower-session.js

@@ -2,8 +2,9 @@ import { RuntimeFacade } from '@langflower/runtime';
 import { deriveExecutionProgressStatus } from '@langflower/shared/langflower.js';
 import { Subscription } from 'rxjs';
 import { PendingPermissionAsks } from '../harness/pending-permission-asks.js';
+import { emptySettingsDraftStore, } from './settings-draft-session.js';
 const SESSION_READY_VERSION = 1;
-const SNAPSHOT_VERSION = 5;
+const SNAPSHOT_VERSION = 6;
 export class LangflowerSession {
     runtime = new RuntimeFacade({ log: true });
     /** Feed permission.ask pause/resume for the internal tool loop. */
@@ -21,6 +22,13 @@ export class LangflowerSession {
     };
     /** In-memory canvas selection, shared across tabs. `null` = nothing selected. */
     selectedNodeId = null;
+    /** Settings aside chrome — session memory only (not persisted to disk). */
+    settings = {
+        open: false,
+        scope: 'project',
+    };
+    /** Unsaved Settings form draft per scope (session memory). */
+    settingsDraft = emptySettingsDraftStore();
     subscriptions = new Subscription();
     mcpDispose;
     constructor() {

package/vendor/server/dist/session/settings-draft-session.d.ts

@@ -0,0 +1,24 @@
+/**
+ * In-memory Settings draft per scope (session memory, not disk).
+ */
+import type { LangflowerConfig, LangflowerConfigDraftSnapshotPayload, LangflowerConfigScope, ProviderConnectionStatus, SettingsDraft } from '@langflower/shared/langflower.js';
+export type ScopeSettingsDraft = {
+    readonly draft: SettingsDraft;
+    readonly baseline: SettingsDraft;
+    readonly connections: Readonly<Record<string, ProviderConnectionStatus>>;
+};
+export type SettingsDraftStore = {
+    project: ScopeSettingsDraft | undefined;
+    global: ScopeSettingsDraft | undefined;
+};
+export declare const emptySettingsDraftStore: () => SettingsDraftStore;
+export declare const idleConnectionsForDraft: (draft: SettingsDraft) => Readonly<Record<string, ProviderConnectionStatus>>;
+export declare const seedScopeDraft: (layerConfig: LangflowerConfig) => ScopeSettingsDraft;
+/** Indexes of draft rows that should be probed (non-empty Base URL). */
+export declare const providerIndexesWithBaseUrl: (draft: SettingsDraft) => readonly number[];
+export declare const buildDraftSnapshot: (scope: LangflowerConfigScope, state: ScopeSettingsDraft) => LangflowerConfigDraftSnapshotPayload;
+export declare const applyDraftPatch: (previous: ScopeSettingsDraft, incoming: SettingsDraft) => {
+    readonly next: ScopeSettingsDraft;
+    readonly probeIndexes: readonly number[];
+};
+export declare const setConnectionStatus: (state: ScopeSettingsDraft, index: number, status: ProviderConnectionStatus) => ScopeSettingsDraft;