langflower 0.0.7 → 0.0.9

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

@@ -0,0 +1,681 @@
+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, resolveSpawnPayload, SPAWN_SUBAGENT_TOOL, 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, spawn_subagent) 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();
+        }));
+    });
+};
+const invokeTool = (state, call, options, cancelSignal) => {
+    const callLog = emit({
+        kind: 'toolLog',
+        text: `→ ${call.name}(${previewToolLogText(call.arguments)})`,
+    });
+    if (call.name === SPAWN_SUBAGENT_TOOL) {
+        const resolved = resolveSpawnPayload(call, options.subagentRegistrations ?? [], state.openSpawnCallId);
+        if (!resolved.ok || options.waitForSubagentResult === undefined) {
+            const result = !resolved.ok
+                ? `Error: ${resolved.text}`
+                : 'Error: Sub-Agent spawn is not wired (no result wait).';
+            return toolResultPackets(state, call, result, options, [callLog]);
+        }
+        const { payload } = resolved;
+        const wait$ = defer(() => options.waitForSubagentResult?.(payload.callId, cancelSignal) ??
+            Promise.reject(new Error('Sub-Agent wait unavailable')));
+        const boundedWait$ = options.recovery.subagentTimeoutMs > 0
+            ? wait$.pipe(timeout({
+                first: options.recovery.subagentTimeoutMs,
+            }))
+            : wait$;
+        return concat(of(callLog, emit({
+            kind: 'subagentSpawn',
+            payload,
+        }), emit({
+            kind: 'toolLog',
+            text: `… waiting for subagentResult callId=${payload.callId}`,
+        })), boundedWait$.pipe(catchError((error) => of(error instanceof TimeoutError
+            ? `Error: Sub-Agent ${payload.callId} timed out after ${options.recovery.subagentTimeoutMs}ms.`
+            : `Error: ${classifyLlmFailure(error).message}`)), mergeMap((result) => toolResultPackets(state, call, result, options, []))));
+    }
+    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 boundedInvocation$ = options.recovery.toolTimeoutMs > 0
+        ? invocation$.pipe(timeout({
+            first: options.recovery.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 ${options.recovery.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 'waiting-subagent':
+            return EMPTY;
+        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, Sub-Agent, 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()));
+});