langflower 0.0.1

package/vendor/shared/dist/langflower-bus-config.js

@@ -0,0 +1,574 @@
+import { message } from '@langflower/websocket-bridge';
+/**
+ * **Editor** — live session canvas bound to {@link RuntimeEditorApi}.
+ *
+ * Context: per-WebSocket session holds a `RuntimeFacade.editor` mirror of what
+ * the user sees on ngDiagram.
+ *
+ * **Canvas topology sync:** on reconnect the full graph document arrives in
+ * `workflow.current.snapshot` (snapshot — replace projection; includes
+ * `activeWorkflow.graph.viewport`). After bootstrap, structural edits append
+ * `editor.*.delta` facts (event-sourcing friendly). Server broadcasts each
+ * delta to all connected tabs. `workflow.current.snapshot` is reserved for
+ * load/save/rename and connect — not live canvas edits.
+ * Do **not** expect graph / viewport on {@link SessionStateSnapshotPayload}.
+ *
+ * Does not load/save workflow JSON — that is {@link workflowManagerConfig}.
+ * Does not wire or run ports — that is {@link runnerConfig}.
+ */
+const editorConfig = {
+    fromClientToServer: {
+        /**
+         * Palette drop or explicit add-node intent — minimal
+         * {@link EditorAddNodeRequestedPayload}.
+         *
+         * UI sends node `type`, canvas `position`, and optional initial
+         * `params`, `inputs`, and `label`. Server owns `nodeId` assignment,
+         * default param/input filling, runtime materialization, graph insertion,
+         * and dirty marking when runner is not `'running'`.
+         *
+         * Emits `editor.addNode.delta` with added nodes or `[]` (broadcast).
+         */
+        'editor.addNode.requested': message(),
+        /**
+         * Committed update for one existing node — unified
+         * {@link EditorUpdateNodeRequestedPayload}.
+         *
+         * Payload uses `nodeId` plus any combination of optional root-level
+         * `position`, `ui`, `params`, and `inputs`. Covers move, resize, label,
+         * panel params, inline params, and open input seed values. Server rejects
+         * payloads with no update fields and while the graph is locked.
+         *
+         * `ui` / `position` / panel `params` update the session document only
+         * (params never rebind the runtime mirror — they are next-run ctx seeds).
+         * `inputs` updates also rebind the runtime mirror while unlocked.
+         * Panel `params` apply even while `runnerStatus === 'running'`;
+         * `position` / `ui` / `inputs` return `[]` while locked.
+         *
+         * Emits `editor.updateNodes` with updated nodes or `[]` (broadcast).
+         */
+        'editor.updateNode.requested': message(),
+        /**
+         * User connected two ports on the canvas.
+         *
+         * Server materializes runtime ports and calls
+         * {@link RuntimeEditorApi.addEdge}. Emits `editor.addEdge.delta`
+         * with added edges or `[]` (broadcast).
+         */
+        'editor.addEdge.requested': message(),
+        /**
+         * Clipboard paste batch — {@link EditorPasteRequestedPayload}.
+         *
+         * Client strips optimistic local clones then sends remappable
+         * `clientId`s. Server materializes nodes (honoring optional size on
+         * `position`) and edges in one dirty mark, then emits
+         * `editor.addNodes` then `editor.addEdges` (broadcast).
+         */
+        'editor.paste.requested': message(),
+        /**
+         * User deleted an edge — payload is the canvas edge id.
+         */
+        'editor.removeEdge.requested': message(),
+        /**
+         * User deleted a node — payload is the canvas node id.
+         */
+        'editor.removeNode.requested': message(),
+        /**
+         * Canvas pan/zoom committed — shared session viewport slice.
+         *
+         * Does not lock with graph edits; server stores on session and
+         * broadcasts `editor.viewport.delta` to all tabs.
+         */
+        'editor.viewport.requested': message(),
+        /**
+         * Divider positions changed — client sends on drag end.
+         *
+         * Server validates, updates session, broadcasts to all tabs, and
+         * persists to `langflower.jsonc`.
+         */
+        'editor.dividers.requested': message(),
+        /**
+         * Canvas selection changed — `nodeId` is the clicked node, or `null`
+         * to clear. Shared session state, like {@link CanvasViewport}: not
+         * locked with graph edits, not persisted to the workflow document.
+         *
+         * Server validates `nodeId` against the active graph, stores it on
+         * the session, and broadcasts `editor.nodeSelected` to all tabs.
+         */
+        'editor.selectNode.requested': message(),
+    },
+    fromServerToClient: {
+        /** Added nodes — client applies delta. Empty array = no change applied. */
+        'editor.addNodes': message(),
+        /** Updated nodes — client applies delta. Empty array = no change applied. */
+        'editor.updateNodes': message(),
+        /** Added edges — client merges / remaps ids. Empty array = no change applied. */
+        'editor.addEdges': message(),
+        /** Removed nodes — client deletes by `id`. Empty array = no change applied. */
+        'editor.deleteNodes': message(),
+        /** Removed edges (incl. cascade) — client deletes by `id`. Empty array = no change applied. */
+        'editor.deleteEdges': message(),
+        /** Shared canvas viewport — client applies via ng-diagram `setViewport`. */
+        'editor.viewport.delta': message(),
+        /** Divider positions — broadcast to all tabs after server persistence. */
+        'editor.dividers.snapshot': message(),
+        /**
+         * Authoritative selected node — full {@link WorkflowNodePersisted}
+         * plus its {@link PaletteNodeDefinition} (for Inspector panel
+         * `uiSchema` fields), or `node: null` when nothing is selected.
+         *
+         * Broadcast to all tabs after `editor.selectNode.requested`, after an
+         * `editor.updateNode.requested` that touches the selected node, and
+         * when the selection is invalidated (node removed, workflow switched).
+         * Client renders the Inspector directly from this payload — no local
+         * lookup against other node lists.
+         */
+        'editor.nodeSelected': message(),
+    },
+};
+/**
+ * **Runner** — session execution control and port telemetry.
+ *
+ * Context: {@link RuntimeRunnerApi} on the same session `RuntimeFacade` as
+ * {@link editorConfig}.
+ *
+ * **Runtime sync (snapshot + event-sourcing):**
+ * - **Reconnect:** dedicated `executionFeed.snapshot` (and `runner.snapshot`)
+ *   replay value-state port frames (`RuntimeRunnerEvent`) so a refreshed tab
+ *   restores mid-run UI. Not part of {@link SessionStateSnapshotPayload}.
+ * - **Live:** only **new** `runner.*` telemetry frames — hot streams, no
+ *   per-mutation full snapshot. Late subscribers rely on bootstrap replay first.
+ *
+ * Load workflows through {@link workflowManagerConfig} before using raw
+ * `runner.*` intents; runner events operate on the graph already bound into
+ * this session.
+ */
+const runnerConfig = {
+    fromClientToServer: {
+        /**
+         * Run the **current session graph** (already in editor). Wires all
+         * edges, seeds open inputs, sets status `'running'`.
+         *
+         * Server calls {@link RuntimeRunnerApi.start}. Emits `runner.started`
+         * (`runId`) then port telemetry.
+         */
+        'runner.start.requested': message(),
+        /**
+         * Run-from-node — wire only the weakly connected cluster of `nodeId`.
+         *
+         * Server calls {@link RuntimeRunnerApi.startNode}. Emits
+         * `runner.startNode.started`.
+         */
+        'runner.startNode.requested': message(),
+        /**
+         * Cancel active run (Stop). Unsubscribes wiring, status `'stopped'`.
+         *
+         * Server calls {@link RuntimeRunnerApi.interrupt} (`'cancel'`). Emits
+         * `runner.interrupted`.
+         */
+        'runner.interrupt.requested': message(),
+        /**
+         * Push a value into a node input via
+         * {@link RuntimeRunnerApi.pushIntoInput}.
+         *
+         * Used for canvas HITL gates (`inputsConfigs[].config.hitl`) and for
+         * soft Pause / Steer on the hidden LLM inventory port `steerControl`
+         * (docs ADR-032) — `{ kind: 'pause' | 'steer' | 'resume', … }`. One
+         * event targets one
+         * `nodeId` / `portId`. Multiple awaits may be open concurrently.
+         * Message name is historical; not limited to visible HITL chrome.
+         */
+        'runner.hitl.event': message(),
+        /**
+         * Allow / Deny for a runtime permission ask inside the tool loop
+         * (not a canvas HITL port — see `runner.permission.ask`).
+         */
+        'runner.permission.reply': message(),
+        /**
+         * Clear the execution feed (work log). Server drops the runner event
+         * log and re-broadcasts an empty `executionFeed.snapshot`. No payload.
+         */
+        'runner.executionFeed.clear.requested': message(),
+        /**
+         * Continue from a durable checkpoint after Stop / process restart.
+         * Payload requires `runId` (picker-chosen entry; no latest-only omit).
+         */
+        'runner.resume.requested': message(),
+        /**
+         * Discard a durable checkpoint (corrupt / abandoned job).
+         */
+        'runner.checkpoint.discard.requested': message(),
+    },
+    fromServerToClient: {
+        /**
+         * {@link RuntimeRunnerApi.start} succeeded — payload is `runId`.
+         * Empty graph → instant `runner.done` and status `'idle'`.
+         */
+        'runner.started': message(),
+        /**
+         * {@link RuntimeRunnerApi.startNode} succeeded — payload is `runId`.
+         */
+        'runner.startNode.started': message(),
+        /**
+         * {@link RuntimeRunnerApi.resume} succeeded — payload is `runId`.
+         */
+        'runner.resume.started': message(),
+        /**
+         * Resume rejected — corrupt / stale / missing checkpoint, or busy.
+         */
+        'runner.resume.failed': message(),
+        /**
+         * {@link RuntimeRunnerApi.interrupt} applied — payload is reason
+         * (today only `'cancel'`).
+         */
+        'runner.interrupted': message(),
+        /**
+         * Output port signal — {@link RuntimeRunnerEvent} with
+         * `kind === 'output-emitted'`.
+         */
+        'runner.output-emitted': message(),
+        /**
+         * Input port signal — {@link RuntimeRunnerEvent} with
+         * `kind === 'input-received'` (wires, seeds).
+         */
+        'runner.input-received': message(),
+        /**
+         * Natural run end — {@link RuntimeRunnerEvent} with `kind === 'done'`
+         * (empty graph, {@link RuntimeNode.stopsRun}, or forced complete).
+         * Runner status becomes `'idle'`.
+         */
+        'runner.done': message(),
+        /**
+         * Runtime permission ask for a gated harness tool call (feed + composer).
+         * Stays inside the internal tool loop — not a graph HITL edge.
+         */
+        'runner.permission.ask': message(),
+        /**
+         * Resumable checkpoints for the active workflow (bootstrap + after
+         * Stop / discard / complete).
+         */
+        'runner.checkpoints.snapshot': message(),
+        /**
+         * One checkpoint write succeeded (stage boundary or Stop).
+         */
+        'runner.checkpointed': message(),
+    },
+};
+/**
+ * **Bootstrap** — WebSocket connect / reconnect and cold-start projection.
+ *
+ * Context: UI holds **no durable state**. On every connection the server emits
+ * a **slim** {@link SessionStateSnapshotPayload}, then **dedicated domain
+ * snapshots**, then `session.ready`. Client **replaces** (not merges) each
+ * slice from its own key — there is no fat all-domains bootstrap payload.
+ *
+ * **Slim `session.state.snapshot` only:** `version`, `langflowerConfig`,
+ * `dividerPositions`, `selectedNode`.
+ *
+ * **Do not put here** (dedicated keys, see emit order on
+ * {@link langflowerWsConfig}): workflows, viewport, runner gate, execution
+ * feed, tool config, palette.
+ *
+ * Authoritative emit order:
+ * `packages/server/src/bridge/emit-bootstrap.ts`.
+ */
+const bootstrapConfig = {
+    fromClientToServer: {},
+    fromServerToClient: {
+        /**
+         * Slim session projection — emitted on **every** connect and reconnect,
+         * first in the bootstrap sequence (before domain snapshots and
+         * `session.ready`).
+         *
+         * Payload is only {@link SessionStateSnapshotPayload}: `version`,
+         * `langflowerConfig`, `dividerPositions`, `selectedNode`. Replace those
+         * slices from this event; hydrate workflows / runner / feed / viewport /
+         * tool config from their dedicated snapshot keys (see state-sync table
+         * on {@link langflowerWsConfig}).
+         */
+        'session.state.snapshot': message(),
+        /**
+         * Terminal marker: bootstrap sequence for this connection is complete.
+         * Client enables diagram interactions after this.
+         *
+         * Follows slim `session.state.snapshot` **and** the dedicated domain
+         * snapshots on the same connection (`runner.snapshot`,
+         * `executionFeed.snapshot`, `toolConfig.snapshot`,
+         * `workflow.*.snapshot`, …). `version` bumps when bootstrap semantics
+         * change.
+         */
+        'session.ready': message(),
+        /**
+         * Runner snapshot — run gate status (idle/running, runId, activeWorkflowId).
+         */
+        'runner.snapshot': message(),
+        /**
+         * Execution feed snapshot — replay of `RuntimeRunnerEvent` frames.
+         * `null` when no run exists or the feed was cleared.
+         */
+        'executionFeed.snapshot': message(),
+        /**
+         * Tool config snapshot — `.langflower/config.json` settings.
+         */
+        'toolConfig.snapshot': message(),
+    },
+};
+/**
+ * **Langflower project config** — project + global `langflower.jsonc` layers.
+ *
+ * Context: **snapshot-only**. Server pushes on connect after `session.ready`
+ * and after every `langflower.config.save.requested`. Effective merge is
+ * project > global; payload also carries redacted layers + `globalPath`.
+ * Slim {@link SessionStateSnapshotPayload} carries effective
+ * `langflowerConfig` on reconnect (not the full layer payload).
+ */
+const langflowerProjectConfig = {
+    fromClientToServer: {
+        /**
+         * Settings Save — persist one scope (project or global), then
+         * broadcast {@link LangflowerConfigSnapshotPayload}. No parallel
+         * `settings.*` bus.
+         */
+        'langflower.config.save.requested': message(),
+        /**
+         * Settings → Bootstrap — force-reseed skeleton templates into the
+         * open project (workflows / skills / my-nodes / instructions).
+         * Never rewrites `langflower.jsonc`. Rejected while a run is active.
+         * Replies with {@link ProjectBootstrapResultPayload}; on success also
+         * broadcasts workflow / custom-palette snapshots.
+         */
+        'project.bootstrap.requested': message(),
+    },
+    fromServerToClient: {
+        /**
+         * Authoritative config — emitted per connection after `session.ready`
+         * and after Settings Save. Includes effective + layer slices.
+         */
+        'langflower.config.snapshot': message(),
+        /**
+         * Authoritative live model catalogs for all configured providers.
+         * Server-pushed after {@link LangflowerConfigSnapshotPayload} on
+         * connect (async, non-blocking) and after Settings Save. Static
+         * jsonc models remain in config; UI merges both. No client refresh
+         * intent — server owns fetch.
+         */
+        'langflower.models.catalog.snapshot': message(),
+        /**
+         * Outcome of `project.bootstrap.requested` (Result — expected failures
+         * are `ok: false`, not throws).
+         */
+        'project.bootstrap.result': message(),
+    },
+};
+/**
+ * **Palette** — system (built-in) node registry for canvas drop.
+ *
+ * Context: **snapshot-only** catalog. Server pushes `palette.snapshot` on
+ * connect (after `langflower.config.snapshot`). Custom packs use
+ * {@link customPaletteConfig}. Multi-tab: broadcast snapshot so every tab
+ * shares the same catalog without RPC-style replies.
+ */
+const paletteConfig = {
+    fromClientToServer: {
+        /**
+         * Refresh the system palette catalog (no custom-node compile).
+         *
+         * Emits `palette.snapshot`. May broadcast to other connections.
+         */
+        'palette.reload.requested': message(),
+    },
+    fromServerToClient: {
+        /**
+         * Authoritative **system** catalog — outcome of
+         * `palette.reload.requested` or connect bootstrap.
+         */
+        'palette.snapshot': message(),
+    },
+};
+/**
+ * **Custom palette** — project packs under `.langflower/nodes/`.
+ *
+ * Source of truth for the Custom nodes UI section: compiled nodes, pack
+ * errors (same content as each pack's `COMPILATION_ERRORS.md`), and status.
+ */
+const customPaletteConfig = {
+    fromClientToServer: {
+        /**
+         * Recompile project custom packs and refresh the custom registry.
+         *
+         * Server broadcasts `customPalette.snapshot` (`compiling`, then final).
+         */
+        'customPalette.update.requested': message(),
+    },
+    fromServerToClient: {
+        /**
+         * Authoritative custom-node slice for the Custom palette section.
+         */
+        'customPalette.snapshot': message(),
+    },
+};
+/**
+ * **Workflow manager** — persisted workflows, catalog, active session workflow.
+ *
+ * ## Why snapshots (not command replies)
+ *
+ * Several browser tabs can share one server session. Catalog and active-workflow
+ * changes must stay in sync across tabs without asking “which command caused this?”
+ *
+ * RPC-style replies break in that model:
+ *
+ * 1. Tab A: `workflow.saveCurrent.requested`
+ * 2. Server → all tabs: `workflow.saved` (metadata only)
+ * 3. Tab B: saved *what*? Which workflow is active? Is the catalog stale?
+ *
+ * Instead: after every intent the server **broadcasts authoritative state slices**.
+ * Every tab applies the same snapshot — no correlation id, no per-command reply.
+ *
+ * ## Flow
+ *
+ * 1. Client emits `workflow.*.requested` (intent only).
+ * 2. Server executes (or skips mutation on failure).
+ * 3. Server pushes snapshot(s) — to **all** connected clients when the slice
+ *    changed globally (catalog save/delete), otherwise at least to the requester.
+ *
+ * Two snapshot contexts (apply independently):
+ * - {@link WorkflowListSnapshotPayload} — catalog metadata rows
+ * - {@link WorkflowCurrentSnapshotPayload} — active workflow document + dirty flag
+ *
+ * On failure the server still pushes the current authoritative slice (unchanged
+ * content is valid — tabs stay aligned). UI verifies outcomes by reading the
+ * snapshot, not by matching a reply to “my” command.
+ *
+ * On connect, both slices arrive as dedicated `workflow.list.snapshot` /
+ * `workflow.current.snapshot` events (not inside
+ * {@link SessionStateSnapshotPayload}).
+ */
+const workflowManagerConfig = {
+    fromClientToServer: {
+        /**
+         * Serialize the session's in-memory active workflow to disk.
+         * Server builds the save payload from `session.activeWorkflow`.
+         */
+        'workflow.saveCurrent.requested': message(),
+        /**
+         * Rename active workflow identity (name + id + `{id}.json`).
+         * Partial save: metadata is persisted immediately; dirty graph edits
+         * remain uncommitted until `workflow.saveCurrent.requested`.
+         */
+        'workflow.renameCurrent.requested': message(),
+        /**
+         * Start an empty workflow in the session (dirty, not written to disk).
+         */
+        'workflow.create.requested': message(),
+        /**
+         * Copy a persisted workflow to a new `{id}-copy.json` file and open it.
+         */
+        'workflow.copy.requested': message(),
+        /**
+         * Load one workflow by `workflowId` from disk into the server session
+         * (bind-replay into editor).
+         */
+        'workflow.load.requested': message(),
+        /**
+         * Refresh workflow catalog (metadata only, no graphs).
+         */
+        'workflow.list.requested': message(),
+        /**
+         * Delete one persisted workflow by id.
+         */
+        'workflow.delete.requested': message(),
+    },
+    fromServerToClient: {
+        /**
+         * Active workflow document and dirty/pristine state.
+         * Pushed after workflow manager intents (load/save/rename/delete).
+         */
+        'workflow.current.snapshot': message(),
+        /**
+         * Dirty/pristine flag only — broadcast after editor mutations without
+         * replacing the canvas graph (see `editor.*.delta`).
+         */
+        'workflow.currentStatus.snapshot': message(),
+        /**
+         * Workflow catalog (metadata only). Pushed on list intent and after
+         * save/delete when the on-disk catalog changes.
+         */
+        'workflow.list.snapshot': message(),
+    },
+};
+/**
+ * Typed internal WebSocket registry for co-versioned Langflower
+ * UI/server/runtime (ws-bridge, **pure event-driven**).
+ *
+ * Runtime APIs are the protocol source of truth by design: changing runtime
+ * method shapes should fail fast at compile time across server and UI instead
+ * of spawning DTO adapters that can drift. The shared transport path/port lives
+ * here for the same reason — client and server consume one source of truth.
+ *
+ * No RPC envelopes, no `requestId`. Client emits `*.requested` intents; the server
+ * executes and broadcasts authoritative snapshots (see {@link workflowManagerConfig}
+ * for multi-tab workflow sync). Clients **replace local projection from snapshots**
+ * — they do not correlate replies to “their” command.
+ *
+ * ## State sync model (snapshot vs event-sourcing)
+ *
+ * Several tabs may share one server session. On **connect / reconnect** (browser
+ * refresh, new tab) each client must reach the same authoritative state without
+ * replaying full history. Domains use **dedicated snapshot keys** — slim
+ * {@link SessionStateSnapshotPayload} is **not** a fat reconnect bundle.
+ *
+ * | Domain | Model | Reconnect | Live updates |
+ * | ------ | ----- | --------- | -------------- |
+ * | Session chrome (dividers, selection) + effective `langflowerConfig` | **snapshot only** | slim `session.state.snapshot` | dividers / selection via `editor.dividers.snapshot` / `editor.nodeSelected` |
+ * | Langflower project config (full layers) | **snapshot only** | `langflower.config.snapshot` after `session.ready`; effective also in slim session | full slice replace |
+ * | Live provider model catalogs | **snapshot only** | `langflower.models.catalog.snapshot` after config (async on connect) + after Save | full map replace |
+ * | Tool config | **snapshot only** | `toolConfig.snapshot` | full slice replace |
+ * | Workflow catalog + active doc | **snapshot only** | `workflow.list.snapshot` / `workflow.current.snapshot` | full slice replace |
+ * | Workflow dirty/pristine | **snapshot only** | `currentStatus` in `workflow.current.snapshot`; `workflow.currentStatus.snapshot` after editor mutations | status slice replace |
+ * | Palette (system) | **snapshot only** | `palette.snapshot` on connect (server-pushed) | full slice replace |
+ * | Custom palette | **snapshot only** | `customPalette.snapshot` after system palette | full slice replace |
+ * | Canvas graph (topology) | **snapshot** in workflow slice | `activeWorkflow` in `workflow.current.snapshot` | `editor.*.delta` (broadcast to all tabs) |
+ * | Canvas viewport (pan/zoom) | **snapshot + event-sourcing** | `activeWorkflow.graph.viewport` in `workflow.current.snapshot` | `editor.viewport.delta` (broadcast to all tabs) |
+ * | Runtime / execution on graph | **snapshot + event-sourcing** | `runner.snapshot` + `executionFeed.snapshot` (+ `runner.checkpoints.snapshot`) | `runner.*` (`RuntimeRunnerEvent`) — **new events only** |
+ *
+ * **Reconnect sequence** (authoritative:
+ * `packages/server/src/bridge/emit-bootstrap.ts`):
+ * `session.state.snapshot` → `runner.snapshot` → `executionFeed.snapshot` →
+ * `runner.checkpoints.snapshot` → `toolConfig.snapshot` →
+ * `workflow.list.snapshot` → `workflow.current.snapshot` → `session.ready` →
+ * `langflower.config.snapshot` → (async) `langflower.models.catalog.snapshot` →
+ * `palette.snapshot` → `customPalette.snapshot`. Later workflow intents
+ * broadcast `workflow.*.snapshot`.
+ *
+ * **Runtime after reconnect:** hydrate the log / port state from
+ * `executionFeed.snapshot`, then append live `runner.output-emitted`,
+ * `runner.input-received`, `runner.done`, … — no replay of the full runner
+ * history on every mutation, only the dedicated feed snapshot plus new frames.
+ *
+ * Partials: {@link editorConfig} | {@link runnerConfig} |
+ * {@link bootstrapConfig} | {@link langflowerProjectConfig} |
+ * {@link paletteConfig} | {@link customPaletteConfig} |
+ * {@link workflowManagerConfig}.
+ */
+export const langflowerWsConfig = {
+    transport: { path: '/ws', port: 4010 },
+    fromClientToServer: {
+        ...editorConfig.fromClientToServer,
+        ...runnerConfig.fromClientToServer,
+        ...bootstrapConfig.fromClientToServer,
+        ...langflowerProjectConfig.fromClientToServer,
+        ...paletteConfig.fromClientToServer,
+        ...customPaletteConfig.fromClientToServer,
+        ...workflowManagerConfig.fromClientToServer,
+    },
+    fromServerToClient: {
+        ...editorConfig.fromServerToClient,
+        ...runnerConfig.fromServerToClient,
+        ...bootstrapConfig.fromServerToClient,
+        ...langflowerProjectConfig.fromServerToClient,
+        ...paletteConfig.fromServerToClient,
+        ...customPaletteConfig.fromServerToClient,
+        ...workflowManagerConfig.fromServerToClient,
+    },
+};
+//# sourceMappingURL=langflower-bus-config.js.map

package/vendor/shared/dist/langflower-bus-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"langflower-bus-config.js","sourceRoot":"","sources":["../src/langflower-bus-config.ts"],"names":[],"mappings":"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"}

package/vendor/shared/dist/langflower-config/mcp-tool-id.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Stable inventory ids for MCP tools mapped into the internal tool loop.
+ * Shape: `<mcp_name>__<toolName>` where `mcp_name` is the MCP server's
+ * `serverInfo.name` (OpenAI-safe `[a-zA-Z0-9_-]` segments).
+ *
+ * **Boundary twin** of the owner implementation in
+ * `@langflower/tools/mcp-tool-id` (`packages/tools/src/mcp/mcp-tool-id.ts`).
+ * Shared must not import tools; tools must not import shared. Parity is pinned
+ * by `packages/tools/src/mcp/mcp-tool-id.parity.test.ts` — change both (or
+ * update the owner first, then mirror here).
+ */
+/** Jsonc / Inspector map key for system MCP (`mcp.servers.<id>`). */
+export declare const isValidMcpServerId: (serverId: string) => boolean;
+/**
+ * Encode inventory tool id from MCP server name + tool name.
+ * @param mcpName - `serverInfo.name` from initialize (not config/node id)
+ */
+export declare const encodeMcpToolId: (mcpName: string, toolName: string) => string;
+export declare const parseMcpToolId: (toolId: string) => {
+    readonly serverId: string;
+    readonly toolName: string;
+} | null;
+export declare const isMcpToolId: (toolId: string) => boolean;
+//# sourceMappingURL=mcp-tool-id.d.ts.map

package/vendor/shared/dist/langflower-config/mcp-tool-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tool-id.d.ts","sourceRoot":"","sources":["../../src/langflower-config/mcp-tool-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAUH,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,OAC1B,CAAC;AAE7B;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,EAAE,UAAU,MAAM,KAAG,MASnE,CAAC;AAEF,eAAO,MAAM,cAAc,GAC1B,QAAQ,MAAM,KACZ;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAe7D,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,KAAG,OACb,CAAC"}

package/vendor/shared/dist/langflower-config/mcp-tool-id.js

@@ -0,0 +1,44 @@
+/**
+ * Stable inventory ids for MCP tools mapped into the internal tool loop.
+ * Shape: `<mcp_name>__<toolName>` where `mcp_name` is the MCP server's
+ * `serverInfo.name` (OpenAI-safe `[a-zA-Z0-9_-]` segments).
+ *
+ * **Boundary twin** of the owner implementation in
+ * `@langflower/tools/mcp-tool-id` (`packages/tools/src/mcp/mcp-tool-id.ts`).
+ * Shared must not import tools; tools must not import shared. Parity is pinned
+ * by `packages/tools/src/mcp/mcp-tool-id.parity.test.ts` — change both (or
+ * update the owner first, then mirror here).
+ */
+const SERVER_ID_RE = /^[a-zA-Z][a-zA-Z0-9-]*$/;
+const sanitizeMcpSegment = (raw) => raw
+    .trim()
+    .replace(/[^a-zA-Z0-9_-]+/g, '_')
+    .replace(/^_+|_+$/g, '');
+/** Jsonc / Inspector map key for system MCP (`mcp.servers.<id>`). */
+export const isValidMcpServerId = (serverId) => SERVER_ID_RE.test(serverId);
+/**
+ * Encode inventory tool id from MCP server name + tool name.
+ * @param mcpName - `serverInfo.name` from initialize (not config/node id)
+ */
+export const encodeMcpToolId = (mcpName, toolName) => {
+    const server = sanitizeMcpSegment(mcpName);
+    const tool = sanitizeMcpSegment(toolName);
+    if (server.length === 0 || tool.length === 0) {
+        return '';
+    }
+    return `${server}__${tool}`;
+};
+export const parseMcpToolId = (toolId) => {
+    const match = /^([a-zA-Z0-9_-]+)__(.+)$/.exec(toolId.trim());
+    if (match === null) {
+        return null;
+    }
+    const serverId = match[1] ?? '';
+    const toolName = match[2] ?? '';
+    if (serverId.length === 0 || toolName.length === 0) {
+        return null;
+    }
+    return { serverId, toolName };
+};
+export const isMcpToolId = (toolId) => parseMcpToolId(toolId) !== null;
+//# sourceMappingURL=mcp-tool-id.js.map

package/vendor/shared/dist/langflower-config/mcp-tool-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tool-id.js","sourceRoot":"","sources":["../../src/langflower-config/mcp-tool-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,YAAY,GAAG,yBAAyB,CAAC;AAE/C,MAAM,kBAAkB,GAAG,CAAC,GAAW,EAAU,EAAE,CAClD,GAAG;KACD,IAAI,EAAE;KACN,OAAO,CAAC,kBAAkB,EAAE,GAAG,CAAC;KAChC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;AAE3B,qEAAqE;AACrE,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,QAAgB,EAAW,EAAE,CAC/D,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAE7B;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,OAAe,EAAE,QAAgB,EAAU,EAAE;IAC5E,MAAM,MAAM,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAE1C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9C,OAAO,EAAE,CAAC;IACX,CAAC;IAED,OAAO,GAAG,MAAM,KAAK,IAAI,EAAE,CAAC;AAC7B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAC7B,MAAc,EACoD,EAAE;IACpE,MAAM,KAAK,GAAG,0BAA0B,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAE7D,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAChC,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAEhC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAC/B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,MAAc,EAAW,EAAE,CACtD,cAAc,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC"}

package/vendor/shared/dist/langflower-config/merge-langflower-config-layers.d.ts

@@ -0,0 +1,7 @@
+import type { LangflowerConfig } from '../types/langflower-config.js';
+/**
+ * Merge global then project — project wins for overlapping top-level fields
+ * and for the same provider id (full provider entry replace).
+ */
+export declare const mergeLangflowerConfigLayers: (globalConfig: LangflowerConfig, projectConfig: LangflowerConfig) => LangflowerConfig;
+//# sourceMappingURL=merge-langflower-config-layers.d.ts.map

package/vendor/shared/dist/langflower-config/merge-langflower-config-layers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-langflower-config-layers.d.ts","sourceRoot":"","sources":["../../src/langflower-config/merge-langflower-config-layers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;;GAGG;AACH,eAAO,MAAM,2BAA2B,GACvC,cAAc,gBAAgB,EAC9B,eAAe,gBAAgB,KAC7B,gBAeF,CAAC"}