@oh-my-pi/pi-ai 18.13.2 → 18.13.3

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [18.13.3] - 2026-10-28
+
+### Changed
+
+- Updated Bun engine requirement to ≥1.4.4
+
 ## [18.13.2] - 2026-10-27
 
 ### Fixed

package/dist/types/providers/openai-completions.d.ts

@@ -3,6 +3,8 @@ import type { AssistantMessage, Context, Model, ServiceTier, StreamFunction, Str
 import type { ChatCompletionMessageParam } from "./openai-chat-wire.js";
 import { type OpenAIPromptCacheOptions } from "./openai-shared.js";
 export { applyOpenRouterRoutingVariant } from "./openai-shared.js";
+/** Whether a thinking block's signature is a raw LiteLLM (Anthropic) one, not a reasoning field name. */
+export declare function isLiteLLMThinkingSignature(signature: string | undefined): signature is string;
 /**
  * Identify "real progress" stream chunks vs. keepalives, role-only preambles,
  * and empty `{choices:[]}` no-ops emitted by some OpenAI-compatible endpoints.
@@ -43,4 +45,15 @@ export interface OpenAICompletionsOptions extends StreamOptions {
  */
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
 export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined, timestamp?: number, cachedTokensHeader?: number): AssistantMessage["usage"];
+/**
+ * Whether every chat-completions request to `model` drops the thinking text of
+ * its own prior turns: neither the base compat nor its `whenThinking` view
+ * sends it. Blocks with a raw LiteLLM signature ({@link isLiteLLMThinkingSignature})
+ * still replay in `thinking_blocks`.
+ */
+export declare function completionsDropsOwnThinking(model: {
+    api?: string;
+    reasoning?: boolean;
+    compat?: Model["compat"];
+} | null | undefined): boolean;
 export declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompat): ChatCompletionMessageParam[];

package/dist/types/providers/transform-messages.d.ts

@@ -1,3 +1,4 @@
+import type { ResolvedOpenAICompat } from "@oh-my-pi/pi-catalog/types";
 import type { Api, AssistantMessage, Message, Model } from "../types.js";
 /**
  * Maximum tool-call id length the strictest replay provider accepts.
@@ -54,6 +55,14 @@ export declare function isSurvivingAssistant(msg: AssistantMessage, model?: Mode
 export declare function isAnthropicMessagesModel(model: Model): model is Model<"anthropic-messages">;
 /** Whether `turn` came from `model` itself: its own turns replay their native reasoning unchanged. */
 export declare function isSameModelTurn(turn: Pick<AssistantMessage, "provider" | "api" | "model">, model: Pick<Model, "provider" | "api" | "id">): boolean;
+/**
+ * Whether chat completions (`convertMessages`) writes the model's own past
+ * thinking under `compat`: as Mistral content parts, demoted text, or a
+ * reasoning field. Otherwise it drops it.
+ */
+export declare function completionsSendsOwnThinking(model: {
+    reasoning?: boolean;
+}, compat: Pick<ResolvedOpenAICompat, "mistralReasoningContentParts" | "requiresThinkingAsText" | "requiresReasoningContentForToolCalls" | "thinkingFormat" | "replayReasoningContent">): boolean;
 /**
  * Normalize tool call ID for cross-provider compatibility.
  * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.

package/package.json

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

package/src/judgment/text.ts

@@ -98,15 +98,7 @@ function renderStateField(key: string, value: JsonValue): string {
 	if (typeof value !== "object" || value === null) {
 		return `${open}${escapeXmlText(value === null ? "null" : String(value))}${close}`;
 	}
-	const yaml = YAML.stringify(value, null, 2)
-		// Bun <=1.4.2 emits `key: ` before a nested block and puts an empty
-		// collection on its own line; 1.4.3 emits `key:` and `key: {}`. Pin the
-		// newer form so prompt bytes (and prompt-cache keys) do not depend on the
-		// Bun build. Values with edge whitespace are always quoted, so trimming
-		// line ends never alters data.
-		.replace(/[ \t]+$/gm, "")
-		.replace(/:\n +(\{\}|\[\])$/gm, ": $1")
-		.trimEnd();
+	const yaml = YAML.stringify(value, null, 2);
 	return `${open}\n${escapeXmlText(yaml)}\n${close}`;
 }
 

package/src/providers/cowork-fetch.ts

@@ -200,9 +200,6 @@ async function sendCoworkRequest(
 		const reason = signal?.reason;
 		const error = reason instanceof Error ? reason : new DOMException("The operation was aborted.", "AbortError");
 		request?.destroy(error);
-		// Bun before 1.4 emits 'close' but not 'error' for destroy(error), so the
-		// 'error' listener below never settles a request still waiting for headers.
-		result.reject(error);
 	};
 	if (signal?.aborted) {
 		release();

package/src/providers/openai-completions.ts

@@ -121,7 +121,7 @@ import {
 	shouldDropAutoToolChoiceForReasoning,
 	shouldRetryWithoutStrictTools,
 } from "./openai-shared";
-import { transformMessages } from "./transform-messages";
+import { completionsSendsOwnThinking, transformMessages } from "./transform-messages";
 import {
 	isOpenAICompletionsVisionSupported,
 	joinTextWithImagePlaceholder,
@@ -273,6 +273,13 @@ function getLiteLLMThinkingBlocksDelta(delta: object): unknown[] | undefined {
 	return Array.isArray(mirrored) && mirrored.length > 0 ? mirrored : undefined;
 }
 
+/** Whether a thinking block's signature is a raw LiteLLM (Anthropic) one, not a reasoning field name. */
+export function isLiteLLMThinkingSignature(signature: string | undefined): signature is string {
+	return (
+		!!signature && signature !== "reasoning_content" && signature !== "reasoning" && signature !== "reasoning_text"
+	);
+}
+
 /**
  * Rebuilds LiteLLM `thinking_blocks` from a stored assistant turn. Thinking
  * blocks parsed from `thinking_blocks` keep the raw Anthropic signature as
@@ -286,14 +293,7 @@ function encodeLiteLLMThinkingBlocks(content: AssistantMessage["content"]): Lite
 	for (const block of content) {
 		if (block.type === "thinking") {
 			const signature = block.thinkingSignature;
-			if (
-				!signature ||
-				signature === "reasoning_content" ||
-				signature === "reasoning" ||
-				signature === "reasoning_text"
-			) {
-				continue;
-			}
+			if (!isLiteLLMThinkingSignature(signature)) continue;
 			blocks.push({ type: "thinking", thinking: block.thinking, signature });
 		} else if (block.type === "redactedThinking") {
 			blocks.push({ type: "redacted_thinking", data: block.data });
@@ -2366,6 +2366,25 @@ function maybeAddAnthropicCacheControl(compat: ResolvedOpenAICompat, messages: C
 	}
 }
 
+/**
+ * Whether every chat-completions request to `model` drops the thinking text of
+ * its own prior turns: neither the base compat nor its `whenThinking` view
+ * sends it. Blocks with a raw LiteLLM signature ({@link isLiteLLMThinkingSignature})
+ * still replay in `thinking_blocks`.
+ */
+export function completionsDropsOwnThinking(
+	model: { api?: string; reasoning?: boolean; compat?: Model["compat"] } | null | undefined,
+): boolean {
+	if (model?.api !== "openai-completions" || !model.compat) return false;
+	const compat = model.compat as ResolvedOpenAICompat;
+	// A row without a resolved replay flag can't tell; counting the thinking never undercounts.
+	if (!("replayReasoningContent" in compat)) return false;
+	return (
+		!completionsSendsOwnThinking(model, compat) &&
+		(compat.whenThinking === undefined || !completionsSendsOwnThinking(model, compat.whenThinking))
+	);
+}
+
 export function convertMessages(
 	model: Model<"openai-completions">,
 	context: Context,

package/src/providers/transform-messages.ts

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { resolveCatalogPolicy } from "@oh-my-pi/pi-catalog/compat/catalog-policy";
 import { carriesReasoning } from "@oh-my-pi/pi-catalog/compat/reasoning-carry";
+import type { ResolvedOpenAICompat } from "@oh-my-pi/pi-catalog/types";
 import { renderDemotedThinking } from "../dialect/demotion";
 import type {
 	Api,
@@ -543,6 +544,31 @@ function targetReadsForeignThinking(model: Model, compat: Model["compat"]): bool
 	return model.reasoning && compat.thinkingFormat === "zai";
 }
 
+/**
+ * Whether chat completions (`convertMessages`) writes the model's own past
+ * thinking under `compat`: as Mistral content parts, demoted text, or a
+ * reasoning field. Otherwise it drops it.
+ */
+export function completionsSendsOwnThinking(
+	model: { reasoning?: boolean },
+	compat: Pick<
+		ResolvedOpenAICompat,
+		| "mistralReasoningContentParts"
+		| "requiresThinkingAsText"
+		| "requiresReasoningContentForToolCalls"
+		| "thinkingFormat"
+		| "replayReasoningContent"
+	>,
+): boolean {
+	return Boolean(
+		compat.mistralReasoningContentParts ||
+		compat.requiresThinkingAsText ||
+		compat.requiresReasoningContentForToolCalls ||
+		(compat.thinkingFormat === "zai" && model.reasoning) ||
+		compat.replayReasoningContent,
+	);
+}
+
 /**
  * Whether the target's encoder already replays the target's own plaintext
  * reasoning in a native slot. Reasoning carried from another host of the same
@@ -565,13 +591,7 @@ function targetReplaysPlaintextReasoning(model: Model, compat: Model["compat"]):
 	if (!("requiresReasoningContentForToolCalls" in compat)) return false;
 	switch (model.api) {
 		case "openai-completions":
-			return (
-				!compat.requiresThinkingAsText &&
-				(compat.mistralReasoningContentParts === true ||
-					compat.requiresReasoningContentForToolCalls ||
-					compat.thinkingFormat === "zai" ||
-					compat.replayReasoningContent)
-			);
+			return !compat.requiresThinkingAsText && completionsSendsOwnThinking(model, compat);
 		case "openrouter":
 			return !compat.filterReasoningHistory && compat.requiresReasoningContentForToolCalls;
 		case "openai-responses":