@oh-my-pi/pi-ai 17.0.1 → 17.0.3

package/src/error/rate-limit.ts

@@ -116,16 +116,19 @@ export function calculateRateLimitBackoffMs(reason: RateLimitReason): number {
 
 /** Detect usage/quota limit errors in error messages (persistent, requires credential switch). */
 const USAGE_LIMIT_PATTERN =
-	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?(?:exceeded|reached|insufficient)|额度不足|额度耗尽|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)|run out of credits|out of credits|spending[- _]?limit|personal-team-blocked/i;
+	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?(?:exceeded|reached|insufficient)|额度不足|额度耗尽|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)|balance.?exhausted|run out of credits|out of credits|spending[- _]?limit|personal-team-blocked/i;
 
 /**
  * HTTP status codes that, absent richer body classification, represent an
  * account-local usage cap rather than a bad credential or a transient blip.
+ * HTTP 402 Payment Required is categorically an account-billing cap (xAI
+ * Grok Build "usage balance exhausted", DeepSeek "Insufficient Balance",
+ * OpenRouter credit exhaustion) — never a transient blip or bad credential.
  * Always combine with {@link isUsageLimitOutcome} when a message is available
  * — a 429 carrying transient rate-limit wording is NOT a usage cap.
  */
 export function isUsageLimitStatus(status: number | undefined): boolean {
-	return status === 429;
+	return status === 429 || status === 402;
 }
 
 /**
@@ -135,7 +138,7 @@ export function isUsageLimitStatus(status: number | undefined): boolean {
  *  1. Body matches {@link isUsageLimitError} (Codex `usage_limit_reached`,
  *     Anthropic account rate-limit, Google `resource_exhausted`, OpenAI
  *     `insufficient_quota`, …) → rotate.
- *  2. Status is not 429 → backoff (caller's domain).
+ *  2. Status is not a usage-limit status (429/402) → backoff (caller's domain).
  *  3. Body is absent or {@link isOpaqueStatusBody opaque} (just the status,
  *     empty JSON, HTTP framing only) → rotate conservatively: the server
  *     gave us nothing else to go on.
@@ -154,14 +157,15 @@ export function isUsageLimitOutcome(status: number | undefined, message: string
 }
 
 /**
- * A 429 body is opaque when it carries no signal beyond the status itself —
- * empty, whitespace-only, the status digits with HTTP/JSON framing, or
- * generic punctuation. Anything else (retry hints, capacity wording, error
- * descriptions) is informative enough to defer to the classifier.
+ * A usage-limit status body is opaque when it carries no signal beyond the
+ * status itself — empty, whitespace-only, the status digits with HTTP/JSON
+ * framing, or generic punctuation. Anything else (retry hints, capacity
+ * wording, error descriptions) is informative enough to defer to the
+ * classifier.
  */
 export function isOpaqueStatusBody(message: string): boolean {
 	const cleaned = message
-		.replace(/\b429\b/g, "")
+		.replace(/\b(?:429|402)\b/g, "")
 		.replace(/\b(?:http|https|status|error|code|response|message)\b/gi, "");
 	return !/[a-z\d]{3,}/i.test(cleaned);
 }

package/src/providers/__tests__/kimi-code-thinking.test.ts

@@ -1,7 +1,13 @@
-import { describe, expect, it } from "bun:test";
+import { afterEach, describe, expect, it, vi } from "bun:test";
 import { getBundledModel } from "@oh-my-pi/pi-catalog";
-import type { Context } from "../../types";
+import { buildModel } from "@oh-my-pi/pi-catalog/build";
+import { Effort } from "@oh-my-pi/pi-catalog/effort";
+import type { ModelSpec } from "@oh-my-pi/pi-catalog/types";
+import * as kimiOauth from "../../registry/oauth/kimi";
+import { streamSimple } from "../../stream";
+import type { Context, Model } from "../../types";
 import type { MessageCreateParamsStreaming } from "../anthropic-wire";
+import { type KimiApiFormat, streamKimi } from "../kimi";
 import { streamOpenAIAnthropicShim } from "../openai-anthropic-shim";
 import {
 	applyChatCompletionsCompatPolicy,
@@ -10,6 +16,15 @@ import {
 } from "../openai-shared";
 
 const BASE_CHAT_COMPLETIONS_PARAMS: OpenAICompletionsParams = { messages: [], model: "unused", stream: true };
+const KIMI_HEADERS = Object.freeze({
+	"User-Agent": "KimiCLI/test",
+	"X-Msh-Platform": "kimi_cli",
+	"X-Msh-Version": "test",
+	"X-Msh-Device-Name": "test",
+	"X-Msh-Device-Model": "test",
+	"X-Msh-Os-Version": "test",
+	"X-Msh-Device-Id": "test",
+});
 const TITLE_CONTEXT: Context = {
 	systemPrompt: ["Generate a title."],
 	messages: [{ role: "user", content: "Explain the login failure", timestamp: 0 }],
@@ -27,8 +42,125 @@ const TITLE_CONTEXT: Context = {
 	],
 };
 
+const K3_MODEL = buildModel({
+	id: "k3",
+	name: "K3",
+	api: "openai-completions",
+	provider: "kimi-code",
+	baseUrl: "https://api.kimi.com/coding/v1",
+	reasoning: true,
+	input: ["text"],
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	contextWindow: 1_048_576,
+	maxTokens: 32_000,
+	thinking: {
+		mode: "effort",
+		efforts: [Effort.Low, Effort.High, Effort.Max],
+		defaultLevel: Effort.Max,
+		requiresEffort: true,
+	},
+	compat: {
+		thinkingFormat: "kimi",
+		kimiApiFormat: "openai",
+		reasoningContentField: "reasoning_content",
+		supportsDeveloperRole: false,
+	},
+} satisfies ModelSpec<"openai-completions">);
+
+async function captureKimiPayload(
+	model: Model<"openai-completions">,
+	reasoning: Effort,
+	format?: KimiApiFormat,
+): Promise<unknown> {
+	let payload: unknown;
+	const stream = streamKimi(
+		model,
+		{
+			systemPrompt: [],
+			messages: [{ role: "user", content: "Reply OK", timestamp: 0 }],
+			tools: [],
+		},
+		{
+			...(format ? { format } : {}),
+			apiKey: "test-key",
+			reasoning,
+			onPayload: body => {
+				payload = body;
+				throw new Error("stop after payload capture");
+			},
+		},
+	);
+	await stream.result();
+	if (payload === undefined) throw new Error("Kimi request payload was not captured");
+	return payload;
+}
+
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+
+describe("Kimi K3 thinking transport", () => {
+	it("sends every live named effort through Kimi's native thinking object by default", async () => {
+		vi.spyOn(kimiOauth, "getKimiCommonHeaders").mockReturnValue(KIMI_HEADERS);
+
+		for (const effort of [Effort.Low, Effort.High, Effort.Max]) {
+			const payload = await captureKimiPayload(K3_MODEL, effort);
+			expect(payload).toMatchObject({ thinking: { type: "enabled", effort } });
+			expect(payload).not.toHaveProperty("reasoning_effort");
+		}
+	});
+
+	it("uses adaptive named effort rather than a token budget for an explicit Anthropic override", async () => {
+		vi.spyOn(kimiOauth, "getKimiCommonHeaders").mockReturnValue(KIMI_HEADERS);
+
+		const payload = await captureKimiPayload(K3_MODEL, Effort.Max, "anthropic");
+
+		expect(payload).toMatchObject({
+			thinking: { type: "adaptive" },
+			output_config: { effort: Effort.Max },
+		});
+		expect(payload).not.toHaveProperty("thinking.budget_tokens");
+	});
+
+	it("keeps the legacy K2 default on the Anthropic transport", async () => {
+		vi.spyOn(kimiOauth, "getKimiCommonHeaders").mockReturnValue(KIMI_HEADERS);
+		const model = getBundledModel<"openai-completions">("kimi-code", "kimi-for-coding");
+
+		const payload = await captureKimiPayload(model, Effort.High);
+
+		expect(payload).toMatchObject({ thinking: { type: "enabled" } });
+		expect(payload).toHaveProperty("thinking.budget_tokens");
+	});
+
+	it("clamps disabled thinking to the lowest effort for a mandatory-thinking K3", async () => {
+		vi.spyOn(kimiOauth, "getKimiCommonHeaders").mockReturnValue(KIMI_HEADERS);
+
+		let payload: unknown;
+		const stream = streamSimple(
+			K3_MODEL,
+			{
+				systemPrompt: [],
+				messages: [{ role: "user", content: "Reply OK", timestamp: 0 }],
+				tools: [],
+			},
+			{
+				apiKey: "test-key",
+				disableReasoning: true,
+				onPayload: body => {
+					payload = body;
+					throw new Error("stop after payload capture");
+				},
+			},
+		);
+		await stream.result();
+
+		expect(payload).toMatchObject({ thinking: { type: "enabled", effort: Effort.Low } });
+		expect(payload).not.toMatchObject({ thinking: { type: "disabled" } });
+	});
+});
+
 describe("Kimi K2.7 Code thinking policy", () => {
-	it("omits disabled thinking for title-generator-style Kimi Code requests", () => {
+	it("expresses disabled thinking explicitly for title-generator-style Kimi Code requests", () => {
 		const model = getBundledModel<"openai-completions">("kimi-code", "kimi-for-coding");
 		const policy = resolveOpenAICompatPolicy(model, {
 			endpoint: "chat-completions",
@@ -39,11 +171,16 @@ describe("Kimi K2.7 Code thinking policy", () => {
 
 		applyChatCompletionsCompatPolicy(params, policy);
 
-		expect("thinking" in params).toBe(false);
-		expect(model.compat.supportsForcedToolChoice).toBe(false);
+		// Kimi's native hosts speak the z.ai binary thinking field: a disabled
+		// request carries `{ type: "disabled" }` rather than omitting the block.
+		expect((params as Record<string, unknown>).thinking).toEqual({ type: "disabled" });
+		// Thinking yields to a forced tool choice (#5758 review): the choice is
+		// honored and reasoning is turned off, instead of downgrading the choice.
+		expect(model.compat.supportsForcedToolChoice).toBe(true);
+		expect(model.compat.disableReasoningOnForcedToolChoice).toBe(true);
 	});
 
-	it("enables thinking and downgrades forced tool choice on Kimi Code's Anthropic endpoint", async () => {
+	it("keeps the forced tool choice and omits thinking on Kimi Code's Anthropic endpoint", async () => {
 		const model = getBundledModel<"openai-completions">("kimi-code", "kimi-for-coding");
 		let payload: MessageCreateParamsStreaming | undefined;
 		const stream = streamOpenAIAnthropicShim(
@@ -67,8 +204,43 @@ describe("Kimi K2.7 Code thinking policy", () => {
 
 		await stream.result();
 
-		expect(payload?.thinking?.type).toBe("enabled");
-		expect(payload?.tool_choice).toEqual({ type: "auto" });
+		// With reasoning disabled the Anthropic wire carries no thinking block,
+		// and the forced tool choice survives (thinking yields to the choice).
+		expect(payload?.thinking).toBeUndefined();
+		expect(payload?.tool_choice).toEqual({ type: "tool", name: "set_title" });
+	});
+
+	it("uses the configured Kimi base URL for Anthropic requests", async () => {
+		vi.spyOn(kimiOauth, "getKimiCommonHeaders").mockReturnValue(KIMI_HEADERS);
+		const bundledModel = getBundledModel<"openai-completions">("kimi-code", "kimi-for-coding");
+		const model = { ...bundledModel, baseUrl: "https://gateway.example.com/v1" };
+		let requestedUrl: string | undefined;
+		const stream = streamKimi(
+			model,
+			{
+				systemPrompt: [],
+				messages: [{ role: "user", content: "Reply OK", timestamp: 0 }],
+				tools: [],
+			},
+			{
+				format: "anthropic",
+				apiKey: "gateway-key",
+				fetch: async input => {
+					requestedUrl = String(input);
+					return new Response(
+						JSON.stringify({
+							type: "error",
+							error: { type: "authentication_error", message: "stop after URL capture" },
+						}),
+						{ status: 401, headers: { "content-type": "application/json" } },
+					);
+				},
+			},
+		);
+
+		await stream.result();
+
+		expect(requestedUrl).toBe("https://gateway.example.com/v1/messages");
 	});
 
 	it("omits disabled thinking for native Moonshot Kimi K2.7 Code variants", () => {

package/src/providers/cursor.ts

@@ -213,6 +213,34 @@ function parseConnectEndStream(data: Uint8Array): Error | null {
 	}
 }
 
+/**
+ * Maps an opaque HTTP/2 negotiation failure into an actionable error.
+ *
+ * bun only opens an HTTP/2 session when TLS-ALPN negotiates `h2`. Behind a
+ * TLS-intercepting proxy that strips ALPN (e.g. Zscaler), the handshake yields
+ * no `h2` protocol and bun throws `ERR_HTTP2_ERROR: h2 is not supported`. The
+ * Cursor run RPC is HTTP/2-only (the ALB rejects HTTP/1.1 with 464), so there
+ * is no h1 fallback the way model discovery has one — the run simply cannot
+ * proceed. Replace the opaque message with one that names the cause and points
+ * at the `providers.cursor.baseUrl` workaround.
+ *
+ * Non-ALPN errors pass through untouched.
+ */
+export function mapH2TransportError(error: unknown, baseUrl: string): unknown {
+	const code = (error as { code?: unknown } | null)?.code;
+	const message = error instanceof Error ? error.message : String(error);
+	if (code === "ERR_HTTP2_ERROR" && /h2 is not supported/i.test(message)) {
+		return new AIError.ProviderResponseError(
+			`Cursor run transport could not negotiate HTTP/2 with ${baseUrl}: "h2 is not supported". ` +
+				"This host serves the run RPC over HTTP/2 only, and the TLS handshake did not negotiate " +
+				"h2 via ALPN — typically an ALPN-stripping TLS-intercepting proxy (e.g. Zscaler). " +
+				"Front the provider with a local HTTP/2 bridge and set providers.cursor.baseUrl to it.",
+			{ provider: "cursor", kind: "runtime", cause: error },
+		);
+	}
+	return error;
+}
+
 function debugBytes(bytes: Uint8Array, asHex: boolean): string {
 	if (asHex) {
 		return Buffer.from(bytes).toString("hex");
@@ -352,7 +380,30 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 		let heartbeatTimer: NodeJS.Timeout | null = null;
 		let debugResponseLogPromise: Promise<RequestDebugResponseLog | undefined> | undefined;
 		const h2Completion = Promise.withResolvers<void>();
-		let resolveH2: (() => void) | undefined = h2Completion.resolve;
+		let h2Settled = false;
+		let sawTurnEnded = false;
+		let endStreamError: Error | null = null;
+		const settleH2 = (error?: unknown): void => {
+			if (h2Settled) return;
+			h2Settled = true;
+			if (error !== undefined) {
+				h2Completion.reject(error);
+				return;
+			}
+			if (endStreamError) {
+				h2Completion.reject(endStreamError);
+				return;
+			}
+			if (!sawTurnEnded) {
+				h2Completion.reject(
+					new AIError.ProviderResponseError("Cursor stream ended before turnEnded", {
+						kind: "incomplete-stream",
+					}),
+				);
+				return;
+			}
+			h2Completion.resolve();
+		};
 
 		try {
 			const apiKey = options?.apiKey;
@@ -408,17 +459,17 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 			} else {
 				h2Client = http2.connect(baseUrl);
 			}
-			h2Client.on("error", h2Completion.reject);
+			h2Client.on("error", error => settleH2(mapH2TransportError(error, baseUrl)));
 
 			h2Request = h2Client.request(requestHeaders);
 
 			stream.push({ type: "start", partial: output });
 
 			let pendingBuffer = Buffer.alloc(0);
-			let endStreamError: Error | null = null;
 			let currentTextBlock: (TextContent & { [kStreamingBlockIndex]: number }) | null = null;
 			let currentThinkingBlock: (ThinkingContent & { [kStreamingBlockIndex]: number }) | null = null;
 			let currentToolCall: ToolCallState | null = null;
+			const resolvedMcpToolCallIds = new Set<string>();
 			const usageState: UsageState = { sawTokenDelta: false };
 
 			const state: BlockState = {
@@ -431,6 +482,7 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 				get currentToolCall() {
 					return currentToolCall;
 				},
+				resolvedMcpToolCallIds,
 				get firstTokenTime() {
 					return firstTokenTime;
 				},
@@ -505,12 +557,9 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 							log("error", "handleServerMessage", { error: String(error) });
 						});
 
-						// Resolve only on explicit turnEnded. stopReason defaults to "stop"
-						// and is not a reliable signal for stream completion.
-						if (isTurnEnded && resolveH2) {
-							const r = resolveH2;
-							resolveH2 = undefined;
-							r();
+						// Application completion is not protocol success; wait for a clean HTTP/2 end.
+						if (isTurnEnded) {
+							sawTurnEnded = true;
 						}
 					} catch (e) {
 						log("error", "parseServerMessage", { error: String(e) });
@@ -537,40 +586,30 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 			h2Request.on("trailers", trailers => {
 				const status = trailers["grpc-status"];
 				const msg = trailers["grpc-message"];
-				if (status && status !== "0") {
-					void closeDebugLog().finally(() => {
-						h2Completion.reject(
-							new AIError.ProviderResponseError(
-								`gRPC error ${status}: ${decodeURIComponent(String(msg || ""))}`,
-								{ kind: "envelope" },
-							),
-						);
-					});
+				if (status && status !== "0" && !endStreamError) {
+					endStreamError = new AIError.ProviderResponseError(
+						`gRPC error ${status}: ${decodeURIComponent(String(msg || ""))}`,
+						{ kind: "envelope" },
+					);
 				}
 			});
 
 			h2Request.on("end", () => {
-				resolveH2 = undefined;
 				void closeDebugLog()
-					.then(() => {
-						if (endStreamError) {
-							h2Completion.reject(endStreamError);
-							return;
-						}
-						h2Completion.resolve();
-					})
-					.catch(h2Completion.reject);
+					.then(() => settleH2())
+					.catch(error => settleH2(error));
 			});
 
 			h2Request.on("error", error => {
-				void closeDebugLog().finally(() => h2Completion.reject(error));
+				const mapped = mapH2TransportError(error, baseUrl);
+				void closeDebugLog().finally(() => settleH2(mapped));
 			});
 
 			if (options?.signal) {
 				options.signal.addEventListener("abort", () => {
 					h2Request?.close();
 					void closeDebugLog().finally(() => {
-						h2Completion.reject(new AIError.AbortError());
+						settleH2(new AIError.AbortError());
 					});
 				});
 			}
@@ -640,6 +679,8 @@ export interface BlockState {
 	currentTextBlock: (TextContent & { [kStreamingBlockIndex]: number }) | null;
 	currentThinkingBlock: (ThinkingContent & { [kStreamingBlockIndex]: number }) | null;
 	currentToolCall: ToolCallState | null;
+	/** MCP call IDs executed through Cursor's exec channel before their stream block arrives. */
+	resolvedMcpToolCallIds: Set<string>;
 	firstTokenTime: number | undefined;
 	setTextBlock: (b: (TextContent & { [kStreamingBlockIndex]: number }) | null) => void;
 	setThinkingBlock: (b: (ThinkingContent & { [kStreamingBlockIndex]: number }) | null) => void;
@@ -1292,6 +1333,13 @@ async function handleExecServerMessage(
 		case "mcpArgs": {
 			const args = execMsg.message.value;
 			const mcpCall = decodeMcpCall(args);
+			if (execHandlers?.mcp) {
+				if (state.currentToolCall?.id === mcpCall.toolCallId) {
+					state.currentToolCall[kCursorExecResolved] = true;
+				} else {
+					state.resolvedMcpToolCallIds.add(mcpCall.toolCallId);
+				}
+			}
 			const { execResult } = await resolveExecHandler(
 				mcpCall,
 				execHandlers?.mcp?.bind(execHandlers),
@@ -2217,15 +2265,19 @@ export function processInteractionUpdate(
 			const mcpCall = toolCall.mcpToolCall;
 			if (mcpCall) {
 				const args = mcpCall.args || {};
+				const id = args.toolCallId || crypto.randomUUID();
 				const block: ToolCallState = {
 					type: "toolCall",
-					id: args.toolCallId || crypto.randomUUID(),
+					id,
 					name: args.name || args.toolName || "",
 					arguments: {},
 					[kStreamingBlockIndex]: output.content.length,
 					[kStreamingPartialJson]: "",
 					[kStreamingBlockKind]: "mcp",
 				};
+				if (state.resolvedMcpToolCallIds.delete(id)) {
+					block[kCursorExecResolved] = true;
+				}
 				output.content.push(block);
 				state.setToolCall(block);
 				stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });

package/src/providers/gitlab-duo-workflow.ts

@@ -24,6 +24,7 @@ import { normalizeSystemPrompts } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { toolWireSchema } from "../utils/schema/wire";
 import chatmlHistoryNote from "./gitlab-duo-workflow-chatml-note.md" with { type: "text" };
+import { redactSensitiveCredentials } from "./transform-messages";
 
 export const GITLAB_DUO_WORKFLOW_PROVIDER_ID = "gitlab-duo-agent";
 export const GITLAB_DUO_WORKFLOW_API = "gitlab-duo-agent";
@@ -2581,10 +2582,13 @@ function isGitLabDuoWorkflowChatMlGoal(context: Context): boolean {
 // conversation sequences the way `Human:`/`Assistant:` are.
 function buildGitLabDuoWorkflowGoal(context: Context): string {
 	const conversation = buildGitLabDuoWorkflowConversationHistory(context.messages);
+	// The goal transcript bypasses transformMessages, so apply the outbound
+	// credential redaction here — the same scrub the flow-config system slot
+	// already receives — before the payload leaves the process.
 	if (conversation.length <= 1) {
-		return extractLatestUserPrompt(context.messages);
+		return redactSensitiveCredentials(extractLatestUserPrompt(context.messages));
 	}
-	return renderGitLabDuoWorkflowChatMl(conversation);
+	return redactSensitiveCredentials(renderGitLabDuoWorkflowChatMl(conversation));
 }
 
 const GITLAB_DUO_WORKFLOW_CHATML_START = "<|im_start|>";

package/src/providers/kimi.ts

@@ -5,8 +5,8 @@
  * - OpenAI: https://api.kimi.com/coding/v1/chat/completions
  * - Anthropic: https://api.kimi.com/coding/v1/messages
  *
- * The Anthropic API is generally more stable and recommended.
- * Note: Kimi calculates TPM rate limits based on max_tokens, not actual output.
+ * Each discovered model selects its server-declared protocol; legacy models
+ * without protocol metadata retain the Anthropic-compatible default.
  */
 
 import { getKimiCommonHeaders } from "../registry/oauth/kimi";
@@ -20,11 +20,8 @@ import {
 
 export type KimiApiFormat = OpenAIAnthropicApiFormat;
 
-// Note: Anthropic SDK appends /v1/messages, so base URL should not include /v1
-const KIMI_ANTHROPIC_BASE_URL = "https://api.kimi.com/coding";
-
 export interface KimiOptions extends OpenAIAnthropicShimOptions {
-	/** API format: "openai" or "anthropic". Default: "anthropic" */
+	/** Explicit API format override. Defaults to the model's discovered protocol. */
 	format?: KimiApiFormat;
 }
 
@@ -38,8 +35,9 @@ export function streamKimi(
 	options?: KimiOptions,
 ): AssistantMessageEventStream {
 	return streamOpenAIAnthropicShim(model, context, options, {
-		anthropicBaseUrl: KIMI_ANTHROPIC_BASE_URL,
-		defaultFormat: "anthropic",
+		anthropicBaseUrl: model.baseUrl.replace(/\/v1\/?$/, ""),
+		defaultFormat: model.compat.kimiApiFormat ?? "anthropic",
+		anthropicThinkingMode: model.compat.thinkingFormat === "kimi" ? "anthropic-adaptive" : undefined,
 		extraHeaders: getKimiCommonHeaders,
 	});
 }

package/src/providers/openai-anthropic-shim.ts

@@ -10,7 +10,7 @@
 
 import { buildModel } from "@oh-my-pi/pi-catalog/build";
 import { ANTHROPIC_THINKING, mapAnthropicToolChoice } from "../stream";
-import type { Context, Model, ModelSpec, SimpleStreamOptions } from "../types";
+import type { Context, Model, ModelSpec, SimpleStreamOptions, ThinkingControlMode } from "../types";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { createProviderErrorMessage } from "./error-message";
 import { streamAnthropic, streamOpenAICompletions } from "./register-builtins";
@@ -29,6 +29,8 @@ export interface OpenAIAnthropicShimConfig {
 	openaiBaseUrl?: string;
 	/** Default API format when caller does not specify one. */
 	defaultFormat: OpenAIAnthropicApiFormat;
+	/** Thinking transport used when this provider's Anthropic endpoint differs from generic budget semantics. */
+	anthropicThinkingMode?: ThinkingControlMode;
 	/** Provider-specific headers (e.g. auth/session) merged ahead of user-supplied headers. */
 	extraHeaders?: () => Record<string, string>;
 }
@@ -67,6 +69,9 @@ export function streamOpenAIAnthropicShim(
 					contextWindow: model.contextWindow,
 					maxTokens: model.maxTokens,
 					reasoning: model.reasoning,
+					...(config.anthropicThinkingMode && model.thinking
+						? { thinking: { ...model.thinking, mode: config.anthropicThinkingMode } }
+						: {}),
 					input: model.input,
 					cost: model.cost,
 				} as ModelSpec<"anthropic-messages">);
@@ -95,6 +100,7 @@ export function streamOpenAIAnthropicShim(
 					fetch: options?.fetch,
 					thinkingEnabled,
 					thinkingBudgetTokens: thinkingBudget,
+					reasoning: config.anthropicThinkingMode ? reasoningEffort : undefined,
 					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
 					serviceTier: options?.serviceTier,
 				});

package/src/providers/openai-codex/request-transformer.ts

@@ -269,6 +269,7 @@ function stripImageDetails(input: unknown[]): void {
 export interface CodexLiteShapedBody {
 	instructions?: unknown;
 	tools?: unknown;
+	tool_choice?: unknown;
 	input?: unknown;
 	parallel_tool_calls?: unknown;
 }
@@ -278,9 +279,14 @@ export interface CodexLiteShapedBody {
  * `build_responses_request` with `use_responses_lite`): strips pinned image
  * detail, forces parallel tool calling off, moves tools into a leading
  * `additional_tools` developer item and the base instructions into a
- * developer message, then omits top-level `instructions`/`tools`. Shared by
- * normal turns and both remote-compaction paths — codex-rs routes
- * `/responses/compact` through the same builder.
+ * developer message, then omits top-level `instructions`/`tools`. Because the
+ * rewrite removes top-level `tools`, a forced hosted-tool choice (e.g.
+ * `{ type: "web_search" }`) would leave the backend unable to validate the
+ * choice against a tools collection and it rejects the request with HTTP 400
+ * (#5771). Such choices must fall back to `"auto"`; explicit string constraints
+ * such as `"none"` and `"required"` remain valid. Shared by normal turns and
+ * both remote-compaction paths — codex-rs routes `/responses/compact` through
+ * the same builder.
  */
 export function applyCodexResponsesLiteShape(body: CodexLiteShapedBody): void {
 	const input = Array.isArray(body.input) ? body.input : [];
@@ -297,6 +303,9 @@ export function applyCodexResponsesLiteShape(body: CodexLiteShapedBody): void {
 		});
 	}
 	body.input = [...prefix, ...input];
+	if (body.tool_choice !== "none" && body.tool_choice !== "required") {
+		body.tool_choice = "auto";
+	}
 	delete body.instructions;
 	delete body.tools;
 }

package/src/providers/openai-codex-responses.ts

@@ -112,7 +112,7 @@ import {
 	promoteResponsesToolUseStopReason,
 	type SequentialCutoffSummaryState,
 } from "./openai-shared";
-import { transformMessages } from "./transform-messages";
+import { redactSensitiveInObject, transformMessages } from "./transform-messages";
 
 export interface OpenAICodexResponsesOptions extends StreamOptions {
 	reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
@@ -3954,13 +3954,14 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 				| Array<ResponseInput[number]>
 				| undefined;
 			if (historyItems) {
-				for (const item of historyItems) {
+				const redactedHistoryItems = redactSensitiveInObject(historyItems).result as Array<ResponseInput[number]>;
+				for (const item of redactedHistoryItems) {
 					const maybe = item as { type?: string; call_id?: string };
 					if (maybe.type === "custom_tool_call" && typeof maybe.call_id === "string") {
 						customCallIds.add(maybe.call_id);
 					}
 				}
-				messages.push(...historyItems);
+				messages.push(...redactedHistoryItems);
 				msgIndex += 1;
 				continue;
 			}

package/src/providers/openai-completions.ts

@@ -94,9 +94,9 @@ import {
 	type OpenAIStrictToolsState,
 	parseAzureDeploymentNameMap,
 	resolveOpenAICompatPolicy,
+	resolveOpenAICompletionsOutputClamp,
 	resolveOpenAIOutputTokenParam,
 	resolveOpenAIRequestSetup,
-	resolveZaiReasoningOutputClamp,
 	shouldRetryWithoutStrictTools,
 } from "./openai-shared";
 import { transformMessages } from "./transform-messages";
@@ -1571,7 +1571,7 @@ function buildParams(
 		omitMaxOutputTokens: model.omitMaxOutputTokens ?? false,
 		isOpenRouterHost: compat.isOpenRouterHost,
 		alwaysSendMaxTokens: compat.alwaysSendMaxTokens,
-		providerOutputClamp: resolveZaiReasoningOutputClamp(model, compat),
+		providerOutputClamp: resolveOpenAICompletionsOutputClamp(model, compat),
 	});
 	if (outputToken) {
 		if (outputToken.field === "max_tokens") {