dsh-client-auto-continue 0.7.1 → 0.7.3

package/lib/index.js

@@ -45,10 +45,14 @@ var AutoContinueSchema = z.object({
   loopGuard: z.boolean().default(true),
   /** A model message shorter than this many chars counts as a short sentence (loop signal). */
   loopShortChars: z.natural().min(1).default(40),
-  /** Consecutive short sentences with no tool call in between trip the loop guard. */
-  loopShortCount: z.natural().min(2).default(8),
-  /** Consecutive identical tool calls trip the loop guard. */
-  loopToolRepeat: z.natural().min(2).default(4),
+  /** Consecutive short sentences within this window (ms) with no tool call in between trip the loop guard. */
+  loopWindowMs: z.natural().min(1e3).default(3e4),
+  /** Consecutive short sentences trip the loop guard. */
+  loopShortCount: z.natural().min(2).default(12),
+  /** Consecutive identical short sentences trip the loop guard (strongest spinning signal). */
+  loopRepeatText: z.natural().min(2).default(4),
+  /** Consecutive identical tool calls with identical arguments AND results trip the loop guard. */
+  loopToolRepeat: z.natural().min(2).default(5),
   /** Text sent after the loop guard cancels and restarts a turn (supports {tool}). */
   loopText: z.string().default("(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)")
 });

package/lib/types/client/engine.d.ts

@@ -55,10 +55,14 @@ export interface AutoContinueSettings {
     loopGuard?: boolean;
     /** A model message shorter than this many chars counts as a "short sentence" (loop signal). */
     loopShortChars?: number;
-    /** Consecutive short sentences with no tool call in between trip the loop guard. */
+    /** Consecutive short sentences within this window (ms) with no tool call in between trip the loop guard. */
+    loopWindowMs?: number;
+    /** Consecutive short sentences trip the loop guard. */
     loopShortCount?: number;
-    /** Consecutive identical tool calls trip the loop guard. */
+    /** Consecutive identical tool calls with identical arguments AND identical results trip the loop guard. */
     loopToolRepeat?: number;
+    /** Consecutive identical short sentences trip the loop guard (strongest spinning signal). */
+    loopRepeatText?: number;
     /** Text sent after the loop guard cancels and restarts a turn (supports {tool}). */
     loopText?: string;
 }
@@ -186,8 +190,9 @@ export declare class AutoContinueRunner {
     /** 从 assistant/message 事件提取纯文本。 */
     private assistantText;
     /**
-     * loop guard 信号 1(空转): 连续短句且期间无工具调用。
-     * 短句 = 模型消息文本短于 loopShortChars; 长句或工具调用都会重置计数。
+     * loop guard 信号 1(空转): 时间窗内连续短句且期间无工具调用。
+     * 短句 = 模型消息文本短于 loopShortChars; 长句、工具调用、或短句间隔超过
+     * loopWindowMs(正常思考的短文本散布在长时间里)都会重置计数。
      */
     private onAssistantMessage;
     /** 两个循环信号的公共检查; 命中且本回合未打断过则打断。 */

package/lib/types/client/locales.d.ts

@@ -56,8 +56,12 @@ export declare const zh: {
     'field.loopGuardHint': string;
     'field.loopShortChars': string;
     'field.loopShortCharsHint': string;
+    'field.loopWindowMs': string;
+    'field.loopWindowMsHint': string;
     'field.loopShortCount': string;
     'field.loopShortCountHint': string;
+    'field.loopRepeatText': string;
+    'field.loopRepeatTextHint': string;
     'field.loopToolRepeat': string;
     'field.loopToolRepeatHint': string;
     'field.loopText': string;

package/lib/types/client/settings-card.d.ts

@@ -25,7 +25,9 @@ export interface AutoContinueSettingsCardState extends CardShell {
     notify: CardFieldState;
     loopGuard: CardFieldState;
     loopShortChars: CardFieldState;
+    loopWindowMs: CardFieldState;
     loopShortCount: CardFieldState;
+    loopRepeatText: CardFieldState;
     loopToolRepeat: CardFieldState;
     loopText: CardFieldState;
 }

package/lib/types/index.d.ts

@@ -51,9 +51,13 @@ export declare const AutoContinueSchema: z<Schemastery.ObjectS<{
     loopGuard: z<boolean, boolean>;
     /** A model message shorter than this many chars counts as a short sentence (loop signal). */
     loopShortChars: z<number, number>;
-    /** Consecutive short sentences with no tool call in between trip the loop guard. */
+    /** Consecutive short sentences within this window (ms) with no tool call in between trip the loop guard. */
+    loopWindowMs: z<number, number>;
+    /** Consecutive short sentences trip the loop guard. */
     loopShortCount: z<number, number>;
-    /** Consecutive identical tool calls trip the loop guard. */
+    /** Consecutive identical short sentences trip the loop guard (strongest spinning signal). */
+    loopRepeatText: z<number, number>;
+    /** Consecutive identical tool calls with identical arguments AND results trip the loop guard. */
     loopToolRepeat: z<number, number>;
     /** Text sent after the loop guard cancels and restarts a turn (supports {tool}). */
     loopText: z<string, string>;
@@ -100,9 +104,13 @@ export declare const AutoContinueSchema: z<Schemastery.ObjectS<{
     loopGuard: z<boolean, boolean>;
     /** A model message shorter than this many chars counts as a short sentence (loop signal). */
     loopShortChars: z<number, number>;
-    /** Consecutive short sentences with no tool call in between trip the loop guard. */
+    /** Consecutive short sentences within this window (ms) with no tool call in between trip the loop guard. */
+    loopWindowMs: z<number, number>;
+    /** Consecutive short sentences trip the loop guard. */
     loopShortCount: z<number, number>;
-    /** Consecutive identical tool calls trip the loop guard. */
+    /** Consecutive identical short sentences trip the loop guard (strongest spinning signal). */
+    loopRepeatText: z<number, number>;
+    /** Consecutive identical tool calls with identical arguments AND results trip the loop guard. */
     loopToolRepeat: z<number, number>;
     /** Text sent after the loop guard cancels and restarts a turn (supports {tool}). */
     loopText: z<string, string>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-client-auto-continue",
   "description": "DSH Web UI plugin: automatically sends \"继续\" (continue) when a request is interrupted by network errors or other non-human causes",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/client/engine.ts

@@ -64,10 +64,14 @@ export interface AutoContinueSettings {
   loopGuard?: boolean;
   /** A model message shorter than this many chars counts as a "short sentence" (loop signal). */
   loopShortChars?: number;
-  /** Consecutive short sentences with no tool call in between trip the loop guard. */
+  /** Consecutive short sentences within this window (ms) with no tool call in between trip the loop guard. */
+  loopWindowMs?: number;
+  /** Consecutive short sentences trip the loop guard. */
   loopShortCount?: number;
-  /** Consecutive identical tool calls trip the loop guard. */
+  /** Consecutive identical tool calls with identical arguments AND identical results trip the loop guard. */
   loopToolRepeat?: number;
+  /** Consecutive identical short sentences trip the loop guard (strongest spinning signal). */
+  loopRepeatText?: number;
   /** Text sent after the loop guard cancels and restarts a turn (supports {tool}). */
   loopText?: string;
 }
@@ -98,8 +102,10 @@ export const DEFAULT_CONFIG: AutoContinueConfig = {
   paused: false,
   loopGuard: true,
   loopShortChars: 40,
-  loopShortCount: 8,
-  loopToolRepeat: 4,
+  loopWindowMs: 30000,
+  loopShortCount: 12,
+  loopRepeatText: 4,
+  loopToolRepeat: 5,
   loopText: '(检测到你可能陷入循环, 请停止重复刚才的动作, 换一种方式继续)',
 };
 
@@ -152,7 +158,9 @@ export function resolveConfig(section: AutoContinueSettings | undefined): AutoCo
     paused: booleanOr(value.paused, DEFAULT_CONFIG.paused),
     loopGuard: booleanOr(value.loopGuard, DEFAULT_CONFIG.loopGuard),
     loopShortChars: Math.max(1, numberOr(value.loopShortChars, DEFAULT_CONFIG.loopShortChars)),
+    loopWindowMs: Math.max(1000, numberOr(value.loopWindowMs, DEFAULT_CONFIG.loopWindowMs)),
     loopShortCount: Math.max(2, numberOr(value.loopShortCount, DEFAULT_CONFIG.loopShortCount)),
+    loopRepeatText: Math.max(2, numberOr(value.loopRepeatText, DEFAULT_CONFIG.loopRepeatText)),
     loopToolRepeat: Math.max(2, numberOr(value.loopToolRepeat, DEFAULT_CONFIG.loopToolRepeat)),
     loopText:
       typeof value.loopText === 'string' && value.loopText.trim() !== ''
@@ -596,8 +604,28 @@ interface SessionState {
   pendingRecoveryAt: number;
   /** 当前连续短句数(loop guard 信号 1: 空转)。 */
   shortRun: number;
-  /** 当前连续相同工具调用(loop guard 信号 2: 死循环)。 */
-  toolRun: { name: string; count: number } | undefined;
+  /** 最后一条短句的时间(时间窗判定用)。 */
+  lastShortAt: number;
+  /** 最后一条模型消息的文本(相同文本重复判定用)。 */
+  lastAssistantText: string;
+  /** 连续相同文本消息数(最强空转信号, 不限长度)。 */
+  sameTextRun: number;
+  /**
+   * 工具重复信号(loop guard 信号 2: 死循环)。
+   * 只有「同工具 + 同参数 + 同结果」的连续调用才累计; 参数或结果有变化视为有进展, 计数重置。
+   */
+  toolRun:
+    | {
+        /** 工具名 + 参数(用于判定是否同一调用)。 */
+        key: string;
+        /** 连续相同调用数(结果确认后更新)。 */
+        count: number;
+        /** 上次该调用的结果摘要(比较用)。 */
+        lastResult: string | undefined;
+        /** 本次调用等待结果确认。 */
+        waiting: boolean;
+      }
+    | undefined;
   /** 本回合已触发过 loop guard(防重复打断)。 */
   loopFired: boolean;
   /** 我们主动 cancel 过本回合(区分用户停止)。 */
@@ -620,6 +648,9 @@ const freshState = (): SessionState => ({
   lastTurn: undefined,
   pendingRecoveryAt: 0,
   shortRun: 0,
+  lastShortAt: 0,
+  lastAssistantText: '',
+  sameTextRun: 0,
   toolRun: undefined,
   loopFired: false,
   loopCancelled: false,
@@ -769,19 +800,35 @@ export class AutoContinueRunner {
             const state = this.state(frame.sessionId);
             state.lastTool = name;
             state.lastToolResult = 'pending'; // 已发起, 尚未见结果
-            // loop guard 信号 2: 连续相同工具调用(工具调用 = 有进展, 重置短句信号)
+            // loop guard 信号 2: 同工具+同参数才可能是循环; 参数变化 = 有进展
+            // (工具调用本身也重置短句信号)。计数在结果确认后才推进。
             state.shortRun = 0;
-            if (state.toolRun?.name === name) {
-              state.toolRun.count += 1;
+            const key = `${name}\n${frame.event.data.arguments}`;
+            if (state.toolRun?.key === key) {
+              state.toolRun.waiting = true; // 结果到达时与上次结果比较
             } else {
-              state.toolRun = { name, count: 1 };
+              state.toolRun = { key, count: 1, lastResult: undefined, waiting: false };
             }
-            this.checkLoop(frame.sessionId, state);
           }
         } else if (frame.event.type === 'tool/result') {
           const state = this.state(frame.sessionId);
           if (state.lastToolResult === 'pending') {
-            state.lastToolResult = toolResultFacts(frame.event.data);
+            const facts = toolResultFacts(frame.event.data);
+            state.lastToolResult = facts;
+            // 结果确认: 与上次相同 → 计数推进; 不同 → 有进展, 重置
+            const run = state.toolRun;
+            if (run !== undefined && run.waiting) {
+              run.waiting = false;
+              if (run.lastResult !== undefined && run.lastResult === facts.excerpt) {
+                run.count += 1;
+                this.checkLoop(frame.sessionId, state);
+              } else {
+                run.lastResult = facts.excerpt;
+                run.count = 1;
+              }
+            } else if (run !== undefined && !run.waiting) {
+              run.lastResult = facts.excerpt;
+            }
           }
         } else if (frame.event.type === 'assistant/message') {
           const state = this.state(frame.sessionId);
@@ -812,8 +859,9 @@ export class AutoContinueRunner {
   }
 
   /**
-   * loop guard 信号 1(空转): 连续短句且期间无工具调用。
-   * 短句 = 模型消息文本短于 loopShortChars; 长句或工具调用都会重置计数。
+   * loop guard 信号 1(空转): 时间窗内连续短句且期间无工具调用。
+   * 短句 = 模型消息文本短于 loopShortChars; 长句、工具调用、或短句间隔超过
+   * loopWindowMs(正常思考的短文本散布在长时间里)都会重置计数。
    */
   private onAssistantMessage(
     sessionId: SessionId,
@@ -822,10 +870,26 @@ export class AutoContinueRunner {
   ): void {
     if (!this.getConfig().loopGuard) return;
     const text = this.assistantText(event);
-    if (text.trim().length < this.getConfig().loopShortChars) {
+    const trimmed = text.trim();
+    // 相同文本重复(不限长度): 模型反复输出完全相同的消息是最强的循环信号,
+    // 例如 "Let me test variants of the regex..." 连续 7 遍
+    if (trimmed !== '' && trimmed === state.lastAssistantText) {
+      state.sameTextRun += 1;
+    } else {
+      state.lastAssistantText = trimmed;
+      state.sameTextRun = 1;
+    }
+    // 短句计数(长度 < loopShortChars 且落在时间窗内): 空转信号
+    if (trimmed.length < this.getConfig().loopShortChars) {
+      const now = Date.now();
+      if (now - state.lastShortAt > this.getConfig().loopWindowMs) {
+        state.shortRun = 0; // 超过时间窗: 上一次短句太久远, 不算连续
+      }
       state.shortRun += 1;
+      state.lastShortAt = now;
     } else {
       state.shortRun = 0; // 长句 = 有实际输出, 重置
+      state.lastShortAt = 0;
     }
     this.checkLoop(sessionId, state);
   }
@@ -836,11 +900,15 @@ export class AutoContinueRunner {
     if (state.loopFired) return;
     if (!state.running) return; // 只干预运行中的回合
     const config = this.getConfig();
-    if (state.shortRun >= config.loopShortCount) {
+    if (state.sameTextRun >= config.loopRepeatText) {
+      this.log(`检测到空转循环 ${sessionId}: 连续 ${state.sameTextRun} 条相同消息`);
+      void this.interruptLoop(sessionId, state);
+    } else if (state.shortRun >= config.loopShortCount) {
       this.log(`检测到空转循环 ${sessionId}: 连续 ${state.shortRun} 条短句且无工具调用`);
       void this.interruptLoop(sessionId, state);
     } else if (state.toolRun !== undefined && state.toolRun.count >= config.loopToolRepeat) {
-      this.log(`检测到工具死循环 ${sessionId}: 「${state.toolRun.name}」连续 ${state.toolRun.count} 次`);
+      const toolName = state.toolRun.key.split('\n')[0] ?? '?';
+      this.log(`检测到工具死循环 ${sessionId}: 「${toolName}」连续 ${state.toolRun.count} 次(同参数同结果)`);
       void this.interruptLoop(sessionId, state);
     }
   }
@@ -882,6 +950,9 @@ export class AutoContinueRunner {
         state.lastToolResult = undefined;
         // loop guard 状态按回合重置
         state.shortRun = 0;
+        state.lastShortAt = 0;
+        state.lastAssistantText = '';
+        state.sameTextRun = 0;
         state.toolRun = undefined;
         state.loopFired = false;
         state.loopCancelled = false;
@@ -905,6 +976,9 @@ export class AutoContinueRunner {
             state.consecutive = 0;
             state.pendingRecoveryAt = 0;
             state.shortRun = 0;
+            state.lastShortAt = 0;
+            state.lastAssistantText = '';
+            state.sameTextRun = 0;
             state.toolRun = undefined;
             state.lastAttemptAt = 0;
             this.schedule(sessionId, 'loop:aborted');

package/src/client/locales.ts

@@ -57,10 +57,14 @@ export const zh = {
   'field.loopGuardHint': '检测运行中的回合空转: 连续短句且无工具调用, 或连续调用相同工具时, 自动取消并用循环提示文本重启回合。',
   'field.loopShortChars': '短句长度上限 (字符)',
   'field.loopShortCharsHint': '模型消息文本短于该值计为一条短句(空转信号)。',
+  'field.loopWindowMs': '短句时间窗 (ms)',
+  'field.loopWindowMsHint': '连续短句必须落在这个时间窗内; 正常思考的短文本散布在长时间里不会被误判。',
   'field.loopShortCount': '连续短句阈值',
-  'field.loopShortCountHint': '连续多少条短句且期间无工具调用时判定空转循环。',
-  'field.loopToolRepeat': '相同工具连续次数',
-  'field.loopToolRepeatHint': '连续调用同一工具多少次时判定死循环。',
+  'field.loopShortCountHint': '时间窗内连续多少条短句且期间无工具调用时判定空转循环。',
+  'field.loopRepeatText': '相同消息重复次数',
+  'field.loopRepeatTextHint': '连续输出多少条完全相同的消息时判定空转(最强信号, 不限长度, 如模型反复说同一句话)。',
+  'field.loopToolRepeat': '同工具重复次数',
+  'field.loopToolRepeatHint': '同工具+同参数+同结果的连续调用多少次时判定死循环; 参数或结果有变化视为有进展。',
   'field.loopText': '循环提示文本',
   'field.loopTextHint': '打断后重启回合时发送的文本, 支持 {tool} 占位符。',
   'stats.byCode': '按错误码统计',
@@ -143,10 +147,14 @@ export const en: Record<SettingsCardKey, string> = {
   'field.loopGuardHint': 'Detects a running turn spinning in place — many short sentences with no tool calls, or the same tool repeating — cancels it and restarts with the loop text.',
   'field.loopShortChars': 'Short-sentence max (chars)',
   'field.loopShortCharsHint': 'A model message shorter than this counts as a short sentence (spinning signal).',
+  'field.loopWindowMs': 'Short-sentence window (ms)',
+  'field.loopWindowMsHint': 'Consecutive short sentences must land inside this window; normal thinking spread over time is not misjudged.',
   'field.loopShortCount': 'Short-sentence threshold',
-  'field.loopShortCountHint': 'How many consecutive short sentences with no tool call trip the loop guard.',
+  'field.loopShortCountHint': 'How many consecutive short sentences inside the window, with no tool call, trip the loop guard.',
+  'field.loopRepeatText': 'Identical message count',
+  'field.loopRepeatTextHint': 'How many consecutive identical messages trip the guard (strongest signal, any length, e.g. the model repeating the same line).',
   'field.loopToolRepeat': 'Same-tool repeat count',
-  'field.loopToolRepeatHint': 'How many consecutive identical tool calls trip the loop guard.',
+  'field.loopToolRepeatHint': 'How many consecutive calls of the same tool with identical arguments and results trip the loop guard; a changed argument or result counts as progress.',
   'field.loopText': 'Loop text',
   'field.loopTextHint': 'Text sent after the loop guard restarts a turn; supports the {tool} placeholder.',
   'stats.byCode': 'By error code',

package/src/client/settings-card.tsx

@@ -57,7 +57,9 @@ export interface AutoContinueSettingsCardState extends CardShell {
   notify: CardFieldState;
   loopGuard: CardFieldState;
   loopShortChars: CardFieldState;
+  loopWindowMs: CardFieldState;
   loopShortCount: CardFieldState;
+  loopRepeatText: CardFieldState;
   loopToolRepeat: CardFieldState;
   loopText: CardFieldState;
 }
@@ -101,7 +103,9 @@ export class AutoContinueSettingsCardController {
       booleanField('notify'),
       booleanField('loopGuard'),
       numberField('loopShortChars', 1),
+      numberField('loopWindowMs', 1000),
       numberField('loopShortCount', 2),
+      numberField('loopRepeatText', 2),
       numberField('loopToolRepeat', 2),
       textField('loopText'),
     ]);
@@ -132,7 +136,9 @@ export class AutoContinueSettingsCardController {
       notify: this.form.field('notify'),
       loopGuard: this.form.field('loopGuard'),
       loopShortChars: this.form.field('loopShortChars'),
+      loopWindowMs: this.form.field('loopWindowMs'),
       loopShortCount: this.form.field('loopShortCount'),
+      loopRepeatText: this.form.field('loopRepeatText'),
       loopToolRepeat: this.form.field('loopToolRepeat'),
       loopText: this.form.field('loopText'),
     };
@@ -617,6 +623,16 @@ export function AutoContinueSettingsCard(props: AutoContinueSettingsCardProps) {
         onEdit={(text) => props.edit('loopShortChars', text)}
         onReset={() => props.resetField('loopShortChars')}
       />
+      <ValueField
+        id="auto-continue-loop-window-ms"
+        label={t('field.loopWindowMs')}
+        hint={t('field.loopWindowMsHint')}
+        numeric
+        {...shared}
+        {...state.loopWindowMs}
+        onEdit={(text) => props.edit('loopWindowMs', text)}
+        onReset={() => props.resetField('loopWindowMs')}
+      />
       <ValueField
         id="auto-continue-loop-short-count"
         label={t('field.loopShortCount')}
@@ -637,6 +653,16 @@ export function AutoContinueSettingsCard(props: AutoContinueSettingsCardProps) {
         onEdit={(text) => props.edit('loopToolRepeat', text)}
         onReset={() => props.resetField('loopToolRepeat')}
       />
+      <ValueField
+        id="auto-continue-loop-repeat-text"
+        label={t('field.loopRepeatText')}
+        hint={t('field.loopRepeatTextHint')}
+        numeric
+        {...shared}
+        {...state.loopRepeatText}
+        onEdit={(text) => props.edit('loopRepeatText', text)}
+        onReset={() => props.resetField('loopRepeatText')}
+      />
       <ValueField
         id="auto-continue-loop-text"
         label={t('field.loopText')}

package/src/index.ts

@@ -60,10 +60,14 @@ export const AutoContinueSchema = z.object({
   loopGuard: z.boolean().default(true),
   /** A model message shorter than this many chars counts as a short sentence (loop signal). */
   loopShortChars: z.natural().min(1).default(40),
-  /** Consecutive short sentences with no tool call in between trip the loop guard. */
-  loopShortCount: z.natural().min(2).default(8),
-  /** Consecutive identical tool calls trip the loop guard. */
-  loopToolRepeat: z.natural().min(2).default(4),
+  /** Consecutive short sentences within this window (ms) with no tool call in between trip the loop guard. */
+  loopWindowMs: z.natural().min(1000).default(30000),
+  /** Consecutive short sentences trip the loop guard. */
+  loopShortCount: z.natural().min(2).default(12),
+  /** Consecutive identical short sentences trip the loop guard (strongest spinning signal). */
+  loopRepeatText: z.natural().min(2).default(4),
+  /** Consecutive identical tool calls with identical arguments AND results trip the loop guard. */
+  loopToolRepeat: z.natural().min(2).default(5),
   /** Text sent after the loop guard cancels and restarts a turn (supports {tool}). */
   loopText: z
     .string()