@linxiraos/pi-ai 1.3.0 → 1.3.2

package/src/judgment/systemone.ts

@@ -20,7 +20,14 @@ import { $env, isRecord } from "@linxiraos/pi-utils";
 import * as AIError from "../error";
 import { embeddedImageDataUrl } from "../images/shared";
 import type { ImageContent } from "../types";
-import { type JsonValue, type JudgmentRequest, tokenUsage } from "./types";
+import {
+	type BoxQuestion,
+	type JsonValue,
+	type JudgmentRequest,
+	type Question,
+	type Questions,
+	tokenUsage,
+} from "./types";
 import { type DecodedJudgment, finiteNumber, type JudgmentImageAssets, type JudgmentWire } from "./wire";
 
 function decodeSystemOne(payload: unknown): DecodedJudgment | undefined {
@@ -70,7 +77,7 @@ export function referencedImageAssets(request: JudgmentRequest, assets: Judgment
 	for (const id in request.questions) {
 		const question = request.questions[id];
 		visit(question.instructions);
-		visit(question.criteria);
+		if (question.type !== "box") visit(question.criteria);
 	}
 	// `fromEntries` defines own properties, so a `__proto__` reference stays an ordinary key.
 	return Object.fromEntries(Object.entries(assets).filter(([reference]) => !pending.has(reference)));
@@ -91,11 +98,23 @@ function encodeSystemOneImage(image: ImageContent): SystemOneImageAsset {
 	};
 }
 
+type WireQuestion = Exclude<Question, BoxQuestion> | Omit<BoxQuestion, "image">;
+
+/** `questions` as System One takes them: a box question's `image` only names the image its edges measure locally. */
+function wireQuestions(questions: Questions): Record<string, WireQuestion> {
+	const wire: Record<string, WireQuestion> = {};
+	for (const id in questions) {
+		const question = questions[id];
+		wire[id] = question.type === "box" ? { type: "box", instructions: question.instructions } : question;
+	}
+	return wire;
+}
+
 /** A System One dialect posting the verbatim request to `path` under the base URL with the key as bearer. */
 function systemOneWire(path: string): JudgmentWire {
 	return {
 		target: (baseUrl, _model, key) => ({ url: `${baseUrl}${path}`, token: key }),
-		encode: (request, model) => ({ state: request.state, model, questions: request.questions }),
+		encode: (request, model) => ({ state: request.state, model, questions: wireQuestions(request.questions) }),
 		decode: decodeSystemOne,
 	};
 }
@@ -108,11 +127,12 @@ export const typesafeWire: JudgmentWire = {
 	imagesRequireOptIn: true,
 	imageHeaders: { "TypeSafe-Danger-Zone-Images": "true" },
 	ignoresImageDetail: true,
+	boxes: true,
 	encode(request, model, imageAssets) {
 		const suppliedAssets = Object.entries(imageAssets ?? {});
 		const images = request.images ?? [];
 		if (suppliedAssets.length === 0 && images.length === 0) {
-			return { state: request.state, model, questions: request.questions };
+			return { state: request.state, model, questions: wireQuestions(request.questions) };
 		}
 
 		const assets: Record<string, SystemOneImageAsset> = Object.fromEntries(
@@ -129,7 +149,7 @@ export const typesafeWire: JudgmentWire = {
 		return {
 			state: references.length ? stateWithImages(request.state, references) : request.state,
 			model,
-			questions: request.questions,
+			questions: wireQuestions(request.questions),
 			assets,
 		};
 	},
@@ -140,6 +160,7 @@ export const openrouterDecisionsWire: JudgmentWire = {
 	...systemOneWire("/decisions"),
 	images: {},
 	imagesRequireOptIn: true,
+	boxes: true,
 	encode(request, model) {
 		const imageParts: JsonValue[] = (request.images ?? []).map(image => ({
 			type: "image_url",
@@ -151,7 +172,7 @@ export const openrouterDecisionsWire: JudgmentWire = {
 		return {
 			state: imageParts.length ? stateWithImages(request.state, imageParts) : request.state,
 			model,
-			questions: request.questions,
+			questions: wireQuestions(request.questions),
 		};
 	},
 };

package/src/judgment/text.ts

@@ -265,6 +265,8 @@ export function parseAnswer(id: string, question: Question, reply: string): Answ
 			}
 			return { type: "score", score: level, probabilities, confidence: 1 };
 		}
+		case "box":
+			throw new AIError.ValidationError(`judgment "${id}": text judges cannot answer box questions`);
 	}
 }
 
@@ -288,6 +290,10 @@ export class TextJudge implements Judge {
 		if (request.images?.length && this.#backend.supportsImages !== true) {
 			throw new AIError.ValidationError(`Text judgment backend ${this.label} does not support image inputs`);
 		}
+		for (const id of ids) {
+			if (request.questions[id].type !== "box") continue;
+			throw new AIError.ValidationError(`Text judgment backend ${this.label} does not answer box questions`);
+		}
 		const rendered = renderJudgmentPrompt(request, { guardState: this.#backend.guardState });
 		const retries = this.#backend.parseRetries ?? 0;
 		for (let attempt = 0; ; attempt++) {

package/src/judgment/types.ts

@@ -3,8 +3,9 @@
  *
  * A {@link Judge} answers a map of named questions — {@link ChoiceQuestion}
  * (one option from a fixed set), {@link NoulQuestion} (probability that a
- * yes/no condition holds), {@link ScoreQuestion} (position on ordered levels)
- * — about one {@link JudgmentState}. Every question in a request sees the same
+ * yes/no condition holds), {@link ScoreQuestion} (position on ordered levels),
+ * {@link BoxQuestion} (where a target is in one of the request's images, native
+ * judges only) — about one {@link JudgmentState}. Every question in a request sees the same
  * state and is answered independently, so callers batch independent questions
  * into one call. The shape mirrors TypeSafe's System One API so the native
  * backend ({@link NativeJudge}) forwards requests verbatim, while the text
@@ -40,7 +41,20 @@ export interface ScoreQuestion {
 	criteria: readonly [string, string, ...string[]];
 }
 
-export type Question = ChoiceQuestion | NoulQuestion | ScoreQuestion;
+/**
+ * Where one target is in an image (TypeSafe Box, Jev 1.14+): https://docs.typesafe.ai/primitives/box.
+ * Only native judges answer it. `instructions` must name the target and, among several images, which
+ * one to search; `image` stays local and says which entry of {@link JudgmentRequest.images} the
+ * answer's edges measure, so a judge that resizes or pads that image can map them back.
+ */
+export interface BoxQuestion {
+	type: "box";
+	instructions: string;
+	/** Index into the request's `images` of the image searched. */
+	image: number;
+}
+
+export type Question = ChoiceQuestion | NoulQuestion | ScoreQuestion | BoxQuestion;
 
 /** Questions keyed by caller-chosen ids; answers come back under the same ids. */
 export type Questions = Record<string, Question>;
@@ -71,11 +85,33 @@ export interface ScoreAnswer {
 	confidence: number;
 }
 
-export type Answer = ChoiceAnswer | NoulAnswer | ScoreAnswer;
+/** A rectangle's edges as 0–1 fractions of an image's width (`left` < `right`) and height (`top` < `bottom`), from its top-left corner. */
+export interface BoxEdges {
+	top: number;
+	bottom: number;
+	left: number;
+	right: number;
+}
+
+export interface BoxAnswer {
+	type: "box";
+	/** Smallest rectangle containing the target, on the image the question's `image` names. Always present: absence is a separate yes/no question. */
+	box: BoxEdges;
+	/** How sure the model is of the box, 0–1. */
+	confidence: number;
+}
+
+export type Answer = ChoiceAnswer | NoulAnswer | ScoreAnswer | BoxAnswer;
 
 /** The answer type for a question, preserving choice labels. */
 export type AnswerFor<Q extends Question> =
-	Q extends ChoiceQuestion<infer L> ? ChoiceAnswer<L> : Q extends NoulQuestion ? NoulAnswer : ScoreAnswer;
+	Q extends ChoiceQuestion<infer L>
+		? ChoiceAnswer<L>
+		: Q extends NoulQuestion
+			? NoulAnswer
+			: Q extends BoxQuestion
+				? BoxAnswer
+				: ScoreAnswer;
 
 export interface JudgmentRequest<Q extends Questions = Questions> {
 	state: JudgmentState;

package/src/judgment/wire.ts

@@ -46,6 +46,8 @@ export interface JudgmentWire {
 	imagesRequireOptIn?: boolean;
 	/** Whether this wire drops per-image detail metadata. */
 	ignoresImageDetail?: boolean;
+	/** Whether this dialect forwards `box` questions; others reject them before sending. */
+	boxes?: boolean;
 	/** The response's answers and usage; `undefined` when the payload is not this API's response shape. */
 	decode(payload: unknown): DecodedJudgment | undefined;
 }

package/src/providers/ollama.ts

@@ -245,6 +245,17 @@ function convertMessage(
 	};
 }
 
+/** Whether Ollama chat removes assistant thinking from replayed history. */
+export function ollamaChatDropsOwnThinking(
+	model: { api?: string; compat?: Model["compat"] } | null | undefined,
+): boolean {
+	if (model?.api !== "ollama-chat") return false;
+	const compat = model.compat;
+	// Cached model rows without compat predate this guard; strip for safe replay.
+	if (!compat || !("stripThinkingHistory" in compat)) return true;
+	return compat.stripThinkingHistory ?? true;
+}
+
 function convertMessages(model: Model<"ollama-chat">, context: Context): OllamaMessage[] {
 	const systemPrompts = normalizeSystemPrompts(context.systemPrompt);
 	const systemMessages: Message[] = systemPrompts.map(systemPrompt => ({
@@ -253,10 +264,7 @@ function convertMessages(model: Model<"ollama-chat">, context: Context): OllamaM
 		timestamp: Date.now(),
 	}));
 	const messages: Message[] = [...systemMessages, ...context.messages];
-	// Model rows cached or bundled before Ollama had a compat record carry none;
-	// stripping is the replay-safe answer for them until they are rebuilt.
-	const compat: Partial<typeof model.compat> | undefined = model.compat;
-	const stripThinkingHistory = compat?.stripThinkingHistory ?? true;
+	const stripThinkingHistory = ollamaChatDropsOwnThinking(model);
 	const supportsImages = model.input.includes("image");
 	const converted = transformMessages(messages, model).map((msg, index) => {
 		// Real `systemPrompt` entries (always emitted first) stay on Ollama's

package/src/providers/transform-messages.ts

@@ -518,6 +518,14 @@ export function isAnthropicMessagesModel(model: Model): model is Model<"anthropi
 	return model.api === "anthropic-messages";
 }
 
+/** Whether `turn` came from `model` itself: its own turns replay their native reasoning unchanged. */
+export function isSameModelTurn(
+	turn: Pick<AssistantMessage, "provider" | "api" | "model">,
+	model: Pick<Model, "provider" | "api" | "id">,
+): boolean {
+	return turn.provider === model.provider && turn.api === model.api && turn.model === model.id;
+}
+
 /**
  * Targets that have proven they read unsigned foreign thinking when replayed
  * natively. This is a semantic-carry allowlist only: OpenAI-compatible
@@ -883,10 +891,7 @@ export function transformMessages<TApi extends Api>(
 		// Assistant messages need transformation check
 		if (msg.role === "assistant") {
 			const assistantMsg = msg as AssistantMessage;
-			const isSameModel =
-				assistantMsg.provider === model.provider &&
-				assistantMsg.api === model.api &&
-				assistantMsg.model === model.id;
+			const isSameModel = isSameModelTurn(assistantMsg, model);
 			// The same model on another host (or another id of the same model):
 			// its full plaintext reasoning replays natively where the target has
 			// a native slot, exactly as the target replays its own turns. Errored

package/src/usage/muse-code.ts

@@ -1,11 +1,25 @@
 import * as AIError from "../error";
-import { type MuseCodeKeyResponse, parseMuseCodeCredential, requestMuseCodeKey } from "../registry/oauth/muse-code";
-import type { UsageAmount, UsageFetchParams, UsageLimit, UsageProvider, UsageReport, UsageWindow } from "../usage";
+import { parseMuseCodeCredential, requestMuseCodeKey, type MuseCodeKeyResponse } from "../registry/oauth/muse-code";
+import {
+	resolveUsedFraction,
+	type UsageAmount,
+	type UsageFetchParams,
+	type UsageLimit,
+	type UsageProvider,
+	type UsageReport,
+	type UsageWindow,
+} from "../usage";
 import { parseIsoTimestamp, parsePositiveTimestamp, usageStatus, WEEK_MS } from "./shared";
 
 const PROVIDER = "muse-code";
 const SOURCE = "api.meta.ai/muse-code/key";
 const FAILURE_BACKOFF_MS = 5 * 60_000;
+const WEEKLY_ID = "1w";
+/** Limit ids `rollingWindow()` produces: `<minutes>m`, or `rolling` when Meta names no duration. */
+const ROLLING_ID = /^(?:rolling|\d+m)$/;
+/** Meta's documented rolling window, used when no earlier report names one. */
+const DEFAULT_ROLLING_MINUTES = 300;
+type MuseCodeSubscriptionUsage = NonNullable<MuseCodeKeyResponse["subs_usage"]>;
 
 function parseResetTimestamp(value: string | number | undefined): number | undefined {
 	return typeof value === "string" ? parseIsoTimestamp(value) : parsePositiveTimestamp(value);
@@ -24,15 +38,15 @@ function percentAmount(usedPercent: number): UsageAmount {
 	};
 }
 
-function buildLimit(
+function percentLimit(
 	id: string,
 	label: string,
-	usedPercent: number | undefined,
+	usedPercent: number,
 	window: UsageWindow,
 	tier: string | undefined,
 	accountId: string | undefined,
-): UsageLimit | undefined {
-	if (typeof usedPercent !== "number" || !Number.isFinite(usedPercent) || usedPercent < 0) return undefined;
+	notes?: string[],
+): UsageLimit {
 	const amount = percentAmount(usedPercent);
 	return {
 		id,
@@ -41,9 +55,22 @@ function buildLimit(
 		window,
 		amount,
 		status: usageStatus(amount.usedFraction),
+		...(notes ? { notes } : {}),
 	};
 }
 
+function buildLimit(
+	id: string,
+	label: string,
+	usedPercent: number | undefined,
+	window: UsageWindow,
+	tier: string | undefined,
+	accountId: string | undefined,
+): UsageLimit | undefined {
+	if (typeof usedPercent !== "number" || !Number.isFinite(usedPercent) || usedPercent < 0) return undefined;
+	return percentLimit(id, label, usedPercent, window, tier, accountId);
+}
+
 function formatRollingWindowLabel(minutes: number | undefined): string {
 	if (minutes === undefined) return "Rolling Window";
 	if (minutes % 60 === 0) {
@@ -53,29 +80,27 @@ function formatRollingWindowLabel(minutes: number | undefined): string {
 	return `${minutes} ${minutes === 1 ? "Minute" : "Minutes"}`;
 }
 
-function buildLimits(payload: MuseCodeKeyResponse, accountId: string | undefined): UsageLimit[] {
-	const usage = payload.subs_usage;
-	if (!usage) return [];
-	const tier = payload.subs_tier_name?.trim() || payload.subs_tier_id?.trim() || undefined;
+function rollingWindow(minutes: number | undefined): UsageWindow {
+	const valid = typeof minutes === "number" && Number.isFinite(minutes) && minutes > 0;
+	const durationMs = valid ? minutes * 60_000 : undefined;
+	const label = formatRollingWindowLabel(valid ? Math.round(minutes) : undefined);
+	const id = durationMs === undefined ? "rolling" : `${Math.round(durationMs / 60_000)}m`;
+	return { id, label, durationMs };
+}
+
+function buildLimits(
+	usage: MuseCodeSubscriptionUsage,
+	tier: string | undefined,
+	accountId: string | undefined,
+): UsageLimit[] {
 	const limits: UsageLimit[] = [];
 	if (usage.window) {
-		const minutes = usage.window.window_duration_mins;
-		const durationMs =
-			typeof minutes === "number" && Number.isFinite(minutes) && minutes > 0 ? minutes * 60_000 : undefined;
-		const label = formatRollingWindowLabel(
-			typeof minutes === "number" && Number.isFinite(minutes) && minutes > 0 ? Math.round(minutes) : undefined,
-		);
-		const id = durationMs === undefined ? "rolling" : `${Math.round(durationMs / 60_000)}m`;
+		const window = rollingWindow(usage.window.window_duration_mins);
 		const limit = buildLimit(
-			id,
-			label,
+			window.id,
+			window.label,
 			usage.window.used_percent,
-			{
-				id,
-				label,
-				durationMs,
-				resetsAt: parseResetTimestamp(usage.window.resets_at),
-			},
+			{ ...window, resetsAt: parseResetTimestamp(usage.window.resets_at) },
 			tier,
 			accountId,
 		);
@@ -83,11 +108,11 @@ function buildLimits(payload: MuseCodeKeyResponse, accountId: string | undefined
 	}
 	if (usage.weekly) {
 		const limit = buildLimit(
-			"1w",
+			WEEKLY_ID,
 			"Weekly",
 			usage.weekly.used_percent,
 			{
-				id: "1w",
+				id: WEEKLY_ID,
 				label: "Weekly",
 				durationMs: WEEK_MS,
 				resetsAt: parseResetTimestamp(usage.weekly.resets_at),
@@ -100,6 +125,54 @@ function buildLimits(payload: MuseCodeKeyResponse, accountId: string | undefined
 	return limits;
 }
 
+/**
+ * Limits for a key response that omits `subs_usage`, which Meta does while the
+ * rolling window is idle: no request has opened one, so it is unused. Weekly
+ * usage only accrues inside a rolling window, so the previous report's weekly
+ * figure holds until its reset and is zero after it. The carried figure is a
+ * lower bound: usage after that report (late in its window, or from another
+ * client on the same subscription) is not visible. Meta's weekly reset is a
+ * fixed weekly boundary (observed at Monday 00:00 UTC), so a passed reset rolls
+ * forward by whole weeks. Without a previous weekly figure and its reset the
+ * weekly limit stays unreported: an unbounded carry would present old usage as
+ * current forever.
+ */
+function buildIdleLimits(
+	previous: UsageReport | undefined,
+	tier: string | undefined,
+	accountId: string | undefined,
+	now: number,
+): UsageLimit[] {
+	const previousRolling = previous?.limits.find(limit => ROLLING_ID.test(limit.id));
+	const shape = previousRolling?.window ?? rollingWindow(DEFAULT_ROLLING_MINUTES);
+	const window: UsageWindow = { id: shape.id, label: shape.label, durationMs: shape.durationMs };
+	const limits = [
+		percentLimit(window.id, window.label, 0, window, tier, accountId, ["Idle: no request has opened this window"]),
+	];
+	const previousWeekly = previous?.limits.find(limit => limit.id === WEEKLY_ID);
+	const usedFraction = previousWeekly ? resolveUsedFraction(previousWeekly) : undefined;
+	let resetsAt = previousWeekly?.window?.resetsAt;
+	if (usedFraction === undefined || resetsAt === undefined) return limits;
+	const reset = resetsAt <= now;
+	if (reset) resetsAt += (Math.floor((now - resetsAt) / WEEK_MS) + 1) * WEEK_MS;
+	limits.push(
+		percentLimit(
+			WEEKLY_ID,
+			"Weekly",
+			reset ? 0 : usedFraction * 100,
+			{ id: WEEKLY_ID, label: "Weekly", durationMs: WEEK_MS, resetsAt },
+			tier,
+			accountId,
+			[
+				reset
+					? "Reset since the last reported usage"
+					: "Carried from the last reported usage; later usage not visible",
+			],
+		),
+	);
+	return limits;
+}
+
 export const museCodeUsageProvider: UsageProvider = {
 	id: PROVIDER,
 	validatesCredentials: true,
@@ -137,14 +210,27 @@ export const museCodeUsageProvider: UsageProvider = {
 		}
 		const email = payload.user_email?.trim().toLowerCase() || params.credential.email;
 		const accountId = payload.user_id?.trim() || params.credential.accountId || email;
-		const limits = buildLimits(payload, accountId);
+		const tier = payload.subs_tier_name?.trim() || payload.subs_tier_id?.trim() || undefined;
+		const now = Date.now();
+		// Payment-required responses omit `subs_usage` too; only an explicitly
+		// active subscription with no payment demand or action means an idle window.
+		const idle =
+			payload.is_subs_active === true &&
+			payload.require_payment !== true &&
+			!payload.require_payment_action_url?.trim() &&
+			!payload.action_url?.trim();
+		const limits = payload.subs_usage
+			? buildLimits(payload.subs_usage, tier, accountId)
+			: idle
+				? buildIdleLimits(ctx.previousReport, tier, accountId, now)
+				: [];
 		if (limits.length === 0) return null;
 		const raw = { ...payload };
 		delete raw.api_key;
 
 		return {
 			provider: PROVIDER,
-			fetchedAt: Date.now(),
+			fetchedAt: now,
 			limits,
 			metadata: {
 				source: SOURCE,

package/src/utils/dsml-leak.ts

@@ -1,15 +1,22 @@
 /**
- * Removal of DeepSeek DSML tool-call markup left in visible assistant text.
+ * Removal of DeepSeek tool-call markup left in visible assistant text.
  *
  * DeepSeek models on OpenAI-compatible hosts sometimes emit their tool calls as
- * raw `<｜DSML｜…>` markup in `content`. A well-formed envelope is healed into a
- * structured call by `StreamMarkupHealing`, but a degraded model can drop the
- * opening `<｜DSML｜tool_calls>` / `<｜DSML｜invoke name="…">` tags (or the host
- * runs no healer at all). That markup must not stay in history: replaying it
- * teaches the model to keep writing tool calls as text (issue #10556). Callers
- * strip it before the message is committed and tell the model its call failed.
+ * text in `content`: the V4 `<｜DSML｜…>` envelope or the V3 chat-template
+ * tokens (`<｜tool▁calls▁begin｜>` …). A well-formed call is healed into a
+ * structured call by `StreamMarkupHealing`, but a degraded model can drop
+ * required tags (or the host runs no healer at all). That markup must not stay
+ * in history: replaying it teaches the model to keep writing tool calls as text
+ * (issue #10556). Callers strip it before the message is committed and tell the
+ * model its call failed.
  */
 
+import {
+	DEEPSEEK_TOOL_CALL_END,
+	DEEPSEEK_TOOL_CALL_TOKENS,
+	DEEPSEEK_TOOL_CALLS_END,
+	findDeepSeekTemplateToken,
+} from "../dialect/deepseek";
 import type { AssistantMessage, Model } from "../types";
 
 // Structural DSML tags in either pipe spelling (fullwidth `｜` U+FF5C or ASCII),
@@ -24,26 +31,56 @@ const TRAILING_TOOL_NAME_LINE = /(^|\n)[ \t]*[A-Za-z_][\w.-]*[ \t]*\r?\n[ \t]*$/
 const CLOSING_TAG_PATTERN = /^<\s*\//;
 const BLANK_LINE_PATTERN = /\r?\n[ \t]*\r?\n/;
 
+interface MarkupTag {
+	readonly index: number;
+	readonly end: number;
+	/** Ends a call or envelope, so the broken call stops here. */
+	readonly closing: boolean;
+}
+
+/** DSML tags and tool-call template tokens (in any spelling the scanner accepts), in text order. */
+function findMarkupTags(text: string): MarkupTag[] {
+	const tags: MarkupTag[] = [];
+	for (const match of text.matchAll(DSML_TAG_PATTERN)) {
+		tags.push({
+			index: match.index,
+			end: match.index + match[0].length,
+			closing: CLOSING_TAG_PATTERN.test(match[0]),
+		});
+	}
+	for (
+		let match = findDeepSeekTemplateToken(text, DEEPSEEK_TOOL_CALL_TOKENS);
+		match;
+		match = findDeepSeekTemplateToken(text, DEEPSEEK_TOOL_CALL_TOKENS, match.index + match.raw.length)
+	) {
+		tags.push({
+			index: match.index,
+			end: match.index + match.raw.length,
+			closing: match.token === DEEPSEEK_TOOL_CALL_END || match.token === DEEPSEEK_TOOL_CALLS_END,
+		});
+	}
+	return tags.sort((a, b) => a.index - b.index);
+}
+
 /**
  * Remove the broken tool call from one stretch of unquoted text: everything from
- * the first DSML tag (or the tool-name line just before it) through the last.
+ * the first markup tag (or the tool-name line just before it) through the last.
  * The DSML scanner keeps a malformed call's closers, so its last closer marks
  * the end. When the closers never arrived, the dangling argument value runs to
  * the next blank line (or the end of the stretch); prose after that survives.
  */
 function stripUnquoted(text: string): string {
-	const tags = [...text.matchAll(DSML_TAG_PATTERN)];
+	const tags = findMarkupTags(text);
 	if (tags.length === 0) return text;
 	const first = tags[0]!;
 	const last = tags[tags.length - 1]!;
 	let start = first.index;
 	const nameLine = TRAILING_TOOL_NAME_LINE.exec(text.slice(0, start));
 	if (nameLine) start = nameLine.index + nameLine[1]!.length;
-	const lastEnd = last.index + last[0].length;
-	let end = lastEnd;
-	if (!CLOSING_TAG_PATTERN.test(last[0])) {
-		const blankLine = text.slice(lastEnd).search(BLANK_LINE_PATTERN);
-		end = blankLine === -1 ? text.length : lastEnd + blankLine;
+	let end = last.end;
+	if (!last.closing) {
+		const blankLine = text.slice(last.end).search(BLANK_LINE_PATTERN);
+		end = blankLine === -1 ? text.length : last.end + blankLine;
 	}
 	const before = text.slice(0, start).trimEnd();
 	const after = text.slice(end).trimStart();
@@ -53,8 +90,8 @@ function stripUnquoted(text: string): string {
 /**
  * Whether DSML leak recovery applies to `model`: a DeepSeek-class model, or one
  * explicitly configured with the `dsml` stream healer (e.g. a `models.yml` entry
- * whose id the classifier cannot place). Other models never write DSML tool
- * calls, so DSML text from them is prose and is left alone.
+ * whose id the classifier cannot place). Other models never write DeepSeek tool
+ * calls, so such markup from them is prose and is left alone.
  */
 export function isDsmlLeakRecoveryTarget(model: Model): boolean {
 	if (model.identity?.class === "deepseek") return true;
@@ -65,11 +102,13 @@ export function isDsmlLeakRecoveryTarget(model: Model): boolean {
 }
 
 /**
- * Strip leaked DSML tool-call markup from `text`, leaving quoted code intact.
- * Returns `undefined` when `text` carries no such markup.
+ * Strip leaked DeepSeek tool-call markup (DSML or chat-template tokens) from
+ * `text`, leaving quoted code intact. Returns `undefined` when `text` carries
+ * no such markup.
  */
 export function stripDsmlToolMarkup(text: string): string | undefined {
-	if (!text.includes("DSML")) return undefined;
+	// Every DSML tag names `DSML`; every template token spelling carries a fullwidth bar.
+	if (!text.includes("DSML") && !text.includes("｜")) return undefined;
 	let out = "";
 	let cursor = 0;
 	let changed = false;