langflower 0.0.7 → 0.0.9

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

@@ -0,0 +1,113 @@
+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/features/llm-loop/dead-loop-detector.d.ts

@@ -0,0 +1,28 @@
+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/features/llm-loop/dead-loop-detector.js

@@ -0,0 +1,194 @@
+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/features/llm-loop/live-get-tools.d.ts

@@ -0,0 +1,9 @@
+import type { ToolHandle } from '@langflower/node-sdk';
+/**
+ * Stash a live inventory reader on the snapshot array so agent loops can
+ * re-read after custom-node hot-swap without each catalog node forwarding
+ * `getTools` through `runAgentLoop` args.
+ */
+export declare const tagLiveGetTools: (list: readonly ToolHandle[], getTools: () => readonly ToolHandle[]) => readonly ToolHandle[];
+export declare const readTaggedGetTools: (list: readonly ToolHandle[]) => (() => readonly ToolHandle[]) | undefined;
+//# sourceMappingURL=live-get-tools.d.ts.map

package/vendor/common-nodes/dist/ai/features/llm-loop/live-get-tools.js

@@ -0,0 +1,21 @@
+const liveGetToolsSymbol = Symbol('langflower.liveGetTools');
+/**
+ * Stash a live inventory reader on the snapshot array so agent loops can
+ * re-read after custom-node hot-swap without each catalog node forwarding
+ * `getTools` through `runAgentLoop` args.
+ */
+export const tagLiveGetTools = (list, getTools) => {
+    Object.defineProperty(list, liveGetToolsSymbol, {
+        value: getTools,
+        enumerable: false,
+        writable: false,
+    });
+    return list;
+};
+export const readTaggedGetTools = (list) => {
+    const tagged = list[liveGetToolsSymbol];
+    return typeof tagged === 'function'
+        ? tagged
+        : undefined;
+};
+//# sourceMappingURL=live-get-tools.js.map

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

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

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

@@ -0,0 +1,216 @@
+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);
+    }
+};