langflower 0.1.0 → 0.1.2

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

@@ -1,302 +0,0 @@
-import { isPortTelemetry, isRuntimeDone, } from '@langflower/runtime';
-import { buildWorkflowFingerprint, } from '@langflower/shared/langflower.js';
-import { Subscription } from 'rxjs';
-import { listResumableCheckpoints } from '../checkpoint/list-resumable-checkpoints.js';
-import { resolveCheckpointBoundary } from '../checkpoint/resolve-checkpoint-boundary.js';
-import { resetSessionExecutionFeed } from '../session/reset-session-execution-feed.js';
-import { buildContextSeeds, applyObservableContextSeeds, } from './build-execution-context.js';
-import { getLiveWiredTools } from './get-live-wired-tools.js';
-import { createLangflowerToolsRpc } from './langflower-tools-rpc.js';
-import { bridgeEmit, clientEmit } from './bridge-outbound.js';
-import { findClientById } from './client-index.js';
-import { isInboundEvent } from './inbound-guards.js';
-const mergeSeeds = (...parts) => {
-    const result = {};
-    for (const part of parts) {
-        if (!part) {
-            continue;
-        }
-        for (const [nodeId, seeds] of Object.entries(part)) {
-            result[nodeId] = [...(result[nodeId] ?? []), ...seeds];
-        }
-    }
-    return result;
-};
-const broadcastCheckpoints = async (bridge, session, checkpoints) => {
-    const workflowId = session.activeWorkflowId ?? null;
-    const list = await listResumableCheckpoints(checkpoints.getStore(), workflowId, session.activeWorkflow);
-    bridgeEmit(bridge, 'runner.checkpoints.snapshot', {
-        workflowId,
-        checkpoints: list,
-    });
-};
-/**
- * When a run has no `stopsRun` node in scope, the appended finish sink (one per
- * terminal node) ends the run; no `output-emitted` "complete" signal is needed.
- */
-export const wireRunnerHandlers = (bridge, context, session, checkpoints) => {
-    const subscription = new Subscription();
-    const emitPermissionAsk = (payload) => {
-        bridgeEmit(bridge, 'runner.permission.ask', payload);
-    };
-    const requestLangflowerBus = createLangflowerToolsRpc(bridge);
-    const liveWiredTools = (agentNodeId) => getLiveWiredTools(session, agentNodeId);
-    subscription.add(session.runtime.runner.events$.subscribe((event) => {
-        const [, nodeId, portId] = isPortTelemetry(event) ? event : [];
-        const boundary = isPortTelemetry(event) &&
-            event[0] === 'out' &&
-            typeof portId === 'string' &&
-            session.activeWorkflow !== null
-            ? resolveCheckpointBoundary(session.activeWorkflow, String(nodeId), portId)
-            : undefined;
-        const shouldPersist = checkpoints.observe(event, boundary === undefined
-            ? undefined
-            : boundary.label !== undefined
-                ? { label: boundary.label }
-                : {});
-        if (shouldPersist) {
-            void checkpoints
-                .persist('running')
-                .then((summary) => {
-                if (summary === undefined) {
-                    return;
-                }
-                bridgeEmit(bridge, 'runner.checkpointed', summary);
-            })
-                .catch(() => undefined);
-        }
-        if (isRuntimeDone(event)) {
-            void checkpoints
-                .markCompleted()
-                .then(async (summary) => {
-                if (summary !== undefined) {
-                    bridgeEmit(bridge, 'runner.checkpointed', summary);
-                }
-                await broadcastCheckpoints(bridge, session, checkpoints);
-            })
-                .catch(() => undefined);
-        }
-    }));
-    subscription.add(bridge['runner.start.requested'].subscribe((raw) => {
-        void (async () => {
-            if (!isInboundEvent(raw)) {
-                return;
-            }
-            const connected = findClientById(bridge, raw.clientId);
-            if (connected === undefined) {
-                return;
-            }
-            const [clientInitialPayload, clientRunId] = raw.payload;
-            const resolvedRunId = (clientRunId ??
-                crypto.randomUUID());
-            // Lock before async seed build so workflow load cannot race in.
-            session.runnerStatus = 'running';
-            const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, resolvedRunId, emitPermissionAsk, requestLangflowerBus, liveWiredTools));
-            const initialPayload = mergeSeeds(contextSeeds, clientInitialPayload);
-            if (session.activeWorkflow !== null) {
-                checkpoints.beginRun(resolvedRunId, session.activeWorkflow);
-            }
-            const runId = session.runtime.runner.start(initialPayload, resolvedRunId);
-            if (runId === false) {
-                session.runnerStatus = 'idle';
-                checkpoints.clearActive();
-                return;
-            }
-            session.runId = runId;
-            bridgeEmit(bridge, 'runner.started', runId);
-        })();
-    }));
-    subscription.add(bridge['runner.startNode.requested'].subscribe((raw) => {
-        void (async () => {
-            if (!isInboundEvent(raw)) {
-                return;
-            }
-            const connected = findClientById(bridge, raw.clientId);
-            if (connected === undefined) {
-                return;
-            }
-            const [nodeId, clientInitialPayload, clientRunId] = raw.payload;
-            const resolvedRunId = (clientRunId ??
-                crypto.randomUUID());
-            session.runnerStatus = 'running';
-            const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, resolvedRunId, emitPermissionAsk, requestLangflowerBus, liveWiredTools));
-            const initialPayload = mergeSeeds(contextSeeds, clientInitialPayload);
-            if (session.activeWorkflow !== null) {
-                checkpoints.beginRun(resolvedRunId, session.activeWorkflow);
-            }
-            const runId = session.runtime.runner.startNode(nodeId, initialPayload, resolvedRunId);
-            if (runId === false) {
-                session.runnerStatus = 'idle';
-                checkpoints.clearActive();
-                return;
-            }
-            session.runId = runId;
-            bridgeEmit(bridge, 'runner.startNode.started', runId);
-        })();
-    }));
-    subscription.add(bridge['runner.interrupt.requested'].subscribe((raw) => {
-        if (!isInboundEvent(raw)) {
-            return;
-        }
-        const connected = findClientById(bridge, raw.clientId);
-        if (connected === undefined) {
-            return;
-        }
-        session.runtime.runner.interrupt(raw.payload);
-        bridgeEmit(bridge, 'runner.interrupted', raw.payload);
-        void checkpoints
-            .markStopped()
-            .then(async (summary) => {
-            if (summary !== undefined) {
-                bridgeEmit(bridge, 'runner.checkpointed', summary);
-            }
-            await broadcastCheckpoints(bridge, session, checkpoints);
-        })
-            .catch(() => undefined);
-    }));
-    subscription.add(bridge['runner.resume.requested'].subscribe((raw) => {
-        void (async () => {
-            if (!isInboundEvent(raw)) {
-                return;
-            }
-            const connected = findClientById(bridge, raw.clientId);
-            if (connected === undefined) {
-                return;
-            }
-            const fail = (code, message, runId) => {
-                clientEmit(connected, 'runner.resume.failed', {
-                    code,
-                    message,
-                    ...(runId !== undefined ? { runId } : {}),
-                });
-            };
-            if (session.runnerStatus === 'running') {
-                fail('BUSY', 'A run is already active');
-                return;
-            }
-            const workflow = session.activeWorkflow;
-            if (workflow === null ||
-                session.activeWorkflowId === undefined) {
-                fail('NO_WORKFLOW', 'No active workflow to resume');
-                return;
-            }
-            const runId = raw.payload.runId;
-            const loaded = await checkpoints
-                .getStore()
-                .load(session.activeWorkflowId, runId);
-            if (!loaded.ok) {
-                fail(loaded.code, loaded.message, runId);
-                return;
-            }
-            const checkpoint = loaded.checkpoint;
-            const fingerprint = buildWorkflowFingerprint(workflow.graph.nodes, workflow.graph.edges);
-            if (fingerprint !== checkpoint.workflowFingerprint) {
-                fail('STALE_WORKFLOW', 'Workflow topology changed since the checkpoint was written', runId);
-                return;
-            }
-            if (checkpoint.completedNodeIds.length === 0) {
-                fail('NOT_FOUND', 'Checkpoint has no completed stages to resume from', runId);
-                return;
-            }
-            const unsupported = checkpoints.getUnsupportedValueMessage();
-            if (unsupported !== undefined) {
-                fail('UNSUPPORTED_VALUE', unsupported, runId);
-                return;
-            }
-            session.runnerStatus = 'running';
-            const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, checkpoint.runId, emitPermissionAsk, requestLangflowerBus, liveWiredTools));
-            checkpoints.hydrateFromCheckpoint(checkpoint, workflow);
-            const resumeOptions = checkpoints.resumeOptionsFromCheckpoint(checkpoint);
-            const resumed = session.runtime.runner.resume({
-                ...resumeOptions,
-                initialPayload: contextSeeds,
-            });
-            if (resumed === false) {
-                session.runnerStatus = 'idle';
-                checkpoints.clearActive();
-                fail('BUSY', 'Runner rejected resume', runId);
-                return;
-            }
-            session.runId = resumed;
-            bridgeEmit(bridge, 'runner.resume.started', resumed);
-        })();
-    }));
-    subscription.add(bridge['runner.checkpoint.discard.requested'].subscribe((raw) => {
-        void (async () => {
-            if (!isInboundEvent(raw)) {
-                return;
-            }
-            const connected = findClientById(bridge, raw.clientId);
-            if (connected === undefined) {
-                return;
-            }
-            const workflowId = session.activeWorkflowId;
-            if (workflowId === undefined) {
-                return;
-            }
-            await checkpoints
-                .getStore()
-                .discard(workflowId, raw.payload.runId);
-            checkpoints.clearActive();
-            await broadcastCheckpoints(bridge, session, checkpoints);
-        })();
-    }));
-    subscription.add(bridge['runner.hitl.event'].subscribe((raw) => {
-        void (async () => {
-            if (!isInboundEvent(raw)) {
-                return;
-            }
-            const connected = findClientById(bridge, raw.clientId);
-            if (connected === undefined) {
-                return;
-            }
-            const pushPayload = raw.payload;
-            const wasIdle = session.runnerStatus !== 'running';
-            // Cold-start (chat entry): seed context, start cluster, announce
-            // `runner.started`, then deliver the composer message.
-            if (wasIdle) {
-                const resolvedRunId = crypto.randomUUID();
-                session.runnerStatus = 'running';
-                const contextSeeds = applyObservableContextSeeds(session, await buildContextSeeds(session, context, resolvedRunId, emitPermissionAsk, requestLangflowerBus, liveWiredTools));
-                if (session.activeWorkflow !== null) {
-                    checkpoints.beginRun(resolvedRunId, session.activeWorkflow);
-                }
-                const runId = session.runtime.runner.startNode(pushPayload.nodeId, contextSeeds, resolvedRunId);
-                if (runId === false) {
-                    session.runnerStatus = 'idle';
-                    checkpoints.clearActive();
-                    return;
-                }
-                session.runId = runId;
-                bridgeEmit(bridge, 'runner.started', runId);
-            }
-            session.runtime.runner.pushIntoInput(pushPayload);
-        })();
-    }));
-    subscription.add(bridge['runner.permission.reply'].subscribe((raw) => {
-        if (!isInboundEvent(raw)) {
-            return;
-        }
-        const connected = findClientById(bridge, raw.clientId);
-        if (connected === undefined) {
-            return;
-        }
-        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)) {
-            return;
-        }
-        // Clear is only allowed after a run settles — wiping the log mid-run
-        // also wiped canvas chrome (shared executionFeed.snapshot).
-        if (session.runnerStatus === 'running') {
-            return;
-        }
-        resetSessionExecutionFeed(session);
-        // Re-broadcast the (now empty) feed to every tab.
-        bridgeEmit(bridge, 'executionFeed.snapshot', session.buildExecutionFeed());
-    }));
-    return subscription;
-};

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

@@ -1,5 +0,0 @@
-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 wireWorkflowHandlers: (bridge: LangflowerBridge, context: ServerContext, session: LangflowerSession) => Subscription;

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

@@ -1,245 +0,0 @@
-import { Subscription } from 'rxjs';
-import { listResumableCheckpoints } from '../checkpoint/list-resumable-checkpoints.js';
-import { WorkflowCheckpointStore } from '../checkpoint/workflow-checkpoint-store.js';
-import { resetSessionExecutionFeed } from '../session/reset-session-execution-feed.js';
-import { buildSaveCurrentPayload } from '../workflow/build-save-current-payload.js';
-import { copyWorkflowToSession } from '../workflow/copy-workflow-to-session.js';
-import { createEmptyWorkflowInSession } from '../workflow/create-empty-workflow-in-session.js';
-import { loadWorkflowIntoSession } from '../workflow/load-workflow-into-session.js';
-import { renameActiveWorkflow } from '../workflow/rename-active-workflow.js';
-import { bridgeEmit, clientEmit } from './bridge-outbound.js';
-import { findClientById } from './client-index.js';
-import { isInboundEvent } from './inbound-guards.js';
-/**
- * Composer: optional feed reset → clear selection → current snapshot →
- * optional catalog sync. Sibling steps — handlers do not nest these.
- */
-const syncAfterWorkflowMutation = async (bridge, context, session, client, options) => {
-    // 1. Document switch: empty feed before the new catalog so the UI never
-    // paints the previous run under the next workflow's nodes.
-    if (options.resetFeed === true) {
-        resetSessionExecutionFeed(session);
-        bridgeEmit(bridge, 'executionFeed.snapshot', session.buildExecutionFeed());
-    }
-    // 2. Clear selection (and notify tabs if it was set)
-    if (options.clearSelection) {
-        const hadSelection = session.selectedNodeId !== null;
-        session.selectedNodeId = null;
-        if (hadSelection) {
-            bridgeEmit(bridge, 'editor.nodeSelected', { node: null });
-        }
-    }
-    // 3. Authoritative current-workflow slice (session-shared — fan out)
-    bridgeEmit(bridge, 'workflow.current.snapshot', {
-        activeWorkflow: session.activeWorkflow,
-        currentStatus: { status: session.currentStatus },
-    });
-    // 4. Resumable checkpoints for the active workflow (explicit boundaries)
-    const workflowId = session.activeWorkflowId ?? null;
-    const checkpoints = await listResumableCheckpoints(new WorkflowCheckpointStore(context.projectDir), workflowId, session.activeWorkflow);
-    bridgeEmit(bridge, 'runner.checkpoints.snapshot', {
-        workflowId,
-        checkpoints,
-    });
-    // 5. Catalog sync
-    if (options.catalog.kind === 'broadcast') {
-        const workflows = await context.workflowService.list();
-        bridgeEmit(bridge, 'workflow.list.snapshot', { workflows });
-        return;
-    }
-    if (options.catalog.kind === 'emitToClient') {
-        const workflows = await context.workflowService.list();
-        clientEmit(client, 'workflow.list.snapshot', { workflows });
-    }
-};
-export const wireWorkflowHandlers = (bridge, context, session) => {
-    const subscription = new Subscription();
-    subscription.add(bridge['workflow.list.requested'].subscribe(async (raw) => {
-        if (!isInboundEvent(raw)) {
-            return;
-        }
-        const connected = findClientById(bridge, raw.clientId);
-        if (connected === undefined) {
-            return;
-        }
-        const workflows = await context.workflowService.list();
-        clientEmit(connected, 'workflow.list.snapshot', { workflows });
-    }));
-    subscription.add(bridge['workflow.load.requested'].subscribe(async (raw) => {
-        if (!isInboundEvent(raw)) {
-            return;
-        }
-        const connected = findClientById(bridge, raw.clientId);
-        if (connected === undefined) {
-            return;
-        }
-        let clearSelection = false;
-        let resetFeed = false;
-        if (!session.isGraphLocked()) {
-            // 1. Load document into session
-            const loaded = await loadWorkflowIntoSession(session, context.workflowService, context.projectDir, raw.payload.workflowId, context.resolveDefinition);
-            // 2. Persist current-workflow id when load succeeded
-            if (loaded.ok) {
-                resetFeed = true;
-                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', {
-                    workflowId: raw.payload.workflowId,
-                    code: loaded.code,
-                    message: loaded.message,
-                });
-            }
-            clearSelection = true;
-        }
-        else {
-            clientEmit(connected, 'workflow.load.failed', {
-                workflowId: raw.payload.workflowId,
-                code: 'GRAPH_LOCKED',
-                message: 'Cannot load workflow while the graph is locked',
-            });
-        }
-        // 3. Sync outbound
-        await syncAfterWorkflowMutation(bridge, context, session, connected, { clearSelection, catalog: { kind: 'none' }, resetFeed });
-    }));
-    subscription.add(bridge['workflow.saveCurrent.requested'].subscribe(async (raw) => {
-        if (!isInboundEvent(raw)) {
-            return;
-        }
-        const connected = findClientById(bridge, raw.clientId);
-        if (connected === undefined) {
-            return;
-        }
-        let catalogChanged = false;
-        if (!session.isGraphLocked()) {
-            const payload = buildSaveCurrentPayload(session);
-            if (payload !== null) {
-                const result = await context.workflowService.save(payload);
-                if (result.ok) {
-                    session.activeWorkflow = result.document;
-                    session.activeWorkflowId = result.document.workflowId;
-                    session.markPristine();
-                    catalogChanged = true;
-                }
-            }
-        }
-        await syncAfterWorkflowMutation(bridge, context, session, connected, {
-            clearSelection: false,
-            catalog: catalogChanged
-                ? { kind: 'broadcast' }
-                : { kind: 'none' },
-        });
-    }));
-    subscription.add(bridge['workflow.renameCurrent.requested'].subscribe(async (raw) => {
-        if (!isInboundEvent(raw)) {
-            return;
-        }
-        const connected = findClientById(bridge, raw.clientId);
-        if (connected === undefined) {
-            return;
-        }
-        let catalogChanged = false;
-        if (!session.isGraphLocked()) {
-            const renamed = await renameActiveWorkflow(session, context.workflowService, raw.payload.name);
-            if (renamed !== null) {
-                catalogChanged = renamed.catalogChanged;
-                await context.langflowerConfigService.setCurrentWorkflowId(renamed.document.workflowId);
-            }
-        }
-        await syncAfterWorkflowMutation(bridge, context, session, connected, {
-            clearSelection: false,
-            catalog: catalogChanged
-                ? { kind: 'broadcast' }
-                : { kind: 'none' },
-        });
-    }));
-    subscription.add(bridge['workflow.create.requested'].subscribe(async (raw) => {
-        if (!isInboundEvent(raw)) {
-            return;
-        }
-        const connected = findClientById(bridge, raw.clientId);
-        if (connected === undefined) {
-            return;
-        }
-        let clearSelection = false;
-        let resetFeed = false;
-        if (!session.isGraphLocked()) {
-            const created = await createEmptyWorkflowInSession(session, context.workflowService, context.projectDir, context.resolveDefinition);
-            clearSelection = true;
-            resetFeed = created;
-        }
-        await syncAfterWorkflowMutation(bridge, context, session, connected, { clearSelection, catalog: { kind: 'none' }, resetFeed });
-    }));
-    subscription.add(bridge['workflow.copy.requested'].subscribe(async (raw) => {
-        if (!isInboundEvent(raw)) {
-            return;
-        }
-        const connected = findClientById(bridge, raw.clientId);
-        if (connected === undefined) {
-            return;
-        }
-        let catalogChanged = false;
-        let clearSelection = false;
-        let resetFeed = false;
-        if (!session.isGraphLocked()) {
-            const copied = await copyWorkflowToSession(session, context.workflowService, context.projectDir, raw.payload.workflowId, context.resolveDefinition);
-            if (copied && session.activeWorkflowId !== undefined) {
-                catalogChanged = true;
-                resetFeed = true;
-                await context.langflowerConfigService.setCurrentWorkflowId(session.activeWorkflowId);
-            }
-            clearSelection = true;
-        }
-        await syncAfterWorkflowMutation(bridge, context, session, connected, {
-            clearSelection,
-            resetFeed,
-            catalog: catalogChanged
-                ? { kind: 'broadcast' }
-                : { kind: 'none' },
-        });
-    }));
-    subscription.add(bridge['workflow.delete.requested'].subscribe(async (raw) => {
-        if (!isInboundEvent(raw)) {
-            return;
-        }
-        const connected = findClientById(bridge, raw.clientId);
-        if (connected === undefined) {
-            return;
-        }
-        let catalogChanged = false;
-        let clearSelection = false;
-        if (!session.isGraphLocked()) {
-            // 1. Delete persisted workflow
-            const result = await context.workflowService.delete(raw.payload.workflowId);
-            if (result.ok) {
-                catalogChanged = true;
-                // 2. If it was active — deactivate session + clear config
-                if (session.activeWorkflowId === raw.payload.workflowId) {
-                    session.activeWorkflow = null;
-                    session.activeWorkflowId = undefined;
-                    session.markPristine();
-                    await context.langflowerConfigService.setCurrentWorkflowId(undefined);
-                    clearSelection = true;
-                }
-            }
-        }
-        // 3. Sync outbound (broadcast catalog on success; else refresh list for requester)
-        await syncAfterWorkflowMutation(bridge, context, session, connected, {
-            clearSelection,
-            catalog: catalogChanged
-                ? { kind: 'broadcast' }
-                : { kind: 'emitToClient' },
-        });
-    }));
-    return subscription;
-};

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

@@ -1,10 +0,0 @@
-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, permission?: PermissionConfig) => readonly ToolHandle[];

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

@@ -1,42 +0,0 @@
-import { isToolAlwaysDenied, } from '@langflower/tools/permission';
-const filterEnabledBuiltins = (builtins, enabledToolIds) => {
-    if (enabledToolIds === undefined) {
-        return builtins;
-    }
-    if (enabledToolIds.length === 0) {
-        return [];
-    }
-    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, permission) => {
-    const filtered = filterAlwaysDeniedBuiltins(filterEnabledBuiltins(harness.listBuiltinRegistrations(), enabledToolIds), permission);
-    return filtered.map((reg) => ({
-        toolId: reg.toolId,
-        name: reg.name,
-        description: reg.description,
-        inputSchema: reg.inputSchema,
-        invoke: async (args, toolCtx) => {
-            // Shell passes tools host bag (optional signal); SDK type stays identity-only.
-            const hostCtx = toolCtx;
-            const result = await harness.invoke({
-                toolId: reg.toolId,
-                args,
-                ...(hostCtx?.signal !== undefined
-                    ? { signal: hostCtx.signal }
-                    : {}),
-            });
-            if (!result.ok) {
-                throw new Error(result.text);
-            }
-            return result.text;
-        },
-    }));
-};

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

@@ -1,4 +0,0 @@
-import { type WorkflowCheckpointSummary, type WorkflowLoadedPayload } from '@langflower/shared/langflower.js';
-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[]>;

package/vendor/server/dist/checkpoint/list-resumable-checkpoints.js

@@ -1,11 +0,0 @@
-import { buildWorkflowFingerprint, } from '@langflower/shared/langflower.js';
-/** List resumable checkpoints, marking fingerprint mismatches as stale. */
-export const listResumableCheckpoints = async (store, workflowId, workflow) => {
-    if (workflowId === null) {
-        return [];
-    }
-    const fingerprint = workflow !== null
-        ? buildWorkflowFingerprint(workflow.graph.nodes, workflow.graph.edges)
-        : undefined;
-    return store.listResumable(workflowId, fingerprint);
-};

package/vendor/server/dist/checkpoint/resolve-checkpoint-boundary.d.ts

@@ -1,11 +0,0 @@
-import type { WorkflowLoadedPayload } from '@langflower/shared/langflower.js';
-type CheckpointBoundary = {
-    readonly createCheckpoint: true;
-    readonly label?: string;
-};
-/**
- * Resolve whether an output emission is an explicit checkpoint boundary
- * (`createCheckpoint` on output meta, e.g. `common-checkpoint`).
- */
-export declare const resolveCheckpointBoundary: (workflow: WorkflowLoadedPayload, nodeId: string, portId: string) => CheckpointBoundary | undefined;
-export {};

package/vendor/server/dist/checkpoint/resolve-checkpoint-boundary.js

@@ -1,31 +0,0 @@
-import { getCommonReactiveNode } from '@langflower/common-nodes';
-/**
- * Resolve whether an output emission is an explicit checkpoint boundary
- * (`createCheckpoint` on output meta, e.g. `common-checkpoint`).
- */
-export const resolveCheckpointBoundary = (workflow, nodeId, portId) => {
-    const node = workflow.graph.nodes.find((entry) => entry.id === nodeId);
-    if (node === undefined) {
-        return undefined;
-    }
-    const definition = getCommonReactiveNode(node.type);
-    const portMeta = definition?.outputsConfigs.find((port) => port.portId === portId);
-    if (portMeta?.createCheckpoint !== true) {
-        return undefined;
-    }
-    const inputLabel = node.inputs['label'];
-    const fromInputs = typeof inputLabel === 'string' && inputLabel.trim().length > 0
-        ? inputLabel.trim()
-        : undefined;
-    const fromMeta = typeof portMeta.checkpointLabel === 'string' &&
-        portMeta.checkpointLabel.trim().length > 0
-        ? portMeta.checkpointLabel.trim()
-        : undefined;
-    const fromUi = typeof node.ui.label === 'string' && node.ui.label.trim().length > 0
-        ? node.ui.label.trim()
-        : undefined;
-    const label = fromInputs ?? fromMeta ?? fromUi;
-    return label !== undefined
-        ? { createCheckpoint: true, label }
-        : { createCheckpoint: true };
-};