langflower 0.0.7 → 0.0.9

package/vendor/common-nodes/dist/ai/features/llm-session/run-session-machine.d.ts

@@ -0,0 +1,21 @@
+import type { ChatCompletionMessage } from '../chat-completion-stream.js';
+import type { PermissionAskRequest } from '@langflower/tools/permission';
+import { type Observable } from 'rxjs';
+export type LlmSessionPreparation<Session> = {
+    readonly history: readonly ChatCompletionMessage[];
+    readonly trackAssistantHistory: boolean;
+    readonly appendUserFeedbackToHistory: boolean;
+    readonly session: Session;
+};
+type LlmSessionContext = {
+    readonly maxFeedbackTurns: number;
+    readonly requestPermission?: (request: PermissionAskRequest) => Promise<'allow' | 'deny'>;
+};
+/**
+ * Sequential session fold. Each turn is an inner Observable reduced into the
+ * accumulator; concurrency 1 queues feedback while a turn is streaming.
+ */
+export declare const runLlmSessionMachine: <Context extends LlmSessionContext, Session, Chunk extends {
+    readonly kind: string;
+}>(context: Context, turn$: Observable<unknown>, preparation: LlmSessionPreparation<Session>, runTurn: (context: Context, turnPayload: unknown, history: readonly ChatCompletionMessage[], session: Session) => Observable<Chunk>, primeTurn0: boolean) => Observable<Chunk>;
+export {};

package/vendor/common-nodes/dist/ai/features/llm-session/run-session-machine.js

@@ -0,0 +1,118 @@
+import { EMPTY, concat, filter, from, map, mergeScan, of, scan, startWith, switchMap, throwError, } from 'rxjs';
+const isBlankTurn = (raw) => raw === null ||
+    raw === undefined ||
+    (typeof raw === 'string' && raw.trim().length === 0);
+const readHistorySync = (chunk) => {
+    if (chunk.kind !== 'historySync' ||
+        !('messages' in chunk) ||
+        !Array.isArray(chunk.messages)) {
+        return undefined;
+    }
+    return chunk.messages;
+};
+const readAssistantResponse = (chunk) => chunk.kind === 'response' &&
+    'text' in chunk &&
+    typeof chunk.text === 'string'
+    ? chunk.text
+    : undefined;
+const reduceChunk = (state, chunk) => {
+    const syncedHistory = readHistorySync(chunk);
+    if (syncedHistory !== undefined) {
+        return {
+            ...state,
+            history: [...syncedHistory],
+            emitted: chunk,
+        };
+    }
+    const assistantResponse = readAssistantResponse(chunk);
+    if (assistantResponse !== undefined &&
+        state.preparation.trackAssistantHistory) {
+        return {
+            ...state,
+            history: [
+                ...state.history,
+                { role: 'assistant', content: assistantResponse },
+            ],
+            emitted: chunk,
+        };
+    }
+    return { ...state, emitted: chunk };
+};
+const acceptFeedbackTurn = (context, state, raw, runTurn, feedbackTurns) => {
+    const history = state.preparation.appendUserFeedbackToHistory
+        ? [
+            ...state.history,
+            { role: 'user', content: String(raw ?? '') },
+        ]
+        : state.history;
+    const next = {
+        ...state,
+        history,
+        feedbackTurns,
+        emitted: undefined,
+    };
+    return runTurn(context, raw, next.history, next.preparation.session).pipe(scan((accumulator, chunk) => reduceChunk(accumulator, chunk), next));
+};
+const denyMaxFeedbackTurns = (state, maxFeedbackTurns) => {
+    const message = `Stopped: maxFeedbackTurns ` + `(${maxFeedbackTurns}) reached`;
+    return concat(of({
+        ...state,
+        emitted: {
+            kind: 'toolLog',
+            text: `⚠ ${message}`,
+        },
+    }), throwError(() => message));
+};
+const runTurnFromState = (context, state, raw, primeTurn0, runTurn) => {
+    if (!state.turn0Done) {
+        if (!primeTurn0 && isBlankTurn(raw)) {
+            return EMPTY;
+        }
+        const next = { ...state, turn0Done: true };
+        return runTurn(context, primeTurn0 ? undefined : raw, next.history, next.preparation.session).pipe(scan((accumulator, chunk) => reduceChunk(accumulator, chunk), next));
+    }
+    if (isBlankTurn(raw)) {
+        return EMPTY;
+    }
+    if (context.maxFeedbackTurns > 0 &&
+        state.feedbackTurns >= context.maxFeedbackTurns) {
+        const ask = context.requestPermission;
+        if (ask === undefined) {
+            return denyMaxFeedbackTurns(state, context.maxFeedbackTurns);
+        }
+        const waitingText = `⚠ Max feedback turns (${context.maxFeedbackTurns}) reached. ` +
+            'Allow to continue for another budget, or Deny to stop.';
+        return concat(of({
+            ...state,
+            emitted: {
+                kind: 'toolLog',
+                text: waitingText,
+            },
+        }), from(ask({
+            toolId: 'agent.maxFeedbackTurns',
+            detail: String(context.maxFeedbackTurns),
+            summary: `Max feedback turns (${context.maxFeedbackTurns}) ` +
+                'reached. Allow to continue?',
+        })).pipe(switchMap((decision) => {
+            if (decision !== 'allow') {
+                return denyMaxFeedbackTurns(state, context.maxFeedbackTurns);
+            }
+            return acceptFeedbackTurn(context, state, raw, runTurn, 1);
+        })));
+    }
+    return acceptFeedbackTurn(context, state, raw, runTurn, state.feedbackTurns + 1);
+};
+/**
+ * Sequential session fold. Each turn is an inner Observable reduced into the
+ * accumulator; concurrency 1 queues feedback while a turn is streaming.
+ */
+export const runLlmSessionMachine = (context, turn$, preparation, runTurn, primeTurn0) => {
+    const initial = {
+        history: [...preparation.history],
+        turn0Done: false,
+        feedbackTurns: 0,
+        preparation,
+    };
+    const turns$ = primeTurn0 ? turn$.pipe(startWith('')) : turn$;
+    return turns$.pipe(mergeScan((state, raw) => runTurnFromState(context, state, raw, primeTurn0, runTurn), initial, 1), filter((state) => state.emitted !== undefined), map((state) => state.emitted));
+};

package/vendor/common-nodes/dist/ai/features/openai/context-length-error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Typed context-window overflow from OpenAI-compatible chat.create.
+ * Detected before the stream yields reasoning/draft chunks.
+ */
+export declare class ContextLengthExceededError extends Error {
+    readonly code: "context_length_exceeded";
+    constructor(message?: string);
+}
+export declare const isContextLengthExceededError: (error: unknown) => error is ContextLengthExceededError;
+/**
+ * Classify provider/SDK errors thrown while creating a chat completion stream.
+ * Structured fields win; narrow message fallback covers LM Studio / vLLM.
+ */
+export declare const classifyContextLengthError: (error: unknown) => ContextLengthExceededError | undefined;

package/vendor/common-nodes/dist/ai/features/openai/context-length-error.js

@@ -0,0 +1,63 @@
+/**
+ * Typed context-window overflow from OpenAI-compatible chat.create.
+ * Detected before the stream yields reasoning/draft chunks.
+ */
+export class ContextLengthExceededError extends Error {
+    code = 'context_length_exceeded';
+    constructor(message = 'Context length exceeded') {
+        super(message);
+        this.name = 'ContextLengthExceededError';
+    }
+}
+export const isContextLengthExceededError = (error) => error instanceof ContextLengthExceededError;
+const CONTEXT_MESSAGE_RE = /context[_ ]length|maximum context|context window|too many tokens|n_ctx|max_model_len|prompt is too long|exceeds? (?:the )?(?:maximum|model) (?:context|token)/i;
+const readString = (value) => typeof value === 'string' && value.length > 0 ? value : undefined;
+const readNested = (record, key) => {
+    const nested = record[key];
+    return nested !== null && typeof nested === 'object'
+        ? nested
+        : undefined;
+};
+/**
+ * Classify provider/SDK errors thrown while creating a chat completion stream.
+ * Structured fields win; narrow message fallback covers LM Studio / vLLM.
+ */
+export const classifyContextLengthError = (error) => {
+    if (error instanceof ContextLengthExceededError) {
+        return error;
+    }
+    if (error === null || typeof error !== 'object') {
+        return undefined;
+    }
+    const record = error;
+    const status = typeof record['status'] === 'number'
+        ? record['status']
+        : typeof record['statusCode'] === 'number'
+            ? record['statusCode']
+            : undefined;
+    const code = readString(record['code']) ??
+        readString(readNested(record, 'error')?.['code']);
+    const type = readString(record['type']) ??
+        readString(readNested(record, 'error')?.['type']);
+    const message = readString(record['message']) ??
+        readString(readNested(record, 'error')?.['message']) ??
+        (error instanceof Error ? error.message : undefined);
+    if (code === 'context_length_exceeded') {
+        return new ContextLengthExceededError(message ?? 'Context length exceeded');
+    }
+    if (type === 'invalid_request_error' &&
+        message !== undefined &&
+        CONTEXT_MESSAGE_RE.test(message)) {
+        return new ContextLengthExceededError(message);
+    }
+    if ((status === 400 || status === undefined) &&
+        message !== undefined &&
+        CONTEXT_MESSAGE_RE.test(message)) {
+        // Avoid false positives on rate-limit / auth wording.
+        if (/rate[_ ]?limit|unauthorized|authentication|invalid[_ ]api[_ ]key|timeout/i.test(message)) {
+            return undefined;
+        }
+        return new ContextLengthExceededError(message);
+    }
+    return undefined;
+};

package/vendor/common-nodes/dist/ai/features/openai/create-chat-completion-stream.d.ts

@@ -0,0 +1,19 @@
+import type { ChatCompletionFinishReason, CreateChatCompletionStream } from '../chat-completion-stream.js';
+import { classifyContextLengthError, ContextLengthExceededError } from './context-length-error.js';
+export type { ChatCompletionAbortSignal, ChatCompletionFinishReason, ChatCompletionMessage, ChatCompletionStreamChunk, ChatCompletionToolCall, ChatCompletionToolDefinition, CreateChatCompletionStream, CreateChatCompletionStreamArgs, } from '../chat-completion-stream.js';
+export { ContextLengthExceededError, classifyContextLengthError };
+export { isContextLengthExceededError } from './context-length-error.js';
+export type OpenAiProviderCredentials = {
+    readonly apiKey?: string;
+    readonly baseURL?: string;
+};
+export declare const mapFinishReason: (value: string | null | undefined) => ChatCompletionFinishReason;
+/** LM Studio / DeepSeek-style CoT fields on OpenAI-compatible deltas. */
+export declare const reasoningTextFromDelta: (delta: unknown) => string;
+/**
+ * Unbound OpenAI-compatible chat stream factory.
+ * Caller supplies credential resolve (server injects secrets).
+ */
+export declare const createChatCompletionStream: (deps: {
+    readonly resolveProvider: (providerId: string) => Promise<OpenAiProviderCredentials>;
+}) => CreateChatCompletionStream;

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

@@ -0,0 +1,182 @@
+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/features/openai/list-provider-models.d.ts

@@ -0,0 +1,28 @@
+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/features/openai/list-provider-models.js

@@ -0,0 +1,52 @@
+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/features/openai/llm-context-compaction.d.ts

@@ -0,0 +1,31 @@
+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;