@oh-my-pi/pi-ai 16.2.2 → 16.2.3

package/CHANGELOG.md

@@ -2,9 +2,18 @@
 
 ## [Unreleased]
 
+## [16.2.3] - 2026-06-28
+
 ### Changed
 
-- Default reasoning context to `all_turns` for all Codex requests
+- Enabled automatic removal of leaked reasoning tags for all models
+- Prevented reasoning text duplication when models emit both structured and inline thinking
+- Defaulted reasoning context to all turns for all Codex requests.
+
+### Fixed
+
+- Enabled freeform tool patch support for Azure OpenAI and Codex models.
+- Fixed an issue where the `/usage show` command returned "No usage data available" when using a custom proxy base URL for Codex.
 
 ## [16.2.2] - 2026-06-27
 

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

@@ -118,9 +118,9 @@ export declare function buildParams(model: Model<"openai-responses">, context: C
  * runtime path only consumes that metadata.
  * @internal Exported for tests.
  */
-export declare function supportsFreeformApplyPatch(model: Model<"openai-responses">): boolean;
+export declare function supportsFreeformApplyPatch(model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">): boolean;
 /** @internal Exported for tests. */
 export declare function mapOpenAIResponsesToolChoiceForTools(choice: ToolChoice | undefined, tools: Tool[], model: Model<"openai-responses">): OpenAIResponsesToolChoice;
 /** @internal Exported for tests. */
-export declare function convertTools(tools: Tool[], strictMode: boolean, model: Model<"openai-responses">, onQuarantine?: (toolName: string, schemaPath: string) => void): OpenAITool[];
+export declare function convertTools(tools: Tool[], strictMode: boolean, model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">, onQuarantine?: (toolName: string, schemaPath: string) => void): OpenAITool[];
 export {};

package/dist/types/usage/openai-codex-base-url.d.ts

@@ -1 +1,18 @@
+/**
+ * Resolve the base URL for ChatGPT account-API requests (`wham/usage`,
+ * `wham/rate-limit-reset-credits`).
+ *
+ * These endpoints live on the canonical ChatGPT origin and authenticate with
+ * the Codex OAuth bearer minted for that origin. They are NOT part of the
+ * `/responses` API surface that streaming proxies (Headroom, 9router, etc.)
+ * forward, so a `providers.openai-codex.baseUrl` override pointed at such a
+ * proxy MUST NOT be used here — doing so 404s and silently breaks
+ * `/usage show` (issue #3679).
+ *
+ * Accepted overrides are the canonical `chatgpt.com` / `chat.openai.com`
+ * origins. Any extra path (e.g. a streaming override like
+ * `/backend-api/codex/responses`) is normalized to `${origin}/backend-api`,
+ * since the account endpoints always live directly under `/backend-api`. Any
+ * other host falls back to {@link CODEX_BASE_URL}.
+ */
 export declare function normalizeCodexBaseUrl(baseUrl?: string): string;

package/dist/types/utils/stream-markup-healing.d.ts

@@ -29,6 +29,12 @@ export type StreamMarkupHealingEvent = {
  * State machine that consumes streamed visible text and emits cleaned text,
  * thinking deltas, and reconstructed tool calls.
  *
+ * A {@link ThinkingInbandScanner} always heals leaked reasoning idioms
+ * (`<think>`, `<thinking>`, ` ```thinking `, Gemma/Harmony channels, …) out of
+ * the visible channel. For Kimi / DeepSeek-DSML the provider tool-call grammar
+ * runs first and its cleaned text is piped through that thinking healer, so a
+ * model can leak tool-call markup and reasoning in the same stream.
+ *
  * Feed only one stream channel (usually `delta.content` / `message.content`).
  * Mixing reasoning and visible text into the same instance can corrupt held-back
  * partial tag buffers.
@@ -71,8 +77,11 @@ export declare class StreamMarkupHealing {
 export declare function modelMayLeakKimiToolCalls(provider: string, modelId: string): boolean;
 /** Cheap model/provider gate for DeepSeek DSML envelope leaks. */
 export declare function modelMayLeakDsmlToolCalls(provider: string, modelId: string): boolean;
-/** Cheap model/provider gate for MiniMax plain thinking tag leaks. */
-export declare function modelMayLeakThinkingTags(provider: string, modelId: string): boolean;
-export declare function getStreamMarkupHealingPattern(provider: string, modelId: string, options?: {
-    readonly parseThinkingTags?: boolean;
-}): StreamMarkupHealingPattern | undefined;
+/**
+ * Pick the leaked-markup healer for an OpenAI-compatible / Ollama visible-text
+ * stream. Kimi chat-template tokens and DeepSeek DSML envelopes need their
+ * dedicated tool-call grammars; every other model uses `"thinking"`. All three
+ * patterns run the generic {@link ThinkingInbandScanner}, so leaked reasoning
+ * idioms (e.g. a Gemini ` ```thinking ` fence on OpenRouter) are always healed.
+ */
+export declare function getStreamMarkupHealingPattern(provider: string, modelId: string): StreamMarkupHealingPattern;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.2.2",
+	"version": "16.2.3",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.2.2",
-		"@oh-my-pi/pi-utils": "16.2.2",
-		"@oh-my-pi/pi-wire": "16.2.2",
+		"@oh-my-pi/pi-catalog": "16.2.3",
+		"@oh-my-pi/pi-utils": "16.2.3",
+		"@oh-my-pi/pi-wire": "16.2.3",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/providers/ollama.ts

@@ -465,6 +465,10 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			? new StreamMarkupHealing({ pattern: streamMarkupHealingPattern })
 			: undefined;
 		let healedToolCallEmitted = false;
+		// Once the provider streams native reasoning (`message.thinking`), drop any
+		// thinking the text-channel healer also recovers so a model that emits both
+		// does not double-count its reasoning.
+		let suppressHealedThinking = false;
 		const endActiveTextBlock = (): void => {
 			if (activeTextIndex === undefined) return;
 			endTextBlock(stream, output, activeTextIndex);
@@ -542,7 +546,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			if (event.type === "text") {
 				appendVisibleText(event.text);
 			} else if (event.type === "thinking") {
-				appendVisibleThinking(event.thinking);
+				if (!suppressHealedThinking) appendVisibleThinking(event.thinking);
 			} else {
 				emitHealedToolCall(event.call);
 			}
@@ -614,6 +618,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			stream.push({ type: "start", partial: output });
 			for await (const chunk of iterateNdjson(response.body)) {
 				if (chunk.message?.thinking) {
+					suppressHealedThinking = true;
 					endActiveTextBlock();
 					if (activeThinkingIndex === undefined) {
 						output.content.push({ type: "thinking", thinking: "" });

package/src/providers/openai-responses.ts

@@ -936,7 +936,9 @@ export function buildParams(
  * runtime path only consumes that metadata.
  * @internal Exported for tests.
  */
-export function supportsFreeformApplyPatch(model: Model<"openai-responses">): boolean {
+export function supportsFreeformApplyPatch(
+	model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">,
+): boolean {
 	return model.applyPatchToolType === "freeform";
 }
 
@@ -970,7 +972,7 @@ export function mapOpenAIResponsesToolChoiceForTools(
 export function convertTools(
 	tools: Tool[],
 	strictMode: boolean,
-	model: Model<"openai-responses">,
+	model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">,
 	onQuarantine: (toolName: string, schemaPath: string) => void = (toolName, schemaPath) =>
 		logger.warn(
 			`Tool "${toolName}" omitted from the openai-responses request: its parameter schema is invalid for this provider at ${schemaPath} (an enum/const value cannot match its declared type). Other tools are unaffected.`,

package/src/usage/openai-codex-base-url.ts

@@ -1,15 +1,35 @@
 import { CODEX_BASE_URL } from "@oh-my-pi/pi-catalog/wire/codex";
 
+/**
+ * Resolve the base URL for ChatGPT account-API requests (`wham/usage`,
+ * `wham/rate-limit-reset-credits`).
+ *
+ * These endpoints live on the canonical ChatGPT origin and authenticate with
+ * the Codex OAuth bearer minted for that origin. They are NOT part of the
+ * `/responses` API surface that streaming proxies (Headroom, 9router, etc.)
+ * forward, so a `providers.openai-codex.baseUrl` override pointed at such a
+ * proxy MUST NOT be used here — doing so 404s and silently breaks
+ * `/usage show` (issue #3679).
+ *
+ * Accepted overrides are the canonical `chatgpt.com` / `chat.openai.com`
+ * origins. Any extra path (e.g. a streaming override like
+ * `/backend-api/codex/responses`) is normalized to `${origin}/backend-api`,
+ * since the account endpoints always live directly under `/backend-api`. Any
+ * other host falls back to {@link CODEX_BASE_URL}.
+ */
 export function normalizeCodexBaseUrl(baseUrl?: string): string {
-	const fallback = CODEX_BASE_URL;
-	const trimmed = baseUrl?.trim() ? baseUrl.trim() : fallback;
-	const base = trimmed.replace(/\/+$/, "");
-	const lower = base.toLowerCase();
-	if (
-		(lower.startsWith("https://chatgpt.com") || lower.startsWith("https://chat.openai.com")) &&
-		!lower.includes("/backend-api")
-	) {
-		return `${base}/backend-api`;
+	const trimmed = baseUrl?.trim().replace(/\/+$/, "");
+	if (!trimmed) return CODEX_BASE_URL;
+	let parsed: URL;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return CODEX_BASE_URL;
 	}
-	return base;
+	const host = parsed.host.toLowerCase();
+	if (host !== "chatgpt.com" && host !== "chat.openai.com") return CODEX_BASE_URL;
+	// wham/usage always lives at `${origin}/backend-api/...` on the canonical
+	// ChatGPT origin, so ignore any extra path (e.g. `/backend-api/codex/responses`
+	// from a streaming baseUrl) — otherwise we'd build `.../codex/responses/wham/usage`.
+	return `${parsed.origin}/backend-api`;
 }

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

@@ -38,24 +38,33 @@ export type StreamMarkupHealingEvent =
  * State machine that consumes streamed visible text and emits cleaned text,
  * thinking deltas, and reconstructed tool calls.
  *
+ * A {@link ThinkingInbandScanner} always heals leaked reasoning idioms
+ * (`<think>`, `<thinking>`, ` ```thinking `, Gemma/Harmony channels, …) out of
+ * the visible channel. For Kimi / DeepSeek-DSML the provider tool-call grammar
+ * runs first and its cleaned text is piped through that thinking healer, so a
+ * model can leak tool-call markup and reasoning in the same stream.
+ *
  * Feed only one stream channel (usually `delta.content` / `message.content`).
  * Mixing reasoning and visible text into the same instance can corrupt held-back
  * partial tag buffers.
  */
 export class StreamMarkupHealing {
 	readonly #pattern: StreamMarkupHealingPattern;
-	readonly #scanner: InbandScanner;
+	/** Provider tool-call grammar (Kimi tokens / DSML envelope); absent for plain text streams. */
+	readonly #toolScanner: InbandScanner | undefined;
+	/** Always-on healer for leaked reasoning idioms in the visible text channel. */
+	readonly #thinkingScanner = new ThinkingInbandScanner();
 	#sectionTerminated = false;
 	readonly #completed: HealedToolCall[] = [];
 
 	constructor(options: StreamMarkupHealingOptions) {
 		this.#pattern = options.pattern;
-		this.#scanner =
+		this.#toolScanner =
 			options.pattern === "kimi"
 				? createInbandScanner("kimi")
 				: options.pattern === "dsml"
 					? createInbandScanner("xml", { xmlTagset: "dsml" })
-					: new ThinkingInbandScanner();
+					: undefined;
 	}
 
 	get pattern(): StreamMarkupHealingPattern {
@@ -84,7 +93,8 @@ export class StreamMarkupHealing {
 	feedEvents(text: string): StreamMarkupHealingEvent[] {
 		if (text.length === 0) return [];
 		this.#markSectionClosed(text);
-		return this.#convertScannerEvents(this.#scanner.feed(text));
+		if (!this.#toolScanner) return this.#convertScannerEvents(this.#thinkingScanner.feed(text));
+		return this.#convertScannerEvents(this.#healThinking(this.#toolScanner.feed(text)));
 	}
 
 	/**
@@ -120,7 +130,9 @@ export class StreamMarkupHealing {
 	 * behavior.
 	 */
 	flushEvents(): StreamMarkupHealingEvent[] {
-		return this.#convertScannerEvents(this.#scanner.flush());
+		const tail = this.#toolScanner ? this.#healThinking(this.#toolScanner.flush()) : [];
+		tail.push(...this.#thinkingScanner.flush());
+		return this.#convertScannerEvents(tail);
 	}
 
 	/** Flush held-back text only. Reconstructed calls are retained for {@link drainCompleted}. */
@@ -142,7 +154,7 @@ export class StreamMarkupHealing {
 	}
 
 	#markSectionClosed(text: string): void {
-		if (this.#sectionTerminated) return;
+		if (this.#sectionTerminated || !this.#toolScanner) return;
 		if (this.#pattern === "kimi") {
 			this.#sectionTerminated = text.includes(KIMI_SECTION_END);
 			return;
@@ -151,6 +163,20 @@ export class StreamMarkupHealing {
 			text.includes(DSML_TOOL_CALLS_CLOSE_FULLWIDTH) || text.includes(DSML_TOOL_CALLS_CLOSE_ASCII);
 	}
 
+	/**
+	 * Re-scan the tool scanner's visible text through the always-on thinking
+	 * healer: `text` events are healed for leaked reasoning idioms, while the tool
+	 * scanner's own thinking / tool-call events pass through in stream order.
+	 */
+	#healThinking(toolEvents: readonly InbandScanEvent[]): InbandScanEvent[] {
+		const out: InbandScanEvent[] = [];
+		for (const event of toolEvents) {
+			if (event.type === "text") out.push(...this.#thinkingScanner.feed(event.text));
+			else out.push(event);
+		}
+		return out;
+	}
+
 	#convertScannerEvents(events: readonly InbandScanEvent[]): StreamMarkupHealingEvent[] {
 		const out: StreamMarkupHealingEvent[] = [];
 		for (const event of events) {
@@ -207,18 +233,15 @@ export function modelMayLeakDsmlToolCalls(provider: string, modelId: string): bo
 	);
 }
 
-/** Cheap model/provider gate for MiniMax plain thinking tag leaks. */
-export function modelMayLeakThinkingTags(provider: string, modelId: string): boolean {
-	return /minimax/i.test(provider) || /minimax/i.test(modelId);
-}
-
-export function getStreamMarkupHealingPattern(
-	provider: string,
-	modelId: string,
-	options?: { readonly parseThinkingTags?: boolean },
-): StreamMarkupHealingPattern | undefined {
-	if (options?.parseThinkingTags || modelMayLeakThinkingTags(provider, modelId)) return "thinking";
+/**
+ * Pick the leaked-markup healer for an OpenAI-compatible / Ollama visible-text
+ * stream. Kimi chat-template tokens and DeepSeek DSML envelopes need their
+ * dedicated tool-call grammars; every other model uses `"thinking"`. All three
+ * patterns run the generic {@link ThinkingInbandScanner}, so leaked reasoning
+ * idioms (e.g. a Gemini ` ```thinking ` fence on OpenRouter) are always healed.
+ */
+export function getStreamMarkupHealingPattern(provider: string, modelId: string): StreamMarkupHealingPattern {
 	if (modelMayLeakKimiToolCalls(provider, modelId)) return "kimi";
 	if (modelMayLeakDsmlToolCalls(provider, modelId)) return "dsml";
-	return undefined;
+	return "thinking";
 }