langflower 0.0.7 → 0.0.9

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

@@ -1,3 +1,4 @@
+export const DEFAULT_AUTOKICK_USER_MESSAGE = 'I notice you are repeating yourself. Please stop and provide a concise answer.';
 export const DEFAULT_LLM_RECOVERY_POLICY = {
     streamIdleTimeoutMs: 90_000,
     toolTimeoutMs: 60_000,
@@ -5,6 +6,22 @@ export const DEFAULT_LLM_RECOVERY_POLICY = {
     maxTransientRetries: 2,
     retryBaseDelayMs: 1_000,
     maxToolResultChars: 40_000,
+    autokickOnIdle: true,
+    deadLoopEnabled: true,
+    maxAutokickAttempts: 0,
+    autokickBackoffMs: 60_000,
+    autokickMaxBackoffMs: 960_000,
+    autokickUserMessage: DEFAULT_AUTOKICK_USER_MESSAGE,
+    autokickPenaltyDelta: {
+        frequency: 0.3,
+        presence: 0.3,
+    },
+    deadLoop: {
+        maxWindowTokens: 1_000,
+        consecutiveThreshold: 5,
+        minRepetitions: 3,
+        minPatternTokens: 2,
+    },
 };
 export const initialLlmLoopState = (messages) => ({
     phase: 'prepare',
@@ -17,4 +34,6 @@ export const initialLlmLoopState = (messages) => ({
         draft: '',
     },
     pendingToolCalls: [],
+    autokickAttempts: 0,
+    autokickKickAttempts: 0,
 });

package/vendor/common-nodes/dist/ai/llm-loop/normalize-llm-recovery-policy.js

@@ -1,4 +1,4 @@
-import { DEFAULT_LLM_RECOVERY_POLICY, } from './llm-loop-types.js';
+import { DEFAULT_AUTOKICK_USER_MESSAGE, DEFAULT_LLM_RECOVERY_POLICY, } from './llm-loop-types.js';
 const normalizePositiveInteger = (value, fallback, max) => {
     const number = typeof value === 'number' ? value : Number(value);
     if (!Number.isFinite(number) || number < 0) {
@@ -6,11 +6,54 @@ const normalizePositiveInteger = (value, fallback, max) => {
     }
     return Math.min(max, Math.floor(number));
 };
-export const normalizeLlmRecoveryPolicy = (params) => ({
-    streamIdleTimeoutMs: normalizePositiveInteger(params['streamIdleTimeoutMs'], DEFAULT_LLM_RECOVERY_POLICY.streamIdleTimeoutMs, 3_600_000),
-    toolTimeoutMs: normalizePositiveInteger(params['toolTimeoutMs'], DEFAULT_LLM_RECOVERY_POLICY.toolTimeoutMs, 3_600_000),
-    subagentTimeoutMs: normalizePositiveInteger(params['subagentTimeoutMs'], DEFAULT_LLM_RECOVERY_POLICY.subagentTimeoutMs, 86_400_000),
-    maxTransientRetries: normalizePositiveInteger(params['maxTransientRetries'], DEFAULT_LLM_RECOVERY_POLICY.maxTransientRetries, 10),
-    retryBaseDelayMs: normalizePositiveInteger(params['retryBaseDelayMs'], DEFAULT_LLM_RECOVERY_POLICY.retryBaseDelayMs, 60_000),
-    maxToolResultChars: normalizePositiveInteger(params['maxToolResultChars'], DEFAULT_LLM_RECOVERY_POLICY.maxToolResultChars, 1_000_000),
-});
+const normalizeBoolean = (value, fallback) => typeof value === 'boolean' ? value : fallback;
+const normalizePenalty = (value, fallback) => {
+    const number = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(number)) {
+        return fallback;
+    }
+    return Math.min(2, Math.max(-2, number));
+};
+const readRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : undefined;
+const nestedDeadLoop = (params) => readRecord(params['deadLoop']) ?? {};
+const nestedPenalty = (params) => readRecord(params['autokickPenaltyDelta']) ?? {};
+export const normalizeLlmRecoveryPolicy = (params) => {
+    const deadLoop = nestedDeadLoop(params);
+    const penalty = nestedPenalty(params);
+    const autokickBackoffMs = Math.max(1_000, normalizePositiveInteger(params['autokickBackoffMs'], DEFAULT_LLM_RECOVERY_POLICY.autokickBackoffMs, 3_600_000));
+    const autokickMaxBackoffMs = Math.max(autokickBackoffMs, normalizePositiveInteger(params['autokickMaxBackoffMs'], DEFAULT_LLM_RECOVERY_POLICY.autokickMaxBackoffMs, 3_600_000));
+    const kick = typeof params['autokickUserMessage'] === 'string' &&
+        params['autokickUserMessage'].trim().length > 0
+        ? params['autokickUserMessage'].trim()
+        : DEFAULT_AUTOKICK_USER_MESSAGE;
+    return {
+        streamIdleTimeoutMs: normalizePositiveInteger(params['streamIdleTimeoutMs'], DEFAULT_LLM_RECOVERY_POLICY.streamIdleTimeoutMs, 3_600_000),
+        toolTimeoutMs: normalizePositiveInteger(params['toolTimeoutMs'], DEFAULT_LLM_RECOVERY_POLICY.toolTimeoutMs, 3_600_000),
+        subagentTimeoutMs: normalizePositiveInteger(params['subagentTimeoutMs'], DEFAULT_LLM_RECOVERY_POLICY.subagentTimeoutMs, 86_400_000),
+        maxTransientRetries: normalizePositiveInteger(params['maxTransientRetries'], DEFAULT_LLM_RECOVERY_POLICY.maxTransientRetries, 10),
+        retryBaseDelayMs: normalizePositiveInteger(params['retryBaseDelayMs'], DEFAULT_LLM_RECOVERY_POLICY.retryBaseDelayMs, 60_000),
+        maxToolResultChars: normalizePositiveInteger(params['maxToolResultChars'], DEFAULT_LLM_RECOVERY_POLICY.maxToolResultChars, 1_000_000),
+        autokickOnIdle: normalizeBoolean(params['autokickOnIdle'], DEFAULT_LLM_RECOVERY_POLICY.autokickOnIdle),
+        deadLoopEnabled: normalizeBoolean(params['deadLoopEnabled'], DEFAULT_LLM_RECOVERY_POLICY.deadLoopEnabled),
+        maxAutokickAttempts: normalizePositiveInteger(params['maxAutokickAttempts'], DEFAULT_LLM_RECOVERY_POLICY.maxAutokickAttempts, 1_000),
+        autokickBackoffMs,
+        autokickMaxBackoffMs,
+        autokickUserMessage: kick,
+        autokickPenaltyDelta: {
+            frequency: normalizePenalty(penalty['frequency'] ?? params['autokickPenaltyFrequency'], DEFAULT_LLM_RECOVERY_POLICY.autokickPenaltyDelta.frequency),
+            presence: normalizePenalty(penalty['presence'] ?? params['autokickPenaltyPresence'], DEFAULT_LLM_RECOVERY_POLICY.autokickPenaltyDelta.presence),
+        },
+        deadLoop: {
+            maxWindowTokens: Math.min(8_000, Math.max(10, normalizePositiveInteger(deadLoop['maxWindowTokens'] ??
+                params['deadLoopMaxWindowTokens'], DEFAULT_LLM_RECOVERY_POLICY.deadLoop.maxWindowTokens, 8_000))),
+            consecutiveThreshold: Math.max(1, normalizePositiveInteger(deadLoop['consecutiveThreshold'] ??
+                params['deadLoopConsecutiveThreshold'], DEFAULT_LLM_RECOVERY_POLICY.deadLoop.consecutiveThreshold, 100)),
+            minRepetitions: Math.max(1, normalizePositiveInteger(deadLoop['minRepetitions'] ??
+                params['deadLoopMinRepetitions'], DEFAULT_LLM_RECOVERY_POLICY.deadLoop.minRepetitions, 20)),
+            minPatternTokens: Math.max(1, normalizePositiveInteger(deadLoop['minPatternTokens'] ??
+                params['deadLoopMinPatternTokens'], DEFAULT_LLM_RECOVERY_POLICY.deadLoop.minPatternTokens, 100)),
+        },
+    };
+};

package/vendor/common-nodes/dist/ai/llm-loop/operators/observe-provider-stream.d.ts

@@ -1,6 +1,7 @@
 import type { SteerControlPayload } from '@langflower/node-sdk/llm';
 import { type Observable } from 'rxjs';
 import type { ChatCompletionFinishReason, ChatCompletionStreamChunk, ChatCompletionToolCall } from '../../chat-completion-stream.js';
+import { type DeadLoopChannel, type DeadLoopDetectorOptions } from '../dead-loop-detector.js';
 import type { LlmFailure } from '../llm-loop-types.js';
 export type ProviderStreamFact = {
     readonly kind: 'provider.reasoning';
@@ -18,6 +19,10 @@ export type ProviderStreamFact = {
 } | {
     readonly kind: 'provider.idle';
     readonly idleMs: number;
+} | {
+    readonly kind: 'provider.dead-loop';
+    readonly channel: DeadLoopChannel;
+    readonly reason: 'consecutive' | 'cyclic';
 } | {
     readonly kind: 'provider.failed';
     readonly failure: LlmFailure;
@@ -28,10 +33,11 @@ export type ObserveProviderStreamOptions = {
     readonly cancel$: Observable<void>;
     readonly idleTimeoutMs: number;
     readonly onAbort?: () => void;
+    readonly deadLoop?: DeadLoopDetectorOptions | false;
 };
 /**
  * Convert the provider AsyncIterable into typed, cancellable RxJS facts.
- * Pause and idle are terminal for one provider attempt, not terminal for the
- * surrounding LLM loop.
+ * Pause, idle, and dead-loop are terminal for one provider attempt, not
+ * terminal for the surrounding LLM loop.
  */
 export declare const observeProviderStream: (options: ObserveProviderStreamOptions) => Observable<ProviderStreamFact>;

package/vendor/common-nodes/dist/ai/llm-loop/operators/observe-provider-stream.js

@@ -1,6 +1,7 @@
 import { isSteerControlPause } from '@langflower/node-sdk/llm';
-import { catchError, defer, endWith, filter, finalize, from, map, merge, of, switchMap, take, takeUntil, takeWhile, tap, timeout, } from 'rxjs';
+import { catchError, concatMap, defer, endWith, filter, finalize, from, map, merge, of, switchMap, take, takeUntil, takeWhile, tap, timeout, } from 'rxjs';
 import { classifyLlmFailure } from '../classify-llm-failure.js';
+import { createDeadLoopDetector, } from '../dead-loop-detector.js';
 const toProviderStreamFact = (chunk) => {
     switch (chunk.kind) {
         case 'reasoning':
@@ -23,32 +24,62 @@ const toProviderStreamFact = (chunk) => {
 const isTerminalProviderFact = (fact) => fact.kind === 'provider.done' ||
     fact.kind === 'provider.paused' ||
     fact.kind === 'provider.idle' ||
+    fact.kind === 'provider.dead-loop' ||
     fact.kind === 'provider.failed';
-const withIdleTimeout = (source$, idleTimeoutMs) => {
+const withIdleTimeout = (source$, idleTimeoutMs, onIdle) => {
     if (idleTimeoutMs <= 0) {
         return source$;
     }
     return source$.pipe(timeout({
         first: idleTimeoutMs,
         each: idleTimeoutMs,
-        with: () => of({
-            kind: 'provider.idle',
-            idleMs: idleTimeoutMs,
-        }),
+        with: () => {
+            onIdle();
+            return of({
+                kind: 'provider.idle',
+                idleMs: idleTimeoutMs,
+            });
+        },
     }));
 };
+const guardDeadLoop = (fact, detectors, abort) => {
+    if (detectors === undefined ||
+        (fact.kind !== 'provider.reasoning' && fact.kind !== 'provider.draft')) {
+        return of(fact);
+    }
+    const channel = fact.kind === 'provider.reasoning' ? 'reasoning' : 'draft';
+    const detected = detectors[channel].push(fact.text);
+    if (detected.ok) {
+        return of(fact);
+    }
+    abort();
+    return of(fact, {
+        kind: 'provider.dead-loop',
+        channel: detected.error.channel,
+        reason: detected.error.reason,
+    });
+};
 /**
  * Convert the provider AsyncIterable into typed, cancellable RxJS facts.
- * Pause and idle are terminal for one provider attempt, not terminal for the
- * surrounding LLM loop.
+ * Pause, idle, and dead-loop are terminal for one provider attempt, not
+ * terminal for the surrounding LLM loop.
  */
 export const observeProviderStream = (options) => defer(() => {
     const abort = new AbortController();
-    const pause$ = options.pause$.pipe(filter(isSteerControlPause), take(1), tap(() => {
+    const stopProvider = () => {
         abort.abort();
         options.onAbort?.();
+    };
+    const detectors = options.deadLoop === false
+        ? undefined
+        : {
+            reasoning: createDeadLoopDetector('reasoning', options.deadLoop ?? {}),
+            draft: createDeadLoopDetector('draft', options.deadLoop ?? {}),
+        };
+    const pause$ = options.pause$.pipe(filter(isSteerControlPause), take(1), tap(() => {
+        stopProvider();
     }), map(() => ({ kind: 'provider.paused' })));
-    const chunks$ = withIdleTimeout(from(options.createStream(abort.signal)).pipe(switchMap((stream) => from(stream)), map(toProviderStreamFact), catchError((error) => of({
+    const chunks$ = withIdleTimeout(from(options.createStream(abort.signal)).pipe(switchMap((stream) => from(stream)), concatMap((chunk) => guardDeadLoop(toProviderStreamFact(chunk), detectors, stopProvider)), catchError((error) => of({
         kind: 'provider.failed',
         failure: classifyLlmFailure(error),
     })), endWith({
@@ -58,9 +89,8 @@ export const observeProviderStream = (options) => defer(() => {
             message: 'Provider stream completed without a done chunk.',
             recoverable: true,
         },
-    })), options.idleTimeoutMs);
+    })), options.idleTimeoutMs, stopProvider);
     return merge(chunks$, pause$).pipe(takeWhile((fact) => !isTerminalProviderFact(fact), true), takeUntil(options.cancel$), finalize(() => {
-        abort.abort();
-        options.onAbort?.();
+        stopProvider();
     }));
 });

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

@@ -1,5 +1,5 @@
 import type { ToolHandle } from '@langflower/node-sdk';
-import { type SteerControlPayload } from '@langflower/node-sdk/llm';
+import { type LlmRecoveryNotice, type SteerControlPayload } from '@langflower/node-sdk/llm';
 import type { Harness } from '@langflower/tools/create-project-harness';
 import type { ToolHandlerContext } from '@langflower/tools/domain-tool-configs';
 import type { PermissionAskRequest } from '@langflower/tools/permission';
@@ -17,11 +17,9 @@ export type SharedLlmLoopChunk = {
 } | {
     readonly kind: 'toolLog';
     readonly text: string;
-} | {
+} | ({
     readonly kind: 'recoveryNotice';
-    readonly code: 'retry' | 'suspended';
-    readonly text: string;
-} | {
+} & LlmRecoveryNotice) | {
     readonly kind: 'historySync';
     readonly messages: readonly ChatCompletionMessage[];
 } | {

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

@@ -4,6 +4,7 @@ import { invokeInventoryTool, previewToolLogText, resolveSpawnPayload, SPAWN_SUB
 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';
@@ -17,6 +18,10 @@ 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();
@@ -39,6 +44,61 @@ const isOutputTruncation = (fact) => {
     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({
@@ -65,12 +125,31 @@ const recoveryPackets = (state, failure, options) => {
         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',
@@ -165,6 +244,12 @@ const providerFactAction = (fact) => {
             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;
     }
@@ -198,14 +283,32 @@ const providerFactPackets = (frame, options) => {
             };
             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: `⚠ ${failure.message} Paused to avoid repeating partial work.`,
+                    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': {
@@ -292,6 +395,9 @@ const prepareAndStream = (state, options, cancel$, cancelSignal) => {
         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,
@@ -300,6 +406,12 @@ const prepareAndStream = (state, options, cancel$, cancelSignal) => {
             tools: options.chatTools,
             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({
@@ -360,6 +472,9 @@ const prepareAndStream = (state, options, cancel$, cancelSignal) => {
                 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 {

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

@@ -28,4 +28,86 @@ export declare const llmRecoveryUiSchema: readonly [{
     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/llm-recovery-ui-schema.js

@@ -1,3 +1,4 @@
+import { DEFAULT_LLM_RECOVERY_POLICY } from './llm-loop/llm-loop-types.js';
 /** Shared Inspector fields for provider/tool recovery policy. */
 export const llmRecoveryUiSchema = [
     {
@@ -33,4 +34,98 @@ export const llmRecoveryUiSchema = [
         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/llm-session-shell.d.ts

@@ -2,7 +2,7 @@ import type { ToolHandle, configureOutput, makeInput } from '@langflower/node-sd
 import type { ToolHandlerContext } from '@langflower/tools/domain-tool-configs';
 import type { PermissionAskRequest } from '@langflower/tools/permission';
 import type { ChatCompletionMessage } from './chat-completion-stream.js';
-import type { LlmInventoryInputs, SteerControlPayload } from '@langflower/node-sdk/llm';
+import { type LlmInventoryInputs, type LlmRecoveryNotice, type SteerControlPayload } from '@langflower/node-sdk/llm';
 import type { PortMeta } from '@langflower/node-sdk';
 import type { combineStatefulObservables, StatefulObservable } from '@rx-evo/stateful-observable';
 import { type Observable, type OperatorFunction } from 'rxjs';
@@ -67,11 +67,9 @@ type StandardLlmAgentChunk = {
 } | {
     readonly kind: 'toolLog';
     readonly text: string;
-} | {
+} | ({
     readonly kind: 'recoveryNotice';
-    readonly code: 'retry' | 'suspended';
-    readonly text: string;
-} | {
+} & LlmRecoveryNotice) | {
     readonly kind: 'response';
     readonly text: string;
 } | {
@@ -142,10 +140,7 @@ export declare const bindLlmAgentSession: <Context extends LlmAgentInventoryCont
     outputs: StatefulObservable<string, unknown, import("@langflower/node-sdk").OutputParams & PortMeta>[];
     inventoryOutputs: {
         toolLog$: StatefulObservable<string, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
-        recovery$: StatefulObservable<{
-            code: "suspended" | "retry";
-            text: string;
-        }, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
+        recovery$: StatefulObservable<LlmRecoveryNotice, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
         subagent$: StatefulObservable<SubAgentSpawnPayload, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
     };
 };