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

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [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

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.6.0",
+	"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.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"
+		"@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

@@ -128,6 +128,8 @@ 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;
 	/**
@@ -194,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;
 	}
@@ -249,6 +257,7 @@ 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;
 			}
@@ -381,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();
@@ -404,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/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/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()) : [];