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

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [18.6.1] - 2026-10-04
+
+### Fixed
+
+- Fixed compatibility with Command Code DeepSeek and other DeepSeek-family models by preserving the reasoning context required for warm OpenAI Responses sessions and correctly handling incomplete DSML tool-call wrappers in visible output.
+
+## [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/dist/types/utils/stream-markup-healing.d.ts

@@ -63,10 +63,10 @@ export declare class StreamMarkupHealing {
     /** Drain accumulated tool calls from calls to {@link feed}. */
     drainCompleted(): HealedToolCall[];
     /**
-     * Flush held-back stream-end fragments as ordered events. Partial tool-call
-     * sections/envelopes are dropped by the delegated scanners; unterminated
-     * thinking blocks are emitted as thinking, matching the previous MiniMax parser
-     * behavior.
+     * Flush held-back stream-end fragments as ordered events. Partial tool calls
+     * are dropped by the delegated scanners; a DSML wrapper without an invoke
+     * remains visible for agent-layer leak recovery. Unterminated thinking blocks
+     * are emitted as thinking.
      */
     flushEvents(): StreamMarkupHealingEvent[];
     /** Flush held-back text only. Reconstructed calls are retained for {@link drainCompleted}. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.5.1",
+	"version": "18.6.1",
 	"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.1",
+		"@oh-my-pi/pi-catalog": "18.6.1",
+		"@oh-my-pi/pi-natives": "18.6.1",
+		"@oh-my-pi/pi-utils": "18.6.1",
+		"@oh-my-pi/pi-wire": "18.6.1"
 	},
 	"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"
@@ -123,8 +128,19 @@ export class DeepSeekInbandScanner implements InbandScanner {
 	#dsmlParamName = "";
 	#dsmlParamIsString = true;
 	#dsmlParamRaw = "";
+	/** Unclassified wrapper text is kept until an invoke proves it is a tool call. */
+	#pendingDsmlSection: string | undefined;
 	#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;
@@ -180,6 +196,12 @@ export class DeepSeekInbandScanner implements InbandScanner {
 			if (!this.#consumeDsmlParam(final, events)) break;
 		}
 		if (final && this.#state === "thinking") this.#endThinking(events);
+		if (final && this.#pendingDsmlSection !== undefined) {
+			this.#emitText(this.#pendingDsmlSection + this.#buffer, events);
+			this.#pendingDsmlSection = undefined;
+			this.#buffer = "";
+			this.#state = "outside";
+		}
 		if (final && this.#buffer.length === 0 && this.#rawBlock.length > 0) this.#rawBlock = "";
 		return events;
 	}
@@ -201,12 +223,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);
@@ -236,17 +257,28 @@ export class DeepSeekInbandScanner implements InbandScanner {
 					? DSML_TOOL_CALLS_OPEN_FULLWIDTH
 					: DSML_TOOL_CALLS_OPEN_ASCII;
 				this.#buffer = this.#buffer.slice(openToken.length);
+				this.#pendingDsmlSection = openToken;
 				this.#state = "dsmlSection";
 				return;
 			}
 			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 +286,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) {
@@ -351,16 +390,25 @@ export class DeepSeekInbandScanner implements InbandScanner {
 	}
 
 	#consumeDsmlSection(final: boolean, events: InbandScanEvent[]): boolean {
+		const initial = this.#buffer;
 		while (this.#buffer.length > 0) {
 			this.#skipWhitespace();
 			const close = this.#matchingDsmlClose(DSML_TOOL_CALLS_CLOSE_FULLWIDTH, DSML_TOOL_CALLS_CLOSE_ASCII);
 			if (close) {
+				if (this.#pendingDsmlSection !== undefined) {
+					this.#emitText(
+						this.#pendingDsmlSection + initial.slice(0, initial.length - this.#buffer.length) + close,
+						events,
+					);
+					this.#pendingDsmlSection = undefined;
+				}
 				this.#buffer = this.#buffer.slice(close.length);
 				this.#state = "outside";
 				return true;
 			}
 			const invoke = this.#matchDsmlOpen("invoke");
 			if (invoke) {
+				this.#pendingDsmlSection = undefined;
 				this.#rawBlock = invoke.raw;
 				this.#name = invoke.name;
 				this.#id = mintToolCallId();
@@ -374,12 +422,15 @@ export class DeepSeekInbandScanner implements InbandScanner {
 					(this.#buffer.startsWith("<｜DSML｜invoke") || this.#buffer.startsWith("<|DSML|invoke")) &&
 					!this.#buffer.includes(">")
 				)
-					return false;
-				if (partialSuffixOverlapAny(this.#buffer, DSML_SECTION_TOKENS) === this.#buffer.length) return false;
+					break;
+				if (partialSuffixOverlapAny(this.#buffer, DSML_SECTION_TOKENS) === this.#buffer.length) break;
 			}
-			if (this.#buffer.length === 0) return false;
+			if (this.#buffer.length === 0) break;
 			this.#buffer = this.#buffer.slice(1);
 		}
+		if (this.#pendingDsmlSection !== undefined) {
+			this.#pendingDsmlSection += initial.slice(0, initial.length - this.#buffer.length);
+		}
 		return final;
 	}
 

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/providers/openai-shared.ts

@@ -2303,6 +2303,30 @@ function createSyntheticResponsesReasoningItem(
 	return item as ResponseReasoningItem;
 }
 
+/**
+ * Fill a replayed reasoning item's missing `reasoning_text` for targets that
+ * require it on every replayed turn (DeepSeek family, #10690). Servers that
+ * stream reasoning as summary text return summary-only items; a warm session
+ * replays them natively, so without this the wire carries no `reasoning_text`
+ * while the cold rebuild of the same turn does (#14288). The summary is the
+ * same text the cold path carries from the thinking block. Items carrying
+ * `encrypted_content` are the server's opaque reasoning and replay untouched:
+ * OpenRouter sets the tool-call requirement for every reasoning model, and its
+ * OpenAI-family items must not gain a summary posing as raw reasoning text.
+ */
+function withRequiredReasoningText(item: ResponseReasoningItem): ResponseReasoningItem {
+	if (typeof item.encrypted_content === "string") return item;
+	if (item.content?.some(part => part.type === "reasoning_text" && part.text.trim().length > 0)) return item;
+	const summaryText = (item.summary ?? [])
+		.map(part => part.text)
+		.filter(text => text.trim().length > 0)
+		.join("\n\n");
+	return {
+		...item,
+		content: [{ type: "reasoning_text", text: summaryText || SYNTHETIC_REASONING_REPLAY_PLACEHOLDER }],
+	};
+}
+
 function isResponsesAssistantTurnBoundary(item: ResponseInput[number]): boolean {
 	if (responsesToolOutputKind(item.type) !== undefined) return true;
 	if (item.type === "compaction") return true;
@@ -2317,7 +2341,8 @@ function ensureRequiredResponsesReasoningReplay(
 ): ResponseInput {
 	if (stopReason === "error" || (!requiresAllTurns && !requiresToolCalls)) return items;
 
-	const insertBefore: number[] = [];
+	const repaired: ResponseInput = [];
+	let changed = false;
 	let turnStart = 0;
 	for (let index = 0; index <= items.length; index++) {
 		if (index < items.length && !isResponsesAssistantTurnBoundary(items[index])) continue;
@@ -2334,23 +2359,21 @@ function ensureRequiredResponsesReasoningReplay(
 			hasContent = true;
 			if (classifyResponsesBatchItem(item) === "call") hasToolCall = true;
 		}
-		if (hasContent && !hasReasoning && (requiresAllTurns || (requiresToolCalls && hasToolCall))) {
-			insertBefore.push(turnStart);
-		}
-		turnStart = index + 1;
-	}
-	if (insertBefore.length === 0) return items;
-
-	const repaired: ResponseInput = [];
-	let insertionIndex = 0;
-	for (let index = 0; index < items.length; index++) {
-		if (insertBefore[insertionIndex] === index) {
+		const required = hasContent && (requiresAllTurns || (requiresToolCalls && hasToolCall));
+		if (required && !hasReasoning) {
 			repaired.push(createSyntheticResponsesReasoningItem());
-			insertionIndex++;
+			changed = true;
 		}
-		repaired.push(items[index]);
+		for (let turnIndex = turnStart; turnIndex < index; turnIndex++) {
+			const item = items[turnIndex];
+			const replayed = required && item.type === "reasoning" ? withRequiredReasoningText(item) : item;
+			if (replayed !== item) changed = true;
+			repaired.push(replayed);
+		}
+		if (index < items.length) repaired.push(items[index]);
+		turnStart = index + 1;
 	}
-	return repaired;
+	return changed ? repaired : items;
 }
 
 export function convertResponsesAssistantMessage<TApi extends Api>(
@@ -2404,7 +2427,7 @@ export function convertResponsesAssistantMessage<TApi extends Api>(
 			}
 			const reasoningItem = parseResponseReasoningReplayItem(block.thinkingSignature);
 			if (reasoningItem) {
-				outputItems.push(reasoningItem);
+				outputItems.push(requiresReasoningItem ? withRequiredReasoningText(reasoningItem) : reasoningItem);
 				reasoningItemEmitted = true;
 			}
 			continue;

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;
+}

package/src/utils/stream-markup-healing.ts

@@ -126,10 +126,10 @@ export class StreamMarkupHealing {
 	}
 
 	/**
-	 * Flush held-back stream-end fragments as ordered events. Partial tool-call
-	 * sections/envelopes are dropped by the delegated scanners; unterminated
-	 * thinking blocks are emitted as thinking, matching the previous MiniMax parser
-	 * behavior.
+	 * Flush held-back stream-end fragments as ordered events. Partial tool calls
+	 * are dropped by the delegated scanners; a DSML wrapper without an invoke
+	 * remains visible for agent-layer leak recovery. Unterminated thinking blocks
+	 * are emitted as thinking.
 	 */
 	flushEvents(): StreamMarkupHealingEvent[] {
 		const tail = this.#toolScanner ? this.#healThinking(this.#toolScanner.flush()) : [];