langflower 0.1.0 → 0.1.2

package/vendor/common-nodes/dist/ai/llm-compaction-ui-schema.js

@@ -1,18 +0,0 @@
-import { DEFAULT_CONTEXT_SIZE } from './openai/normalize-compaction-params.js';
-/** Shared Inspector fields for OpenAI-compatible chat compaction. */
-export const llmCompactionUiSchema = [
-    {
-        field: 'contextSize',
-        type: 'number',
-        label: 'Context size (approx tokens)',
-        default: DEFAULT_CONTEXT_SIZE,
-        min: 0,
-        step: 1,
-    },
-    {
-        field: 'compactOnError',
-        type: 'boolean',
-        label: 'Compact on context error',
-        default: false,
-    },
-];

package/vendor/common-nodes/dist/ai/llm-loop/autokick-recovery.d.ts

@@ -1,13 +0,0 @@
-export declare const autokickBackoffMs: (attempt: number, baseMs: number, maxMs: number) => number;
-export declare const clampChatPenalty: (value: number) => number;
-export declare const autokickPenalties: (attempt: number, delta: {
-    readonly frequency: number;
-    readonly presence: number;
-}) => {
-    readonly frequency: number;
-    readonly presence: number;
-};
-export declare const autokickKickUserTurn: (content: string) => {
-    readonly role: "user";
-    readonly content: string;
-};

package/vendor/common-nodes/dist/ai/llm-loop/autokick-recovery.js

@@ -1,17 +0,0 @@
-export const autokickBackoffMs = (attempt, baseMs, maxMs) => {
-    const safeAttempt = Math.max(1, attempt);
-    const delay = baseMs * 2 ** (safeAttempt - 1);
-    return Math.min(delay, maxMs);
-};
-export const clampChatPenalty = (value) => Math.min(2, Math.max(-2, value));
-export const autokickPenalties = (attempt, delta) => {
-    const safeAttempt = Math.max(1, attempt);
-    return {
-        frequency: clampChatPenalty(delta.frequency * safeAttempt),
-        presence: clampChatPenalty(delta.presence * safeAttempt),
-    };
-};
-export const autokickKickUserTurn = (content) => ({
-    role: 'user',
-    content,
-});

package/vendor/common-nodes/dist/ai/llm-loop/classify-llm-failure.d.ts

@@ -1,2 +0,0 @@
-import type { LlmFailure } from './llm-loop-types.js';
-export declare const classifyLlmFailure: (error: unknown) => LlmFailure;

package/vendor/common-nodes/dist/ai/llm-loop/classify-llm-failure.js

@@ -1,113 +0,0 @@
-import { isContextLengthExceededError } from '../openai/context-length-error.js';
-const readRecord = (value) => value !== null && typeof value === 'object'
-    ? value
-    : undefined;
-const readString = (value) => typeof value === 'string' && value.trim().length > 0
-    ? value.trim()
-    : undefined;
-const readStatus = (record) => {
-    const value = record['status'] ?? record['statusCode'];
-    return typeof value === 'number' && Number.isFinite(value)
-        ? value
-        : undefined;
-};
-const readHeader = (record, name) => {
-    const headers = readRecord(record['headers']);
-    if (headers === undefined) {
-        return undefined;
-    }
-    return readString(headers[name]) ?? readString(headers[name.toLowerCase()]);
-};
-const sanitizeMessage = (message, status) => {
-    if (/<(?:!doctype|html|head|body|pre)\b/i.test(message)) {
-        return status === undefined
-            ? 'Provider returned an HTML error response.'
-            : `Provider returned HTTP ${status} with an HTML error response.`;
-    }
-    return message.length <= 500 ? message : `${message.slice(0, 499)}…`;
-};
-export const classifyLlmFailure = (error) => {
-    if (isContextLengthExceededError(error)) {
-        return {
-            kind: 'context-overflow',
-            message: sanitizeMessage(error.message),
-            recoverable: true,
-        };
-    }
-    const record = readRecord(error);
-    const nestedError = readRecord(record?.['error']);
-    const status = record === undefined ? undefined : readStatus(record);
-    const rawMessage = readString(record?.['message']) ??
-        readString(nestedError?.['message']) ??
-        (error instanceof Error ? error.message : String(error));
-    const message = sanitizeMessage(rawMessage, status);
-    const rawContentType = record === undefined ? undefined : readHeader(record, 'content-type');
-    const retryAfterRaw = record === undefined ? undefined : readHeader(record, 'retry-after');
-    const retryAfterSeconds = retryAfterRaw === undefined ? Number.NaN : Number(retryAfterRaw);
-    const retryAfterMs = Number.isFinite(retryAfterSeconds)
-        ? Math.max(0, retryAfterSeconds * 1_000)
-        : undefined;
-    const code = readString(record?.['code']) ?? readString(nestedError?.['code']);
-    const messageLower = message.toLowerCase();
-    if (status === 401 ||
-        status === 403 ||
-        /authentication|unauthorized|invalid api key|invalid_api_key/.test(messageLower)) {
-        return {
-            kind: 'authentication',
-            message,
-            recoverable: false,
-            ...(status !== undefined ? { status } : {}),
-        };
-    }
-    if (status === 404 ||
-        /model .* not found|unknown model|provider is required|model is required/.test(messageLower)) {
-        return {
-            kind: 'configuration',
-            message,
-            recoverable: false,
-            ...(status !== undefined ? { status } : {}),
-        };
-    }
-    if (status === 429 || /rate.?limit/.test(messageLower)) {
-        return {
-            kind: 'rate-limit',
-            message,
-            recoverable: true,
-            ...(status !== undefined ? { status } : {}),
-            ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
-        };
-    }
-    if (status !== undefined && (status === 408 || status >= 500)) {
-        return {
-            kind: 'provider-unavailable',
-            message,
-            recoverable: true,
-            status,
-            ...(rawContentType !== undefined ? { rawContentType } : {}),
-        };
-    }
-    if (code === 'ECONNRESET' ||
-        code === 'ECONNREFUSED' ||
-        code === 'ETIMEDOUT' ||
-        /network|socket|connection reset|fetch failed|timeout/.test(messageLower)) {
-        return {
-            kind: 'network',
-            message,
-            recoverable: true,
-        };
-    }
-    if (message.startsWith('Cannot compact history:')) {
-        return {
-            kind: 'protocol',
-            message,
-            recoverable: true,
-        };
-    }
-    return {
-        kind: 'unknown',
-        message,
-        recoverable: true,
-        ...(status !== undefined ? { status } : {}),
-        ...(rawContentType !== undefined ? { rawContentType } : {}),
-    };
-};

package/vendor/common-nodes/dist/ai/llm-loop/dead-loop-detector.d.ts

@@ -1,28 +0,0 @@
-export type DeadLoopChannel = 'reasoning' | 'draft';
-export type DeadLoopDetectorOptions = {
-    readonly maxWindowTokens?: number;
-    readonly consecutiveThreshold?: number;
-    readonly minRepetitions?: number;
-    readonly minPatternTokens?: number;
-};
-type DeadLoopError = {
-    readonly name: 'DeadLoopError';
-    readonly message: string;
-    readonly partialText: string;
-    readonly lastTokens: readonly string[];
-    readonly reason: 'consecutive' | 'cyclic';
-    readonly channel: DeadLoopChannel;
-};
-type DeadLoopPushResult = {
-    readonly ok: true;
-} | {
-    readonly ok: false;
-    readonly error: DeadLoopError;
-};
-export type DeadLoopDetector = {
-    readonly hashLookups: number;
-    readonly exactCompareTokenVisits: number;
-    readonly push: (text: string) => DeadLoopPushResult;
-};
-export declare const createDeadLoopDetector: (channel: DeadLoopChannel, options?: DeadLoopDetectorOptions) => DeadLoopDetector;
-export {};

package/vendor/common-nodes/dist/ai/llm-loop/dead-loop-detector.js

@@ -1,194 +0,0 @@
-const DEFAULT_DEAD_LOOP_OPTIONS = {
-    maxWindowTokens: 1_000,
-    consecutiveThreshold: 5,
-    minRepetitions: 3,
-    minPatternTokens: 2,
-};
-const BASE1 = 911_382_323;
-const BASE2 = 972_663_749;
-const FNV_OFFSET1 = 2_166_136_261;
-const FNV_OFFSET2 = 84_696_351;
-const FNV_PRIME = 16_777_619;
-const hashString = (text, offset) => {
-    let hash = offset >>> 0;
-    for (let index = 0; index < text.length; index += 1) {
-        hash ^= text.charCodeAt(index);
-        hash = Math.imul(hash, FNV_PRIME);
-    }
-    return hash >>> 0;
-};
-const createPowTable = (base, maxExponent) => {
-    const table = new Uint32Array(maxExponent + 1);
-    table[0] = 1;
-    for (let exponent = 1; exponent <= maxExponent; exponent += 1) {
-        table[exponent] = Math.imul(table[exponent - 1] ?? 1, base) >>> 0;
-    }
-    return table;
-};
-export const createDeadLoopDetector = (channel, options = {}) => {
-    const maxWindowTokens = options.maxWindowTokens ?? DEFAULT_DEAD_LOOP_OPTIONS.maxWindowTokens;
-    const consecutiveThreshold = options.consecutiveThreshold ??
-        DEFAULT_DEAD_LOOP_OPTIONS.consecutiveThreshold;
-    const minRepetitions = options.minRepetitions ?? DEFAULT_DEAD_LOOP_OPTIONS.minRepetitions;
-    const minPatternTokens = options.minPatternTokens ?? DEFAULT_DEAD_LOOP_OPTIONS.minPatternTokens;
-    const capacity = Math.max(1, maxWindowTokens);
-    const tokens = new Array(capacity);
-    const hashes1 = new Uint32Array(capacity);
-    const hashes2 = new Uint32Array(capacity);
-    const prefix1 = new Uint32Array(capacity + 1);
-    const prefix2 = new Uint32Array(capacity + 1);
-    const pow1 = createPowTable(BASE1, capacity);
-    const pow2 = createPowTable(BASE2, capacity);
-    const stats = {
-        hashLookups: 0,
-        exactCompareTokenVisits: 0,
-    };
-    let head = 0;
-    let size = 0;
-    let consecutiveCount = 0;
-    const physicalIndex = (logical) => (head + logical) % capacity;
-    const tokenAt = (logical) => tokens[physicalIndex(logical)] ?? '';
-    const dropOldest = () => {
-        const removedPhysical = head;
-        const removed1 = hashes1[removedPhysical] ?? 0;
-        const removed2 = hashes2[removedPhysical] ?? 0;
-        for (let logical = 1; logical < size; logical += 1) {
-            prefix1[logical] =
-                ((prefix1[logical + 1] ?? 0) -
-                    Math.imul(removed1, pow1[logical] ?? 1)) >>>
-                    0;
-            prefix2[logical] =
-                ((prefix2[logical + 1] ?? 0) -
-                    Math.imul(removed2, pow2[logical] ?? 1)) >>>
-                    0;
-        }
-        prefix1[0] = 0;
-        prefix2[0] = 0;
-        head = (head + 1) % capacity;
-        size -= 1;
-    };
-    const appendPrefix = (physical) => {
-        prefix1[size] =
-            (Math.imul(prefix1[size - 1] ?? 0, BASE1) +
-                (hashes1[physical] ?? 0)) >>>
-                0;
-        prefix2[size] =
-            (Math.imul(prefix2[size - 1] ?? 0, BASE2) +
-                (hashes2[physical] ?? 0)) >>>
-                0;
-    };
-    const rangeHashesEqual = (leftStart, rightStart, length) => {
-        stats.hashLookups += 1;
-        const leftEnd = leftStart + length;
-        const rightEnd = rightStart + length;
-        const powA = pow1[length] ?? 1;
-        const powB = pow2[length] ?? 1;
-        const left1 = ((prefix1[leftEnd] ?? 0) -
-            Math.imul(prefix1[leftStart] ?? 0, powA)) >>>
-            0;
-        const right1 = ((prefix1[rightEnd] ?? 0) -
-            Math.imul(prefix1[rightStart] ?? 0, powA)) >>>
-            0;
-        if (left1 !== right1) {
-            return false;
-        }
-        const left2 = ((prefix2[leftEnd] ?? 0) -
-            Math.imul(prefix2[leftStart] ?? 0, powB)) >>>
-            0;
-        const right2 = ((prefix2[rightEnd] ?? 0) -
-            Math.imul(prefix2[rightStart] ?? 0, powB)) >>>
-            0;
-        return left2 === right2;
-    };
-    const sliceTokens = (start, end) => {
-        const sliced = [];
-        for (let logical = start; logical < end; logical += 1) {
-            sliced.push(tokenAt(logical));
-        }
-        return sliced;
-    };
-    const joinTokens = () => {
-        let text = '';
-        for (let logical = 0; logical < size; logical += 1) {
-            text += tokenAt(logical);
-        }
-        return text;
-    };
-    const exactBlocksMatch = (patternLength) => {
-        const baseStart = size - patternLength;
-        for (let repeat = 1; repeat < minRepetitions; repeat += 1) {
-            const otherStart = size - (repeat + 1) * patternLength;
-            for (let offset = 0; offset < patternLength; offset += 1) {
-                stats.exactCompareTokenVisits += 1;
-                if (tokenAt(baseStart + offset) !== tokenAt(otherStart + offset)) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    };
-    const fail = (reason, lastTokens) => ({
-        ok: false,
-        error: {
-            name: 'DeadLoopError',
-            message: reason === 'consecutive'
-                ? `Consecutive token repetition on ${channel}`
-                : `Cyclic repetition on ${channel}`,
-            partialText: joinTokens(),
-            lastTokens,
-            reason,
-            channel,
-        },
-    });
-    const detectCyclic = () => {
-        const maxPatternLength = Math.floor(size / minRepetitions);
-        for (let patternLength = minPatternTokens; patternLength <= maxPatternLength; patternLength += 1) {
-            const blockStart = size - patternLength;
-            let repeats = true;
-            for (let repeat = 1; repeat < minRepetitions; repeat += 1) {
-                const start = size - (repeat + 1) * patternLength;
-                if (!rangeHashesEqual(start, blockStart, patternLength)) {
-                    repeats = false;
-                    break;
-                }
-            }
-            if (!repeats) {
-                continue;
-            }
-            if (exactBlocksMatch(patternLength)) {
-                return fail('cyclic', sliceTokens(blockStart, size));
-            }
-        }
-        return undefined;
-    };
-    const push = (text) => {
-        if (text.length === 0) {
-            return { ok: true };
-        }
-        const previous = size === 0 ? undefined : tokenAt(size - 1);
-        consecutiveCount = previous === text ? consecutiveCount + 1 : 1;
-        if (size === capacity) {
-            dropOldest();
-        }
-        const physical = physicalIndex(size);
-        tokens[physical] = text;
-        hashes1[physical] = hashString(text, FNV_OFFSET1);
-        hashes2[physical] = hashString(text, FNV_OFFSET2);
-        size += 1;
-        appendPrefix(physical);
-        if (consecutiveCount >= consecutiveThreshold) {
-            const start = Math.max(0, size - consecutiveCount);
-            return fail('consecutive', sliceTokens(start, size));
-        }
-        return detectCyclic() ?? { ok: true };
-    };
-    return {
-        get hashLookups() {
-            return stats.hashLookups;
-        },
-        get exactCompareTokenVisits() {
-            return stats.exactCompareTokenVisits;
-        },
-        push,
-    };
-};

package/vendor/common-nodes/dist/ai/llm-loop/llm-loop-reducer.d.ts

@@ -1,2 +0,0 @@
-import type { LlmLoopAction, LlmLoopState } from './llm-loop-types.js';
-export declare const reduceLlmLoop: (state: LlmLoopState, action: LlmLoopAction) => LlmLoopState;

package/vendor/common-nodes/dist/ai/llm-loop/llm-loop-reducer.js

@@ -1,216 +0,0 @@
-import { autokickKickUserTurn } from './autokick-recovery.js';
-const assertNever = (value) => {
-    throw new Error(`Unhandled LLM loop action: ${JSON.stringify(value)}`);
-};
-export const reduceLlmLoop = (state, action) => {
-    switch (action.type) {
-        case 'round.prepared':
-            return {
-                ...state,
-                phase: 'streaming',
-                committedMessages: [...action.messages],
-                roundCheckpoint: [...action.messages],
-                partial: { reasoning: '', draft: '' },
-                suspendedBy: undefined,
-                failure: undefined,
-            };
-        case 'stream.reasoning':
-            return {
-                ...state,
-                partial: {
-                    ...state.partial,
-                    reasoning: `${state.partial.reasoning}${action.text}`,
-                },
-            };
-        case 'stream.draft':
-            return {
-                ...state,
-                partial: {
-                    ...state.partial,
-                    draft: `${state.partial.draft}${action.text}`,
-                },
-            };
-        case 'stream.done':
-            if (action.toolCalls !== undefined && action.toolCalls.length > 0) {
-                return {
-                    ...state,
-                    phase: 'tools',
-                    committedMessages: [
-                        ...state.committedMessages,
-                        {
-                            role: 'assistant',
-                            content: action.text.length > 0
-                                ? action.text
-                                : state.partial.draft,
-                            tool_calls: action.toolCalls,
-                        },
-                    ],
-                    partial: {
-                        ...state.partial,
-                        draft: action.text.length > 0
-                            ? action.text
-                            : state.partial.draft,
-                        toolCalls: action.toolCalls,
-                    },
-                    pendingToolCalls: action.toolCalls,
-                };
-            }
-            return {
-                ...state,
-                phase: 'complete',
-                partial: {
-                    ...state.partial,
-                    draft: action.text.length > 0
-                        ? action.text
-                        : state.partial.draft,
-                },
-            };
-        case 'stream.paused':
-            return {
-                ...state,
-                phase: 'suspended',
-                committedMessages: [...state.roundCheckpoint],
-                suspendedBy: { kind: 'user-pause' },
-            };
-        case 'stream.idle':
-            return {
-                ...state,
-                phase: 'suspended',
-                committedMessages: [...state.roundCheckpoint],
-                suspendedBy: {
-                    kind: 'stream-idle',
-                    idleMs: action.idleMs,
-                },
-            };
-        case 'stream.dead-loop':
-            return {
-                ...state,
-                phase: 'suspended',
-                committedMessages: [...state.roundCheckpoint],
-                suspendedBy: {
-                    kind: 'dead-loop',
-                    channel: action.channel,
-                    reason: action.reason,
-                },
-            };
-        case 'provider.failed':
-            return {
-                ...state,
-                phase: action.failure.recoverable ? 'suspended' : 'failed',
-                committedMessages: [...state.roundCheckpoint],
-                suspendedBy: action.failure.recoverable
-                    ? {
-                        kind: 'provider-failure',
-                        failure: action.failure,
-                    }
-                    : undefined,
-                failure: action.failure,
-            };
-        case 'tool.completed': {
-            const pendingToolCalls = state.pendingToolCalls.slice(1);
-            const messages = [
-                ...state.committedMessages,
-                {
-                    role: 'tool',
-                    content: action.result,
-                    tool_call_id: action.call.id,
-                },
-            ];
-            return {
-                ...state,
-                phase: pendingToolCalls.length === 0 ? 'prepare' : 'tools',
-                committedMessages: messages,
-                roundCheckpoint: pendingToolCalls.length === 0
-                    ? messages
-                    : state.roundCheckpoint,
-                iteration: pendingToolCalls.length === 0
-                    ? state.iteration + 1
-                    : state.iteration,
-                transientAttempts: pendingToolCalls.length === 0 ? 0 : state.transientAttempts,
-                partial: pendingToolCalls.length === 0
-                    ? { reasoning: '', draft: '' }
-                    : state.partial,
-                pendingToolCalls,
-            };
-        }
-        case 'subagent.waiting':
-            return {
-                ...state,
-                phase: 'waiting-subagent',
-                openSpawnCallId: action.callId,
-            };
-        case 'subagent.completed':
-            return {
-                ...state,
-                phase: 'tools',
-                openSpawnCallId: undefined,
-            };
-        case 'retry.scheduled':
-            return {
-                ...state,
-                phase: 'prepare',
-                committedMessages: [...state.roundCheckpoint],
-                transientAttempts: state.transientAttempts + 1,
-                partial: { reasoning: '', draft: '' },
-                pendingToolCalls: [],
-                suspendedBy: undefined,
-                failure: undefined,
-            };
-        case 'autokick.scheduled':
-            return {
-                ...state,
-                phase: 'prepare',
-                committedMessages: action.kickUserMessage === undefined
-                    ? [...state.roundCheckpoint]
-                    : [
-                        ...state.roundCheckpoint,
-                        autokickKickUserTurn(action.kickUserMessage),
-                    ],
-                autokickAttempts: state.autokickAttempts + 1,
-                autokickKickAttempts: action.kickUserMessage === undefined
-                    ? state.autokickKickAttempts
-                    : state.autokickKickAttempts + 1,
-                lastAutokickAt: action.atMs,
-                transientAttempts: 0,
-                partial: { reasoning: '', draft: '' },
-                pendingToolCalls: [],
-                suspendedBy: undefined,
-                failure: undefined,
-            };
-        case 'steer.received': {
-            const text = action.text?.trim() ?? '';
-            const messages = text.length === 0
-                ? [...state.roundCheckpoint]
-                : [
-                    ...state.roundCheckpoint,
-                    { role: 'user', content: text },
-                ];
-            return {
-                ...state,
-                phase: 'prepare',
-                committedMessages: messages,
-                roundCheckpoint: messages,
-                transientAttempts: 0,
-                autokickAttempts: 0,
-                autokickKickAttempts: 0,
-                lastAutokickAt: undefined,
-                partial: { reasoning: '', draft: '' },
-                pendingToolCalls: [],
-                suspendedBy: undefined,
-                failure: undefined,
-            };
-        }
-        case 'round.completed':
-            return { ...state, phase: 'complete' };
-        case 'failure.fatal':
-            return {
-                ...state,
-                phase: 'failed',
-                failure: action.failure,
-            };
-        case 'cancel.requested':
-            return { ...state, phase: 'cancelled' };
-        default:
-            return assertNever(action);
-    }
-};