langflower 0.1.0 → 0.1.2

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

@@ -1,225 +0,0 @@
-import { toLlmRecoveryPortValue, } from '@langflower/node-sdk/llm';
-import { statefulObservable, } from '@rx-evo/stateful-observable';
-import { concatMap, filter, map, pipe, shareReplay, startWith, switchMap, } from 'rxjs';
-import { buildEffectiveSystemPrompt } from '../prompt/build-effective-system-prompt.js';
-import { collectAgentToolHandles } from '../../../tools/collect-agent-tool-handles.js';
-import { parseLlmRolePreset, resolveEffectiveSkillId, } from '../llm-role-preset.js';
-import { normalizeCompactionConfig } from '../openai/normalize-compaction-params.js';
-import { resolveChatProviderModel } from '../prompt/resolve-chat-provider-model.js';
-import { buildAgentToolCtx, getRunHostServices } from '../run-host-services.js';
-import { AGENT_MAX_ITERATIONS_CAP, DEFAULT_AGENT_MAX_ITERATIONS, normalizeMaxIterations as normalizeMaxIterationsParam, } from '../prompt/normalize-max-iterations.js';
-import { normalizeLlmRecoveryPolicy } from '../llm-loop/normalize-llm-recovery-policy.js';
-import { isBlankTurn, runTurnFromState, } from './run-session-machine.js';
-const asPortList = (value) => {
-    if (value === undefined || value === null) {
-        return [];
-    }
-    return Array.isArray(value) ? value : [value];
-};
-/**
- * Close over live editor wired tools when the server hook is present;
- * otherwise freeze the combineInputs snapshot (unit tests).
- */
-const createAgentGetTools = (ec, toolList) => {
-    const hostServices = getRunHostServices(ec);
-    return () => {
-        const live = hostServices?.getLiveWiredTools?.(ec.nodeId);
-        return collectAgentToolHandles({
-            toolHandles: ec.toolHandles,
-            toolsPort: live === undefined
-                ? toolList
-                : [...asPortList(toolList), ...live],
-        });
-    };
-};
-const toolLabel = (tool) => tool.name.length > 0 ? tool.name : tool.toolId || 'unknown';
-const formatList = (items, labelOf) => (items.length === 0 ? 'none' : items.map(labelOf).join(', '));
-/** 0 = unlimited; positive = max feedback turns after turn 0. */
-export const normalizeMaxFeedbackTurns = (value) => {
-    const n = typeof value === 'number' ? value : Number(value);
-    if (!Number.isFinite(n) || n < 1) {
-        return 0;
-    }
-    return Math.min(AGENT_MAX_ITERATIONS_CAP, Math.floor(n));
-};
-export const appendToolInventory = (systemPrompt, tools) => {
-    if (tools.length === 0) {
-        return systemPrompt;
-    }
-    return [
-        systemPrompt,
-        `Available tools (callable via internal tool loop): ${formatList(tools, toolLabel)}.`,
-    ]
-        .filter((part) => part.trim().length > 0)
-        .join('\n\n');
-};
-/**
- * Step: merge prompt / inventory / role panel into the shared agent context.
- */
-const assembleLlmAgentInventoryContext = (prompt, toolList, systemPromptValue, ec) => {
-    const rolePreset = parseLlmRolePreset(ec.params.rolePreset);
-    const skillId = resolveEffectiveSkillId(rolePreset, ec.params.skillId);
-    const hostServices = getRunHostServices(ec);
-    const skillMarkdown = hostServices?.skillMarkdown ?? '';
-    const agentsMarkdown = hostServices?.agentsMarkdown ?? '';
-    const getTools = createAgentGetTools(ec, toolList);
-    return {
-        prompt: String(prompt ?? ''),
-        tools: getTools(),
-        getTools,
-        ...resolveChatProviderModel(ec.params, hostServices),
-        skillId,
-        rolePreset,
-        skillMarkdown,
-        agentsMarkdown,
-        effectiveSystemPrompt: buildEffectiveSystemPrompt({
-            rolePreset,
-            systemPromptInput: String(systemPromptValue ?? ''),
-            agentsMarkdown,
-            skillMarkdown,
-        }),
-        toolCtx: buildAgentToolCtx({ projectDir: ec.projectDir, runId: ec.runId }, hostServices),
-        maxIterations: normalizeMaxIterationsParam(ec.params.maxIterations, {
-            fallback: DEFAULT_AGENT_MAX_ITERATIONS,
-            maxCap: AGENT_MAX_ITERATIONS_CAP,
-        }),
-        maxFeedbackTurns: normalizeMaxFeedbackTurns(ec.params.maxFeedbackTurns),
-        ...(hostServices?.requestPermission !== undefined
-            ? { requestPermission: hostServices.requestPermission }
-            : {}),
-        compaction: normalizeCompactionConfig(ec.params),
-        recovery: normalizeLlmRecoveryPolicy(ec.params),
-    };
-};
-/**
- * RxJS operator: filter session chunks by `kind` and project the payload.
- * Use inside `pipeValue` — do not wrap as `(cycle$) => cycle$.pipeValue(...)`.
- *
- * `@rx-evo` wraps values in `NoInfer`, which breaks `Extract` type guards —
- * callers narrow with a cast inside `project`.
- */
-export const demuxByKind = (kind, project) => pipe(filter((chunk) => chunk.kind === kind), map(project));
-const asKind = (chunk) => chunk;
-const demuxLlmAgentPorts = (cycle$) => ({
-    reasoning$: cycle$.pipeValue(demuxByKind('reasoning', (chunk) => asKind(chunk).text)),
-    draftResponse$: cycle$.pipeValue(demuxByKind('draftResponse', (chunk) => asKind(chunk).text)),
-    toolLog$: cycle$.pipeValue(demuxByKind('toolLog', (chunk) => asKind(chunk).text)),
-    recovery$: cycle$.pipeValue(demuxByKind('recoveryNotice', (chunk) => {
-        const notice = asKind(chunk);
-        return toLlmRecoveryPortValue(notice);
-    })),
-    response$: cycle$.pipeValue(demuxByKind('response', (chunk) => asKind(chunk).text)),
-});
-/**
- * Shared LLM session cycle (ADR-016): init context recreates the session;
- * turn$ drives turn 0 + later turns with accumulated `messages[]`.
- *
- * All LLM nodes (openai / fake / critique / review / future) MUST use this —
- * do not invent per-node cold-start `switchMap` history.
- */
-export const createLlmSessionCycle$ = (context$, turn$, prepareSession, runTurn, options) => {
-    const primeTurn0 = options?.primeTurn0 ?? true;
-    const ticks$ = context$.pipeValue(switchMap((context) => {
-        const prep = prepareSession(context);
-        const turns$ = primeTurn0 ? turn$.pipe(startWith('')) : turn$;
-        return turns$.pipe(map((raw) => ({ context, prep, raw })));
-    }));
-    let state;
-    const isSkippableTick = (tick) => {
-        const prepChanged = state === undefined || state.preparation !== tick.prep;
-        if (prepChanged || !state?.turn0Done) {
-            return !primeTurn0 && isBlankTurn(tick.raw);
-        }
-        return isBlankTurn(tick.raw);
-    };
-    const workTicks$ = ticks$.pipeValue(filter((tick) => !isSkippableTick(tick)));
-    // pipeValue uses switchMap and would cancel an in-flight turn when the
-    // next tick arrives (startWith + a blank BehaviorSubject, or feedback
-    // during a stream). Queue turns with concatMap so pending comes from
-    // the loader, matching withLoading() + sequential I/O.
-    return statefulObservable({
-        input: workTicks$.value$,
-        mapOperator: concatMap,
-        loader: (tick) => {
-            const { context, prep, raw } = tick;
-            if (state === undefined || state.preparation !== prep) {
-                state = {
-                    history: [...prep.history],
-                    turn0Done: false,
-                    feedbackTurns: 0,
-                    preparation: prep,
-                };
-            }
-            return runTurnFromState(context, state, raw, primeTurn0, runTurn).pipe(map((next) => {
-                state = next;
-                return next;
-            }), filter((next) => next.emitted !== undefined), map((next) => next.emitted));
-        },
-    }).pipe(shareReplay({ bufferSize: 1, refCount: true }));
-};
-/**
- * Composer entry for OpenAI / Fake agent binds.
- *
- * Order:
- * 1. make role inputs (userPrompt / systemPrompt / feedback)
- * 2. assemble inventory context$ (+ provider extend)
- * 3. ADR-016 feedback cycle$
- * 4. demux chunk ports
- * 5. configure standard outputs
- */
-export const bindLlmAgentSession = (ctx, helpers, inventory, options) => {
-    const { makeInput, configureOutput, combineInputs } = helpers;
-    const { tools, steerControl } = inventory;
-    // 1. role inputs
-    const userPrompt = makeInput('userPrompt', {
-        name: 'userPrompt',
-        wireType: 'string',
-        inline: 'text-multiline',
-        required: true,
-    });
-    const systemPrompt = makeInput('systemPrompt', {
-        name: 'systemPrompt',
-        wireType: 'string',
-        inline: 'text-multiline',
-        defaultValue: '',
-    });
-    const feedback = makeInput('feedback', {
-        name: 'feedback',
-        wireType: 'string',
-        multi: 'merge',
-        defaultValue: '',
-    });
-    // 2. inventory context$
-    const context$ = combineInputs([userPrompt, tools, systemPrompt, ctx], ([prompt, toolList, systemPromptValue, ec]) => {
-        const base = assembleLlmAgentInventoryContext(prompt, toolList, systemPromptValue, ec);
-        return {
-            ...options.extendContext(base, ec),
-            steerControl$: steerControl.value$,
-        };
-    });
-    // 3. feedback cycle$ (ADR-016 Soft↔Hard: primeTurn0)
-    const cycle$ = createLlmSessionCycle$(context$, feedback.value$, options.prepareSession, (context, turnFeedback, history, session) => options.runTurn(context, turnFeedback === undefined
-        ? undefined
-        : String(turnFeedback ?? ''), history, session), { primeTurn0: true });
-    // 4. demux
-    const { reasoning$, draftResponse$, toolLog$, recovery$, response$ } = demuxLlmAgentPorts(cycle$);
-    // 5. outputs
-    return {
-        inputs: [userPrompt, systemPrompt, feedback],
-        outputs: [
-            configureOutput('reasoning', reasoning$, {
-                wireType: 'string',
-                feed: { role: 'reasoning', streaming: true },
-            }),
-            configureOutput('draftResponse', draftResponse$, {
-                wireType: 'string',
-                feed: { role: 'draft', streaming: true },
-            }),
-            configureOutput('response', response$, {
-                wireType: 'string',
-                feed: { role: 'result' },
-            }),
-        ],
-        inventoryOutputs: { toolLog$, recovery$ },
-    };
-};

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

@@ -1,32 +0,0 @@
-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'>;
-};
-export type LlmSessionState<Session, Chunk> = {
-    readonly history: readonly ChatCompletionMessage[];
-    readonly turn0Done: boolean;
-    readonly feedbackTurns: number;
-    readonly preparation: LlmSessionPreparation<Session>;
-    readonly emitted?: Chunk | undefined;
-};
-export declare const isBlankTurn: (raw: unknown) => boolean;
-export declare const runTurnFromState: <Context extends LlmSessionContext, Session, Chunk extends {
-    readonly kind: string;
-}>(context: Context, state: LlmSessionState<Session, Chunk>, raw: unknown, primeTurn0: boolean, runTurn: (context: Context, turnPayload: unknown, history: readonly ChatCompletionMessage[], session: Session) => Observable<Chunk>) => Observable<LlmSessionState<Session, Chunk>>;
-/**
- * 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

@@ -1,118 +0,0 @@
-import { EMPTY, concat, filter, from, map, mergeScan, of, scan, startWith, switchMap, throwError, } from 'rxjs';
-export 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));
-};
-export 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

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,63 +0,0 @@
-/**
- * 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

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

@@ -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();
-    };
-};