langflower 0.1.0 → 0.1.2

package/vendor/common-nodes/dist/ai/openai/create-chat-completion-stream.js

@@ -1,182 +0,0 @@
-import OpenAI from 'openai';
-import { classifyContextLengthError, ContextLengthExceededError, } from './context-length-error.js';
-export { ContextLengthExceededError, classifyContextLengthError };
-export { isContextLengthExceededError } from './context-length-error.js';
-const requireNonEmpty = (value, label) => {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${label} is required for OpenAI-compatible chat`);
-    }
-    return trimmed;
-};
-export const mapFinishReason = (value) => {
-    switch (value) {
-        case 'stop':
-        case 'length':
-        case 'tool_calls':
-        case 'content_filter':
-            return value;
-        default:
-            return 'unknown';
-    }
-};
-const toOpenAiMessages = (messages) => messages.map((message) => {
-    if (message.role === 'tool') {
-        return {
-            role: 'tool',
-            content: message.content,
-            tool_call_id: message.tool_call_id,
-        };
-    }
-    if (message.role === 'assistant' && message.tool_calls !== undefined) {
-        return {
-            role: 'assistant',
-            content: message.content.length > 0 ? message.content : null,
-            tool_calls: message.tool_calls.map((call) => ({
-                id: call.id,
-                type: 'function',
-                function: {
-                    name: call.name,
-                    arguments: call.arguments,
-                },
-            })),
-        };
-    }
-    return {
-        role: message.role,
-        content: message.content,
-    };
-});
-const mergeToolCallDelta = (acc, index, delta) => {
-    const current = acc.get(index) ?? { id: '', name: '', arguments: '' };
-    acc.set(index, {
-        id: delta.id !== undefined && delta.id.length > 0
-            ? delta.id
-            : current.id,
-        name: delta.function?.name !== undefined && delta.function.name.length > 0
-            ? `${current.name}${delta.function.name}`
-            : current.name,
-        arguments: delta.function?.arguments !== undefined
-            ? `${current.arguments}${delta.function.arguments}`
-            : current.arguments,
-    });
-};
-const finalizeToolCalls = (acc) => [...acc.entries()]
-    .sort(([a], [b]) => a - b)
-    .map(([, call]) => ({
-    id: call.id.length > 0 ? call.id : `call_${call.name}`,
-    name: call.name,
-    arguments: call.arguments,
-}))
-    .filter((call) => call.name.length > 0);
-/** LM Studio / DeepSeek-style CoT fields on OpenAI-compatible deltas. */
-export const reasoningTextFromDelta = (delta) => {
-    if (delta === null || typeof delta !== 'object') {
-        return '';
-    }
-    const record = delta;
-    const reasoning = record['reasoning'];
-    const reasoningContent = record['reasoning_content'];
-    if (typeof reasoning === 'string' && reasoning.length > 0) {
-        return reasoning;
-    }
-    if (typeof reasoningContent === 'string' && reasoningContent.length > 0) {
-        return reasoningContent;
-    }
-    return '';
-};
-/**
- * Unbound OpenAI-compatible chat stream factory.
- * Caller supplies credential resolve (server injects secrets).
- */
-export const createChatCompletionStream = (deps) => {
-    return async (args) => {
-        const providerId = requireNonEmpty(args.providerId, 'Provider');
-        const model = requireNonEmpty(args.model, 'Model');
-        const credentials = await deps.resolveProvider(providerId);
-        const client = new OpenAI({
-            apiKey: credentials.apiKey ?? 'local-no-key',
-            ...(credentials.baseURL !== undefined
-                ? { baseURL: credentials.baseURL }
-                : {}),
-        });
-        const tools = args.tools !== undefined && args.tools.length > 0
-            ? args.tools.map((tool) => ({
-                type: 'function',
-                function: {
-                    name: tool.function.name,
-                    ...(tool.function.description !== undefined
-                        ? { description: tool.function.description }
-                        : {}),
-                    ...(tool.function.parameters !== undefined
-                        ? {
-                            parameters: tool.function
-                                .parameters,
-                        }
-                        : {}),
-                },
-            }))
-            : undefined;
-        let stream;
-        try {
-            stream = (await client.chat.completions.create({
-                model,
-                messages: toOpenAiMessages(args.messages),
-                stream: true,
-                ...(tools !== undefined ? { tools } : {}),
-                ...(args.frequency_penalty !== undefined
-                    ? { frequency_penalty: args.frequency_penalty }
-                    : {}),
-                ...(args.presence_penalty !== undefined
-                    ? { presence_penalty: args.presence_penalty }
-                    : {}),
-            }, {
-                signal: args.signal,
-            }));
-        }
-        catch (error) {
-            const contextError = classifyContextLengthError(error);
-            if (contextError !== undefined) {
-                throw contextError;
-            }
-            throw error;
-        }
-        async function* iterate() {
-            let fullText = '';
-            let lastFinishReason;
-            const toolAcc = new Map();
-            for await (const chunk of stream) {
-                const choice = chunk.choices[0];
-                if (choice?.finish_reason !== undefined) {
-                    lastFinishReason = mapFinishReason(choice.finish_reason);
-                }
-                const delta = choice?.delta;
-                const reasoningText = reasoningTextFromDelta(delta);
-                if (reasoningText.length > 0) {
-                    yield { kind: 'reasoning', text: reasoningText };
-                }
-                const content = delta?.content;
-                if (content !== undefined &&
-                    content !== null &&
-                    content.length > 0) {
-                    fullText += content;
-                    yield { kind: 'draft', text: content };
-                }
-                const toolDeltas = delta?.tool_calls;
-                if (toolDeltas !== undefined) {
-                    for (const toolDelta of toolDeltas) {
-                        mergeToolCallDelta(toolAcc, toolDelta.index ?? 0, toolDelta);
-                    }
-                }
-            }
-            const tool_calls = finalizeToolCalls(toolAcc);
-            yield {
-                kind: 'done',
-                text: fullText,
-                finishReason: lastFinishReason ?? 'unknown',
-                ...(tool_calls.length > 0 ? { tool_calls } : {}),
-            };
-        }
-        return iterate();
-    };
-};

package/vendor/common-nodes/dist/ai/openai/create-embedding.d.ts

@@ -1,18 +0,0 @@
-import type { OpenAiProviderCredentials } from './create-chat-completion-stream.js';
-/**
- * Server-bound embedding factory (credentials resolved server-side).
- * KB tooling uses this when present; otherwise falls back to local hashing.
- */
-export type CreateEmbedding = (texts: readonly string[]) => Promise<readonly Float32Array[]>;
-export type EmbeddingResolveResult = OpenAiProviderCredentials & {
-    readonly model: string;
-    readonly dimensions?: number;
-};
-/**
- * Unbound OpenAI-compatible embedding factory.
- * Caller supplies resolve (server reads `langflower.jsonc` embedding block).
- */
-export declare const createEmbedding: (deps: {
-    readonly resolveEmbedding: () => Promise<EmbeddingResolveResult>;
-}) => CreateEmbedding;
-//# sourceMappingURL=create-embedding.d.ts.map

package/vendor/common-nodes/dist/ai/openai/create-embedding.js

@@ -1,43 +0,0 @@
-import OpenAI from 'openai';
-const requireNonEmpty = (value, label) => {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${label} is required for embeddings`);
-    }
-    return trimmed;
-};
-/**
- * Unbound OpenAI-compatible embedding factory.
- * Caller supplies resolve (server reads `langflower.jsonc` embedding block).
- */
-export const createEmbedding = (deps) => {
-    return async (texts) => {
-        const embedding = await deps.resolveEmbedding();
-        const model = requireNonEmpty(embedding.model, 'embedding.model');
-        const client = new OpenAI({
-            apiKey: embedding.apiKey ?? 'local-no-key',
-            ...(embedding.baseURL !== undefined
-                ? { baseURL: embedding.baseURL }
-                : {}),
-        });
-        if (texts.length === 0) {
-            return [];
-        }
-        const response = await client.embeddings.create({
-            model,
-            input: [...texts],
-            ...(embedding.dimensions !== undefined
-                ? { dimensions: embedding.dimensions }
-                : {}),
-        });
-        const byIndex = new Map(response.data.map((row) => [row.index, row.embedding]));
-        return texts.map((_, index) => {
-            const values = byIndex.get(index);
-            if (values === undefined) {
-                throw new Error(`embedding response missing index ${index}`);
-            }
-            return Float32Array.from(values);
-        });
-    };
-};
-//# sourceMappingURL=create-embedding.js.map

package/vendor/common-nodes/dist/ai/openai/list-provider-models.d.ts

@@ -1,28 +0,0 @@
-import type { OpenAiProviderCredentials } from './create-chat-completion-stream.js';
-export type ProviderModelEntry = {
-    readonly id: string;
-    readonly name?: string;
-};
-export type ListProviderModelsResult = {
-    readonly models: readonly ProviderModelEntry[];
-    readonly error?: string;
-};
-type OpenAiModelsClient = {
-    readonly models: {
-        readonly list: () => Promise<{
-            readonly data: readonly {
-                readonly id: string;
-                readonly name?: string;
-            }[];
-        }>;
-    };
-};
-type ListProviderModelsDeps = {
-    readonly createClient?: (credentials: OpenAiProviderCredentials) => OpenAiModelsClient;
-};
-/**
- * Lists models for resolved credentials. Never throws — failures return
- * `{ models: [], error }`.
- */
-export declare const listProviderModels: (credentials: OpenAiProviderCredentials, deps?: ListProviderModelsDeps) => Promise<ListProviderModelsResult>;
-export {};

package/vendor/common-nodes/dist/ai/openai/list-provider-models.js

@@ -1,52 +0,0 @@
-import OpenAI from 'openai';
-const SECRET_SUBSTRINGS = ['sk-', 'apiKey', 'api_key', 'authorization'];
-const toSafeErrorMessage = (message) => {
-    const lower = message.toLowerCase();
-    for (const needle of SECRET_SUBSTRINGS) {
-        if (lower.includes(needle.toLowerCase())) {
-            return 'Failed to list models for provider';
-        }
-    }
-    return message;
-};
-const mapModelEntry = (entry) => {
-    const name = 'name' in entry && typeof entry.name === 'string'
-        ? entry.name
-        : undefined;
-    return {
-        id: entry.id,
-        ...(name !== undefined ? { name } : {}),
-    };
-};
-const defaultCreateClient = (credentials) => new OpenAI({
-    apiKey: credentials.apiKey ?? 'local-no-key',
-    ...(credentials.baseURL !== undefined
-        ? { baseURL: credentials.baseURL }
-        : {}),
-});
-/**
- * Lists models for resolved credentials. Never throws — failures return
- * `{ models: [], error }`.
- */
-export const listProviderModels = async (credentials, deps) => {
-    try {
-        const createClient = deps?.createClient ?? defaultCreateClient;
-        const client = createClient(credentials);
-        const page = await client.models.list();
-        const models = (page.data ?? []).map(mapModelEntry);
-        if (models.length === 0) {
-            return {
-                models: [],
-                error: 'Provider returned no models. For LM Studio / local OpenAI-compatible servers, baseURL usually ends with /v1 (e.g. http://127.0.0.1:1234/v1).',
-            };
-        }
-        return { models };
-    }
-    catch (error) {
-        const raw = error instanceof Error ? error.message : String(error);
-        return {
-            models: [],
-            error: toSafeErrorMessage(raw),
-        };
-    }
-};

package/vendor/common-nodes/dist/ai/openai/llm-context-compaction.d.ts

@@ -1,31 +0,0 @@
-import type { ChatCompletionMessage, ChatCompletionToolDefinition, CreateChatCompletionStream } from '../chat-completion-stream.js';
-import type { LlmCompactionConfig } from './normalize-compaction-params.js';
-export type CompactMessagesResult = {
-    readonly ok: true;
-    readonly messages: readonly ChatCompletionMessage[];
-    readonly beforeTokens: number;
-    readonly afterTokens: number;
-} | {
-    readonly ok: false;
-    readonly message: string;
-};
-export declare const SUMMARY_SYSTEM_PROMPT: string;
-export declare const estimateMessagesTokens: (messages: readonly ChatCompletionMessage[]) => number;
-export declare const estimateToolsTokens: (tools: readonly ChatCompletionToolDefinition[]) => number;
-export declare const estimateRequestTokens: (messages: readonly ChatCompletionMessage[], tools: readonly ChatCompletionToolDefinition[]) => number;
-/**
- * LLM-summary compaction: replace contiguous unprotected message blocks with
- * a summary user message while preserving leading system + last user + newest
- * block and full assistant/tool groups.
- */
-export declare const compactMessagesWithSummary: (args: {
-    readonly factory: CreateChatCompletionStream;
-    readonly providerId: string;
-    readonly model: string;
-    readonly messages: readonly ChatCompletionMessage[];
-    readonly tools: readonly ChatCompletionToolDefinition[];
-    readonly targetTokens: number;
-    readonly signal?: AbortSignal;
-}) => Promise<CompactMessagesResult>;
-export declare const resolveProactiveTargetTokens: (config: LlmCompactionConfig) => number | undefined;
-export declare const resolveForceTargetTokens: (config: LlmCompactionConfig, currentInputEstimate: number) => number;

package/vendor/common-nodes/dist/ai/openai/llm-context-compaction.js

@@ -1,326 +0,0 @@
-import { isContextLengthExceededError } from './context-length-error.js';
-const SUMMARY_PREFIX = '## Compacted conversation context\n';
-export const SUMMARY_SYSTEM_PROMPT = [
-    'Summarize the following conversation history for continuity.',
-    'Preserve requirements, decisions, unfinished tasks, tool outcomes,',
-    'and exact constraints. Be dense and factual. Do not invent content.',
-].join(' ');
-const estimateApproxTokens = (value) => {
-    try {
-        return Math.ceil(JSON.stringify(value).length / 4);
-    }
-    catch {
-        return Math.ceil(String(value).length / 4);
-    }
-};
-export const estimateMessagesTokens = (messages) => estimateApproxTokens(messages);
-export const estimateToolsTokens = (tools) => (tools.length === 0 ? 0 : estimateApproxTokens(tools));
-export const estimateRequestTokens = (messages, tools) => estimateMessagesTokens(messages) + estimateToolsTokens(tools);
-const effectiveInputBudget = (contextSize) => Math.floor(contextSize * 0.8);
-const summarySlotTokens = (inputBudget) => Math.min(4096, Math.max(256, Math.floor(inputBudget * 0.15)));
-const truncateToApproxTokens = (text, maxTokens) => {
-    const maxChars = Math.max(0, maxTokens * 4);
-    if (text.length <= maxChars) {
-        return text;
-    }
-    return text.slice(text.length - maxChars);
-};
-const splitLeadingSystem = (messages) => {
-    let end = 0;
-    while (end < messages.length && messages[end]?.role === 'system') {
-        end += 1;
-    }
-    return {
-        system: messages.slice(0, end),
-        rest: messages.slice(end),
-    };
-};
-const findLastUserIndex = (messages) => {
-    for (let i = messages.length - 1; i >= 0; i -= 1) {
-        if (messages[i]?.role === 'user') {
-            return i;
-        }
-    }
-    return -1;
-};
-const toBlocks = (messages) => {
-    const blocks = [];
-    const lastUserIndex = findLastUserIndex(messages);
-    let i = 0;
-    while (i < messages.length) {
-        const message = messages[i];
-        if (message === undefined) {
-            break;
-        }
-        if (message.role === 'tool') {
-            return {
-                ok: false,
-                message: 'Cannot compact history: orphan tool message without a preceding assistant tool_calls block',
-            };
-        }
-        if (message.role === 'assistant' &&
-            message.tool_calls !== undefined &&
-            message.tool_calls.length > 0) {
-            const callIds = new Set(message.tool_calls.map((call) => call.id));
-            const group = [message];
-            let j = i + 1;
-            while (j < messages.length) {
-                const next = messages[j];
-                if (next === undefined || next.role !== 'tool') {
-                    break;
-                }
-                if (!callIds.has(next.tool_call_id)) {
-                    return {
-                        ok: false,
-                        message: `Cannot compact history: tool message id ${next.tool_call_id} is not part of the preceding assistant tool_calls`,
-                    };
-                }
-                group.push(next);
-                callIds.delete(next.tool_call_id);
-                j += 1;
-            }
-            if (callIds.size > 0) {
-                return {
-                    ok: false,
-                    message: 'Cannot compact history: incomplete assistant tool_calls / tool result block',
-                };
-            }
-            const isNewest = j === messages.length;
-            blocks.push({
-                messages: group,
-                isProtected: isNewest,
-            });
-            i = j;
-            continue;
-        }
-        blocks.push({
-            messages: [message],
-            isProtected: i === lastUserIndex || i === messages.length - 1,
-        });
-        i += 1;
-    }
-    if (blocks.length > 0) {
-        const last = blocks[blocks.length - 1];
-        if (last !== undefined && !last.isProtected) {
-            blocks[blocks.length - 1] = { ...last, isProtected: true };
-        }
-    }
-    return { ok: true, blocks };
-};
-const flattenBlocks = (blocks) => blocks.flatMap((block) => block.messages);
-const serializeMessagesForSummary = (messages) => messages
-    .map((message) => {
-    if (message.role === 'tool') {
-        return `[tool ${message.tool_call_id}]\n${message.content}`;
-    }
-    if (message.role === 'assistant' &&
-        message.tool_calls !== undefined &&
-        message.tool_calls.length > 0) {
-        const calls = message.tool_calls
-            .map((call) => `${call.name}(${call.arguments}) id=${call.id}`)
-            .join('; ');
-        return `[assistant tool_calls]\n${message.content}\n${calls}`;
-    }
-    return `[${message.role}]\n${message.content}`;
-})
-    .join('\n\n');
-const collectDoneText = async (stream) => {
-    let text = '';
-    for await (const chunk of stream) {
-        if (chunk.kind === 'draft' && typeof chunk.text === 'string') {
-            text += chunk.text;
-        }
-        else if (chunk.kind === 'done' && typeof chunk.text === 'string') {
-            text = chunk.text.length > 0 ? chunk.text : text;
-        }
-    }
-    return text.trim();
-};
-const summarizeRange = async (args) => {
-    let sourceBudget = args.sourceBudgetTokens;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-        if (args.signal !== undefined && args.signal.aborted) {
-            return {
-                ok: false,
-                message: 'Compaction aborted',
-                aborted: true,
-            };
-        }
-        const serialized = truncateToApproxTokens(serializeMessagesForSummary(args.source), sourceBudget);
-        try {
-            const stream = await args.factory({
-                providerId: args.providerId,
-                model: args.model,
-                messages: [
-                    { role: 'system', content: SUMMARY_SYSTEM_PROMPT },
-                    { role: 'user', content: serialized },
-                ],
-                ...(args.signal !== undefined ? { signal: args.signal } : {}),
-            });
-            const content = await collectDoneText(stream);
-            if (content.length === 0) {
-                return {
-                    ok: false,
-                    message: 'Compaction summary returned empty text',
-                };
-            }
-            return { ok: true, content };
-        }
-        catch (error) {
-            if (args.signal !== undefined && args.signal.aborted) {
-                return {
-                    ok: false,
-                    message: 'Compaction aborted',
-                    aborted: true,
-                };
-            }
-            if (isContextLengthExceededError(error)) {
-                sourceBudget = Math.max(256, Math.floor(sourceBudget / 2));
-                continue;
-            }
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                ok: false,
-                message: `Compaction summary failed: ${message}`,
-            };
-        }
-    }
-    return {
-        ok: false,
-        message: 'Compaction summary failed after repeated context-length errors',
-    };
-};
-const findRemovableRange = (blocks) => {
-    let start = -1;
-    for (let i = 0; i < blocks.length; i += 1) {
-        if (!blocks[i].isProtected) {
-            start = i;
-            break;
-        }
-    }
-    if (start < 0) {
-        return undefined;
-    }
-    let end = start;
-    while (end + 1 < blocks.length && !blocks[end + 1].isProtected) {
-        end += 1;
-    }
-    return { start, end };
-};
-const buildSummaryMessage = (content, slotTokens) => ({
-    role: 'user',
-    content: `${SUMMARY_PREFIX}${truncateToApproxTokens(content, slotTokens)}`,
-});
-/**
- * LLM-summary compaction: replace contiguous unprotected message blocks with
- * a summary user message while preserving leading system + last user + newest
- * block and full assistant/tool groups.
- */
-export const compactMessagesWithSummary = async (args) => {
-    const beforeTokens = estimateRequestTokens(args.messages, args.tools);
-    if (beforeTokens <= args.targetTokens) {
-        return {
-            ok: true,
-            messages: args.messages,
-            beforeTokens,
-            afterTokens: beforeTokens,
-        };
-    }
-    const { system, rest } = splitLeadingSystem(args.messages);
-    const blocked = toBlocks(rest);
-    if (!blocked.ok) {
-        return blocked;
-    }
-    let blocks = [...blocked.blocks];
-    const toolsTokens = estimateToolsTokens(args.tools);
-    const slot = summarySlotTokens(args.targetTokens);
-    const requiredTokens = estimateMessagesTokens([
-        ...system,
-        ...(findLastUserIndex(rest) >= 0
-            ? [rest[findLastUserIndex(rest)]]
-            : []),
-    ]) +
-        toolsTokens +
-        slot;
-    if (requiredTokens > args.targetTokens) {
-        return {
-            ok: false,
-            message: `Cannot compact history: required system/user/tools already need ~${requiredTokens} approx tokens (budget ${args.targetTokens})`,
-        };
-    }
-    let workingMessages = args.messages;
-    let passes = 0;
-    while (estimateRequestTokens(workingMessages, args.tools) >
-        args.targetTokens &&
-        passes < 2) {
-        if (args.signal !== undefined && args.signal.aborted) {
-            return { ok: false, message: 'Compaction aborted' };
-        }
-        const range = findRemovableRange(blocks);
-        if (range === undefined) {
-            return {
-                ok: false,
-                message: 'Cannot compact history: no removable message blocks left under the protected prefix/suffix',
-            };
-        }
-        const source = flattenBlocks(blocks.slice(range.start, range.end + 1));
-        const remainingBudget = Math.max(256, args.targetTokens -
-            toolsTokens -
-            estimateMessagesTokens([
-                ...system,
-                ...flattenBlocks(blocks.slice(0, range.start)),
-                ...flattenBlocks(blocks.slice(range.end + 1)),
-            ]) -
-            slot);
-        const summary = await summarizeRange({
-            factory: args.factory,
-            providerId: args.providerId,
-            model: args.model,
-            ...(args.signal !== undefined ? { signal: args.signal } : {}),
-            source,
-            sourceBudgetTokens: remainingBudget,
-        });
-        if (!summary.ok) {
-            return {
-                ok: false,
-                message: summary.message,
-            };
-        }
-        const summaryMessage = buildSummaryMessage(summary.content, slot);
-        blocks = [
-            ...blocks.slice(0, range.start),
-            {
-                messages: [summaryMessage],
-                isProtected: true,
-            },
-            ...blocks.slice(range.end + 1),
-        ];
-        workingMessages = [...system, ...flattenBlocks(blocks)];
-        passes += 1;
-    }
-    const afterTokens = estimateRequestTokens(workingMessages, args.tools);
-    if (afterTokens > args.targetTokens) {
-        return {
-            ok: false,
-            message: `Cannot compact history below ~${args.targetTokens} approx tokens (still ~${afterTokens})`,
-        };
-    }
-    return {
-        ok: true,
-        messages: workingMessages,
-        beforeTokens,
-        afterTokens,
-    };
-};
-export const resolveProactiveTargetTokens = (config) => {
-    if (config.contextSize <= 0) {
-        return undefined;
-    }
-    return effectiveInputBudget(config.contextSize);
-};
-export const resolveForceTargetTokens = (config, currentInputEstimate) => {
-    if (config.contextSize > 0) {
-        return Math.min(effectiveInputBudget(config.contextSize), Math.max(256, Math.floor(currentInputEstimate * 0.5)));
-    }
-    return Math.max(256, Math.floor(currentInputEstimate * 0.5));
-};