dsh-repeat-guard 0.2.0 → 0.2.2

package/src/resume.ts

@@ -1,60 +1,62 @@
-/**
- * 续跑：截断之后让本轮不要就此关闭，而是再跑一步。
- *
- * 机制在 dsh 侧：`agent/turn-stopping` 是 serial 事件，在本轮边界提交之前被 await，
- * 之后收件箱会被重新读一次（dsh-agent-loop/lib/index.js:967-973）：
- *
- *     if (turnEnds && this.inbox.nextStep.length === 0) {
- *       await this.dispatch.serial("agent/turn-stopping", { turn, signal });
- *     }
- *     if (turnEnds && this.inbox.nextStep.length === 0) break;   // 重读，读到东西就不 break
- *
- * 所以在监听器里调 `agent.steer(...)` 推入一条输入，本轮就会再跑一步，而不是停下来等
- * 用户输入。dsh 自己的 dsh-hooks-claude-code/lib/index.js:300 就是这么用的。
- *
- * 推什么内容由配置决定（见 config.ts 的 resumeText / resumeSummary）。
- */
-
-import type { Agent } from '@deepseek-ai/dsh-agent';
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
-import type { ContextFormed } from '@deepseek-ai/dsh-llm';
-import type { RepeatGuardConfig } from './config.js';
-import type { GuardState } from './types.js';
-
-// dsh 0.1.7 起 `MessageSourceMap` 没有通用的 `plugin` kind：每个生产者在自己的模块里
-// 声明自己的 kind（merge-extensible），`form` 另由 ContextFormed 提供。
-declare module '@deepseek-ai/dsh-llm' {
-  interface MessageSourceMap {
-    /** 本插件推给模型的续跑提示。 */
-    'repeat-guard': {
-      kind: 'repeat-guard';
-    } & ContextFormed;
-  }
-}
-
-/**
- * 本轮即将关闭时，若上一步刚被掐断过，就推一条输入让本轮继续。
- * @param state - 跨监听保留的拦截状态。
- * @param agent - 本轮所属的 agent 句柄。
- * @param config - 当前配置，正文与摘要都从这里取。
- */
-export function reviveTurn(state: GuardState, agent: Agent, config: RepeatGuardConfig): void {
-  const sessionId = agent.session.id;
-  if (!state.pending.has(sessionId)) {
-    return;
-  }
-  state.pending.delete(sessionId);
-  console.log(`[repeat-guard] turn-stopping：会话 ${sessionId} 续跑一步`);
-  agent.steer(
-    createUserMessage({
-      content: [{ type: 'text', text: config.resumeText }],
-      // `form: 'notice'` 要求同时给出 `summary`（dsh-llm 的 ContextFormed），
-      // 客户端据此把它渲染成折叠的 context 行，而不是用户气泡。
-      source: {
-        kind: 'repeat-guard',
-        form: 'notice',
-        summary: config.resumeSummary,
-      },
-    }),
-  );
-}
+/**
+ * 续跑：截断之后让本轮不要就此关闭，而是再跑一步。
+ *
+ * 机制在 dsh 侧：`agent/turn-stopping` 是 serial 事件，在本轮边界提交之前被 await，
+ * 之后收件箱会被重新读一次（dsh-agent-loop/lib/index.js:967-973）：
+ *
+ *     if (turnEnds && this.inbox.nextStep.length === 0) {
+ *       await this.dispatch.serial("agent/turn-stopping", { turn, signal });
+ *     }
+ *     if (turnEnds && this.inbox.nextStep.length === 0) break;   // 重读，读到东西就不 break
+ *
+ * 所以在监听器里调 `agent.steer(...)` 推入一条输入，本轮就会再跑一步，而不是停下来等
+ * 用户输入。dsh 自己的 dsh-hooks-claude-code/lib/index.js:300 就是这么用的。
+ *
+ * 推什么内容由配置决定（见 config.ts 的 resumeText / resumeSummary）。
+ */
+
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import type { ContextFormed } from '@deepseek-ai/dsh-llm';
+import type { RepeatGuardConfig } from './config.js';
+import type { GuardState } from './types.js';
+
+// dsh 0.1.7 起 `MessageSourceMap` 没有通用的 `plugin` kind：每个生产者在自己的模块里
+// 声明自己的 kind（merge-extensible），`form` 另由 ContextFormed 提供。
+// 用 `plugin:<名>` 而不是裸名：会话格式 v3→v4 的迁移器对历史消息生成的正是这个前缀
+// （dsh-session-format-v3-to-v4 的 producerKind），裸名会让同一生产者出现两种 kind。
+declare module '@deepseek-ai/dsh-llm' {
+  interface MessageSourceMap {
+    /** 本插件推给模型的续跑提示。 */
+    'plugin:repeat-guard': {
+      kind: 'plugin:repeat-guard';
+    } & ContextFormed;
+  }
+}
+
+/**
+ * 本轮即将关闭时，若上一步刚被掐断过，就推一条输入让本轮继续。
+ * @param state - 跨监听保留的拦截状态。
+ * @param agent - 本轮所属的 agent 句柄。
+ * @param config - 当前配置，正文与摘要都从这里取。
+ */
+export function reviveTurn(state: GuardState, agent: Agent, config: RepeatGuardConfig): void {
+  const sessionId = agent.session.id;
+  if (!state.pending.has(sessionId)) {
+    return;
+  }
+  state.pending.delete(sessionId);
+  console.log(`[repeat-guard] turn-stopping：会话 ${sessionId} 续跑一步`);
+  agent.steer(
+    createUserMessage({
+      content: [{ type: 'text', text: config.resumeText }],
+      // `form: 'notice'` 要求同时给出 `summary`（dsh-llm 的 ContextFormed），
+      // 客户端据此把它渲染成折叠的 context 行，而不是用户气泡。
+      source: {
+        kind: 'plugin:repeat-guard',
+        form: 'notice',
+        summary: config.resumeSummary,
+      },
+    }),
+  );
+}

package/src/stream-guard.ts

@@ -1,118 +1,118 @@
-/**
- * `llm/stream` 监听器：包一层上游流，思考段命中复读退化就补完流并提前结束。
- *
- * 只检测 reasoning-delta（思考段）。正文 text-delta 不参与判定，原样透传。
- */
-
-import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
-import type { ConfigSource } from './config.js';
-import { findDegenerateLine } from './detect.js';
-import type { GuardState } from './types.js';
-
-/** `llm/stream` 的监听器签名。 */
-type StreamListener = (
-  options: GenerateOptions,
-  next: () => AsyncIterable<StreamChunk>,
-) => AsyncIterable<StreamChunk>;
-
-/**
- * 逐 chunk 检查上游流的思考段，命中复读退化时补完这段流。
- *
- * 适配器只开一个 reasoning 块（dsh-llm-deepseek: `reasoningBlock` 是单个变量），
- * 所以累积文本用一个字符串即可，不需要按 index 分开存。
- *
- * 命中之后先往下探一格，判"思考段是不是就到这儿了"：再往下若还是 reasoning-delta，
- * 说明思考在继续复读，该拦；若换成正文、工具调用，或直接收尾，说明命中行本来就是
- * 这段思考的最后一句，属正常收尾，不拦。
- *
- * @param downstream - 上游模型的流。
- * @param sessionId - 当前会话 id；有值才登记待续跑标记。
- * @param state - 跨监听保留的拦截状态。
- * @param readConfig - 取当前配置；每个 chunk 现取，改设置立即生效。
- * @param countHit - 记一次拦截；只在真的掐断时调用。
- * @returns 包好的流。
- */
-async function* guardStream(
-  downstream: AsyncIterable<StreamChunk>,
-  sessionId: GenerateOptions['sessionId'],
-  state: GuardState,
-  readConfig: ConfigSource,
-  countHit: () => void,
-): AsyncGenerator<StreamChunk> {
-  const iterator = downstream[Symbol.asyncIterator]();
-  let accumulated = '';
-  try {
-    for (;;) {
-      const step = await iterator.next();
-      if (step.done) {
-        return;
-      }
-      const chunk = step.value;
-      if (chunk.type === 'reasoning-delta') {
-        accumulated += chunk.text;
-        const config = readConfig();
-        const hit = findDegenerateLine(
-          accumulated,
-          config.fragments,
-          config.threshold,
-          config.inlineRepeat,
-        );
-        if (hit !== null) {
-          const probe = await iterator.next();
-          if (!probe.done && probe.value.type === 'reasoning-delta') {
-            countHit();
-            if (sessionId !== undefined) {
-              state.pending.add(sessionId);
-            }
-            console.log(
-              `[repeat-guard] 检出思考段复读，已掐断本次生成 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`,
-            );
-            // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
-            yield chunk;
-            yield { type: 'block-end', index: chunk.index, block: { type: 'reasoning', text: accumulated } };
-            yield { type: 'finish', reason: { kind: 'stop' } };
-            return;
-          }
-          console.log(
-            `[repeat-guard] 命中行位于思考段末尾，未拦截 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`,
-          );
-          yield chunk;
-          if (!probe.done) {
-            yield probe.value;
-          }
-          continue;
-        }
-      }
-      yield chunk;
-    }
-  } finally {
-    // 提前 return 时必须显式向下游传播：不补这一步上游 HTTP 流会继续跑到结束，
-    // 供应商照常计满 token，且连接悬挂。上游可能已经结束/关闭，其异常忽略。
-    try {
-      await iterator.return?.();
-    } catch {
-      /* 上游已经结束或关闭，无需处理 */
-    }
-  }
-}
-
-/**
- * 造一个 `llm/stream` 监听器。
- * @param state - 跨监听保留的拦截状态。
- * @param readConfig - 取当前配置。
- * @param countHit - 记一次拦截。
- * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
- */
-export function createStreamGuard(
-  state: GuardState,
-  readConfig: ConfigSource,
-  countHit: () => void,
-): StreamListener {
-  return (options, next) => {
-    // 辅助调用（上下文压缩、会话标题）不参与检测。
-    if (options.purpose !== undefined) {
-      return next();
-    }
-    return guardStream(next(), options.sessionId, state, readConfig, countHit);
-  };
-}
+/**
+ * `llm/stream` 监听器：包一层上游流，思考段命中复读退化就补完流并提前结束。
+ *
+ * 只检测 reasoning-delta（思考段）。正文 text-delta 不参与判定，原样透传。
+ */
+
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { ConfigSource } from './config.js';
+import { findDegenerateLine } from './detect.js';
+import type { GuardState } from './types.js';
+
+/** `llm/stream` 的监听器签名。 */
+type StreamListener = (
+  options: GenerateOptions,
+  next: () => AsyncIterable<StreamChunk>,
+) => AsyncIterable<StreamChunk>;
+
+/**
+ * 逐 chunk 检查上游流的思考段，命中复读退化时补完这段流。
+ *
+ * 适配器只开一个 reasoning 块（dsh-llm-deepseek: `reasoningBlock` 是单个变量），
+ * 所以累积文本用一个字符串即可，不需要按 index 分开存。
+ *
+ * 命中之后先往下探一格，判"思考段是不是就到这儿了"：再往下若还是 reasoning-delta，
+ * 说明思考在继续复读，该拦；若换成正文、工具调用，或直接收尾，说明命中行本来就是
+ * 这段思考的最后一句，属正常收尾，不拦。
+ *
+ * @param downstream - 上游模型的流。
+ * @param sessionId - 当前会话 id；有值才登记待续跑标记。
+ * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置；每个 chunk 现取，改设置立即生效。
+ * @param countHit - 记一次拦截；只在真的掐断时调用。
+ * @returns 包好的流。
+ */
+async function* guardStream(
+  downstream: AsyncIterable<StreamChunk>,
+  sessionId: GenerateOptions['sessionId'],
+  state: GuardState,
+  readConfig: ConfigSource,
+  countHit: () => void,
+): AsyncGenerator<StreamChunk> {
+  const iterator = downstream[Symbol.asyncIterator]();
+  let accumulated = '';
+  try {
+    for (;;) {
+      const step = await iterator.next();
+      if (step.done) {
+        return;
+      }
+      const chunk = step.value;
+      if (chunk.type === 'reasoning-delta') {
+        accumulated += chunk.text;
+        const config = readConfig();
+        const hit = findDegenerateLine(
+          accumulated,
+          config.fragments,
+          config.threshold,
+          config.inlineRepeat,
+        );
+        if (hit !== null) {
+          const probe = await iterator.next();
+          if (!probe.done && probe.value.type === 'reasoning-delta') {
+            countHit();
+            if (sessionId !== undefined) {
+              state.pending.add(sessionId);
+            }
+            console.log(
+              `[repeat-guard] 检出思考段复读，已掐断本次生成 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`,
+            );
+            // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
+            yield chunk;
+            yield { type: 'block-end', index: chunk.index, block: { type: 'reasoning', text: accumulated } };
+            yield { type: 'finish', reason: { kind: 'stop' } };
+            return;
+          }
+          console.log(
+            `[repeat-guard] 命中行位于思考段末尾，未拦截 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`,
+          );
+          yield chunk;
+          if (!probe.done) {
+            yield probe.value;
+          }
+          continue;
+        }
+      }
+      yield chunk;
+    }
+  } finally {
+    // 提前 return 时必须显式向下游传播：不补这一步上游 HTTP 流会继续跑到结束，
+    // 供应商照常计满 token，且连接悬挂。上游可能已经结束/关闭，其异常忽略。
+    try {
+      await iterator.return?.();
+    } catch {
+      /* 上游已经结束或关闭，无需处理 */
+    }
+  }
+}
+
+/**
+ * 造一个 `llm/stream` 监听器。
+ * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置。
+ * @param countHit - 记一次拦截。
+ * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
+ */
+export function createStreamGuard(
+  state: GuardState,
+  readConfig: ConfigSource,
+  countHit: () => void,
+): StreamListener {
+  return (options, next) => {
+    // 辅助调用（上下文压缩、会话标题）不参与检测。
+    if (options.purpose !== undefined) {
+      return next();
+    }
+    return guardStream(next(), options.sessionId, state, readConfig, countHit);
+  };
+}

package/src/turn-stopping-guard.ts

@@ -1,23 +1,23 @@
-/**
- * `agent/turn-stopping` 监听器：把上一步掐断欠下的续跑补上。
- *
- * 监听器的返回值不被使用（该事件是 serial 的副作用钩子），实现方式是调
- * `agent.steer(...)`，见 resume.ts 的说明。
- */
-
-import type { Agent } from '@deepseek-ai/dsh-agent';
-import type { ConfigSource } from './config.js';
-import { reviveTurn } from './resume.js';
-import type { GuardState } from './types.js';
-
-/**
- * 造一个 `agent/turn-stopping` 监听器。
- * @param state - 跨监听保留的拦截状态。
- * @param readConfig - 取当前配置。
- * @returns 监听器；只在有待续跑标记时推一条输入。
- */
-export function createTurnStoppingGuard(state: GuardState, readConfig: ConfigSource) {
-  return (payload: { agent: Agent }): void => {
-    reviveTurn(state, payload.agent, readConfig());
-  };
-}
+/**
+ * `agent/turn-stopping` 监听器：把上一步掐断欠下的续跑补上。
+ *
+ * 监听器的返回值不被使用（该事件是 serial 的副作用钩子），实现方式是调
+ * `agent.steer(...)`，见 resume.ts 的说明。
+ */
+
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { ConfigSource } from './config.js';
+import { reviveTurn } from './resume.js';
+import type { GuardState } from './types.js';
+
+/**
+ * 造一个 `agent/turn-stopping` 监听器。
+ * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置。
+ * @returns 监听器；只在有待续跑标记时推一条输入。
+ */
+export function createTurnStoppingGuard(state: GuardState, readConfig: ConfigSource) {
+  return (payload: { agent: Agent }): void => {
+    reviveTurn(state, payload.agent, readConfig());
+  };
+}

package/src/types.ts

@@ -1,13 +1,13 @@
-/**
- * 本插件自有的类型。
- *
- * 与 dsh 交互的类型不在这里重抄：`Context`、`StreamChunk`、`GenerateOptions`、
- * `Agent`、`UserMessage` 一律从 `@deepseek-ai/*` 引。本地抄一份会在 dsh 升级时
- * 静默过期，而官方声明会让它在构建期就报出来。
- */
-
-/** 跨两次监听保留的拦截状态。 */
-export interface GuardState {
-  /** 发生过截断、等待下一步续跑的会话 id。 */
-  readonly pending: Set<string>;
-}
+/**
+ * 本插件自有的类型。
+ *
+ * 与 dsh 交互的类型不在这里重抄：`Context`、`StreamChunk`、`GenerateOptions`、
+ * `Agent`、`UserMessage` 一律从 `@deepseek-ai/*` 引。本地抄一份会在 dsh 升级时
+ * 静默过期，而官方声明会让它在构建期就报出来。
+ */
+
+/** 跨两次监听保留的拦截状态。 */
+export interface GuardState {
+  /** 发生过截断、等待下一步续跑的会话 id。 */
+  readonly pending: Set<string>;
+}