langflower 0.0.7 → 0.0.9

package/vendor/common-nodes/dist/ai/features/ui-schema/llm-recovery-ui-schema.d.ts

@@ -0,0 +1,113 @@
+/** Shared Inspector fields for provider/tool recovery policy. */
+export declare const llmRecoveryUiSchema: readonly [{
+    readonly field: "streamIdleTimeoutMs";
+    readonly type: "number";
+    readonly label: "Stream idle timeout (ms, 0 disables)";
+    readonly default: 90000;
+    readonly min: 0;
+    readonly step: 1;
+}, {
+    readonly field: "toolTimeoutMs";
+    readonly type: "number";
+    readonly label: "Tool timeout (ms, 0 disables)";
+    readonly default: 60000;
+    readonly min: 0;
+    readonly step: 1;
+}, {
+    readonly field: "subagentTimeoutMs";
+    readonly type: "number";
+    readonly label: "Sub-Agent timeout (ms, 0 disables)";
+    readonly default: 300000;
+    readonly min: 0;
+    readonly step: 1;
+}, {
+    readonly field: "maxTransientRetries";
+    readonly type: "number";
+    readonly label: "Transient provider retries";
+    readonly default: 2;
+    readonly min: 0;
+    readonly max: 32;
+    readonly step: 1;
+}, {
+    readonly field: "autokickOnIdle";
+    readonly type: "boolean";
+    readonly label: "Autokick on idle and dead-loop";
+    readonly default: boolean;
+}, {
+    readonly field: "deadLoopEnabled";
+    readonly type: "boolean";
+    readonly label: "Detect repetition dead loops";
+    readonly default: boolean;
+}, {
+    readonly field: "maxAutokickAttempts";
+    readonly type: "number";
+    readonly label: "Max autokick reconnects (0 = unlimited)";
+    readonly default: number;
+    readonly min: 0;
+    readonly max: 1000;
+    readonly step: 1;
+}, {
+    readonly field: "autokickBackoffMs";
+    readonly type: "number";
+    readonly label: "Autokick backoff base (ms)";
+    readonly default: number;
+    readonly min: 1000;
+    readonly step: 1000;
+}, {
+    readonly field: "autokickMaxBackoffMs";
+    readonly type: "number";
+    readonly label: "Autokick backoff clamp (ms)";
+    readonly default: number;
+    readonly min: 1000;
+    readonly step: 1000;
+}, {
+    readonly field: "autokickUserMessage";
+    readonly type: "string";
+    readonly label: "Autokick kick message";
+    readonly default: string;
+}, {
+    readonly field: "autokickPenaltyFrequency";
+    readonly type: "number";
+    readonly label: "Autokick frequency_penalty delta";
+    readonly default: number;
+    readonly min: -2;
+    readonly max: 2;
+    readonly step: 0.1;
+}, {
+    readonly field: "autokickPenaltyPresence";
+    readonly type: "number";
+    readonly label: "Autokick presence_penalty delta";
+    readonly default: number;
+    readonly min: -2;
+    readonly max: 2;
+    readonly step: 0.1;
+}, {
+    readonly field: "deadLoopMaxWindowTokens";
+    readonly type: "number";
+    readonly label: "Dead-loop window (tokens)";
+    readonly default: number;
+    readonly min: 10;
+    readonly max: 8000;
+    readonly step: 1;
+}, {
+    readonly field: "deadLoopConsecutiveThreshold";
+    readonly type: "number";
+    readonly label: "Dead-loop consecutive identical deltas";
+    readonly default: number;
+    readonly min: 1;
+    readonly step: 1;
+}, {
+    readonly field: "deadLoopMinRepetitions";
+    readonly type: "number";
+    readonly label: "Dead-loop cyclic repetitions";
+    readonly default: number;
+    readonly min: 1;
+    readonly step: 1;
+}, {
+    readonly field: "deadLoopMinPatternTokens";
+    readonly type: "number";
+    readonly label: "Dead-loop min pattern tokens";
+    readonly default: number;
+    readonly min: 1;
+    readonly step: 1;
+}];

package/vendor/common-nodes/dist/ai/features/ui-schema/llm-recovery-ui-schema.js

@@ -0,0 +1,131 @@
+import { DEFAULT_LLM_RECOVERY_POLICY } from '../llm-loop/llm-loop-types.js';
+/** Shared Inspector fields for provider/tool recovery policy. */
+export const llmRecoveryUiSchema = [
+    {
+        field: 'streamIdleTimeoutMs',
+        type: 'number',
+        label: 'Stream idle timeout (ms, 0 disables)',
+        default: 90000,
+        min: 0,
+        step: 1,
+    },
+    {
+        field: 'toolTimeoutMs',
+        type: 'number',
+        label: 'Tool timeout (ms, 0 disables)',
+        default: 60000,
+        min: 0,
+        step: 1,
+    },
+    {
+        field: 'subagentTimeoutMs',
+        type: 'number',
+        label: 'Sub-Agent timeout (ms, 0 disables)',
+        default: 300000,
+        min: 0,
+        step: 1,
+    },
+    {
+        field: 'maxTransientRetries',
+        type: 'number',
+        label: 'Transient provider retries',
+        default: 2,
+        min: 0,
+        max: 32,
+        step: 1,
+    },
+    {
+        field: 'autokickOnIdle',
+        type: 'boolean',
+        label: 'Autokick on idle and dead-loop',
+        default: DEFAULT_LLM_RECOVERY_POLICY.autokickOnIdle,
+    },
+    {
+        field: 'deadLoopEnabled',
+        type: 'boolean',
+        label: 'Detect repetition dead loops',
+        default: DEFAULT_LLM_RECOVERY_POLICY.deadLoopEnabled,
+    },
+    {
+        field: 'maxAutokickAttempts',
+        type: 'number',
+        label: 'Max autokick reconnects (0 = unlimited)',
+        default: DEFAULT_LLM_RECOVERY_POLICY.maxAutokickAttempts,
+        min: 0,
+        max: 1000,
+        step: 1,
+    },
+    {
+        field: 'autokickBackoffMs',
+        type: 'number',
+        label: 'Autokick backoff base (ms)',
+        default: DEFAULT_LLM_RECOVERY_POLICY.autokickBackoffMs,
+        min: 1000,
+        step: 1000,
+    },
+    {
+        field: 'autokickMaxBackoffMs',
+        type: 'number',
+        label: 'Autokick backoff clamp (ms)',
+        default: DEFAULT_LLM_RECOVERY_POLICY.autokickMaxBackoffMs,
+        min: 1000,
+        step: 1000,
+    },
+    {
+        field: 'autokickUserMessage',
+        type: 'string',
+        label: 'Autokick kick message',
+        default: DEFAULT_LLM_RECOVERY_POLICY.autokickUserMessage,
+    },
+    {
+        field: 'autokickPenaltyFrequency',
+        type: 'number',
+        label: 'Autokick frequency_penalty delta',
+        default: DEFAULT_LLM_RECOVERY_POLICY.autokickPenaltyDelta.frequency,
+        min: -2,
+        max: 2,
+        step: 0.1,
+    },
+    {
+        field: 'autokickPenaltyPresence',
+        type: 'number',
+        label: 'Autokick presence_penalty delta',
+        default: DEFAULT_LLM_RECOVERY_POLICY.autokickPenaltyDelta.presence,
+        min: -2,
+        max: 2,
+        step: 0.1,
+    },
+    {
+        field: 'deadLoopMaxWindowTokens',
+        type: 'number',
+        label: 'Dead-loop window (tokens)',
+        default: DEFAULT_LLM_RECOVERY_POLICY.deadLoop.maxWindowTokens,
+        min: 10,
+        max: 8000,
+        step: 1,
+    },
+    {
+        field: 'deadLoopConsecutiveThreshold',
+        type: 'number',
+        label: 'Dead-loop consecutive identical deltas',
+        default: DEFAULT_LLM_RECOVERY_POLICY.deadLoop.consecutiveThreshold,
+        min: 1,
+        step: 1,
+    },
+    {
+        field: 'deadLoopMinRepetitions',
+        type: 'number',
+        label: 'Dead-loop cyclic repetitions',
+        default: DEFAULT_LLM_RECOVERY_POLICY.deadLoop.minRepetitions,
+        min: 1,
+        step: 1,
+    },
+    {
+        field: 'deadLoopMinPatternTokens',
+        type: 'number',
+        label: 'Dead-loop min pattern tokens',
+        default: DEFAULT_LLM_RECOVERY_POLICY.deadLoop.minPatternTokens,
+        min: 1,
+        step: 1,
+    },
+];

package/vendor/common-nodes/dist/ai/features/wait-for-subagent-result.d.ts

@@ -0,0 +1,6 @@
+import { type Observable } from 'rxjs';
+/**
+ * Agent-node internal router: first matching `subagentResult` for `callId`,
+ * aborted when the tool-loop AbortSignal fires (turn Observable teardown).
+ */
+export declare const waitForSubagentResult: (result$: Observable<unknown>, callId: string, signal: AbortSignal, timeoutMs?: number) => Promise<string>;

package/vendor/common-nodes/dist/ai/features/wait-for-subagent-result.js

@@ -0,0 +1,30 @@
+import { filter, firstValueFrom, fromEvent, map, take, takeUntil, timeout, } from 'rxjs';
+import { isSubAgentResultPayload, } from './sub-agent-protocol.js';
+const normalizeResult = (value) => {
+    if (isSubAgentResultPayload(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            return isSubAgentResultPayload(parsed) ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+};
+const observeSubagentResult = (result$, callId, signal, timeoutMs = 0) => {
+    const matching$ = result$.pipe(map(normalizeResult), filter((payload) => payload !== null && payload.callId === callId), map((payload) => payload.result), take(1), takeUntil(fromEvent(signal, 'abort')));
+    return timeoutMs > 0
+        ? matching$.pipe(timeout({ first: timeoutMs }))
+        : matching$;
+};
+/**
+ * Agent-node internal router: first matching `subagentResult` for `callId`,
+ * aborted when the tool-loop AbortSignal fires (turn Observable teardown).
+ */
+export const waitForSubagentResult = (result$, callId, signal, timeoutMs = 0) => signal.aborted
+    ? Promise.reject(new Error('Sub-Agent wait aborted'))
+    : firstValueFrom(observeSubagentResult(result$, callId, signal, timeoutMs));

package/vendor/common-nodes/dist/ai/llm-loop/autokick-recovery.d.ts

@@ -0,0 +1,13 @@
+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/llm-loop/autokick-recovery.js

@@ -0,0 +1,17 @@
+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/llm-loop/dead-loop-detector.d.ts

@@ -0,0 +1,28 @@
+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 {};

package/vendor/common-nodes/dist/ai/llm-loop/dead-loop-detector.js

@@ -0,0 +1,194 @@
+const DEFAULT_DEAD_LOOP_OPTIONS = {
+    maxWindowTokens: 1_000,
+    consecutiveThreshold: 5,
+    minRepetitions: 3,
+    minPatternTokens: 2,
+};
+const BASE1 = 911_382_323;
+const BASE2 = 972_663_749;
+const FNV_OFFSET1 = 2_166_136_261;
+const FNV_OFFSET2 = 84_696_351;
+const FNV_PRIME = 16_777_619;
+const hashString = (text, offset) => {
+    let hash = offset >>> 0;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, FNV_PRIME);
+    }
+    return hash >>> 0;
+};
+const createPowTable = (base, maxExponent) => {
+    const table = new Uint32Array(maxExponent + 1);
+    table[0] = 1;
+    for (let exponent = 1; exponent <= maxExponent; exponent += 1) {
+        table[exponent] = Math.imul(table[exponent - 1] ?? 1, base) >>> 0;
+    }
+    return table;
+};
+export const createDeadLoopDetector = (channel, options = {}) => {
+    const maxWindowTokens = options.maxWindowTokens ?? DEFAULT_DEAD_LOOP_OPTIONS.maxWindowTokens;
+    const consecutiveThreshold = options.consecutiveThreshold ??
+        DEFAULT_DEAD_LOOP_OPTIONS.consecutiveThreshold;
+    const minRepetitions = options.minRepetitions ?? DEFAULT_DEAD_LOOP_OPTIONS.minRepetitions;
+    const minPatternTokens = options.minPatternTokens ?? DEFAULT_DEAD_LOOP_OPTIONS.minPatternTokens;
+    const capacity = Math.max(1, maxWindowTokens);
+    const tokens = new Array(capacity);
+    const hashes1 = new Uint32Array(capacity);
+    const hashes2 = new Uint32Array(capacity);
+    const prefix1 = new Uint32Array(capacity + 1);
+    const prefix2 = new Uint32Array(capacity + 1);
+    const pow1 = createPowTable(BASE1, capacity);
+    const pow2 = createPowTable(BASE2, capacity);
+    const stats = {
+        hashLookups: 0,
+        exactCompareTokenVisits: 0,
+    };
+    let head = 0;
+    let size = 0;
+    let consecutiveCount = 0;
+    const physicalIndex = (logical) => (head + logical) % capacity;
+    const tokenAt = (logical) => tokens[physicalIndex(logical)] ?? '';
+    const dropOldest = () => {
+        const removedPhysical = head;
+        const removed1 = hashes1[removedPhysical] ?? 0;
+        const removed2 = hashes2[removedPhysical] ?? 0;
+        for (let logical = 1; logical < size; logical += 1) {
+            prefix1[logical] =
+                ((prefix1[logical + 1] ?? 0) -
+                    Math.imul(removed1, pow1[logical] ?? 1)) >>>
+                    0;
+            prefix2[logical] =
+                ((prefix2[logical + 1] ?? 0) -
+                    Math.imul(removed2, pow2[logical] ?? 1)) >>>
+                    0;
+        }
+        prefix1[0] = 0;
+        prefix2[0] = 0;
+        head = (head + 1) % capacity;
+        size -= 1;
+    };
+    const appendPrefix = (physical) => {
+        prefix1[size] =
+            (Math.imul(prefix1[size - 1] ?? 0, BASE1) +
+                (hashes1[physical] ?? 0)) >>>
+                0;
+        prefix2[size] =
+            (Math.imul(prefix2[size - 1] ?? 0, BASE2) +
+                (hashes2[physical] ?? 0)) >>>
+                0;
+    };
+    const rangeHashesEqual = (leftStart, rightStart, length) => {
+        stats.hashLookups += 1;
+        const leftEnd = leftStart + length;
+        const rightEnd = rightStart + length;
+        const powA = pow1[length] ?? 1;
+        const powB = pow2[length] ?? 1;
+        const left1 = ((prefix1[leftEnd] ?? 0) -
+            Math.imul(prefix1[leftStart] ?? 0, powA)) >>>
+            0;
+        const right1 = ((prefix1[rightEnd] ?? 0) -
+            Math.imul(prefix1[rightStart] ?? 0, powA)) >>>
+            0;
+        if (left1 !== right1) {
+            return false;
+        }
+        const left2 = ((prefix2[leftEnd] ?? 0) -
+            Math.imul(prefix2[leftStart] ?? 0, powB)) >>>
+            0;
+        const right2 = ((prefix2[rightEnd] ?? 0) -
+            Math.imul(prefix2[rightStart] ?? 0, powB)) >>>
+            0;
+        return left2 === right2;
+    };
+    const sliceTokens = (start, end) => {
+        const sliced = [];
+        for (let logical = start; logical < end; logical += 1) {
+            sliced.push(tokenAt(logical));
+        }
+        return sliced;
+    };
+    const joinTokens = () => {
+        let text = '';
+        for (let logical = 0; logical < size; logical += 1) {
+            text += tokenAt(logical);
+        }
+        return text;
+    };
+    const exactBlocksMatch = (patternLength) => {
+        const baseStart = size - patternLength;
+        for (let repeat = 1; repeat < minRepetitions; repeat += 1) {
+            const otherStart = size - (repeat + 1) * patternLength;
+            for (let offset = 0; offset < patternLength; offset += 1) {
+                stats.exactCompareTokenVisits += 1;
+                if (tokenAt(baseStart + offset) !== tokenAt(otherStart + offset)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+    const fail = (reason, lastTokens) => ({
+        ok: false,
+        error: {
+            name: 'DeadLoopError',
+            message: reason === 'consecutive'
+                ? `Consecutive token repetition on ${channel}`
+                : `Cyclic repetition on ${channel}`,
+            partialText: joinTokens(),
+            lastTokens,
+            reason,
+            channel,
+        },
+    });
+    const detectCyclic = () => {
+        const maxPatternLength = Math.floor(size / minRepetitions);
+        for (let patternLength = minPatternTokens; patternLength <= maxPatternLength; patternLength += 1) {
+            const blockStart = size - patternLength;
+            let repeats = true;
+            for (let repeat = 1; repeat < minRepetitions; repeat += 1) {
+                const start = size - (repeat + 1) * patternLength;
+                if (!rangeHashesEqual(start, blockStart, patternLength)) {
+                    repeats = false;
+                    break;
+                }
+            }
+            if (!repeats) {
+                continue;
+            }
+            if (exactBlocksMatch(patternLength)) {
+                return fail('cyclic', sliceTokens(blockStart, size));
+            }
+        }
+        return undefined;
+    };
+    const push = (text) => {
+        if (text.length === 0) {
+            return { ok: true };
+        }
+        const previous = size === 0 ? undefined : tokenAt(size - 1);
+        consecutiveCount = previous === text ? consecutiveCount + 1 : 1;
+        if (size === capacity) {
+            dropOldest();
+        }
+        const physical = physicalIndex(size);
+        tokens[physical] = text;
+        hashes1[physical] = hashString(text, FNV_OFFSET1);
+        hashes2[physical] = hashString(text, FNV_OFFSET2);
+        size += 1;
+        appendPrefix(physical);
+        if (consecutiveCount >= consecutiveThreshold) {
+            const start = Math.max(0, size - consecutiveCount);
+            return fail('consecutive', sliceTokens(start, size));
+        }
+        return detectCyclic() ?? { ok: true };
+    };
+    return {
+        get hashLookups() {
+            return stats.hashLookups;
+        },
+        get exactCompareTokenVisits() {
+            return stats.exactCompareTokenVisits;
+        },
+        push,
+    };
+};

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

@@ -1,3 +1,4 @@
+import { autokickKickUserTurn } from './autokick-recovery.js';
 const assertNever = (value) => {
     throw new Error(`Unhandled LLM loop action: ${JSON.stringify(value)}`);
 };
@@ -81,6 +82,17 @@ export const reduceLlmLoop = (state, action) => {
                     idleMs: action.idleMs,
                 },
             };
+        case 'stream.dead-loop':
+            return {
+                ...state,
+                phase: 'suspended',
+                committedMessages: [...state.roundCheckpoint],
+                suspendedBy: {
+                    kind: 'dead-loop',
+                    channel: action.channel,
+                    reason: action.reason,
+                },
+            };
         case 'provider.failed':
             return {
                 ...state,
@@ -144,6 +156,27 @@ export const reduceLlmLoop = (state, action) => {
                 suspendedBy: undefined,
                 failure: undefined,
             };
+        case 'autokick.scheduled':
+            return {
+                ...state,
+                phase: 'prepare',
+                committedMessages: action.kickUserMessage === undefined
+                    ? [...state.roundCheckpoint]
+                    : [
+                        ...state.roundCheckpoint,
+                        autokickKickUserTurn(action.kickUserMessage),
+                    ],
+                autokickAttempts: state.autokickAttempts + 1,
+                autokickKickAttempts: action.kickUserMessage === undefined
+                    ? state.autokickKickAttempts
+                    : state.autokickKickAttempts + 1,
+                lastAutokickAt: action.atMs,
+                transientAttempts: 0,
+                partial: { reasoning: '', draft: '' },
+                pendingToolCalls: [],
+                suspendedBy: undefined,
+                failure: undefined,
+            };
         case 'steer.received': {
             const text = action.text?.trim() ?? '';
             const messages = text.length === 0
@@ -158,6 +191,9 @@ export const reduceLlmLoop = (state, action) => {
                 committedMessages: messages,
                 roundCheckpoint: messages,
                 transientAttempts: 0,
+                autokickAttempts: 0,
+                autokickKickAttempts: 0,
+                lastAutokickAt: undefined,
                 partial: { reasoning: '', draft: '' },
                 pendingToolCalls: [],
                 suspendedBy: undefined,

package/vendor/common-nodes/dist/ai/llm-loop/llm-loop-types.d.ts

@@ -13,6 +13,10 @@ type LlmSuspendReason = {
 } | {
     readonly kind: 'stream-idle';
     readonly idleMs: number;
+} | {
+    readonly kind: 'dead-loop';
+    readonly channel: 'reasoning' | 'draft';
+    readonly reason: 'consecutive' | 'cyclic';
 } | {
     readonly kind: 'provider-failure';
     readonly failure: LlmFailure;
@@ -30,6 +34,10 @@ export type LlmLoopState = {
         readonly toolCalls?: readonly ChatCompletionToolCall[];
     };
     readonly pendingToolCalls: readonly ChatCompletionToolCall[];
+    readonly autokickAttempts: number;
+    /** Kick-mode autokicks only; HTTP join does not bump penalties. */
+    readonly autokickKickAttempts: number;
+    readonly lastAutokickAt?: number | undefined;
     readonly openSpawnCallId?: string | undefined;
     readonly suspendedBy?: LlmSuspendReason | undefined;
     readonly failure?: LlmFailure | undefined;
@@ -52,6 +60,10 @@ export type LlmLoopAction = {
 } | {
     readonly type: 'stream.idle';
     readonly idleMs: number;
+} | {
+    readonly type: 'stream.dead-loop';
+    readonly channel: 'reasoning' | 'draft';
+    readonly reason: 'consecutive' | 'cyclic';
 } | {
     readonly type: 'provider.failed';
     readonly failure: LlmFailure;
@@ -66,6 +78,11 @@ export type LlmLoopAction = {
     readonly type: 'subagent.completed';
 } | {
     readonly type: 'retry.scheduled';
+} | {
+    readonly type: 'autokick.scheduled';
+    /** Omit for HTTP replay-only (no kick user turn). */
+    readonly kickUserMessage?: string;
+    readonly atMs: number;
 } | {
     readonly type: 'steer.received';
     readonly text?: string;
@@ -77,6 +94,12 @@ export type LlmLoopAction = {
 } | {
     readonly type: 'cancel.requested';
 };
+type LlmDeadLoopPolicy = {
+    readonly maxWindowTokens: number;
+    readonly consecutiveThreshold: number;
+    readonly minRepetitions: number;
+    readonly minPatternTokens: number;
+};
 export type LlmRecoveryPolicy = {
     readonly streamIdleTimeoutMs: number;
     readonly toolTimeoutMs: number;
@@ -84,7 +107,19 @@ export type LlmRecoveryPolicy = {
     readonly maxTransientRetries: number;
     readonly retryBaseDelayMs: number;
     readonly maxToolResultChars: number;
+    readonly autokickOnIdle: boolean;
+    readonly deadLoopEnabled: boolean;
+    readonly maxAutokickAttempts: number;
+    readonly autokickBackoffMs: number;
+    readonly autokickMaxBackoffMs: number;
+    readonly autokickUserMessage: string;
+    readonly autokickPenaltyDelta: {
+        readonly frequency: number;
+        readonly presence: number;
+    };
+    readonly deadLoop: LlmDeadLoopPolicy;
 };
+export declare const DEFAULT_AUTOKICK_USER_MESSAGE = "I notice you are repeating yourself. Please stop and provide a concise answer.";
 export declare const DEFAULT_LLM_RECOVERY_POLICY: LlmRecoveryPolicy;
 export declare const initialLlmLoopState: (messages: readonly ChatCompletionMessage[]) => LlmLoopState;
 export {};