dsh-dsml-rescue 0.3.0 → 0.4.0

package/README.md

@@ -5,8 +5,8 @@
 <h1 align="center">dsh-dsml-rescue</h1>
 
 <div align="center">
-  <p><strong>A stalled turn gets another one</strong></p>
-  <p><em>空转的轮次，替你续上</em></p>
+  <p><strong>A turn stalled by leaked DSML markup gets another one</strong></p>
+  <p><em>DSML 泄漏导致的空转，替你续上</em></p>
 
   <p>
     <a href="https://github.com/deepseek-ai/deepseek-harness"><img src="https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white" alt="powered by dsh"></a>
@@ -32,7 +32,7 @@
 ## Does this look familiar?
 
 You asked for something. The model reasoned for a while. Then the turn simply ended — no answer, no
-tool call, nothing. The reasoning output ended with lines like these:
+tool call, nothing. What it produced ended with lines like these:
 
 ```
 </｜｜DSML｜｜ parameter>
@@ -40,17 +40,22 @@ tool call, nothing. The reasoning output ended with lines like these:
 </｜｜DSML｜｜ calls>
 ```
 
+<p align="center">
+  <img src="assets/dsml-leak-rescue.png" width="900" alt="The web UI after a stalled turn: what the model produced ends with leaked DSML markup, then the turn stops with no answer">
+</p>
+
 DSML (DeepSeek Markup Language) is how DeepSeek formats a tool call. Some provider routes hand that
-markup back as **ordinary reasoning text** instead of an actual call, so the call never happens, the
-turn closes with no output, and everything waits for someone to type "continue".
+markup back as ordinary message content instead of an actual call — in the reasoning, or in the
+visible reply. Either way the call never happens, the turn closes with no output, and everything
+waits for someone to type "continue".
 
 This plugin types it.
 
 ## What it does
 
-- Continues a stalled turn: DSML markup at the end of the reasoning, and nothing else produced.
-  Neither half alone is enough — an empty turn without the markup is a different failure.
-- Sends one short, neutral line — carry on, or wrap up if the work is done.
+- Continues a stalled turn: DSML markup where the message ends, and no tool call. Both halves are
+  needed — an empty turn without the markup is a different failure.
+- Sends one short, neutral line: take the next step — never an offer to declare the work finished.
 - Backs off while you are typing.
 - Gives up after a few attempts instead of burning requests.
 - Covers subagents too, so a delegated task is not falsely reported as completed while it is stuck.

package/README_zh.md

@@ -5,8 +5,8 @@
 <h1 align="center">dsh-dsml-rescue</h1>
 
 <div align="center">
-  <p><strong>空转的轮次，替你续上</strong></p>
-  <p><em>A stalled turn gets another one</em></p>
+  <p><strong>DSML 泄漏导致的空转，替你续上</strong></p>
+  <p><em>A turn stalled by leaked DSML markup gets another one</em></p>
 
   <p>
     <a href="https://github.com/deepseek-ai/deepseek-harness"><img src="https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white" alt="powered by dsh"></a>
@@ -31,7 +31,7 @@
 
 ## 这场景眼熟吗
 
-你提了要求，模型推理了一会儿，然后这一轮就这么结束了——没有回复、没有工具调用，什么都没有。推理过程的最后几行是这样：
+你提了要求，模型推理了一会儿，然后这一轮就这么结束了——没有回复、没有工具调用，什么都没有。它产出的内容，最后几行是这样：
 
 ```
 </｜｜DSML｜｜ parameter>
@@ -39,14 +39,18 @@
 </｜｜DSML｜｜ calls>
 ```
 
-DSML（DeepSeek Markup Language）是 DeepSeek 表示工具调用的协议标记。某些 provider 路由会把这段标记当成**普通推理文本**返回，而不是真的发出调用；于是调用没有发生，这一轮空着结束，所有人都在等一句「继续」。
+<p align="center">
+  <img src="assets/dsml-leak-rescue.png" width="900" alt="网页界面里的一次空转：模型产出的内容末尾是泄漏的 DSML 标记，这一轮就此停下，没有回答">
+</p>
+
+DSML（DeepSeek Markup Language）是 DeepSeek 表示工具调用的协议标记。某些 provider 路由会把这段标记当成普通消息内容返回——可能落在推理里，也可能落在正文里——而不是真的发出调用；于是调用没有发生，这一轮空着结束，所有人都在等一句「继续」。
 
 这个插件替你把这句「继续」发出去。
 
 ## 它做什么
 
-- 只救空转的轮次：推理过程末尾带着 DSML 标记，而且没有产出任何别的内容。两个条件缺一不可——空转但末尾没有标记，是另一种失败。
-- 发一句很短、很中性的话：接着做，或者已经做完就收尾。
+- 救空转的轮次：标记落在消息末尾，而且没有工具调用。两个条件缺一不可——空转但没有标记，是另一种失败。
+- 发一句很短、很中性的话：接着做下一步，不给「已经做完了」这种台阶。
 - 你正在打字时它让开。
 - 连着几次没救回来就收手，不会一直烧请求。
 - 子代理也管：被派出去的任务不会在卡住时被误报为已完成。

package/lib/index.js

@@ -2,13 +2,14 @@ import z from "@deepseek-ai/schemastery";
 import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 // src/protocol.ts
 /**
-* Protocol-mark detection over one reasoning stream.
+* Protocol-mark detection over one message's content.
 *
 * Some provider routes deliver the model's tool-call dialect as ordinary
-* reasoning text instead of a structured tool call. The dialect's closing
-* tokens then sit at the very end of the thinking stream, and the turn ends
-* having done nothing. This module answers one question about that text: does
-* it end with such a token? It knows nothing about turns, agents, or sessions.
+* content instead of a structured tool call. The dialect's closing tokens then
+* sit at the very end of the message, and the turn ends having done nothing.
+* This module answers one question about that text: does it end with such a
+* token? It knows nothing about turns, agents, or sessions, and nothing about
+* which content kind the route chose to put it in.
 *
 * @module dsh-dsml-rescue/protocol
 */
@@ -19,11 +20,32 @@ import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 */
 const MARKER = /\|\|\s*dsml\s*\|\|/i;
 /**
-* How many trailing non-blank lines are considered. A leak puts its closing
-* tokens at the end; scanning further back starts matching prose *about* the
-* dialect, including examples a model quotes while explaining it.
+* Remove fenced code blocks, keeping a fence opener's line prefix.
+*
+* A fence is quotation: a model that transcribes the call it meant to make puts
+* the transcription inside one, and that transcription is not what the message
+* says. Fences can open mid-line, so this cuts at the delimiter rather than at
+* the start of the line.
+* @param text - one message's content.
+* @returns the same text with fenced spans blanked out.
 */
-const TAIL_LINES = 3;
+function withoutFences(text) {
+	const kept = [];
+	let fenced = false;
+	for (const line of text.split(/\r?\n/)) {
+		let rest = line;
+		let visible = "";
+		for (;;) {
+			const at = rest.search(/```|~~~/);
+			if (at < 0) break;
+			if (!fenced) visible += rest.slice(0, at);
+			rest = rest.slice(at + 3);
+			fenced = !fenced;
+		}
+		kept.push(fenced ? visible : visible + rest);
+	}
+	return kept.join("\n");
+}
 /**
 * A line that is protocol markup rather than a sentence.
 *
@@ -37,22 +59,23 @@ function isMarkupLine(line) {
 	return line.startsWith("<") && MARKER.test(line);
 }
 /**
-* Whether a reasoning stream ends with leaked protocol markup.
+* Whether a message's content ends with leaked protocol markup.
 *
-* Empty or absent reasoning is not a leak: a turn that produced nothing at all
-* is a different failure and stays outside this plugin's scope.
-* @param reasoning - the complete reasoning text of one assistant message.
-* @returns whether any of its last few non-blank lines is protocol markup.
+* Only the last non-blank line is read. A leak is what the message stops on, so
+* anything said after the markup is output, and a turn that produced output is
+* not a stall. Fences are read per stream: a fence cannot span two blocks, and
+* carrying one block's fence state into the next would flip the reading of a
+* block that never opened one.
+* @param streams - one text per text-bearing block, in stream order.
+* @returns whether the last non-blank line of the content is protocol markup.
 */
-function hasLeakedProtocolTail(reasoning) {
-	if (reasoning === "") return false;
-	const lines = reasoning.normalize("NFKC").split(/\r?\n/);
-	let scanned = 0;
-	for (let index = lines.length - 1; index >= 0 && scanned < TAIL_LINES; index -= 1) {
+function hasLeakedProtocolTail(streams) {
+	const lines = [];
+	for (const stream of streams) for (const line of withoutFences(stream).normalize("NFKC").split(/\r?\n/)) lines.push(line);
+	for (let index = lines.length - 1; index >= 0; index -= 1) {
 		const line = (lines[index] ?? "").trim();
 		if (line === "") continue;
-		scanned += 1;
-		if (isMarkupLine(line)) return true;
+		return isMarkupLine(line);
 	}
 	return false;
 }
@@ -60,10 +83,10 @@ function hasLeakedProtocolTail(reasoning) {
 /**
 * The one judgment this plugin makes: does a finished turn deserve a rescue?
 *
-* It deserves one when the turn ended normally yet produced nothing the loop or
-* the user can act on, and its reasoning ends in leaked protocol markup. Both
-* halves are required — a turn that produced nothing for another reason stays
-* untouched, because rescuing it would paper over an unrelated failure.
+* It deserves one when the turn ended normally and its closing message ends in
+* leaked protocol markup. Reasoning and visible text are both content: which of
+* them the route put the markup in says nothing about whether the work happened,
+* and the message's last line says everything.
 *
 * Pure: no host types, no events, no clock. The caller adapts real session
 * events into {@link TurnObservation}.
@@ -71,38 +94,34 @@ function hasLeakedProtocolTail(reasoning) {
 * @module dsh-dsml-rescue/detect
 */
 /**
-* Whether one block produced something a caller could act on.
+* Whether a block carries message content rather than an effect.
 *
-* Reasoning never counts — that is where the leak lives, not where the work
-* lands. An unknown block type does count, on purpose: a provider that adds a
-* content kind this plugin has never seen is far likelier to have produced
-* output than to have produced nothing, and a false rescue costs a request.
+* Everything else — a tool call, or a content kind this plugin has never seen —
+* is output the turn produced, so it ends the question.
 * @param block - one content block of the closing message.
-* @returns whether the block is visible text, a tool call, or an unknown kind.
+* @returns whether the block is reasoning or visible text.
 */
-function isActionable(block) {
-	if (block.type === "reasoning") return false;
-	if (block.type !== "text") return true;
-	return block.text !== void 0 && /\S/.test(block.text);
+function isTextBearing(block) {
+	return block.type === "reasoning" || block.type === "text";
 }
 /**
-* Concatenate every reasoning block of a message.
+* The text of every text-bearing block, in stream order.
 * @param blocks - the turn's closing content blocks.
-* @returns the joined reasoning text, or the empty string when there is none.
+* @returns one entry per block that carries text, empty entries included.
 */
-function joinReasoning(blocks) {
-	return blocks.filter((block) => block.type === "reasoning" && block.text !== void 0).map((block) => block.text ?? "").join("\n");
+function streams(blocks) {
+	return blocks.filter((block) => isTextBearing(block) && block.text !== void 0).map((block) => block.text ?? "");
 }
 /**
 * Decide whether one finished turn is a leaking stall.
 * @param observation - the turn's end reason and its closing message blocks.
-* @returns true only when the turn completed, produced nothing actionable, and
-*   its reasoning ends in protocol markup.
+* @returns true only when the turn completed, produced no non-text block, and
+*   its content ends in protocol markup.
 */
 function isRescueCandidate(observation) {
 	if (!observation.completed) return false;
-	if (observation.blocks.some(isActionable)) return false;
-	return hasLeakedProtocolTail(joinReasoning(observation.blocks));
+	if (observation.blocks.some((block) => !isTextBearing(block))) return false;
+	return hasLeakedProtocolTail(streams(observation.blocks));
 }
 // src/policy.ts
 /**
@@ -229,13 +248,23 @@ function reduce(state, event, limits) {
 * sits below the model — a provider route delivering tool-call markup as text —
 * so nothing the model does can avoid it, and naming it would only invite the
 * model to talk about the failure instead of continuing the work. The wording
-* is fixed rather than configurable: one sentence that asks for the next step,
-* plus one legal way out so a rescue cannot become an open-ended loop.
+* is fixed rather than configurable: one instruction, and no clause inviting the
+* model to declare the work finished. The cap is what bounds a rescue, so the
+* text owes no exit — and offering one gives a stalled model a cheaper way to
+* end the turn than doing the work.
 *
 * @module dsh-dsml-rescue/messages
 */
-/** What the model reads. Two instructions: continue, or close out if finished. */
-const CONTINUE_PROMPT = "Continue with the task. Take the next concrete step now, using a tool if needed. If the work is complete, reply with a short summary.";
+/**
+* What the model reads: one instruction, and nothing about being finished.
+*
+* The rescued turn ended with a tool call that never landed, so the next step
+* has not happened yet; a "say you are done" clause has nothing true to be right
+* about. Taking one is not free either: a prose answer is what detection reads as
+* the message's end, so the turn stops counting as a stall and the run ends with
+* the work undone.
+*/
+const CONTINUE_PROMPT = "Continue with the task. Take the next concrete step now, using a tool if needed.";
 /**
 * Build the continuation turn's message.
 * @param round - this rescue's ordinal in the current streak, from 1.

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "DSML Rescue",
-    "description": "Auto-continues turns stalled by DSML tool-call markup leaking into reasoning."
+    "description": "Auto-continues turns stalled by DSML tool-call markup, wherever the route leaks it."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "DSML 续跑",
-    "description": "当 DSML 工具调用标记泄漏进推理过程导致回合停滞时，自动续跑。"
+    "description": "当 DSML 工具调用标记泄漏在消息末尾（推理或正文皆可）导致回合停滞时，自动续跑。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-dsml-rescue",
-  "version": "0.3.0",
-  "description": "Auto-continues turns stalled by DSML tool-call markup leaking into reasoning.",
+  "version": "0.4.0",
+  "description": "Auto-continues turns stalled by DSML tool-call markup, wherever the route leaks it.",
   "keywords": [
     "dsh",
     "deepseek-harness",