langflower 0.1.0 → 0.1.1

package/vendor/server/dist/checkpoint/run-checkpoint-session.d.ts

@@ -1,41 +0,0 @@
-import { type NodeId, type RunId, type RuntimeRunnerEvent } from '@langflower/runtime';
-import { type WorkflowCheckpoint, type WorkflowCheckpointSummary, type WorkflowLoadedPayload } from '@langflower/shared/langflower.js';
-import { WorkflowCheckpointStore } from './workflow-checkpoint-store.js';
-/**
- * Per-session accumulator for durable checkpoints (ADR-018 D).
- *
- * Always accumulates JSON-safe output snapshots. Persists only when an
- * explicit boundary fires (`createCheckpoint` / `common-checkpoint`), or
- * when Stop/complete updates a run that already crossed a boundary.
- */
-export declare class RunCheckpointSession {
-    private readonly store;
-    private active;
-    private unsupportedValue;
-    /** Serialize disk writes — concurrent stage boundaries race on Windows rename. */
-    private persistChain;
-    constructor(projectDir: string);
-    getStore(): WorkflowCheckpointStore;
-    beginRun(runId: RunId, workflow: WorkflowLoadedPayload): void;
-    hydrateFromCheckpoint(checkpoint: WorkflowCheckpoint, workflow: WorkflowLoadedPayload): void;
-    /**
-     * Accumulate a live output emission.
-     *
-     * @returns `true` when this emission is an explicit checkpoint boundary
-     *          that should trigger an immediate persist.
-     */
-    observe(event: RuntimeRunnerEvent, boundary?: {
-        readonly label?: string;
-    }): boolean;
-    persist(status: WorkflowCheckpoint['status']): Promise<WorkflowCheckpointSummary | undefined>;
-    markCompleted(): Promise<WorkflowCheckpointSummary | undefined>;
-    markStopped(): Promise<WorkflowCheckpointSummary | undefined>;
-    clearActive(): void;
-    getUnsupportedValueMessage(): string | undefined;
-    resumeOptionsFromCheckpoint(checkpoint: WorkflowCheckpoint): {
-        readonly runId: RunId;
-        readonly completedNodeIds: readonly NodeId[];
-        readonly outputSnapshots: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-    };
-    private toCheckpoint;
-}

package/vendor/server/dist/checkpoint/run-checkpoint-session.js

@@ -1,170 +0,0 @@
-import { isPortTelemetry, } from '@langflower/runtime';
-import { buildWorkflowFingerprint, toCheckpointJsonValue, } from '@langflower/shared/langflower.js';
-import { summarizeCheckpoint, WorkflowCheckpointStore, } from './workflow-checkpoint-store.js';
-/**
- * Per-session accumulator for durable checkpoints (ADR-018 D).
- *
- * Always accumulates JSON-safe output snapshots. Persists only when an
- * explicit boundary fires (`createCheckpoint` / `common-checkpoint`), or
- * when Stop/complete updates a run that already crossed a boundary.
- */
-export class RunCheckpointSession {
-    store;
-    active;
-    unsupportedValue;
-    /** Serialize disk writes — concurrent stage boundaries race on Windows rename. */
-    persistChain = Promise.resolve();
-    constructor(projectDir) {
-        this.store = new WorkflowCheckpointStore(projectDir);
-    }
-    getStore() {
-        return this.store;
-    }
-    beginRun(runId, workflow) {
-        this.unsupportedValue = undefined;
-        this.active = {
-            runId: String(runId),
-            workflowId: workflow.workflowId,
-            workflowFingerprint: buildWorkflowFingerprint(workflow.graph.nodes, workflow.graph.edges),
-            completedNodeIds: new Set(),
-            outputSnapshots: new Map(),
-            status: 'running',
-            boundaryCrossed: false,
-            label: undefined,
-        };
-    }
-    hydrateFromCheckpoint(checkpoint, workflow) {
-        this.unsupportedValue = undefined;
-        const outputSnapshots = new Map();
-        for (const [nodeId, ports] of Object.entries(checkpoint.outputSnapshots)) {
-            outputSnapshots.set(nodeId, new Map(Object.entries(ports)));
-        }
-        this.active = {
-            runId: checkpoint.runId,
-            workflowId: workflow.workflowId,
-            workflowFingerprint: buildWorkflowFingerprint(workflow.graph.nodes, workflow.graph.edges),
-            completedNodeIds: new Set(checkpoint.completedNodeIds),
-            outputSnapshots,
-            status: 'running',
-            boundaryCrossed: true,
-            label: checkpoint.label,
-        };
-    }
-    /**
-     * Accumulate a live output emission.
-     *
-     * @returns `true` when this emission is an explicit checkpoint boundary
-     *          that should trigger an immediate persist.
-     */
-    observe(event, boundary) {
-        if (this.active === undefined ||
-            !isPortTelemetry(event) ||
-            event[0] !== 'out') {
-            return false;
-        }
-        const [, nodeIdRaw, portId, response] = event;
-        if (!('value' in response) || typeof portId !== 'string') {
-            return false;
-        }
-        const jsonValue = toCheckpointJsonValue(response.value);
-        if (jsonValue === undefined) {
-            this.unsupportedValue = `${String(nodeIdRaw)}.${portId}`;
-            return false;
-        }
-        const nodeId = String(nodeIdRaw);
-        let ports = this.active.outputSnapshots.get(nodeId);
-        if (ports === undefined) {
-            ports = new Map();
-            this.active.outputSnapshots.set(nodeId, ports);
-        }
-        ports.set(portId, {
-            state: 'value',
-            value: jsonValue,
-        });
-        this.active.completedNodeIds.add(nodeId);
-        if (boundary === undefined) {
-            return false;
-        }
-        this.active.boundaryCrossed = true;
-        if (boundary.label !== undefined) {
-            this.active.label = boundary.label;
-        }
-        return true;
-    }
-    async persist(status) {
-        const run = async () => {
-            if (this.active === undefined || !this.active.boundaryCrossed) {
-                return undefined;
-            }
-            if (this.unsupportedValue !== undefined) {
-                this.active.status = 'failed';
-                const failed = this.toCheckpoint('failed');
-                await this.store.save(failed);
-                return summarizeCheckpoint(failed);
-            }
-            this.active.status = status;
-            const checkpoint = this.toCheckpoint(status);
-            await this.store.save(checkpoint);
-            return summarizeCheckpoint(checkpoint);
-        };
-        const result = this.persistChain.then(run, run);
-        this.persistChain = result.then(() => undefined, () => undefined);
-        return result;
-    }
-    async markCompleted() {
-        const summary = await this.persist('completed');
-        this.active = undefined;
-        return summary;
-    }
-    async markStopped() {
-        const summary = await this.persist('stopped');
-        // Keep active until discard / new run so resume can use in-memory state
-        // without a disk round-trip in the same process; disk is for restart.
-        return summary;
-    }
-    clearActive() {
-        this.active = undefined;
-        this.unsupportedValue = undefined;
-    }
-    getUnsupportedValueMessage() {
-        return this.unsupportedValue === undefined
-            ? undefined
-            : `Unsupported non-JSON output at ${this.unsupportedValue}`;
-    }
-    resumeOptionsFromCheckpoint(checkpoint) {
-        const outputSnapshots = {};
-        for (const [nodeId, ports] of Object.entries(checkpoint.outputSnapshots)) {
-            outputSnapshots[nodeId] = Object.fromEntries(Object.entries(ports).map(([portId, snap]) => [
-                portId,
-                snap.value,
-            ]));
-        }
-        return {
-            runId: checkpoint.runId,
-            completedNodeIds: checkpoint.completedNodeIds,
-            outputSnapshots,
-        };
-    }
-    toCheckpoint(status) {
-        if (this.active === undefined) {
-            throw new Error('No active checkpoint run');
-        }
-        const outputSnapshots = {};
-        for (const [nodeId, ports] of this.active.outputSnapshots) {
-            outputSnapshots[nodeId] = Object.fromEntries(ports);
-        }
-        return {
-            schemaVersion: 1,
-            runId: this.active.runId,
-            workflowId: this.active.workflowId,
-            workflowFingerprint: this.active.workflowFingerprint,
-            updatedAt: new Date().toISOString(),
-            status,
-            completedNodeIds: [...this.active.completedNodeIds],
-            outputSnapshots,
-            ...(this.active.label !== undefined
-                ? { label: this.active.label }
-                : {}),
-        };
-    }
-}

package/vendor/server/dist/checkpoint/workflow-checkpoint-store.d.ts

@@ -1,23 +0,0 @@
-import type { WorkflowCheckpoint, WorkflowCheckpointSummary } from '@langflower/shared/langflower.js';
-type CheckpointLoadResult = {
-    readonly ok: true;
-    readonly checkpoint: WorkflowCheckpoint;
-} | {
-    readonly ok: false;
-    readonly code: 'NOT_FOUND' | 'CORRUPT';
-    readonly message: string;
-};
-export declare class WorkflowCheckpointStore {
-    private readonly projectDir;
-    constructor(projectDir: string);
-    private runsRoot;
-    private checkpointPath;
-    save(checkpoint: WorkflowCheckpoint): Promise<void>;
-    load(workflowId: string, runId: string): Promise<CheckpointLoadResult>;
-    discard(workflowId: string, runId: string): Promise<void>;
-    listResumable(workflowId: string, currentFingerprint?: string): Promise<readonly WorkflowCheckpointSummary[]>;
-}
-export declare const summarizeCheckpoint: (checkpoint: WorkflowCheckpoint, options?: {
-    readonly stale?: boolean;
-}) => WorkflowCheckpointSummary;
-export {};

package/vendor/server/dist/checkpoint/workflow-checkpoint-store.js

@@ -1,177 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-const CHECKPOINT_FILE = 'checkpoint.json';
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const isErrnoCode = (error, code) => typeof error === 'object' &&
-    error !== null &&
-    'code' in error &&
-    error.code === code;
-const isCheckpointStatus = (value) => value === 'running' ||
-    value === 'stopped' ||
-    value === 'completed' ||
-    value === 'failed';
-const parseCheckpoint = (raw) => {
-    if (!isRecord(raw)) {
-        return { corrupt: true, message: 'Checkpoint root must be an object' };
-    }
-    if (raw.schemaVersion !== 1) {
-        return {
-            corrupt: true,
-            message: `Unsupported checkpoint schemaVersion: ${String(raw.schemaVersion)}`,
-        };
-    }
-    if (typeof raw.runId !== 'string' ||
-        typeof raw.workflowId !== 'string' ||
-        typeof raw.workflowFingerprint !== 'string' ||
-        typeof raw.updatedAt !== 'string' ||
-        !isCheckpointStatus(raw.status) ||
-        !Array.isArray(raw.completedNodeIds) ||
-        !isRecord(raw.outputSnapshots)) {
-        return { corrupt: true, message: 'Checkpoint fields are incomplete' };
-    }
-    if (!raw.completedNodeIds.every((id) => typeof id === 'string')) {
-        return { corrupt: true, message: 'completedNodeIds must be strings' };
-    }
-    const label = typeof raw.label === 'string' && raw.label.trim().length > 0
-        ? raw.label.trim()
-        : undefined;
-    return {
-        schemaVersion: 1,
-        runId: raw.runId,
-        workflowId: raw.workflowId,
-        workflowFingerprint: raw.workflowFingerprint,
-        updatedAt: raw.updatedAt,
-        status: raw.status,
-        completedNodeIds: raw.completedNodeIds,
-        outputSnapshots: raw.outputSnapshots,
-        ...(label !== undefined ? { label } : {}),
-    };
-};
-const toSummary = (checkpoint, options) => ({
-    runId: checkpoint.runId,
-    workflowId: checkpoint.workflowId,
-    status: checkpoint.status,
-    updatedAt: checkpoint.updatedAt,
-    completedNodeIds: checkpoint.completedNodeIds,
-    ...(checkpoint.label !== undefined ? { label: checkpoint.label } : {}),
-    ...(options?.stale === true ? { stale: true } : {}),
-});
-const atomicWriteJson = async (filePath, value) => {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    const tempPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
-    const body = `${JSON.stringify(value, null, '\t')}\n`;
-    await fs.writeFile(tempPath, body, 'utf8');
-    try {
-        await fs.rename(tempPath, filePath);
-    }
-    catch (error) {
-        // Windows: replace existing file via unlink + rename when needed.
-        if (!isErrnoCode(error, 'EEXIST') && !isErrnoCode(error, 'EPERM')) {
-            await fs.unlink(tempPath).catch(() => undefined);
-            throw error;
-        }
-        await fs.unlink(filePath).catch(() => undefined);
-        await fs.rename(tempPath, filePath);
-    }
-};
-export class WorkflowCheckpointStore {
-    projectDir;
-    constructor(projectDir) {
-        this.projectDir = projectDir;
-    }
-    runsRoot() {
-        return path.join(this.projectDir, '.langflower', 'runs');
-    }
-    checkpointPath(workflowId, runId) {
-        return path.join(this.runsRoot(), workflowId, runId, CHECKPOINT_FILE);
-    }
-    async save(checkpoint) {
-        await atomicWriteJson(this.checkpointPath(checkpoint.workflowId, checkpoint.runId), checkpoint);
-    }
-    async load(workflowId, runId) {
-        const filePath = this.checkpointPath(workflowId, runId);
-        let text;
-        try {
-            text = await fs.readFile(filePath, 'utf8');
-        }
-        catch (error) {
-            if (isErrnoCode(error, 'ENOENT')) {
-                return {
-                    ok: false,
-                    code: 'NOT_FOUND',
-                    message: `No checkpoint for ${workflowId}/${runId}`,
-                };
-            }
-            throw error;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(text);
-        }
-        catch {
-            return {
-                ok: false,
-                code: 'CORRUPT',
-                message: 'Checkpoint JSON is not parseable',
-            };
-        }
-        const checkpoint = parseCheckpoint(parsed);
-        if ('corrupt' in checkpoint) {
-            return {
-                ok: false,
-                code: 'CORRUPT',
-                message: checkpoint.message,
-            };
-        }
-        if (checkpoint.workflowId !== workflowId ||
-            checkpoint.runId !== runId) {
-            return {
-                ok: false,
-                code: 'CORRUPT',
-                message: 'Checkpoint identity does not match path',
-            };
-        }
-        return { ok: true, checkpoint };
-    }
-    async discard(workflowId, runId) {
-        const dir = path.join(this.runsRoot(), workflowId, runId);
-        await fs.rm(dir, { recursive: true, force: true });
-    }
-    async listResumable(workflowId, currentFingerprint) {
-        const workflowDir = path.join(this.runsRoot(), workflowId);
-        let entries;
-        try {
-            entries = await fs.readdir(workflowDir);
-        }
-        catch (error) {
-            if (isErrnoCode(error, 'ENOENT')) {
-                return [];
-            }
-            throw error;
-        }
-        const summaries = await Promise.all(entries.map(async (runId) => {
-            const loaded = await this.load(workflowId, runId);
-            if (!loaded.ok) {
-                return {
-                    runId,
-                    workflowId,
-                    status: 'failed',
-                    updatedAt: new Date(0).toISOString(),
-                    completedNodeIds: [],
-                    corrupt: true,
-                };
-            }
-            if (loaded.checkpoint.status === 'completed') {
-                return undefined;
-            }
-            const stale = currentFingerprint !== undefined &&
-                loaded.checkpoint.workflowFingerprint !==
-                    currentFingerprint;
-            return toSummary(loaded.checkpoint, { stale });
-        }));
-        return summaries
-            .filter((entry) => entry !== undefined)
-            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-    }
-}
-export const summarizeCheckpoint = (checkpoint, options) => toSummary(checkpoint, options);

package/vendor/server/dist/checkpoint/workflow-checkpoint-store.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=workflow-checkpoint-store.test.d.ts.map

package/vendor/server/dist/checkpoint/workflow-checkpoint-store.test.js

@@ -1,60 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { WorkflowCheckpointStore } from './workflow-checkpoint-store.js';
-const sample = (overrides = {}) => ({
-    schemaVersion: 1,
-    runId: 'run-1',
-    workflowId: 'wf-1',
-    workflowFingerprint: 'v1:n1:common-string::',
-    updatedAt: '2026-07-19T12:00:00.000Z',
-    status: 'stopped',
-    completedNodeIds: ['n1'],
-    outputSnapshots: {
-        n1: { value: { state: 'value', value: 'ok' } },
-    },
-    ...overrides,
-});
-describe('WorkflowCheckpointStore', () => {
-    let projectDir;
-    afterEach(async () => {
-        if (projectDir !== undefined) {
-            await fs.rm(projectDir, { recursive: true, force: true });
-        }
-    });
-    it('round-trips a checkpoint and lists resumable runs', async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-ckpt-'));
-        const store = new WorkflowCheckpointStore(projectDir);
-        await store.save(sample());
-        const loaded = await store.load('wf-1', 'run-1');
-        expect(loaded.ok).toBe(true);
-        if (loaded.ok) {
-            expect(loaded.checkpoint.completedNodeIds).toEqual(['n1']);
-        }
-        const list = await store.listResumable('wf-1');
-        expect(list).toHaveLength(1);
-        expect(list[0]?.runId).toBe('run-1');
-    });
-    it('reports CORRUPT for invalid JSON', async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-ckpt-'));
-        const dir = path.join(projectDir, '.langflower', 'runs', 'wf-1', 'run-bad');
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(path.join(dir, 'checkpoint.json'), '{', 'utf8');
-        const store = new WorkflowCheckpointStore(projectDir);
-        const loaded = await store.load('wf-1', 'run-bad');
-        expect(loaded.ok).toBe(false);
-        if (!loaded.ok) {
-            expect(loaded.code).toBe('CORRUPT');
-        }
-        const list = await store.listResumable('wf-1');
-        expect(list[0]?.corrupt).toBe(true);
-    });
-    it('hides completed checkpoints from resumable list', async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-ckpt-'));
-        const store = new WorkflowCheckpointStore(projectDir);
-        await store.save(sample({ status: 'completed' }));
-        expect(await store.listResumable('wf-1')).toEqual([]);
-    });
-});
-//# sourceMappingURL=workflow-checkpoint-store.test.js.map

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

@@ -1,9 +0,0 @@
-import type { ToolConfig } from '@langflower/shared/types/config.js';
-export type { ToolConfig };
-export declare class ConfigService {
-    private readonly projectDir;
-    constructor(projectDir: string);
-    private configPath;
-    read(): Promise<ToolConfig>;
-    write(config: ToolConfig): Promise<void>;
-}

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

@@ -1,31 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { DEFAULT_CONFIG } from '@langflower/shared/constants/defaults.js';
-export class ConfigService {
-    projectDir;
-    constructor(projectDir) {
-        this.projectDir = projectDir;
-    }
-    configPath() {
-        return path.join(this.projectDir, '.langflower', 'config.json');
-    }
-    async read() {
-        try {
-            const raw = await fs.readFile(this.configPath(), 'utf8');
-            const parsed = JSON.parse(raw);
-            return {
-                port: typeof parsed.port === 'number'
-                    ? parsed.port
-                    : DEFAULT_CONFIG.port,
-                projectDir: this.projectDir,
-            };
-        }
-        catch {
-            return { ...DEFAULT_CONFIG, projectDir: this.projectDir };
-        }
-    }
-    async write(config) {
-        await fs.mkdir(path.dirname(this.configPath()), { recursive: true });
-        await fs.writeFile(this.configPath(), `${JSON.stringify({ ...config, projectDir: this.projectDir }, null, 2)}\n`, 'utf8');
-    }
-}

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

@@ -1,37 +0,0 @@
-import type { DividerPositions, LangflowerConfig, LangflowerConfigScope, LangflowerProviderConfig } from '@langflower/shared/langflower.js';
-export type LangflowerConfigLayers = {
-    readonly project: LangflowerConfig;
-    readonly global: LangflowerConfig;
-};
-export type LangflowerConfigSettingsWrite = {
-    readonly scope: LangflowerConfigScope;
-    readonly model?: string;
-    readonly embedding?: 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;
-    private readonly globalConfigPath;
-    constructor(projectDir: string, globalPath?: string);
-    globalPath(): string;
-    private projectConfigPath;
-    private readRawAt;
-    private writeRawAt;
-    readProject(): Promise<LangflowerConfig>;
-    readGlobal(): Promise<LangflowerConfig>;
-    readLayers(): Promise<LangflowerConfigLayers>;
-    /** Effective config: project > global merge. */
-    read(): Promise<LangflowerConfig>;
-    write(config: LangflowerConfig): Promise<void>;
-    /**
-     * Persist Settings Save for one scope. Preserves existing apiKey when the
-     * corresponding `providerApiKeys` entry is empty/missing.
-     */
-    writeSettings(input: LangflowerConfigSettingsWrite): Promise<LangflowerConfigLayers>;
-    setCurrentWorkflowId(workflowId: string | undefined): Promise<LangflowerConfig>;
-    setDividerPositions(positions: DividerPositions): Promise<LangflowerConfig>;
-    setPaletteVisible(visible: boolean): Promise<LangflowerConfig>;
-}