dsh-client-auto-continue 0.5.7 → 0.6.0

package/lib/index.js

@@ -7,6 +7,12 @@ var AutoContinueSchema = z.object({
   continueText: z.string().default("继续"),
   /** Text sent when the output token ceiling is reached (same placeholders as `continueText`). */
   continueTextMaxTokens: z.string().default("继续"),
+  /** Idempotency guard: inspect the last tool call before resuming and steer the model. */
+  guardTools: z.boolean().default(true),
+  /** Guard text appended when the last tool call has no confirmed result (it may have partially executed). */
+  guardPendingText: z.string().default("(上一步工具「{tool}」可能未完成, 先确认状态再继续, 不要重复执行)"),
+  /** Guard text appended when the last tool call completed successfully (don't rerun it). */
+  guardDoneText: z.string().default("(上一步工具「{tool}」已完成, 结果: {result}; 不要重复执行, 直接继续)"),
   /** Grace period after an interruption before auto-sending (ms). */
   graceMs: z.natural().default(3e3),
   /** Minimum interval between two auto-continues per session (ms). */

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

@@ -17,6 +17,12 @@ export interface AutoContinueSettings {
     continueText?: string;
     /** Text sent when the output token ceiling is reached (same placeholders as `continueText`). */
     continueTextMaxTokens?: string;
+    /** Idempotency guard: inspect the last tool call before resuming and steer the model. */
+    guardTools?: boolean;
+    /** Guard text appended when the last tool call has no confirmed result (it may have partially executed). */
+    guardPendingText?: string;
+    /** Guard text appended when the last tool call completed successfully (don't rerun it). */
+    guardDoneText?: string;
     /** Grace period after an interruption before auto-sending (ms). */
     graceMs?: number;
     /** Minimum interval between two auto-continues per session (ms). */
@@ -99,9 +105,18 @@ export interface TemplateContext {
     sessionTitle?: string;
     /** 自失败发生以来的毫秒数, 对应 {elapsed}。 */
     elapsedMs?: number;
+    /** 上一步工具结果摘要(截断), 对应 {result}(护栏模板用)。 */
+    result?: string;
 }
-/** 用失败事实与回合信息填充 continueText 模板占位符({code}/{message}/{status}/{tool}/{turn}/{errorCount}/{sessionTitle}/{elapsed})。 */
+/** 用失败事实与回合信息填充 continueText 模板占位符({code}/{message}/{status}/{tool}/{turn}/{errorCount}/{sessionTitle}/{elapsed}/{result})。 */
 export declare function fillTemplate(template: string, ctx: TemplateContext): string;
+/** 上一步工具调用的判定结果: 是否已确认完成, 以及文本摘要。 */
+export interface ToolResultFacts {
+    /** 工具是否成功完成(内部失败或 isError 视为未成功)。 */
+    ok: boolean;
+    /** 工具输出的文本摘要(截断)。 */
+    excerpt: string;
+}
 /** 自适应退避: 同一会话连续失败时的有效冷却间隔。 */
 export declare function effectiveCooldown(consecutive: number, base: number, factor: number, max: number): number;
 /** 暂停某会话: 到 `until` 之前, 引擎不会为该会话自动继续(通知按钮等调用)。 */
@@ -172,6 +187,16 @@ export declare class AutoContinueRunner {
     private schedule;
     private cancelPending;
     private fire;
+    /**
+     * 组装本次续跑消息: 模板填充 + 幂等护栏。
+     * 护栏依据上一步工具调用的执行状态附加指引, 防止重跑副作用操作:
+     * - 结果未确认(可能已部分执行)→ 提示先确认状态、不要重复执行
+     * - 已确认成功 → 提示已完成、不要重复执行
+     * - 已失败 → 不加护栏(重试工具本来就是目的)
+     */
+    private buildContinueText;
+    /** 上一步工具调用的护栏状态(实时路径, 由 mux 帧维护)。 */
+    private currentGuard;
     /** 会话标题缓存(来自 session.list 投影, {sessionTitle} 占位符用)。 */
     private readonly titles;
     /** 查一次 session.list, 顺带缓存该会话的标题。 */
@@ -186,4 +211,6 @@ export declare class AutoContinueRunner {
      * @returns 是否成功完成一次扫描(宿主就绪)。
      */
     private scanInterrupted;
+    /** 从历史事件恢复上一步工具调用状态(扫描路径的幂等护栏)。 */
+    private applyGuardFromEvents;
 }

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

@@ -13,6 +13,12 @@ export declare const zh: {
     'field.continueTextHint': string;
     'field.continueTextMaxTokens': string;
     'field.continueTextMaxTokensHint': string;
+    'field.guardTools': string;
+    'field.guardToolsHint': string;
+    'field.guardPendingText': string;
+    'field.guardPendingTextHint': string;
+    'field.guardDoneText': string;
+    'field.guardDoneTextHint': string;
     'field.graceMs': string;
     'field.graceMsHint': string;
     'field.cooldownMs': string;

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

@@ -7,6 +7,9 @@ export interface AutoContinueSettingsCardState extends CardShell {
     paused: CardFieldState;
     continueText: CardFieldState;
     continueTextMaxTokens: CardFieldState;
+    guardTools: CardFieldState;
+    guardPendingText: CardFieldState;
+    guardDoneText: CardFieldState;
     graceMs: CardFieldState;
     cooldownMs: CardFieldState;
     maxConsecutive: CardFieldState;

package/lib/types/index.d.ts

@@ -13,6 +13,12 @@ export declare const AutoContinueSchema: z<Schemastery.ObjectS<{
     continueText: z<string, string>;
     /** Text sent when the output token ceiling is reached (same placeholders as `continueText`). */
     continueTextMaxTokens: z<string, string>;
+    /** Idempotency guard: inspect the last tool call before resuming and steer the model. */
+    guardTools: z<boolean, boolean>;
+    /** Guard text appended when the last tool call has no confirmed result (it may have partially executed). */
+    guardPendingText: z<string, string>;
+    /** Guard text appended when the last tool call completed successfully (don't rerun it). */
+    guardDoneText: z<string, string>;
     /** Grace period after an interruption before auto-sending (ms). */
     graceMs: z<number, number>;
     /** Minimum interval between two auto-continues per session (ms). */
@@ -46,6 +52,12 @@ export declare const AutoContinueSchema: z<Schemastery.ObjectS<{
     continueText: z<string, string>;
     /** Text sent when the output token ceiling is reached (same placeholders as `continueText`). */
     continueTextMaxTokens: z<string, string>;
+    /** Idempotency guard: inspect the last tool call before resuming and steer the model. */
+    guardTools: z<boolean, boolean>;
+    /** Guard text appended when the last tool call has no confirmed result (it may have partially executed). */
+    guardPendingText: z<string, string>;
+    /** Guard text appended when the last tool call completed successfully (don't rerun it). */
+    guardDoneText: z<string, string>;
     /** Grace period after an interruption before auto-sending (ms). */
     graceMs: z<number, number>;
     /** Minimum interval between two auto-continues per session (ms). */

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.5.7",
+  "version": "0.6.0",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/client/engine.ts

@@ -26,6 +26,12 @@ export interface AutoContinueSettings {
   continueText?: string;
   /** Text sent when the output token ceiling is reached (same placeholders as `continueText`). */
   continueTextMaxTokens?: string;
+  /** Idempotency guard: inspect the last tool call before resuming and steer the model. */
+  guardTools?: boolean;
+  /** Guard text appended when the last tool call has no confirmed result (it may have partially executed). */
+  guardPendingText?: string;
+  /** Guard text appended when the last tool call completed successfully (don't rerun it). */
+  guardDoneText?: string;
   /** Grace period after an interruption before auto-sending (ms). */
   graceMs?: number;
   /** Minimum interval between two auto-continues per session (ms). */
@@ -63,6 +69,9 @@ export type AutoContinueConfig = Required<AutoContinueSettings>;
 export const DEFAULT_CONFIG: AutoContinueConfig = {
   continueText: '继续',
   continueTextMaxTokens: '继续',
+  guardTools: true,
+  guardPendingText: '(上一步工具「{tool}」可能未完成, 先确认状态再继续, 不要重复执行)',
+  guardDoneText: '(上一步工具「{tool}」已完成, 结果: {result}; 不要重复执行, 直接继续)',
   graceMs: 3000,
   cooldownMs: 20000,
   maxConsecutive: 3,
@@ -98,9 +107,20 @@ export function resolveConfig(section: AutoContinueSettings | undefined): AutoCo
     typeof value.continueTextMaxTokens === 'string' && value.continueTextMaxTokens.trim() !== ''
       ? value.continueTextMaxTokens
       : DEFAULT_CONFIG.continueTextMaxTokens;
+  const guardPendingText =
+    typeof value.guardPendingText === 'string' && value.guardPendingText.trim() !== ''
+      ? value.guardPendingText
+      : DEFAULT_CONFIG.guardPendingText;
+  const guardDoneText =
+    typeof value.guardDoneText === 'string' && value.guardDoneText.trim() !== ''
+      ? value.guardDoneText
+      : DEFAULT_CONFIG.guardDoneText;
   return {
     continueText: text,
     continueTextMaxTokens: maxTokensText,
+    guardTools: booleanOr(value.guardTools, DEFAULT_CONFIG.guardTools),
+    guardPendingText,
+    guardDoneText,
     graceMs: numberOr(value.graceMs, DEFAULT_CONFIG.graceMs),
     cooldownMs: numberOr(value.cooldownMs, DEFAULT_CONFIG.cooldownMs),
     maxConsecutive: Math.max(1, numberOr(value.maxConsecutive, DEFAULT_CONFIG.maxConsecutive)),
@@ -249,9 +269,11 @@ export interface TemplateContext {
   sessionTitle?: string;
   /** 自失败发生以来的毫秒数, 对应 {elapsed}。 */
   elapsedMs?: number;
+  /** 上一步工具结果摘要(截断), 对应 {result}(护栏模板用)。 */
+  result?: string;
 }
 
-/** 用失败事实与回合信息填充 continueText 模板占位符({code}/{message}/{status}/{tool}/{turn}/{errorCount}/{sessionTitle}/{elapsed})。 */
+/** 用失败事实与回合信息填充 continueText 模板占位符({code}/{message}/{status}/{tool}/{turn}/{errorCount}/{sessionTitle}/{elapsed}/{result})。 */
 export function fillTemplate(template: string, ctx: TemplateContext): string {
   return template
     .replace(/\{code\}/g, ctx.facts?.code ?? '')
@@ -261,7 +283,51 @@ export function fillTemplate(template: string, ctx: TemplateContext): string {
     .replace(/\{turn\}/g, ctx.turn !== undefined ? String(ctx.turn) : '')
     .replace(/\{errorCount\}/g, ctx.errorCount !== undefined ? String(ctx.errorCount) : '')
     .replace(/\{sessionTitle\}/g, ctx.sessionTitle ?? '')
-    .replace(/\{elapsed\}/g, formatElapsed(ctx.elapsedMs));
+    .replace(/\{elapsed\}/g, formatElapsed(ctx.elapsedMs))
+    .replace(/\{result\}/g, ctx.result ?? '');
+}
+
+// ---------- 幂等护栏: 上一步工具调用的执行状态 ----------
+
+/** 工具结果摘要的最大长度(护栏模板 {result} 用)。 */
+const TOOL_RESULT_CAP = 160;
+
+/** 从任意内容块里递归收集文本(结果为模型可见的工具输出)。 */
+function extractText(blocks: unknown, cap: number): string {
+  let out = '';
+  const walk = (value: unknown): void => {
+    if (out.length >= cap) return;
+    if (Array.isArray(value)) {
+      for (const item of value) walk(item);
+      return;
+    }
+    if (typeof value !== 'object' || value === null) return;
+    const record = value as Record<string, unknown>;
+    if (record['type'] === 'text' && typeof record['text'] === 'string') {
+      out += record['text'];
+      return;
+    }
+    for (const child of Object.values(record)) walk(child);
+  };
+  walk(blocks);
+  return out.slice(0, cap);
+}
+
+/** 上一步工具调用的判定结果: 是否已确认完成, 以及文本摘要。 */
+export interface ToolResultFacts {
+  /** 工具是否成功完成(内部失败或 isError 视为未成功)。 */
+  ok: boolean;
+  /** 工具输出的文本摘要(截断)。 */
+  excerpt: string;
+}
+
+/** 从 tool/result 事件载荷提取成功与否与文本摘要。 */
+function toolResultFacts(data: {
+  error?: { name?: string; code?: string };
+  message?: { content?: Array<{ type?: string; content?: unknown; isError?: boolean }> };
+}): ToolResultFacts {
+  const failed = data.error !== undefined || data.message?.content?.[0]?.isError === true;
+  return { ok: !failed, excerpt: extractText(data.message?.content?.[0]?.content, TOOL_RESULT_CAP) };
 }
 
 /** 自适应退避: 同一会话连续失败时的有效冷却间隔。 */
@@ -493,8 +559,10 @@ interface SessionState {
   lastFailure: FailureFacts | undefined;
   /** 最近一次失败的发生时间(模板 {elapsed} 与恢复统计用)。 */
   lastFailureAt: number;
-  /** 失败前最后一次工具调用的名称(模板 {tool})。 */
+  /** 失败前最后一次工具调用的名称(模板 {tool} 与幂等护栏用)。 */
   lastTool: string | undefined;
+  /** 上一步工具调用的结果状态: 'pending' = 已发起未见结果(可能已部分执行)。 */
+  lastToolResult: 'pending' | ToolResultFacts | undefined;
   /** 失败回合的编号(模板 {turn})。 */
   lastTurn: number | undefined;
   /** 我们最近一次自动发送的时间戳; 0 = 没有待确认的恢复。 */
@@ -513,6 +581,7 @@ const freshState = (): SessionState => ({
   lastFailure: undefined,
   lastFailureAt: 0,
   lastTool: undefined,
+  lastToolResult: undefined,
   lastTurn: undefined,
   pendingRecoveryAt: 0,
 });
@@ -657,7 +726,16 @@ export class AutoContinueRunner {
       case 'session/event':
         if (frame.event.type === 'tool/call') {
           const name = frame.event.data.name;
-          if (typeof name === 'string') this.state(frame.sessionId).lastTool = name;
+          if (typeof name === 'string') {
+            const state = this.state(frame.sessionId);
+            state.lastTool = name;
+            state.lastToolResult = 'pending'; // 已发起, 尚未见结果
+          }
+        } else if (frame.event.type === 'tool/result') {
+          const state = this.state(frame.sessionId);
+          if (state.lastToolResult === 'pending') {
+            state.lastToolResult = toolResultFacts(frame.event.data);
+          }
         }
         this.onSessionEvent(frame.sessionId, frame.event);
         break;
@@ -678,6 +756,9 @@ export class AutoContinueRunner {
     switch (event.type) {
       case 'turn/start':
         state.running = true;
+        // 新回合开始: 清空上一步工具调用状态, 避免跨回合误用护栏
+        state.lastTool = undefined;
+        state.lastToolResult = undefined;
         this.cancelPending(sessionId, '宿主自行开启新回合');
         break;
       case 'turn/end': {
@@ -930,14 +1011,7 @@ export class AutoContinueRunner {
         sessionTitle = info?.title;
       }
     }
-    const text = fillTemplate(template, {
-      facts: state.lastFailure,
-      tool: state.lastTool,
-      turn: state.lastTurn,
-      errorCount: state.consecutive + 1,
-      sessionTitle,
-      elapsedMs: state.lastFailureAt > 0 ? Date.now() - state.lastFailureAt : undefined,
-    });
+    const text = this.buildContinueText(config, state, template, sessionTitle);
     const zone = clientTimeZone();
     state.lastAttemptAt = Date.now(); // 先记账: 无论成败, 本次尝试都进入冷却
     try {
@@ -986,6 +1060,51 @@ export class AutoContinueRunner {
     }
   }
 
+  /**
+   * 组装本次续跑消息: 模板填充 + 幂等护栏。
+   * 护栏依据上一步工具调用的执行状态附加指引, 防止重跑副作用操作:
+   * - 结果未确认(可能已部分执行)→ 提示先确认状态、不要重复执行
+   * - 已确认成功 → 提示已完成、不要重复执行
+   * - 已失败 → 不加护栏(重试工具本来就是目的)
+   */
+  private buildContinueText(
+    config: AutoContinueConfig,
+    state: SessionState,
+    template: string,
+    sessionTitle: string | undefined,
+  ): string {
+    let text = fillTemplate(template, {
+      facts: state.lastFailure,
+      tool: state.lastTool,
+      turn: state.lastTurn,
+      errorCount: state.consecutive + 1,
+      sessionTitle,
+      elapsedMs: state.lastFailureAt > 0 ? Date.now() - state.lastFailureAt : undefined,
+    });
+    if (!config.guardTools) return text;
+    const guard = this.currentGuard(state);
+    if (guard.kind === 'pending') {
+      text += ` ${fillTemplate(config.guardPendingText, { tool: guard.tool, result: guard.result })}`;
+    } else if (guard.kind === 'done') {
+      text += ` ${fillTemplate(config.guardDoneText, { tool: guard.tool, result: guard.result })}`;
+    }
+    return text;
+  }
+
+  /** 上一步工具调用的护栏状态(实时路径, 由 mux 帧维护)。 */
+  private currentGuard(state: SessionState): {
+    kind: 'none' | 'pending' | 'done' | 'failed';
+    tool?: string;
+    result?: string;
+  } {
+    if (state.lastTool === undefined || state.lastToolResult === undefined) return { kind: 'none' };
+    if (state.lastToolResult === 'pending') return { kind: 'pending', tool: state.lastTool };
+    if (state.lastToolResult.ok) {
+      return { kind: 'done', tool: state.lastTool, result: state.lastToolResult.excerpt };
+    }
+    return { kind: 'failed', tool: state.lastTool };
+  }
+
   /** 会话标题缓存(来自 session.list 投影, {sessionTitle} 占位符用)。 */
   private readonly titles = new Map<SessionId, string>();
 
@@ -1108,9 +1227,38 @@ export class AutoContinueRunner {
         if (superseded) break;
       }
       if (superseded) continue;
+      // 幂等护栏: 从历史事件里重建上一步工具调用的执行状态
+      this.applyGuardFromEvents(state, events, lastEnd.seq);
       this.log(`扫描发现中断 ${summary.sessionId}(turn/end:${reason.kind}), 安排自动继续`);
       this.schedule(summary.sessionId, `scan:turn/end:${reason.kind}`);
     }
     return true;
   }
+
+  /** 从历史事件恢复上一步工具调用状态(扫描路径的幂等护栏)。 */
+  private applyGuardFromEvents(
+    state: SessionState,
+    events: { event: SessionEvent }[],
+    untilSeq: number,
+  ): void {
+    state.lastTool = undefined;
+    state.lastToolResult = undefined;
+    let call: SessionEvent<'tool/call'> | undefined;
+    for (const entry of events) {
+      const event = entry.event;
+      if (event.seq >= untilSeq) continue;
+      if (event.type === 'tool/call') call = event;
+    }
+    if (call === undefined) return;
+    state.lastTool = call.data.name;
+    state.lastToolResult = 'pending';
+    for (const entry of events) {
+      const event = entry.event;
+      if (event.seq <= call.seq || event.seq >= untilSeq) continue;
+      if (event.type === 'tool/result') {
+        state.lastToolResult = toolResultFacts(event.data);
+        break;
+      }
+    }
+  }
 }

package/src/client/locales.ts

@@ -14,6 +14,12 @@ export const zh = {
   'field.continueTextHint': '中断后自动发送的消息内容。',
   'field.continueTextMaxTokens': '超限时的继续文本',
   'field.continueTextMaxTokensHint': '达到输出 token 上限时自动发送的文本, 支持与继续文本相同的占位符。',
+  'field.guardTools': '幂等护栏',
+  'field.guardToolsHint': '续跑前检查上一步工具调用: 结果未确认时提示先确认状态, 已成功时提示不要重复执行, 避免重复 commit/调 API。',
+  'field.guardPendingText': '结果未确认时的护栏文本',
+  'field.guardPendingTextHint': '上一步工具可能已部分执行时附加到继续文本之后, 支持 {tool} 占位符。',
+  'field.guardDoneText': '工具已成功时的护栏文本',
+  'field.guardDoneTextHint': '上一步工具已确认成功时附加到继续文本之后, 支持 {tool} 与 {result}(结果摘要)占位符。',
   'field.graceMs': '宽限期 (ms)',
   'field.graceMsHint': '检测到中断后等待的时长; 期间宿主自行恢复则取消。',
   'field.cooldownMs': '冷却时间 (ms)',
@@ -83,6 +89,12 @@ export const en: Record<SettingsCardKey, string> = {
   'field.continueTextHint': 'Message automatically sent after an interruption.',
   'field.continueTextMaxTokens': 'Continue text (max tokens)',
   'field.continueTextMaxTokensHint': 'Text sent when the output token ceiling is reached; same placeholders as the continue text.',
+  'field.guardTools': 'Idempotency guard',
+  'field.guardToolsHint': 'Before resuming, inspect the last tool call: if its result is unconfirmed, tell the model to check state first; if it succeeded, tell it not to rerun — avoids duplicate commits / API calls.',
+  'field.guardPendingText': 'Guard text (unconfirmed result)',
+  'field.guardPendingTextHint': 'Appended when the last tool may have partially executed; supports the {tool} placeholder.',
+  'field.guardDoneText': 'Guard text (tool succeeded)',
+  'field.guardDoneTextHint': 'Appended when the last tool is confirmed done; supports {tool} and {result} (result excerpt).',
   'field.graceMs': 'Grace period (ms)',
   'field.graceMsHint': 'Wait after an interruption; cancelled if the host recovers on its own.',
   'field.cooldownMs': 'Cooldown (ms)',

package/src/client/settings-card.tsx

@@ -38,6 +38,9 @@ export interface AutoContinueSettingsCardState extends CardShell {
   paused: CardFieldState;
   continueText: CardFieldState;
   continueTextMaxTokens: CardFieldState;
+  guardTools: CardFieldState;
+  guardPendingText: CardFieldState;
+  guardDoneText: CardFieldState;
   graceMs: CardFieldState;
   cooldownMs: CardFieldState;
   maxConsecutive: CardFieldState;
@@ -74,6 +77,9 @@ export class AutoContinueSettingsCardController {
       booleanField('paused'),
       textField('continueText'),
       textField('continueTextMaxTokens'),
+      booleanField('guardTools'),
+      textField('guardPendingText'),
+      textField('guardDoneText'),
       numberField('graceMs', 0),
       numberField('cooldownMs', 0),
       numberField('maxConsecutive', 1),
@@ -97,6 +103,9 @@ export class AutoContinueSettingsCardController {
       paused: this.form.field('paused'),
       continueText: this.form.field('continueText'),
       continueTextMaxTokens: this.form.field('continueTextMaxTokens'),
+      guardTools: this.form.field('guardTools'),
+      guardPendingText: this.form.field('guardPendingText'),
+      guardDoneText: this.form.field('guardDoneText'),
       graceMs: this.form.field('graceMs'),
       cooldownMs: this.form.field('cooldownMs'),
       maxConsecutive: this.form.field('maxConsecutive'),
@@ -415,6 +424,33 @@ export function AutoContinueSettingsCard(props: AutoContinueSettingsCardProps) {
         onEdit={(text) => props.edit('continueTextMaxTokens', text)}
         onReset={() => props.resetField('continueTextMaxTokens')}
       />
+      <BooleanField
+        id="auto-continue-guard-tools"
+        label={t('field.guardTools')}
+        hint={t('field.guardToolsHint')}
+        {...shared}
+        {...state.guardTools}
+        onEdit={(text) => props.edit('guardTools', text)}
+        onReset={() => props.resetField('guardTools')}
+      />
+      <ValueField
+        id="auto-continue-guard-pending-text"
+        label={t('field.guardPendingText')}
+        hint={t('field.guardPendingTextHint')}
+        {...shared}
+        {...state.guardPendingText}
+        onEdit={(text) => props.edit('guardPendingText', text)}
+        onReset={() => props.resetField('guardPendingText')}
+      />
+      <ValueField
+        id="auto-continue-guard-done-text"
+        label={t('field.guardDoneText')}
+        hint={t('field.guardDoneTextHint')}
+        {...shared}
+        {...state.guardDoneText}
+        onEdit={(text) => props.edit('guardDoneText', text)}
+        onReset={() => props.resetField('guardDoneText')}
+      />
       <ValueField
         id="auto-continue-grace-ms"
         label={t('field.graceMs')}

package/src/index.ts

@@ -18,6 +18,16 @@ export const AutoContinueSchema = z.object({
   continueText: z.string().default('继续'),
   /** Text sent when the output token ceiling is reached (same placeholders as `continueText`). */
   continueTextMaxTokens: z.string().default('继续'),
+  /** Idempotency guard: inspect the last tool call before resuming and steer the model. */
+  guardTools: z.boolean().default(true),
+  /** Guard text appended when the last tool call has no confirmed result (it may have partially executed). */
+  guardPendingText: z
+    .string()
+    .default('(上一步工具「{tool}」可能未完成, 先确认状态再继续, 不要重复执行)'),
+  /** Guard text appended when the last tool call completed successfully (don't rerun it). */
+  guardDoneText: z
+    .string()
+    .default('(上一步工具「{tool}」已完成, 结果: {result}; 不要重复执行, 直接继续)'),
   /** Grace period after an interruption before auto-sending (ms). */
   graceMs: z.natural().default(3000),
   /** Minimum interval between two auto-continues per session (ms). */