dsh-repeat-guard 0.1.1 → 0.1.3

package/src/config.ts

@@ -0,0 +1,94 @@
+/**
+ * 插件配置：拦截短句表与连续命中阈值。
+ *
+ * 配置放在 dsh 的 settings 服务里（命名空间 repeat-guard）：宿主侧在这边注册
+ * schema，客户端设置页写同一个命名空间。判定时现取，改完立即生效，不用重启。
+ */
+
+import type { Context } from '@deepseek-ai/cordis';
+// 空导入：只为加载它的 declaration merging（往 cordis 的 Context 上补 settings 服务）。
+import type {} from '@deepseek-ai/dsh-settings';
+import z from '@deepseek-ai/schemastery';
+
+/** settings 命名空间。客户端设置页必须写同一个值。 */
+export const SETTINGS_NS = 'repeat-guard';
+
+/** 默认的拦截短句表，标点照原样写。 */
+export const DEFAULT_FRAGMENTS: readonly string[] = [
+  '好。',
+  '好的。',
+  '好嘞。',
+  '对。',
+  '对的。',
+  '是。',
+  '是的。',
+  '行。',
+  '嗯。',
+  '可以。',
+  '明白。',
+  '收到。',
+  '了解。',
+  '执行。',
+  '继续。',
+  '确认。',
+  '完成。',
+  '搞定。',
+  '写。',
+  '查。',
+  '看。',
+  'ok.',
+  'okay.',
+  'sure.',
+  'alright.',
+  'right.',
+  'yes.',
+  'done.',
+  'got it.',
+  'let me go.',
+  'let me do it.',
+  'check it.',
+];
+
+/** 默认阈值：1 表示发现即拦。 */
+export const DEFAULT_THRESHOLD = 1;
+
+const SCHEMA = z.object({
+  fragments: z.array(z.string()).default([...DEFAULT_FRAGMENTS]),
+  threshold: z.number().default(DEFAULT_THRESHOLD),
+});
+
+/** 一份生效中的配置，已编译成判定时直接可用的形式。 */
+export interface RepeatGuardConfig {
+  /** 短句表，已全部小写化。 */
+  readonly fragments: ReadonlySet<string>;
+  /** 连续命中多少行才拦。 */
+  readonly threshold: number;
+}
+
+/** 取当前配置。 */
+export type ConfigSource = () => RepeatGuardConfig;
+
+function compile(value: { fragments: readonly string[]; threshold: number }): RepeatGuardConfig {
+  return {
+    fragments: new Set(value.fragments.map((fragment) => fragment.toLowerCase())),
+    threshold: value.threshold,
+  };
+}
+
+/**
+ * 注册配置命名空间，并返回取当前配置的函数。
+ * @param ctx - 宿主 cordis 上下文。
+ * @returns 每次调用都返回最新配置。
+ */
+export function createConfigSource(ctx: Context): ConfigSource {
+  let current = compile({ fragments: DEFAULT_FRAGMENTS, threshold: DEFAULT_THRESHOLD });
+  ctx.inject(['settings'], (settingsCtx) => {
+    const scope = settingsCtx.settings.register(SETTINGS_NS, SCHEMA);
+    const sync = (): void => {
+      current = compile(scope.get());
+    };
+    sync();
+    scope.watch(sync);
+  });
+  return () => current;
+}

package/src/detect.ts

@@ -1,67 +1,35 @@
 /**
  * 复读退化判定：查表。
  *
- * 表里是已知会被模型复读的空话短句，**连标点一起写**。判定就是"思考里有没有
- * 独占一行的表项"，整行与表项全等，不拆解行的内部。
+ * 表里是已知会被模型复读的空话短句，**连标点一起写**，表本身可配置（见 config.ts）。
+ * 判定是"思考里有没有独占一行的表项"：整行与表项全等，不拆解行的内部。
  *
- * 增删条目直接改下面的 FRAGMENTS 即可，改完重新构建。
+ * 阈值是"连续命中多少行才拦"：默认 1 表示发现即拦；调到 n 时，要连着 n 行都命中
+ * （句子可以各不相同）才拦，中间夹一行不命中的就重新计数。
  */
 
-/**
- * 会被复读的空话短句表，标点照原样写。
- *
- * 英文条目一律写小写，判定时会把整行转成小写再比。
- */
-const FRAGMENTS: readonly string[] = [
-  // 中文
-  '好。',
-  '好的。',
-  '好嘞。',
-  '对。',
-  '对的。',
-  '是。',
-  '是的。',
-  '行。',
-  '嗯。',
-  '可以。',
-  '明白。',
-  '收到。',
-  '了解。',
-  '执行。',
-  '继续。',
-  '确认。',
-  '完成。',
-  '搞定。',
-  '写。',
-  '查。',
-  '看。',
-  // 英文
-  'ok.',
-  'okay.',
-  'sure.',
-  'alright.',
-  'right.',
-  'yes.',
-  'done.',
-  'got it.',
-  'let me go.',
-  'let me do it.',
-  'check it.',
-];
-
-/** 查表用的集合。 */
-const FRAGMENT_SET = new Set(FRAGMENTS);
-
 /**
  * 找出退化的碎片行。
  * @param text - 已生成的思考文本。
- * @returns 命中返回该行的原文，未命中返回 null。
+ * @param fragments - 小写化的短句表。
+ * @param threshold - 连续命中多少行才判定为复读。
+ * @returns 计数成立时返回那一行的原文，否则返回 null。
  */
-export function findDegenerateLine(text: string): string | null {
+export function findDegenerateLine(
+  text: string,
+  fragments: ReadonlySet<string>,
+  threshold: number,
+): string | null {
+  let run = 0;
   for (const raw of text.split('\n')) {
     const line = raw.trim();
-    if (line !== '' && FRAGMENT_SET.has(line.toLowerCase())) {
-      return line;
+    if (line !== '' && fragments.has(line.toLowerCase())) {
+      run += 1;
+      if (run >= threshold) {
+        return line;
+      }
+    } else {
+      run = 0;
     }
   }
   return null;

package/src/index.ts

@@ -9,7 +9,7 @@
 // 开始产出；等正文也碎掉再掐，思考段已经白烧了一遍。
 //
 // 判定做什么：思考段里出现独占一行的表项（如"好。""执行。""Let me go."）就掐断，
-// 表在 detect.ts 的 FRAGMENTS 里。不做形状归纳——归纳出的规则总会外溢误伤，表项则是
+// 短句表与阈值都可配置，见 config.ts。不做形状归纳——归纳出的规则总会外溢误伤，表项则是
 // 具体、可增删、可审计的。
 //
 // 掐断之后要让本轮继续，而不是停下来等用户输入：挂在 `agent/turn-stopping` 上，在本轮
@@ -22,6 +22,7 @@
 // 本文件只做装配，具体逻辑在各自的模块里。
 
 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 } from './types.js';
@@ -34,6 +35,7 @@ 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/stream-guard.ts

@@ -5,6 +5,7 @@
  */
 
 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';
 
@@ -20,15 +21,21 @@ 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: GenerateOptions['sessionId'],
   state: GuardState,
+  readConfig: ConfigSource,
 ): AsyncGenerator<StreamChunk> {
   const iterator = downstream[Symbol.asyncIterator]();
   let accumulated = '';
@@ -41,19 +48,31 @@ async function* guardStream(
       const chunk = step.value;
       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)}`,
           );
-          // 触发点本身已经产生了，照常放行；要掐掉的是它之后的思考。
           yield chunk;
-          yield { type: 'block-end', index: chunk.index, block: { type: 'reasoning', text: accumulated } };
-          yield { type: 'finish', reason: { kind: 'stop' } };
-          return;
+          if (!probe.done) {
+            yield probe.value;
+          }
+          continue;
         }
       }
       yield chunk;
@@ -72,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);
   };
 }