langflower 0.1.0 → 0.1.2

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

@@ -1,658 +0,0 @@
-import { isSteerControlContinue, isSteerControlPause, } from '@langflower/node-sdk/llm';
-import { EMPTY, catchError, concat, concatMap, defer, delay, expand, filter, finalize, from, fromEvent, map, mergeMap, NEVER, of, race, scan, switchMap, take, takeUntil, tap, throwError, TimeoutError, timeout, } from 'rxjs';
-import { invokeInventoryTool, previewToolLogText, toChatToolDefinitions, } from '../../../tools/inventory-tool-round.js';
-import { prepareChatCompletion } from '../openai/prepare-chat-completion.js';
-import { compactMessagesWithSummary, estimateRequestTokens, resolveForceTargetTokens, } from '../openai/llm-context-compaction.js';
-import { classifyLlmFailure } from './classify-llm-failure.js';
-import { autokickBackoffMs, autokickPenalties } from './autokick-recovery.js';
-import { reduceLlmLoop } from './llm-loop-reducer.js';
-import { initialLlmLoopState, } from './llm-loop-types.js';
-import { observeProviderStream, } from './operators/observe-provider-stream.js';
-import { normalizeToolResult } from './operators/normalize-tool-result.js';
-const inventoryChatName = (handle) => handle.toolId.length > 0 ? handle.toolId : handle.name;
-const resolveGetTools = (options) => options.getTools;
-const resolveInventoryTools = (options) => {
-    const getTools = resolveGetTools(options);
-    return getTools === undefined ? options.inventoryTools : getTools();
-};
-/**
- * Rebuild provider `tools` from live inventory. Keep extras (Review
- * accept/feedback) in their original positions; drop removed inventory ids;
- * append brand-new ids.
- */
-const resolveChatTools = (options) => {
-    if (resolveGetTools(options) === undefined) {
-        return options.chatTools;
-    }
-    const liveDefs = toChatToolDefinitions(resolveInventoryTools(options));
-    const originalInventoryNames = new Set(options.inventoryTools.map(inventoryChatName));
-    const extraNames = new Set(options.chatTools
-        .filter((tool) => !originalInventoryNames.has(tool.function.name))
-        .map((tool) => tool.function.name));
-    const liveByName = new Map(liveDefs.map((def) => [def.function.name, def]));
-    const merged = [];
-    const usedLive = new Set();
-    for (const tool of options.chatTools) {
-        const name = tool.function.name;
-        if (!originalInventoryNames.has(name)) {
-            merged.push(tool);
-            continue;
-        }
-        const liveDef = liveByName.get(name);
-        if (liveDef !== undefined) {
-            merged.push(liveDef);
-            usedLive.add(name);
-        }
-    }
-    for (const def of liveDefs) {
-        const name = def.function.name;
-        if (!usedLive.has(name) && !extraNames.has(name)) {
-            merged.push(def);
-        }
-    }
-    return merged;
-};
-const emit = (chunk) => ({ kind: 'emit', chunk });
-const transition = (state) => ({
-    kind: 'transition',
-    state,
-});
-const failureText = (failure) => {
-    const status = failure.status === undefined ? '' : ` HTTP ${failure.status}`;
-    return `Provider failure${status}: ${failure.message}`;
-};
-const joinsAutokickWait = (kind) => kind === 'rate-limit' ||
-    kind === 'provider-unavailable' ||
-    kind === 'network';
-const retryReasonFromFailure = (kind) => joinsAutokickWait(kind) ? kind : undefined;
-const isIncompleteToolCallJson = (calls) => {
-    for (const call of calls) {
-        const args = call.arguments.trim();
-        if (args.length === 0) {
-            return true;
-        }
-        try {
-            JSON.parse(args);
-        }
-        catch {
-            return true;
-        }
-    }
-    return false;
-};
-const isOutputTruncation = (fact) => {
-    if (fact.finishReason === 'length') {
-        return true;
-    }
-    const calls = fact.toolCalls ?? [];
-    return calls.length > 0 && isIncompleteToolCallJson(calls);
-};
-const canScheduleAutokick = (state, recovery) => recovery.autokickOnIdle &&
-    (recovery.maxAutokickAttempts === 0 ||
-        state.autokickAttempts < recovery.maxAutokickAttempts);
-const autokickPackets = (state, options, args) => {
-    if (!canScheduleAutokick(state, options.recovery)) {
-        return concat(of(emit({
-            kind: 'recoveryNotice',
-            code: 'suspended',
-            text: args.suspendedText,
-        })), of(transition(state)));
-    }
-    const attempt = state.autokickAttempts + 1;
-    const backoffMs = args.reason === 'dead-loop'
-        ? options.recovery.retryBaseDelayMs
-        : Math.max(autokickBackoffMs(attempt, options.recovery.autokickBackoffMs, options.recovery.autokickMaxBackoffMs), args.retryAfterMs ?? 0);
-    const nowMs = Date.now();
-    const interrupt$ = (options.steerControl$ ?? NEVER).pipe(filter((payload) => isSteerControlPause(payload) || payload.kind === 'steer'), take(1), map((payload) => ({ kind: 'interrupt', payload })));
-    return concat(of(emit({
-        kind: 'recoveryNotice',
-        code: 'retry',
-        text: `⚠ ${args.retryDetail}. Retrying ${attempt} in ${backoffMs}ms.`,
-        attempt,
-        reason: args.reason,
-        backoffMs,
-        nextAttemptAt: nowMs + backoffMs,
-        ...(state.lastAutokickAt !== undefined
-            ? { lastAttemptAt: state.lastAutokickAt }
-            : {}),
-    })), race(of({ kind: 'elapsed' }).pipe(delay(backoffMs)), interrupt$).pipe(switchMap((event) => {
-        if (event.kind === 'interrupt') {
-            if (isSteerControlPause(event.payload)) {
-                return concat(of(emit({
-                    kind: 'toolLog',
-                    text: 'Paused. Send Steer feedback or Resume to continue.',
-                })), of(transition(reduceLlmLoop(state, {
-                    type: 'stream.paused',
-                }))));
-            }
-            const text = event.payload.kind === 'steer'
-                ? event.payload.text
-                : undefined;
-            return of(transition(reduceLlmLoop(state, {
-                type: 'steer.received',
-                ...(text !== undefined ? { text } : {}),
-            })));
-        }
-        return of(transition(reduceLlmLoop(state, {
-            type: 'autokick.scheduled',
-            atMs: Date.now(),
-            ...(args.kickUserMessage !== undefined
-                ? { kickUserMessage: args.kickUserMessage }
-                : {}),
-        })));
-    })));
-};
-const recoveryPackets = (state, failure, options) => {
-    if (!failure.recoverable) {
-        return concat(of(emit({
-            kind: 'toolLog',
-            text: `⚠ ${failureText(failure)}`,
-        })), of(transition(reduceLlmLoop(state, {
-            type: 'failure.fatal',
-            failure,
-        }))));
-    }
-    // Structural history/compaction protocol failures will not heal on retry.
-    if (failure.kind === 'protocol') {
-        return concat(of(emit({
-            kind: 'recoveryNotice',
-            code: 'suspended',
-            text: `⚠ ${failureText(failure)}. Paused for Steer or Resume.`,
-        })), of(transition(reduceLlmLoop(state, {
-            type: 'provider.failed',
-            failure,
-        }))));
-    }
-    if (state.transientAttempts < options.recovery.maxTransientRetries) {
-        const attempt = state.transientAttempts + 1;
-        const delayMs = failure.retryAfterMs ??
-            options.recovery.retryBaseDelayMs * 2 ** (attempt - 1);
-        const next = reduceLlmLoop(state, { type: 'retry.scheduled' });
-        const reason = retryReasonFromFailure(failure.kind);
-        return concat(of(emit({
-            kind: 'recoveryNotice',
-            code: 'retry',
-            text: `⚠ ${failureText(failure)}. Retrying ${attempt}/${options.recovery.maxTransientRetries} in ${delayMs}ms.`,
-            attempt,
-            backoffMs: delayMs,
-            nextAttemptAt: Date.now() + delayMs,
-            ...(reason !== undefined ? { reason } : {}),
-            ...(state.lastAutokickAt !== undefined
-                ? { lastAttemptAt: state.lastAutokickAt }
-                : {}),
-        })), of(transition(next)).pipe(delay(delayMs)));
-    }
-    if (joinsAutokickWait(failure.kind) &&
-        canScheduleAutokick(state, options.recovery)) {
-        return autokickPackets(state, options, {
-            retryDetail: failureText(failure),
-            suspendedText: `⚠ ${failureText(failure)}. Retry budget exhausted; paused for Steer or Resume.`,
-            reason: failure.kind,
-            ...(failure.retryAfterMs !== undefined
-                ? { retryAfterMs: failure.retryAfterMs }
-                : {}),
-        });
-    }
-    return concat(of(emit({
-        kind: 'recoveryNotice',
-        code: 'suspended',
-        text: `⚠ ${failureText(failure)}. Retry budget exhausted; paused for Steer or Resume.`,
-    })), of(transition(reduceLlmLoop(state, {
-        type: 'provider.failed',
-        failure,
-    }))));
-};
-const truncationRecoveryPackets = (state, options, detail) => {
-    const failure = {
-        kind: 'output-truncated',
-        message: detail,
-        recoverable: true,
-    };
-    const notice = emit({
-        kind: 'recoveryNotice',
-        code: 'retry',
-        text: `⚠ ${detail}`,
-    });
-    if (options.compaction.contextSize > 0 &&
-        state.transientAttempts < options.recovery.maxTransientRetries) {
-        const attempt = state.transientAttempts + 1;
-        const chatTools = resolveChatTools(options);
-        const targetTokens = resolveForceTargetTokens(options.compaction, estimateRequestTokens(state.roundCheckpoint, chatTools));
-        return concat(of(notice), defer(() => compactMessagesWithSummary({
-            factory: options.factory,
-            providerId: options.providerId,
-            model: options.model,
-            messages: state.roundCheckpoint,
-            tools: chatTools,
-            targetTokens,
-        })).pipe(catchError((error) => of({
-            ok: false,
-            message: classifyLlmFailure(error).message,
-        })), mergeMap((compacted) => {
-            if (!compacted.ok) {
-                return recoveryPackets(state, {
-                    ...failure,
-                    message: `${detail} Compaction failed: ${compacted.message}`,
-                }, options);
-            }
-            const next = {
-                ...state,
-                phase: 'prepare',
-                committedMessages: [...compacted.messages],
-                roundCheckpoint: [...compacted.messages],
-                iteration: state.iteration,
-                transientAttempts: attempt,
-                partial: { reasoning: '', draft: '' },
-                pendingToolCalls: [],
-                suspendedBy: undefined,
-                failure: undefined,
-            };
-            return from([
-                emit({
-                    kind: 'toolLog',
-                    text: `Compacted history after output truncation ` +
-                        `(retry ${attempt}/${options.recovery.maxTransientRetries}): ` +
-                        `~${compacted.beforeTokens} → ~${compacted.afterTokens} approx tokens`,
-                }),
-                emit({
-                    kind: 'historySync',
-                    messages: [...compacted.messages],
-                }),
-                transition(next),
-            ]);
-        })));
-    }
-    return recoveryPackets(state, failure, options);
-};
-const providerFactAction = (fact) => {
-    switch (fact.kind) {
-        case 'provider.reasoning':
-            return { type: 'stream.reasoning', text: fact.text };
-        case 'provider.draft':
-            return { type: 'stream.draft', text: fact.text };
-        case 'provider.done':
-            if (isOutputTruncation(fact)) {
-                return undefined;
-            }
-            // Policy (`run-tools`) owns the sole assistant+tool_calls commit.
-            // Scan must not append here — a double stream.done leaves an orphan
-            // incomplete block that breaks later compaction.
-            if ((fact.toolCalls?.length ?? 0) > 0) {
-                return undefined;
-            }
-            return {
-                type: 'stream.done',
-                text: fact.text,
-            };
-        case 'provider.paused':
-            return { type: 'stream.paused' };
-        case 'provider.idle':
-            return { type: 'stream.idle', idleMs: fact.idleMs };
-        case 'provider.dead-loop':
-            return {
-                type: 'stream.dead-loop',
-                channel: fact.channel,
-                reason: fact.reason,
-            };
-        case 'provider.failed':
-            return undefined;
-    }
-};
-const providerFactPackets = (frame, options) => {
-    const fact = frame.fact;
-    if (fact === undefined) {
-        return EMPTY;
-    }
-    switch (fact.kind) {
-        case 'provider.reasoning':
-            return of(emit({
-                kind: 'reasoning',
-                text: fact.text,
-            }));
-        case 'provider.draft':
-            return of(emit({
-                kind: 'draftResponse',
-                text: fact.text,
-            }));
-        case 'provider.paused':
-            return concat(of(emit({
-                kind: 'toolLog',
-                text: 'Paused. Send Steer feedback or Resume to continue.',
-            })), of(transition(frame.state)));
-        case 'provider.idle': {
-            const failure = {
-                kind: 'stream-idle',
-                message: `Provider stream emitted no chunks for ${fact.idleMs}ms.`,
-                recoverable: true,
-            };
-            const hasPartial = frame.state.partial.reasoning.length > 0 ||
-                frame.state.partial.draft.length > 0;
-            const suspendedText = hasPartial
-                ? `⚠ ${failure.message} Paused to avoid repeating partial work.`
-                : `⚠ ${failure.message}. Retry budget exhausted; paused for Steer or Resume.`;
-            if (options.recovery.autokickOnIdle) {
-                return autokickPackets(frame.state, options, {
-                    retryDetail: failure.message,
-                    suspendedText,
-                    reason: 'idle',
-                    kickUserMessage: options.recovery.autokickUserMessage,
-                });
-            }
-            return hasPartial
-                ? concat(of(emit({
-                    kind: 'recoveryNotice',
-                    code: 'suspended',
-                    text: suspendedText,
-                })), of(transition(frame.state)))
-                : recoveryPackets(frame.state, failure, options);
-        }
-        case 'provider.dead-loop':
-            return autokickPackets(frame.state, options, {
-                retryDetail: 'Provider output entered a repetition loop',
-                suspendedText: '⚠ Provider output entered a repetition loop. Paused to avoid repeating partial work.',
-                reason: 'dead-loop',
-                kickUserMessage: options.recovery.autokickUserMessage,
-            });
-        case 'provider.failed':
-            return recoveryPackets(frame.state, fact.failure, options);
-        case 'provider.done': {
-            if (isOutputTruncation(fact)) {
-                const incomplete = (fact.toolCalls?.length ?? 0) > 0 &&
-                    isIncompleteToolCallJson(fact.toolCalls ?? []);
-                const reason = fact.finishReason === 'length'
-                    ? 'Provider finished with finish_reason=length (output truncated).'
-                    : 'Provider finished with incomplete tool-call JSON (output truncated).';
-                const detail = incomplete
-                    ? `${reason} Incomplete tool arguments will not be executed.`
-                    : reason;
-                return truncationRecoveryPackets(frame.state, options, detail);
-            }
-            const calls = fact.toolCalls ?? [];
-            const decision = options.policy.decideCompletion({
-                state: frame.state,
-                text: fact.text.length > 0
-                    ? fact.text
-                    : frame.state.partial.draft,
-                toolCalls: calls,
-            });
-            return decisionPackets(frame.state, decision);
-        }
-    }
-};
-const decisionPackets = (state, decision) => {
-    switch (decision.kind) {
-        case 'complete':
-            return concat(from(decision.chunks).pipe(map((chunk) => emit(chunk))), of(transition(reduceLlmLoop(state, {
-                type: 'round.completed',
-            }))));
-        case 'run-tools':
-            return of(transition(reduceLlmLoop(state, {
-                type: 'stream.done',
-                text: state.partial.draft,
-                toolCalls: decision.calls,
-            })));
-        case 'continue': {
-            const next = {
-                ...state,
-                phase: 'prepare',
-                committedMessages: [...decision.messages],
-                roundCheckpoint: [...decision.messages],
-                iteration: state.iteration + 1,
-                transientAttempts: 0,
-                partial: { reasoning: '', draft: '' },
-                pendingToolCalls: [],
-            };
-            return concat(from(decision.chunks).pipe(map((chunk) => emit(chunk))), of(transition(next)));
-        }
-        case 'fail':
-            return concat(of(emit({
-                kind: 'toolLog',
-                text: `⚠ ${decision.failure.message}`,
-            })), of(transition(reduceLlmLoop(state, {
-                type: 'failure.fatal',
-                failure: decision.failure,
-            }))));
-    }
-};
-const prepareAndStream = (state, options, cancel$, cancelSignal) => {
-    if (options.maxIterations > 0 && state.iteration >= options.maxIterations) {
-        const ask = options.requestPermission;
-        if (ask === undefined) {
-            return decisionPackets(state, options.policy.maxIterationsFailure(options.maxIterations));
-        }
-        const waitingText = `Tool-loop reached ${options.maxIterations} iterations ` +
-            '(maxIterations). Allow to continue for another budget, ' +
-            'or Deny to stop.';
-        return concat(of(emit({ kind: 'toolLog', text: waitingText })), from(ask({
-            toolId: 'agent.maxIterations',
-            detail: String(options.maxIterations),
-            summary: `Tool-loop reached ${options.maxIterations} ` +
-                'iterations. Allow to continue?',
-        })).pipe(switchMap((decision) => {
-            if (decision === 'allow') {
-                return prepareAndStream({ ...state, iteration: 0 }, options, cancel$, cancelSignal);
-            }
-            return decisionPackets(state, options.policy.maxIterationsFailure(options.maxIterations));
-        })));
-    }
-    return defer(() => {
-        const attempt = new AbortController();
-        const handleCancel = () => attempt.abort();
-        cancelSignal.addEventListener('abort', handleCancel, { once: true });
-        const penalties = state.autokickKickAttempts > 0
-            ? autokickPenalties(state.autokickKickAttempts, options.recovery.autokickPenaltyDelta)
-            : undefined;
-        const preparationSource$ = from(prepareChatCompletion({
-            factory: options.factory,
-            providerId: options.providerId,
-            model: options.model,
-            messages: state.committedMessages,
-            tools: resolveChatTools(options),
-            signal: attempt.signal,
-            compaction: options.compaction,
-            ...(penalties === undefined
-                ? {}
-                : {
-                    frequency_penalty: penalties.frequency,
-                    presence_penalty: penalties.presence,
-                }),
-        })).pipe(map((prepared) => ({ kind: 'prepared', prepared })), catchError((error) => of({ kind: 'failed', error })));
-        const preparation$ = options.recovery.streamIdleTimeoutMs > 0
-            ? preparationSource$.pipe(timeout({
-                first: options.recovery.streamIdleTimeoutMs,
-                with: () => of({ kind: 'idle' }),
-            }))
-            : preparationSource$;
-        const pause$ = options.steerControl$ === undefined
-            ? NEVER
-            : options.steerControl$.pipe(filter(isSteerControlPause), take(1), tap(() => attempt.abort()), map(() => ({ kind: 'paused' })));
-        return race(preparation$, pause$).pipe(tap((outcome) => {
-            if (outcome.kind === 'idle') {
-                attempt.abort();
-            }
-        }), switchMap((prepared) => {
-            if (prepared.kind === 'paused') {
-                return concat(of(emit({
-                    kind: 'toolLog',
-                    text: 'Paused. Send Steer feedback or Resume to continue.',
-                })), of(transition(reduceLlmLoop(state, {
-                    type: 'stream.paused',
-                }))));
-            }
-            if (prepared.kind === 'idle') {
-                return recoveryPackets(state, {
-                    kind: 'stream-idle',
-                    message: `Provider stream creation emitted no result for ${options.recovery.streamIdleTimeoutMs}ms.`,
-                    recoverable: true,
-                }, options);
-            }
-            if (prepared.kind === 'failed') {
-                return recoveryPackets(state, classifyLlmFailure(prepared.error), options);
-            }
-            const preparedResult = prepared.prepared;
-            if (!preparedResult.ok) {
-                return recoveryPackets(state, classifyLlmFailure(preparedResult.error), options);
-            }
-            const preparedState = reduceLlmLoop(state, {
-                type: 'round.prepared',
-                messages: preparedResult.messages,
-            });
-            const compactionPackets = preparedResult.compaction === undefined
-                ? EMPTY
-                : from([
-                    emit({
-                        kind: 'toolLog',
-                        text: `Compacted history (${preparedResult.compaction.reason}): ~${preparedResult.compaction.beforeTokens} → ~${preparedResult.compaction.afterTokens} approx tokens`,
-                    }),
-                    emit({
-                        kind: 'historySync',
-                        messages: [...preparedResult.messages],
-                    }),
-                ]);
-            const pause$ = options.steerControl$ ?? NEVER;
-            const streamPackets = observeProviderStream({
-                createStream: async () => preparedResult.stream,
-                pause$,
-                cancel$,
-                idleTimeoutMs: options.recovery.streamIdleTimeoutMs,
-                onAbort: () => attempt.abort(),
-                deadLoop: options.recovery.deadLoopEnabled
-                    ? options.recovery.deadLoop
-                    : false,
-            }).pipe(scan((frame, fact) => {
-                const action = providerFactAction(fact);
-                return {
-                    state: action === undefined
-                        ? frame.state
-                        : reduceLlmLoop(frame.state, action),
-                    fact,
-                };
-            }, { state: preparedState }), concatMap((frame) => providerFactPackets(frame, options)));
-            return concat(compactionPackets, streamPackets);
-        }), finalize(() => {
-            cancelSignal.removeEventListener('abort', handleCancel);
-            attempt.abort();
-        }));
-    });
-};
-/** Parent `toolTimeoutMs` does not bound canvas specialists (`Writer_subagent`). */
-const isSubAgentToolCall = (name) => name.endsWith('_subagent') || name.endsWith('(subagent)');
-const invokeTool = (state, call, options, cancelSignal) => {
-    const callLog = emit({
-        kind: 'toolLog',
-        text: `→ ${call.name}(${previewToolLogText(call.arguments)})`,
-    });
-    const toolAbort = new AbortController();
-    const abortTool = () => {
-        toolAbort.abort();
-    };
-    cancelSignal.addEventListener('abort', abortTool);
-    const invokeOptions = {
-        ...(options.policy.toolNotAllowedText === undefined
-            ? {}
-            : {
-                notInAllowlistText: options.policy.toolNotAllowedText,
-            }),
-        signal: toolAbort.signal,
-    };
-    const invocation$ = defer(() => invokeInventoryTool(options.harness, resolveInventoryTools(options), call, options.toolCtx, invokeOptions).catch((error) => {
-        // Avoid unhandled rejection when timeout/cancel aborts in-flight work.
-        if (toolAbort.signal.aborted) {
-            return {
-                ok: false,
-                text: 'Tool aborted.',
-            };
-        }
-        throw error;
-    })).pipe(finalize(() => {
-        cancelSignal.removeEventListener('abort', abortTool);
-    }));
-    const toolTimeoutMs = isSubAgentToolCall(call.name)
-        ? 0
-        : options.recovery.toolTimeoutMs;
-    const boundedInvocation$ = toolTimeoutMs > 0
-        ? invocation$.pipe(timeout({
-            first: toolTimeoutMs,
-        }))
-        : invocation$;
-    return concat(of(callLog), boundedInvocation$.pipe(map((result) => result.ok ? result.text : `Error: ${result.text}`), catchError((error) => {
-        abortTool();
-        return of(error instanceof TimeoutError
-            ? `Error: Tool ${call.name} timed out after ${toolTimeoutMs}ms.`
-            : `Error: ${classifyLlmFailure(error).message}`);
-    }), mergeMap((result) => toolResultPackets(state, call, result, options, []))));
-};
-const toolResultPackets = (state, call, result, options, prefix) => {
-    const normalized = normalizeToolResult(result, options.recovery.maxToolResultChars);
-    const next = reduceLlmLoop(state, {
-        type: 'tool.completed',
-        call,
-        result: normalized,
-    });
-    return from([
-        ...prefix,
-        emit({
-            kind: 'toolLog',
-            text: `← ${call.name}: ${previewToolLogText(normalized)}`,
-        }),
-        transition(next),
-    ]);
-};
-const awaitSteer = (state, options, cancel$) => {
-    if (options.steerControl$ === undefined) {
-        const failure = state.failure ??
-            {
-                kind: 'unknown',
-                message: 'LLM loop suspended without a steerControl input.',
-                recoverable: false,
-            };
-        return of(transition(reduceLlmLoop(state, {
-            type: 'failure.fatal',
-            failure,
-        })));
-    }
-    return options.steerControl$.pipe(filter(isSteerControlContinue), take(1), map((payload) => transition(reduceLlmLoop(state, {
-        type: 'steer.received',
-        ...(payload.kind === 'steer' &&
-            payload.text.trim().length > 0
-            ? { text: payload.text.trim() }
-            : {}),
-    }))), takeUntil(cancel$));
-};
-const executePhase = (state, options, cancel$, cancelSignal) => {
-    switch (state.phase) {
-        case 'prepare':
-        case 'streaming':
-            return prepareAndStream(state, options, cancel$, cancelSignal);
-        case 'tools': {
-            const call = state.pendingToolCalls[0];
-            return call === undefined
-                ? of(transition({
-                    ...state,
-                    phase: 'prepare',
-                    committedMessages: [...state.roundCheckpoint],
-                    pendingToolCalls: [],
-                }))
-                : invokeTool(state, call, options, cancelSignal);
-        }
-        case 'suspended':
-            return awaitSteer(state, options, cancel$);
-        case 'failed':
-            return throwError(() => state.failure?.message ??
-                'LLM loop failed without failure details.');
-        case 'complete':
-        case 'cancelled':
-            return EMPTY;
-    }
-};
-/**
- * One reactive state machine for provider, tool, retry, and Steer
- * phases. Policy owns only the semantic completion decision.
- */
-export const runLlmLoop = (options) => defer(() => {
-    const cancel = new AbortController();
-    const cancel$ = fromEvent(cancel.signal, 'abort').pipe(map(() => undefined), take(1));
-    return of(transition(initialLlmLoopState(options.messages))).pipe(expand((packet) => packet.kind === 'emit'
-        ? EMPTY
-        : executePhase(packet.state, options, cancel$, cancel.signal)), filter((packet) => packet.kind === 'emit'), map((packet) => packet.chunk), finalize(() => cancel.abort()));
-});