dsh-repeat-guard 0.1.0 → 0.1.2

package/src/index.ts

@@ -2,43 +2,40 @@
 //
 // 做法：包一层 `llm/stream`（模型调用的流式 waterfall），逐 chunk 观察思考段
 // （reasoning-delta）。命中退化时，把触发退化的那个 delta 照常放行，补一个 block-end
-// 闭合思考块，再补一个 finish(stop)，然后直接结束流。agent-loop 的 BlockAssembler 会把
-// 这种"没有 finish 就结束"的流当作正常 stop（assembler.js: `this._finish ?? {kind:'stop'}`），
-// 于是本次调用被当成正常完成：已生成的思考照常落盘，本轮该走什么流程就走什么流程。
+// 闭合思考块，再补一个 finish(stop)，然后直接结束流。对 agent-loop 而言这就是一次正常
+// 完成：已生成的思考照常落盘，本轮该走什么流程就走什么流程。
 //
 // 只检测思考段：正文 text-delta 不参与判定。复读退化先出现在思考段，那时正文往往还没
 // 开始产出；等正文也碎掉再掐，思考段已经白烧了一遍。
 //
-// 判定做什么：思考段里出现单独成行的一句空话（中文一到两个汉字，如"好。""执行。"；
-// 英文不超过三个单词，如"OK." "Let me go."）就掐断。判据的取舍见 detect.ts 的注释——
-// 关键是不能把"同样的碎片出现了几次"当作复读信号，那样会误伤正常的短句。
+// 判定做什么：思考段里出现独占一行的表项（如"好。""执行。""Let me go."）就掐断，
+// 短句表与阈值都可配置，见 config.ts。不做形状归纳——归纳出的规则总会外溢误伤，表项则是
+// 具体、可增删、可审计的。
 //
 // 掐断之后要让本轮继续，而不是停下来等用户输入：挂在 `agent/turn-stopping` 上，在本轮
 // 边界提交之前调 `agent.steer(...)` 推一条输入，机器就会再跑一步。详见 resume.ts。
 //
-// 依赖约束（重要）：不得 import 任何外部包，包括 @deepseek-ai/cordis。
-// cordis-plugin-loader 解析裸 specifier 时直接 `import(name)`，锚点是 loader 自身的
-// 文件位置（dsh 安装目录内部），从 profile 或全局顶层加载时都可能解析不到插件的依赖。
-// **相对路径 import 不受此限**：它由 Node 原生 ESM 按当前文件位置解析，所以本插件内部
-// 按职责拆出的这些模块可以正常互相导入。新增模块时照此办理：只连相对路径。
+// 依赖：dsh 把 bundle 的 dependencies / peerDependencies 从安装目录软链进 profile
+// （dsh-app-boot 的 healProfileModuleFallback），所以本插件可以正常 import
+// `@deepseek-ai/*`——它们声明在 peerDependencies 里，由宿主提供。
 //
 // 本文件只做装配，具体逻辑在各自的模块里。
 
+import type { Context } from '@deepseek-ai/cordis';
+import { createConfigSource } from './config.js';
 import { createStreamGuard } from './stream-guard.js';
 import { createTurnStoppingGuard } from './turn-stopping-guard.js';
-import type { GuardState, PluginContext } from './types.js';
-
-/** dsh 跑在 Node 上；只声明本插件用到的全局，避免为此引入 @types/node。 */
-declare const console: { log(...args: unknown[]): void };
+import type { GuardState } from './types.js';
 
 /**
  * 函数式插件入口。ctx 为 cordis 上下文，注册的监听随插件卸载自动释放。
  * @param ctx - 宿主 cordis 上下文。
  */
-export default function repeatGuard(ctx: PluginContext): void {
+export default function repeatGuard(ctx: Context): void {
   // 直接写 stdout：dsh 把插件的 stdout 收进 journal，便于确认插件确实被加载。
   console.log('[repeat-guard] 已加载，复读拦截生效');
   const state: GuardState = { pending: new Set() };
-  ctx.on('llm/stream', createStreamGuard(state), { global: true });
+  const readConfig = createConfigSource(ctx);
+  ctx.on('llm/stream', createStreamGuard(state, readConfig), { global: true });
   ctx.on('agent/turn-stopping', createTurnStoppingGuard(state));
 }

package/src/resume.ts

@@ -10,14 +10,12 @@
  *     if (turnEnds && this.inbox.nextStep.length === 0) break;   // 重读，读到东西就不 break
  *
  * 所以在监听器里调 `agent.steer(...)` 推入一条输入，本轮就会再跑一步，而不是停下来等
- * 用户输入。dsh 自己在 dsh-hooks-claude-code/lib/index.js:292 有同样的用法。
+ * 用户输入。dsh 自己的 dsh-hooks-claude-code/lib/index.js:300 就是这么用的。
  */
 
-import type { GuardState, SteerableAgent } from './types.js';
-
-/** dsh 跑在 Node 上；只声明本插件用到的全局，避免为此引入 @types/node。 */
-declare const crypto: { randomUUID(): string };
-declare const console: { log(...args: unknown[]): void };
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import type { GuardState } from './types.js';
 
 /** 续跑时推给模型的指令正文。 */
 const RESUME_TEXT = [
@@ -26,51 +24,34 @@ const RESUME_TEXT = [
   '请直接继续执行下一步，不要再输出任何确认语、寒暄或空话。',
 ].join('\n');
 
-/** 折叠行显示的一行摘要；空字符串会让客户端回退成 opaque 渲染，故不可为空。 */
-const RESUME_SUMMARY = '复读已截断：请继续执行';
-
 /**
- * 构造推给模型的一条输入，结构与 dsh 的 createUserMessage 对齐。
- * @returns 一条插件来源的 user 消息，客户端会渲染成折叠的 context 行。
+ * 这条注入消息的来源标记。
+ * `form: 'notice'` 要求同时给出 `summary`（dsh-llm 的 ContextFormed），
+ * 客户端据此把它渲染成折叠的 context 行，而不是用户气泡。
  */
-function resumeMessage(): Record<string, unknown> {
-  return {
-    id: crypto.randomUUID(),
-    role: 'user',
-    content: [{ type: 'text', text: RESUME_TEXT }],
-    source: {
-      kind: 'plugin',
-      plugin: 'repeat-guard',
-      form: 'notice',
-      summary: RESUME_SUMMARY,
-    },
-  };
-}
+const PLUGIN_SOURCE = {
+  kind: 'plugin',
+  plugin: 'repeat-guard',
+  form: 'notice',
+  summary: '复读已截断：请继续执行',
+} as const;
 
 /**
  * 本轮即将关闭时，若上一步刚被掐断过，就推一条输入让本轮继续。
  * @param state - 跨监听保留的拦截状态。
  * @param agent - 本轮所属的 agent 句柄。
  */
-export function reviveTurn(state: GuardState, agent: SteerableAgent | undefined): void {
-  // 三个提前返回都要留痕：不打印就无法区分"没触发""id 对不上""没有标记"。
-  if (agent === undefined || typeof agent.steer !== 'function') {
-    console.log('[repeat-guard] turn-stopping：载荷里没有 agent 句柄，不续跑');
-    return;
-  }
-  const sessionId = agent.session?.id;
-  if (sessionId === undefined) {
-    console.log('[repeat-guard] turn-stopping：agent 上没有会话 id，不续跑');
-    return;
-  }
+export function reviveTurn(state: GuardState, agent: Agent): void {
+  const sessionId = agent.session.id;
   if (!state.pending.has(sessionId)) {
-    console.log(
-      `[repeat-guard] turn-stopping：会话 ${sessionId} 没有待续跑标记，不续跑` +
-        `（当前有标记的会话：${[...state.pending].join(',') || '无'}）`,
-    );
     return;
   }
   state.pending.delete(sessionId);
   console.log(`[repeat-guard] turn-stopping：会话 ${sessionId} 续跑一步`);
-  agent.steer(resumeMessage());
+  agent.steer(
+    createUserMessage({
+      content: [{ type: 'text', text: RESUME_TEXT }],
+      source: PLUGIN_SOURCE,
+    }),
+  );
 }

package/src/stream-guard.ts

@@ -4,14 +4,13 @@
  * 只检测 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 { GenerateOptions, GuardState, StreamChunk } from './types.js';
-
-/** dsh 跑在 Node 上；只声明本插件用到的全局，避免为此引入 @types/node。 */
-declare const console: { log(...args: unknown[]): void };
+import type { GuardState } from './types.js';
 
 /** `llm/stream` 的监听器签名。 */
-export type StreamListener = (
+type StreamListener = (
   options: GenerateOptions,
   next: () => AsyncIterable<StreamChunk>,
 ) => AsyncIterable<StreamChunk>;
@@ -22,15 +21,21 @@ export type StreamListener = (
  * 适配器只开一个 reasoning 块（dsh-llm-deepseek: `reasoningBlock` 是单个变量），
  * 所以累积文本用一个字符串即可，不需要按 index 分开存。
  *
+ * 命中之后先往下探一格，判"思考段是不是就到这儿了"：再往下若还是 reasoning-delta，
+ * 说明思考在继续复读，该拦；若换成正文、工具调用，或直接收尾，说明命中行本来就是
+ * 这段思考的最后一句，属正常收尾，不拦。
+ *
  * @param downstream - 上游模型的流。
  * @param sessionId - 当前会话 id；有值才登记待续跑标记。
  * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置；每个 chunk 现取，改设置立即生效。
  * @returns 包好的流。
  */
 async function* guardStream(
   downstream: AsyncIterable<StreamChunk>,
-  sessionId: string | undefined,
+  sessionId: GenerateOptions['sessionId'],
   state: GuardState,
+  readConfig: ConfigSource,
 ): AsyncGenerator<StreamChunk> {
   const iterator = downstream[Symbol.asyncIterator]();
   let accumulated = '';
@@ -41,22 +46,33 @@ async function* guardStream(
         return;
       }
       const chunk = step.value;
-      if (chunk?.type === 'reasoning-delta' && typeof chunk.text === 'string') {
+      if (chunk.type === 'reasoning-delta') {
         accumulated += chunk.text;
-        const hit = findDegenerateLine(accumulated);
+        const config = readConfig();
+        const hit = findDegenerateLine(accumulated, config.fragments, config.threshold);
         if (hit !== null) {
-          if (sessionId !== undefined) {
-            state.pending.add(sessionId);
+          const probe = await iterator.next();
+          if (!probe.done && probe.value.type === 'reasoning-delta') {
+            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)}`,
+            `[repeat-guard] 命中行位于思考段末尾，未拦截 | 会话=${sessionId ?? '无'} | 命中行=${JSON.stringify(hit)}`,
           );
-          // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
-          const index = chunk.index ?? 0;
           yield chunk;
-          yield { type: 'block-end', index, block: { type: 'reasoning', text: accumulated } };
-          yield { type: 'finish', reason: { kind: 'stop' } };
-          return;
+          if (!probe.done) {
+            yield probe.value;
+          }
+          continue;
         }
       }
       yield chunk;
@@ -75,14 +91,15 @@ async function* guardStream(
 /**
  * 造一个 `llm/stream` 监听器。
  * @param state - 跨监听保留的拦截状态。
+ * @param readConfig - 取当前配置。
  * @returns 监听器；辅助调用直接透传，其余包一层复读检测。
  */
-export function createStreamGuard(state: GuardState): StreamListener {
+export function createStreamGuard(state: GuardState, readConfig: ConfigSource): StreamListener {
   return (options, next) => {
     // 辅助调用（上下文压缩、会话标题）不参与检测。
     if (options.purpose !== undefined) {
       return next();
     }
-    return guardStream(next(), options.sessionId, state);
+    return guardStream(next(), options.sessionId, state, readConfig);
   };
 }

package/src/turn-stopping-guard.ts

@@ -5,20 +5,17 @@
  * `agent.steer(...)`，见 resume.ts 的说明。
  */
 
+import type { Agent } from '@deepseek-ai/dsh-agent';
 import { reviveTurn } from './resume.js';
-import type { GuardState, TurnStoppingPayload } from './types.js';
-
-/** `agent/turn-stopping` 的监听器签名。 */
-export type TurnStoppingListener = (payload: unknown) => void;
+import type { GuardState } from './types.js';
 
 /**
  * 造一个 `agent/turn-stopping` 监听器。
  * @param state - 跨监听保留的拦截状态。
  * @returns 监听器；只在有待续跑标记时推一条输入。
  */
-export function createTurnStoppingGuard(state: GuardState): TurnStoppingListener {
-  return (rawPayload) => {
-    const payload = rawPayload as TurnStoppingPayload;
-    reviveTurn(state, payload?.agent);
+export function createTurnStoppingGuard(state: GuardState) {
+  return (payload: { agent: Agent }): void => {
+    reviveTurn(state, payload.agent);
   };
 }

package/src/types.ts

@@ -1,55 +1,11 @@
 /**
- * 与本插件交互的 dsh 接口声明。
+ * 本插件自有的类型。
  *
- * 这些类型一律在本插件内声明，不 import dsh 的类型：那样还要为 tsc 配 paths 指向
- * dsh 安装目录，路径里带 node 版本号，dsh 一升级就失效。
+ * 与 dsh 交互的类型不在这里重抄：`Context`、`StreamChunk`、`GenerateOptions`、
+ * `Agent`、`UserMessage` 一律从 `@deepseek-ai/*` 引。本地抄一份会在 dsh 升级时
+ * 静默过期，而官方声明会让它在构建期就报出来。
  */
 
-/** 一个流式 chunk。本插件只读 reasoning-delta 的 index/text，其余字段原样透传。 */
-export interface StreamChunk {
-  readonly type: string;
-  readonly index?: number;
-  readonly text?: string;
-  readonly [key: string]: unknown;
-}
-
-/** 一次模型调用的参数；只声明本插件读到的两个字段。 */
-export interface GenerateOptions {
-  readonly purpose?: string;
-  readonly sessionId?: string;
-}
-
-/**
- * `agent/turn-stopping` 的载荷。
- *
- * dsh 的注释写明：本轮即将关闭（模型不再欠响应）时、在边界提交之前 await 这个事件；
- * 监听器若不同意关闭，就调 `agent.steer(...)` 推入新的输入，机器会重读收件箱——
- * 有新的 steering 就再跑一步，没有才真正关闭本轮。
- */
-export interface TurnStoppingPayload {
-  readonly agent?: SteerableAgent;
-}
-
-/** 能往本轮收件箱推输入、从而让本轮继续的 agent 句柄。 */
-export interface SteerableAgent {
-  readonly session?: { readonly id?: string };
-  /** 推入 `next-step` 并唤醒驱动器：本轮再跑一步。 */
-  steer(input: unknown): void;
-}
-
-/** 注入给 dsh 的 cordis 上下文；只声明本插件用到的能力。 */
-export interface PluginContext {
-  /**
-   * 监听器的形参随所监听的事件而异，只能声明成 any[]：换成 unknown[] 会因函数
-   * 参数逆变，导致各监听器的具体签名无法赋值。
-   */
-  on(
-    name: string,
-    listener: (...args: any[]) => unknown,
-    options?: { global?: boolean },
-  ): void;
-}
-
 /** 跨两次监听保留的拦截状态。 */
 export interface GuardState {
   /** 发生过截断、等待下一步续跑的会话 id。 */