@oh-my-pi/pi-ai 18.5.1 → 18.6.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [18.6.0] - 2026-10-03
+
+### Fixed
+
+- Fixed Antigravity chat and image requests sending an outdated client version when the model list came from cache, which could make newer models such as Claude Opus 5.5 unavailable.
+- When a DeepSeek model writes a broken DSML tool call (for example with the opening `<｜DSML｜tool_calls>` and `<｜DSML｜invoke>` tags missing), its closing tags are now kept in the streamed text instead of being dropped. This lets the agent remove exactly the broken call while keeping any text after it ([#14202](https://github.com/can1357/oh-my-pi/pull/14202) by [@H4vC](https://github.com/H4vC)).
+
 ## [18.5.1] - 2026-10-03
 
 ### Fixed

package/dist/types/utils/dsml-leak.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Removal of DeepSeek DSML 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.
+ */
+import type { AssistantMessage, Model } from "../types.js";
+/**
+ * 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.
+ */
+export declare 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.
+ */
+export declare function stripDsmlToolMarkup(text: string): string | undefined;
+/**
+ * Remove leaked DSML tool-call markup from `message`'s text blocks in place,
+ * dropping blocks left empty. Returns true when anything was removed.
+ */
+export declare function removeDsmlToolMarkupLeak(message: AssistantMessage): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.5.1",
+	"version": "18.6.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -155,11 +155,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.5.1",
-		"@oh-my-pi/pi-catalog": "18.5.1",
-		"@oh-my-pi/pi-natives": "18.5.1",
-		"@oh-my-pi/pi-utils": "18.5.1",
-		"@oh-my-pi/pi-wire": "18.5.1"
+		"@oh-my-pi/omptype": "18.6.0",
+		"@oh-my-pi/pi-catalog": "18.6.0",
+		"@oh-my-pi/pi-natives": "18.6.0",
+		"@oh-my-pi/pi-utils": "18.6.0",
+		"@oh-my-pi/pi-wire": "18.6.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/dialect/deepseek.ts

@@ -99,6 +99,11 @@ const DSML_INVOKE_TOKENS = [
 ] as const;
 const DSML_PARAMETER_CLOSE_TOKENS = [DSML_PARAMETER_CLOSE_FULLWIDTH, DSML_PARAMETER_CLOSE_ASCII] as const;
 
+// A DSML invoke/parameter opener in visible text: a call whose `tool_calls`
+// wrapper is missing, so the envelope scanner never consumed it.
+const BARE_DSML_OPEN = /<[｜|]DSML[｜|](?:invoke|parameter)\b/u;
+const VISIBLE_TAIL_LIMIT = 48;
+
 type State =
 	| "outside"
 	| "thinking"
@@ -125,6 +130,15 @@ export class DeepSeekInbandScanner implements InbandScanner {
 	#dsmlParamRaw = "";
 	#rawBlock = "";
 	#stripLeadingWhitespace = false;
+	/**
+	 * Visible text already carries a bare DSML `invoke`/`parameter` opener (a
+	 * malformed call missing its `tool_calls` wrapper). Its closers are then kept
+	 * verbatim instead of stripped as orphans, so the agent loop can find where
+	 * the broken call ends and remove exactly that span, keeping prose after it.
+	 */
+	#bareDsmlOpenVisible = false;
+	/** Last few visible characters, so a bare opener split across chunks is still seen. */
+	#visibleTail = "";
 
 	constructor(options: InbandScannerOptions = {}) {
 		this.#parseThinking = options.parseThinking ?? true;
@@ -201,12 +215,11 @@ export class DeepSeekInbandScanner implements InbandScanner {
 			const match = findEarliestToken(this.#buffer, OUTSIDE_TOKENS);
 			if (!match) {
 				const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, OUTSIDE_TOKENS);
-				const emit = this.#buffer.slice(0, this.#buffer.length - hold);
-				if (emit.length > 0) events.push({ type: "text", text: emit });
+				this.#emitText(this.#buffer.slice(0, this.#buffer.length - hold), events);
 				this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
 				return;
 			}
-			if (match.index > 0) events.push({ type: "text", text: this.#buffer.slice(0, match.index) });
+			this.#emitText(this.#buffer.slice(0, match.index), events);
 			this.#buffer = this.#buffer.slice(match.index);
 			if (this.#buffer.startsWith(DEEPSEEK_TOOL_CALLS_BEGIN)) {
 				this.#buffer = this.#buffer.slice(DEEPSEEK_TOOL_CALLS_BEGIN.length);
@@ -241,12 +254,22 @@ export class DeepSeekInbandScanner implements InbandScanner {
 			}
 			const orphanClose = this.#matchingOrphanDsmlClose();
 			if (orphanClose) {
+				if (this.#bareDsmlOpenVisible) this.#emitText(orphanClose, events);
 				this.#buffer = this.#buffer.slice(orphanClose.length);
 				continue;
 			}
 			const control = this.#matchingControlToken();
 			if (control) {
 				this.#buffer = this.#buffer.slice(control.length);
+				if (
+					this.#bareDsmlOpenVisible &&
+					(control === DSML_TOOL_CALLS_CLOSE_FULLWIDTH || control === DSML_TOOL_CALLS_CLOSE_ASCII)
+				) {
+					// Closes the malformed call: keep it as its end marker.
+					this.#emitText(control, events);
+					this.#bareDsmlOpenVisible = false;
+					continue;
+				}
 				this.#stripLeadingWhitespace = true;
 				continue;
 			}
@@ -254,6 +277,13 @@ export class DeepSeekInbandScanner implements InbandScanner {
 		}
 	}
 
+	#emitText(text: string, events: InbandScanEvent[]): void {
+		if (text.length === 0) return;
+		events.push({ type: "text", text });
+		this.#visibleTail = (this.#visibleTail + text).slice(-VISIBLE_TAIL_LIMIT);
+		if (!this.#bareDsmlOpenVisible && BARE_DSML_OPEN.test(this.#visibleTail)) this.#bareDsmlOpenVisible = true;
+	}
+
 	#consumeThinking(final: boolean, events: InbandScanEvent[]): void {
 		const close = this.#buffer.indexOf(THINK_CLOSE);
 		if (close === -1) {

package/src/images/google-antigravity.ts

@@ -60,7 +60,6 @@ async function resolveTarget(
 	const advertised = await fetchAntigravityImageModel({
 		token: credentials.accessToken,
 		endpoint: endpoints.length === 1 ? endpoints[0] : undefined,
-		userAgent: getAntigravityUserAgent(),
 		signal,
 		fetcher: fetchImpl,
 	});

package/src/providers/google-gemini-cli.ts

@@ -8,6 +8,7 @@ import { scheduler } from "node:timers/promises";
 import { type } from "@oh-my-pi/omptype";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
 import {
+	ensureAntigravityVersion,
 	getAntigravityModelWireProfile,
 	getAntigravityUserAgent,
 	getGeminiCliHeaders,
@@ -577,6 +578,9 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			if (replacementPayload !== undefined) {
 				requestBody = replacementPayload as typeof requestBody;
 			}
+			// The backend gates newer models on the client version; a process that
+			// skipped discovery (fresh model cache) must still send the current one.
+			if (isAntigravity) await ensureAntigravityVersion(options?.fetch ?? fetch, options?.signal);
 			const headers = isAntigravity ? { "User-Agent": getAntigravityUserAgent() } : getGeminiCliHeaders(model.id);
 
 			const requestHeaders = {

package/src/utils/dsml-leak.ts

@@ -0,0 +1,109 @@
+/**
+ * Removal of DeepSeek DSML 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.
+ */
+
+import type { AssistantMessage, Model } from "../types";
+
+// Structural DSML tags in either pipe spelling (fullwidth `｜` U+FF5C or ASCII),
+// tolerating stray whitespace inside the delimiter run.
+const DSML_TAG_PATTERN = /<\s*\/?\s*[｜|]\s*DSML\s*[｜|]\s*(?:tool_calls|invoke|parameter)\b[^<>]*>?/gu;
+// Code the model deliberately quoted (fences, inline spans) is not a leak.
+const QUOTED_CODE_PATTERN = /(```|~~~)[\s\S]*?(?:\1|$)|`[^`\n]*`/g;
+// The identifier-only line a degraded model writes in place of
+// `<｜DSML｜invoke name="…">` (e.g. `bash\n<｜DSML｜parameter …>`): part of the
+// broken call, so it goes with the markup.
+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/;
+
+/**
+ * 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 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)];
+	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;
+	}
+	const before = text.slice(0, start).trimEnd();
+	const after = text.slice(end).trimStart();
+	return before.length > 0 && after.length > 0 ? `${before}\n\n${after}` : before + after;
+}
+
+/**
+ * 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.
+ */
+export function isDsmlLeakRecoveryTarget(model: Model): boolean {
+	if (model.identity?.class === "deepseek") return true;
+	const compat = model.compat;
+	return (
+		compat !== undefined && "streamMarkupHealingPattern" in compat && compat.streamMarkupHealingPattern === "dsml"
+	);
+}
+
+/**
+ * Strip leaked DSML tool-call markup 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;
+	let out = "";
+	let cursor = 0;
+	let changed = false;
+	const flush = (end: number): void => {
+		const segment = text.slice(cursor, end);
+		const stripped = stripUnquoted(segment);
+		if (stripped !== segment) changed = true;
+		out += stripped;
+	};
+	for (const quoted of text.matchAll(QUOTED_CODE_PATTERN)) {
+		flush(quoted.index);
+		out += quoted[0];
+		cursor = quoted.index + quoted[0].length;
+	}
+	flush(text.length);
+	return changed ? out : undefined;
+}
+
+/**
+ * Remove leaked DSML tool-call markup from `message`'s text blocks in place,
+ * dropping blocks left empty. Returns true when anything was removed.
+ */
+export function removeDsmlToolMarkupLeak(message: AssistantMessage): boolean {
+	let removed = false;
+	const content: AssistantMessage["content"] = [];
+	for (const block of message.content) {
+		const stripped = block.type === "text" ? stripDsmlToolMarkup(block.text) : undefined;
+		if (block.type !== "text" || stripped === undefined) {
+			content.push(block);
+			continue;
+		}
+		removed = true;
+		if (stripped.trim().length > 0) content.push({ ...block, text: stripped });
+	}
+	if (removed) message.content = content;
+	return removed;
+}