langflower 0.0.10 → 0.1.1

package/vendor/common-nodes/dist/ai/fake-llm/node.js

@@ -1,207 +0,0 @@
-import { interval, map, take } from 'rxjs';
-import { defineLlmNode } from '@langflower/node-sdk/llm';
-import { llmPanelUiSchema } from '../llm-panel-ui-schema.js';
-import { llmRecoveryUiSchema } from '../llm-recovery-ui-schema.js';
-import { appendToolInventory, bindLlmAgentSession, } from '../llm-session-shell.js';
-import { runAgentLoop, } from '../llm-loop/run-agent-loop.js';
-import { DISABLED_COMPACTION_CONFIG } from '../openai/normalize-compaction-params.js';
-import { waitForSubagentResult } from '../wait-for-subagent-result.js';
-import { createScriptedFactory, parseScriptedTurns, } from '../scripted-chat-completion-stream.js';
-import { getRunHostServices } from '../run-host-services.js';
-/**
- * Default pacing for manual demos. Each sentence-sized chunk is emitted at
- * this delay so the final response follows a visible stream promptly.
- */
-const DEFAULT_TOKEN_DELAY_MS = 40;
-const tokenize = (text) => {
-    if (text.length === 0) {
-        return [''];
-    }
-    return text.match(/[^.!?]+[.!?]+(?:\s+|$)|\S+\s*/g) ?? [text];
-};
-const toolLabel = (tool) => tool.name.length > 0 ? tool.name : tool.toolId || 'unknown';
-const formatList = (items, labelOf) => (items.length === 0 ? 'none' : items.map(labelOf).join(', '));
-const summarizeSystemPrompt = (text) => {
-    const trimmed = text.trim();
-    if (trimmed.length === 0) {
-        return '(empty)';
-    }
-    if (trimmed.length <= 120) {
-        return trimmed;
-    }
-    return `${trimmed.slice(0, 117)}…`;
-};
-const buildReasoning = (bundle) => {
-    const toolList = formatList(bundle.tools, toolLabel);
-    const providerLabel = bundle.providerId.length > 0 ? bundle.providerId : 'unset';
-    const modelLabel = bundle.model.length > 0 ? bundle.model : 'unset';
-    const skillLabel = bundle.skillId.length > 0 ? bundle.skillId : 'none';
-    const skillBodyNote = bundle.skillMarkdown.trim().length > 0
-        ? `Loaded skill markdown: ${summarizeSystemPrompt(bundle.skillMarkdown)}.`
-        : 'No skill markdown loaded for this cycle.';
-    const agentsBodyNote = bundle.agentsMarkdown.trim().length > 0
-        ? `Loaded root AGENTS.md: ${summarizeSystemPrompt(bundle.agentsMarkdown)}.`
-        : 'No root AGENTS.md loaded for this cycle.';
-    return [
-        `User asked to «${bundle.prompt}». Let me unpack what they actually need before I commit to an answer.`,
-        `Instance config: provider=${providerLabel}, model=${modelLabel}, skill=${skillLabel}, preset=${bundle.rolePreset}.`,
-        skillBodyNote,
-        agentsBodyNote,
-        `Effective system prompt: ${summarizeSystemPrompt(bundle.effectiveSystemPrompt)}.`,
-        `First pass: is this a research task, a coding change, a planning exercise, or a direct factual question? The wording could fit more than one lane, so I should not rush into tool calls or a one-shot reply.`,
-        `Second pass: what constraints are implied? Tone, length, audience, and whether they want steps versus a finished artifact. If the prompt is short, I still need to invent a reasonable interpretation and state it clearly in the draft.`,
-        `Third pass: do I need tools, or can I answer from general knowledge? Available tools: ${toolList}. If tools are listed, I should mention which ones I would reach for and why; if none, I should say I am answering without tool use.`,
-        `Hypothesis A: treat it as a research / exploration request. Then I would outline sources, open questions, and a short investigation plan before writing anything polished.`,
-        `Hypothesis B: treat it as an implementation or editing request. Then I would clarify the target files or deliverable, list risks, and propose a minimal change set.`,
-        `Hypothesis C: treat it as a brainstorm. Then I would fan out a few options, compare trade-offs, and recommend one default path with an escape hatch.`,
-        `I keep oscillating between A and C when the prompt is abstract, and between A and B when it mentions concrete nouns. For now I will assume a mixed approach: reason carefully, then produce a substantial draft that could stand alone if the user never follows up.`,
-        `Checklist before drafting: restated goal, assumptions, risks, next actions, and a closing summary that mirrors the original ask. I will also leave room to incorporate feedback if a later revision arrives.`,
-        `Still thinking: is there ambiguity around success criteria? Yes. I will define a provisional success bar in the draft so the user can correct it. Is there a chance they wanted only a short answer? Possible, but a longer structured draft is safer for demo and review flows.`,
-        `Tooling note again for the trace: tools=[${toolList}]; preset=${bundle.rolePreset}; skill=${skillLabel}. Even if I do not invoke them in this fake run, listing them here proves the wiring reached the model context.`,
-        `Alright — enough deliberation. I will write a full draft response next, then emit a concise final answer that captures the same conclusion.`,
-    ].join(' ');
-};
-const buildDraft = (prompt, feedback) => {
-    if (feedback !== '') {
-        return [
-            `Draft (revised with feedback).`,
-            `The user previously replied with: «${feedback}».`,
-            `I am folding that feedback into a fuller rewrite rather than a tiny patch, so the draft stays readable as a standalone document.`,
-            `Updated interpretation of the original ask «${prompt}»: keep the core intent, but prioritize the feedback notes above any earlier assumptions that conflict.`,
-            `Section 1 — Restated goal. Explain what we are optimizing for after feedback, including what we will not do.`,
-            `Section 2 — Approach. Describe the plan in ordered steps, call out dependencies, and mention where a tool or MCP server would help if this were a real agent run.`,
-            `Section 3 — Detailed answer. Expand into multiple paragraphs with concrete recommendations, examples, and edge cases. Prefer clarity over cleverness.`,
-            `Section 4 — Risks and open questions. List what still needs confirmation from the user before treating the work as finished.`,
-            `Section 5 — Next actions. Give a short checklist the user (or a downstream agent) can execute immediately.`,
-            `Closing: this revised draft should feel like a careful human editor passed over the first version, not like a brittle string replace on a few tokens.`,
-        ].join(' ');
-    }
-    return [
-        `Draft response for: «${prompt}».`,
-        `Opening. Thanks for the request — here is a structured draft you can skim or wire into a review gate.`,
-        `Restated goal. I am treating your prompt as the primary success criterion. If I guessed the wrong lane (research vs implement vs brainstorm), say so and I will revise.`,
-        `Assumptions. (1) You want a useful standalone answer, not a one-line ack. (2) Extra structure is welcome for demos and HITL review. (3) Tool and MCP availability may be empty in this fake run, but the draft should still read like an agent that considered them.`,
-        `Approach. Step one: clarify the ask in plain language. Step two: outline options. Step three: recommend a default path. Step four: list verification steps. Step five: summarize.`,
-        `Option analysis. Option A is the smallest viable answer — fast, but easy to under-specify. Option B is a deeper treatment with examples and trade-offs — slower to read, better for review. Option C is a speculative expansion that may overfit. I recommend Option B as the default.`,
-        `Main body. Expand the recommended option into several paragraphs. Cover motivation, the proposed solution shape, how you would validate it, and what you would do if the first attempt fails. Keep the language concrete enough that a teammate could act without re-asking the same question.`,
-        `Worked sketch. Imagine applying the answer to a small Langflower workflow: prompt node into an agent-like node, optional tool registrations on the side, then preview or review. Call out where streaming reasoning and draft tokens help a human follow along.`,
-        `Edge cases. Empty tool lists, contradictory feedback, overly broad prompts, and prompts that mix research with coding. For each, prefer asking a focused clarifying question over inventing irreversible steps.`,
-        `Quality bar. The draft is good enough when a reviewer can accept it, reject it with notes, or forward it downstream without rewriting from scratch.`,
-        `Closing paragraph. I will now emit a shorter final response that freezes the recommendation while leaving the longer draft available on the draftResponse stream for the feed UI.`,
-    ].join(' ');
-};
-const buildResponse = (prompt, feedback) => feedback !== ''
-    ? `Final: Revised answer for «${prompt}» after feedback «${feedback}». See the draft stream for the full structured rewrite; this final line is the accepted summary.`
-    : `Final: Answer for «${prompt}». See the draft stream for the full structured write-up; this final line is the accepted summary.`;
-const runFakeImitateCycle = (bundle) => {
-    const delayMs = Math.max(0, bundle.tokenDelayMs);
-    const chunks = [
-        ...tokenize(buildReasoning(bundle)).map((text) => ({ kind: 'reasoning', text })),
-        ...tokenize(buildDraft(bundle.prompt, bundle.feedback)).map((text) => ({
-            kind: 'draftResponse',
-            text,
-        })),
-        {
-            kind: 'response',
-            text: buildResponse(bundle.prompt, bundle.feedback),
-        },
-    ];
-    return interval(delayMs).pipe(take(chunks.length), map((index) => chunks[index]));
-};
-const runFakeToolLoopCycle = (bundle, messages, factory, subagentResult$) => {
-    return runAgentLoop({
-        factory,
-        providerId: bundle.providerId.length > 0 ? bundle.providerId : 'fake',
-        model: bundle.model.length > 0 ? bundle.model : 'fake',
-        messages: [...messages],
-        tools: bundle.tools,
-        toolCtx: bundle.toolCtx,
-        maxIterations: bundle.maxIterations,
-        compaction: DISABLED_COMPACTION_CONFIG,
-        recovery: bundle.recovery,
-        subagentRegistrations: bundle.subagentRegistrations,
-        ...(bundle.requestPermission !== undefined
-            ? { requestPermission: bundle.requestPermission }
-            : {}),
-        ...(bundle.steerControl$ !== undefined
-            ? { steerControl$: bundle.steerControl$ }
-            : {}),
-        ...(bundle.subagentRegistrations.length > 0
-            ? {
-                waitForSubagentResult: (callId, signal) => waitForSubagentResult(subagentResult$, callId, signal),
-            }
-            : {}),
-    });
-};
-const resolveSessionFactory = (context) => 
-// Scripted turns own the loop when present (do not prefer a server-bound
-// OpenAI factory over the script). Injected EC factory is for unit tests
-// only — server omits createChatCompletionStream for this node type.
-context.scriptedTurns !== undefined
-    ? createScriptedFactory(context.scriptedTurns)
-    : context.completionFactory;
-/**
- * Deterministic LLM stand-in for demos / feed UX. Supports an optional
- * scripted tool-loop (`scriptedToolTurns` or injected `createChatCompletionStream`)
- * that invokes `ctx.harness` like openai-llm.
- * @see docs/ADR.md ADR-016
- */
-export const fakeLlmNode = defineLlmNode({
-    type: 'common-fake-llm',
-    displayName: 'Fake LLM',
-    category: 'AI',
-    description: 'Imitates an LLM for demos: streams **reasoning** and **draftResponse**, then **response**. Optional scripted tool loop invokes `ctx.harness`.',
-    uiSchema: [
-        ...llmPanelUiSchema,
-        ...llmRecoveryUiSchema,
-        {
-            field: 'tokenDelayMs',
-            type: 'number',
-            label: 'Token delay (ms)',
-            default: DEFAULT_TOKEN_DELAY_MS,
-            min: 0,
-            step: 1,
-        },
-    ],
-    bind(ctx, helpers, inventory) {
-        return bindLlmAgentSession(ctx, helpers, inventory, {
-            extendContext: (base, ec) => ({
-                ...base,
-                tokenDelayMs: Math.max(0, Number(ec.params.tokenDelayMs ?? DEFAULT_TOKEN_DELAY_MS)),
-                scriptedTurns: parseScriptedTurns(ec.params['scriptedToolTurns']),
-                completionFactory: getRunHostServices(ec)?.createChatCompletionStream,
-            }),
-            prepareSession: (context) => {
-                const useToolLoop = context.scriptedTurns !== undefined ||
-                    context.completionFactory !== undefined;
-                const systemWithTools = appendToolInventory(context.effectiveSystemPrompt, context.tools);
-                return {
-                    history: useToolLoop
-                        ? [
-                            {
-                                role: 'system',
-                                content: systemWithTools,
-                            },
-                            { role: 'user', content: context.prompt },
-                        ]
-                        : [],
-                    trackAssistantHistory: useToolLoop,
-                    appendUserFeedbackToHistory: useToolLoop,
-                    // Session-scoped factory so scripted cursor advances across
-                    // feedback turns (mirrors prior switchMap closure).
-                    session: resolveSessionFactory(context),
-                };
-            },
-            runTurn: (context, feedback, history, subagentResult$, sessionFactory) => {
-                const bundle = {
-                    ...context,
-                    feedback: feedback ?? '',
-                };
-                if (sessionFactory !== undefined) {
-                    return runFakeToolLoopCycle(bundle, history, sessionFactory, subagentResult$);
-                }
-                return runFakeImitateCycle(bundle);
-            },
-        });
-    },
-});

package/vendor/common-nodes/dist/ai/fake-mcp-server/node.d.ts

@@ -1,26 +0,0 @@
-/**
- * Emits one `mcp-server-config` for wiring into LLM `mcp` init ports.
- * Runtime spawn/allowlist lives in `langflower.jsonc` `mcp.*` (server).
- */
-export declare const fakeMcpServerNode: {
-    readonly emitOncePerActivation: boolean;
-    readonly stopsRun: boolean;
-    readonly chatEntry: boolean;
-    readonly uiSchema: readonly [];
-    readonly bypassPorts: Record<string, import("@langflower/runtime").RuntimeWireType>;
-    readonly inputsConfigs: readonly [import("@langflower/node-definitions").InputPortMeta<import("@langflower/node-definitions").ExecutionContext<readonly []>>, ...import("@langflower/node-definitions").InputPortMeta<unknown>[]];
-    readonly outputsConfigs: (({
-        readonly wireType: string;
-    } | {
-        readonly inferTypeFrom: import("@langflower/node-definitions").InputParams<unknown> | import("@rx-evo/stateful-observable").StatefulObservable<unknown, unknown, import("@langflower/runtime").PortMeta>;
-    }) & import("@langflower/node-definitions").OutputParams & import("@langflower/runtime").PortMeta)[];
-    readonly paramsFromUISchema: import("@rx-evo/stateful-observable").StatefulConnection<import("@langflower/node-definitions/create-typed-ui-schema").ParamsFromUISchema<readonly []>, unknown, undefined>;
-    readonly getInstance: () => import("@langflower/node-definitions").ReactiveNodeInstance<readonly []>;
-    readonly paletteSecondary?: true;
-    readonly description?: string;
-    readonly type: string;
-    readonly displayName: string;
-    readonly category: string | undefined;
-    readonly icon: string | undefined;
-};
-//# sourceMappingURL=node.d.ts.map

package/vendor/common-nodes/dist/ai/fake-mcp-server/node.js

@@ -1,67 +0,0 @@
-import { defineReactiveNode } from '@langflower/node-definitions';
-const parseToolNames = (raw) => {
-    if (typeof raw !== 'string') {
-        return [];
-    }
-    return raw
-        .split(/[,\s]+/)
-        .map((name) => name.trim())
-        .filter((name) => name.length > 0);
-};
-/**
- * Emits one `mcp-server-config` for wiring into LLM `mcp` init ports.
- * Runtime spawn/allowlist lives in `langflower.jsonc` `mcp.*` (server).
- */
-export const fakeMcpServerNode = defineReactiveNode({
-    type: 'common-fake-mcp-server',
-    displayName: 'Fake MCP Server',
-    category: 'AI',
-    description: 'Emits an **mcp-server-config** for wiring into Fake LLM / OpenAI LLM `mcp` (init). Tools invoke via the internal loop when the server id is allowlisted in `langflower.jsonc`.',
-    uiSchema: [],
-    bind(_ctx, { makeInput, configureOutput, combineInputs }) {
-        const serverId = makeInput('serverId', {
-            name: 'serverId',
-            wireType: 'string',
-            inline: 'text',
-            defaultValue: 'echo',
-            required: true,
-        });
-        const name = makeInput('name', {
-            name: 'name',
-            wireType: 'string',
-            inline: 'text',
-            defaultValue: 'echo',
-            required: true,
-        });
-        const description = makeInput('description', {
-            name: 'description',
-            wireType: 'string',
-            inline: 'text',
-            defaultValue: 'Fixture MCP server',
-        });
-        const toolNames = makeInput('toolNames', {
-            name: 'toolNames',
-            wireType: 'string',
-            inline: 'text',
-            defaultValue: 'echo',
-        });
-        const config$ = combineInputs([serverId, name, description, toolNames], ([id, serverName, serverDescription, toolsRaw]) => {
-            const names = parseToolNames(toolsRaw);
-            return {
-                id: String(id ?? ''),
-                name: String(serverName ?? ''),
-                description: String(serverDescription ?? ''),
-                ...(names.length > 0 ? { toolNames: names } : {}),
-            };
-        });
-        return {
-            inputs: [serverId, name, description, toolNames],
-            outputs: [
-                configureOutput('mcpServer', config$, {
-                    wireType: 'mcp-server-config',
-                }),
-            ],
-        };
-    },
-});
-//# sourceMappingURL=node.js.map

package/vendor/common-nodes/dist/ai/fake-tool-registration/node.d.ts

@@ -1,26 +0,0 @@
-/**
- * Emits one `tool-registration` record from inline fields — stand-in for a
- * harness tool node until real registrations ship.
- */
-export declare const fakeToolRegistrationNode: {
-    readonly emitOncePerActivation: boolean;
-    readonly stopsRun: boolean;
-    readonly chatEntry: boolean;
-    readonly uiSchema: readonly [];
-    readonly bypassPorts: Record<string, import("@langflower/runtime").RuntimeWireType>;
-    readonly inputsConfigs: readonly [import("@langflower/node-definitions").InputPortMeta<import("@langflower/node-definitions").ExecutionContext<readonly []>>, ...import("@langflower/node-definitions").InputPortMeta<unknown>[]];
-    readonly outputsConfigs: (({
-        readonly wireType: string;
-    } | {
-        readonly inferTypeFrom: import("@langflower/node-definitions").InputParams<unknown> | import("@rx-evo/stateful-observable").StatefulObservable<unknown, unknown, import("@langflower/runtime").PortMeta>;
-    }) & import("@langflower/node-definitions").OutputParams & import("@langflower/runtime").PortMeta)[];
-    readonly paramsFromUISchema: import("@rx-evo/stateful-observable").StatefulConnection<import("@langflower/node-definitions/create-typed-ui-schema").ParamsFromUISchema<readonly []>, unknown, undefined>;
-    readonly getInstance: () => import("@langflower/node-definitions").ReactiveNodeInstance<readonly []>;
-    readonly paletteSecondary?: true;
-    readonly description?: string;
-    readonly type: string;
-    readonly displayName: string;
-    readonly category: string | undefined;
-    readonly icon: string | undefined;
-};
-//# sourceMappingURL=node.d.ts.map

package/vendor/common-nodes/dist/ai/fake-tool-registration/node.js

@@ -1,57 +0,0 @@
-import { defineReactiveNode } from '@langflower/node-definitions';
-/**
- * Emits one `tool-registration` record from inline fields — stand-in for a
- * harness tool node until real registrations ship.
- */
-export const fakeToolRegistrationNode = defineReactiveNode({
-    type: 'common-fake-tool-registration',
-    displayName: 'Fake Tool Registration',
-    category: 'AI',
-    description: 'Emits a **tool-registration** payload for wiring into Fake LLM / agent `tools`.',
-    uiSchema: [],
-    bind(_ctx, { makeInput, configureOutput, combineInputs }) {
-        const toolId = makeInput('toolId', {
-            name: 'toolId',
-            wireType: 'string',
-            inline: 'text',
-            defaultValue: 'grep',
-            required: true,
-        });
-        const name = makeInput('name', {
-            name: 'name',
-            wireType: 'string',
-            inline: 'text',
-            defaultValue: 'grep',
-            required: true,
-        });
-        const description = makeInput('description', {
-            name: 'description',
-            wireType: 'string',
-            inline: 'text',
-            defaultValue: '',
-        });
-        const registration$ = combineInputs([toolId, name, description], ([id, toolName, toolDescription]) => {
-            const resolvedId = String(id ?? '');
-            return {
-                kind: 'handler',
-                toolId: resolvedId,
-                name: String(toolName ?? ''),
-                description: String(toolDescription ?? ''),
-                inputSchema: {},
-                handler: async (args) => JSON.stringify({
-                    fakeTool: resolvedId,
-                    args,
-                }),
-            };
-        });
-        return {
-            inputs: [toolId, name, description],
-            outputs: [
-                configureOutput('toolRegistration', registration$, {
-                    wireType: 'tool-registration',
-                }),
-            ],
-        };
-    },
-});
-//# sourceMappingURL=node.js.map

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

@@ -1,53 +0,0 @@
-export type ChatCompletionAbortSignal = {
-    readonly aborted: boolean;
-};
-export type ChatCompletionToolCall = {
-    readonly id: string;
-    readonly name: string;
-    /** JSON object string (OpenAI-compatible). */
-    readonly arguments: string;
-};
-export type ChatCompletionMessage = {
-    readonly role: 'system' | 'user';
-    readonly content: string;
-} | {
-    readonly role: 'assistant';
-    readonly content: string;
-    readonly tool_calls?: readonly ChatCompletionToolCall[];
-} | {
-    readonly role: 'tool';
-    readonly content: string;
-    readonly tool_call_id: string;
-};
-export type ChatCompletionToolDefinition = {
-    readonly type: 'function';
-    readonly function: {
-        readonly name: string;
-        readonly description?: string;
-        readonly parameters?: object;
-    };
-};
-export type ChatCompletionFinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'unknown';
-export type ChatCompletionStreamChunk = {
-    readonly kind: 'reasoning';
-    readonly text: string;
-} | {
-    readonly kind: 'draft';
-    readonly text: string;
-} | {
-    readonly kind: 'done';
-    readonly text: string;
-    readonly tool_calls?: readonly ChatCompletionToolCall[];
-    readonly finishReason?: ChatCompletionFinishReason;
-};
-export type CreateChatCompletionStreamArgs = {
-    readonly providerId: string;
-    readonly model: string;
-    readonly messages: readonly ChatCompletionMessage[];
-    readonly tools?: readonly ChatCompletionToolDefinition[];
-    readonly signal?: ChatCompletionAbortSignal;
-    readonly frequency_penalty?: number;
-    readonly presence_penalty?: number;
-};
-/** OpenAI-compatible chat stream factory (credentials resolved server-side). */
-export type CreateChatCompletionStream = (args: CreateChatCompletionStreamArgs) => Promise<AsyncIterable<ChatCompletionStreamChunk>>;

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

@@ -1 +0,0 @@
-export {};

package/vendor/common-nodes/dist/ai/features/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/features/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/features/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/features/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/features/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 {};