@oh-my-pi/pi-ai 17.0.2 → 17.0.4

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [17.0.4] - 2026-07-18
+
+### Fixed
+
+- Fixed Kimi Code usage reports dropping the 5h window reset time (`omp usage` showed no "resets in …" for the 5h limit): the API returns `resetTime` on the limit `detail`, not on `window`, so the parsed row-level reset is now carried onto the window when the window itself has none.
+- Made Kimi device-id persistence best-effort: a missing or unwritable `~/.omp/agent` directory no longer throws during Kimi header construction, which silently nulled every `kimi-code` usage probe on fresh installs.
+- Coerced boolean tool-schema subschemas to MFJS object forms for native Moonshot/Kimi endpoints, preventing the task tool's `outputSchema` field from causing HTTP 400 responses ([#5952](https://github.com/can1357/oh-my-pi/issues/5952)).
+
+## [17.0.3] - 2026-07-17
+
+### Fixed
+
+- Replaced the opaque `h2 is not supported` failure on the Cursor run transport with an actionable error naming the ALPN-stripping proxy as the cause and pointing at the `providers.cursor.baseUrl` HTTP/2 bridge workaround. The run RPC is HTTP/2-only, so behind a TLS-intercepting proxy that strips ALPN (e.g. Zscaler) bun cannot negotiate `h2` and the completion cannot proceed ([#5828](https://github.com/can1357/oh-my-pi/issues/5828)).
+- Restored the `createAssistantMessageEventStream()` root export used by legacy provider extensions ([#5879](https://github.com/can1357/oh-my-pi/issues/5879)).
+- Fixed parallel Responses tool-result images interleaving synthetic user messages before all pending outputs, preventing strict OpenRouter/Moonshot backends from rejecting follow-up requests. ([#5850](https://github.com/can1357/oh-my-pi/issues/5850))
+- Fixed Kimi Code K3 requests to send native named efforts (`low`, `high`, `max`) and use adaptive effort rather than generic token budgets on explicit Anthropic transport overrides ([#5893](https://github.com/can1357/oh-my-pi/issues/5893)).
+- Automatically invalidate and rotate OAuth credentials when an "invalidated oauth token" error occurs
+- Fixed Anthropic usage reports treating the organization response header as the account identity, which caused the 5h/7d status-line segment to disappear for OAuth credentials without stored organization metadata. ([#5698](https://github.com/can1357/oh-my-pi/issues/5698))
+
 ## [17.0.2] - 2026-07-17
 
 ### Fixed

package/dist/types/providers/cursor.d.ts

@@ -13,6 +13,20 @@ export interface CursorOptions extends StreamOptions {
     execHandlers?: CursorExecHandlers;
     onToolResult?: CursorToolResultHandler;
 }
+/**
+ * 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 declare function mapH2TransportError(error: unknown, baseUrl: string): unknown;
 export declare const streamCursor: StreamFunction<"cursor-agent">;
 export type ToolCallState = ToolCall & {
     [kStreamingBlockIndex]: number;

package/dist/types/providers/kimi.d.ts

@@ -5,15 +5,15 @@
  * - 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 type { Api, Context, Model } from "../types.js";
 import type { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { type OpenAIAnthropicApiFormat, type OpenAIAnthropicShimOptions } from "./openai-anthropic-shim.js";
 export type KimiApiFormat = OpenAIAnthropicApiFormat;
 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;
 }
 /**

package/dist/types/providers/openai-anthropic-shim.d.ts

@@ -7,7 +7,7 @@
  * format, optional extra headers); the streaming/forwarding plumbing lives
  * here once.
  */
-import type { Context, Model, SimpleStreamOptions } from "../types.js";
+import type { Context, Model, SimpleStreamOptions, ThinkingControlMode } from "../types.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 export type OpenAIAnthropicApiFormat = "openai" | "anthropic";
 export interface OpenAIAnthropicShimOptions extends SimpleStreamOptions {
@@ -21,6 +21,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>;
 }

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

@@ -200,6 +200,7 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
     repetition_penalty?: number;
     thinking?: {
         type: "enabled" | "disabled";
+        effort?: string;
         keep?: "all";
     };
     enable_thinking?: boolean;
@@ -382,6 +383,7 @@ export interface BuildResponsesInputOptions<TApi extends Api> {
 }
 export declare function buildResponsesInput<TApi extends Api>(options: BuildResponsesInputOptions<TApi>): ResponseInput;
 export declare function convertResponsesAssistantMessage<TApi extends Api>(assistantMsg: AssistantMessage, model: Model<TApi>, msgIndex: number, knownCallIds: Set<string>, includeThinkingSignatures?: boolean, customCallIds?: Set<string>, preserveMessageIds?: boolean, supportsCustomToolCalls?: boolean, customToolWireNameMap?: ReadonlyMap<string, string>): ResponseInput;
+/** Appends one tool result while keeping consecutive outputs ahead of its synthetic image messages. */
 export declare function appendResponsesToolResultMessages<TApi extends Api>(messages: ResponseInput, toolResult: ToolResultMessage, model: Model<TApi>, strictResponsesPairing: boolean, supportsImageDetailOriginal: boolean, knownCallIds: ReadonlySet<string>, customCallIds?: ReadonlySet<string>, supportsCustomToolCalls?: boolean): void;
 /**
  * Per-block accumulation helpers shared by the two Responses decode loops —

package/dist/types/types.d.ts

@@ -376,7 +376,7 @@ export interface SimpleStreamOptions extends Omit<StreamOptions, "apiKey"> {
     toolChoice?: ToolChoice;
     /** OpenAI service tier for processing priority/cost control. Ignored by non-OpenAI providers. */
     serviceTier?: ServiceTier;
-    /** API format for Kimi Code provider: "openai" or "anthropic" (default: "anthropic") */
+    /** Explicit Kimi Code API format override; omitted uses live per-model protocol metadata. */
     kimiApiFormat?: "openai" | "anthropic";
     /** API format for Synthetic provider: "openai" or "anthropic" (default: "openai") */
     syntheticApiFormat?: "openai" | "anthropic";

package/dist/types/utils/event-stream.d.ts

@@ -35,3 +35,5 @@ export declare class AssistantMessageEventStream extends EventStream<AssistantMe
     push(event: AssistantMessageEvent): void;
     end(result?: AssistantMessage): void;
 }
+/** Create an assistant-message event stream for legacy extension providers. */
+export declare function createAssistantMessageEventStream(): AssistantMessageEventStream;

package/dist/types/utils/schema/normalize.d.ts

@@ -2,8 +2,11 @@ import { type DescriptionSpillFormat } from "./spill.js";
 import { type JsonObject } from "./types.js";
 export type ResidualSchemaIncompatibility = "type-array" | "type-null" | "nullable" | "combiners" | "not";
 export interface NormalizeSchemaOptions {
-    /** Coerce JSON Schema boolean subschemas for providers whose wire cannot encode them. */
-    coerceBooleanSubschemas?: boolean;
+    /**
+     * Coerce boolean subschemas to object forms. `standard` preserves `false`
+     * with `not`; `permissive` uses `{}` when the provider cannot express it.
+     */
+    coerceBooleanSubschemas?: "standard" | "permissive";
     unsupportedFields: (key: string) => boolean;
     normalizeFieldNames: boolean;
     collapseNullFields: boolean;
@@ -62,6 +65,9 @@ export declare function normalizeSchemaForMCP(value: unknown): unknown;
  *    `default` and `description` are MFJS Meta Data fields and are preserved.
  *  - `additionalProperties` (boolean or schema) and `type: "null"` (incl.
  *    inside `anyOf`) are kept.
+ *  - Boolean subschemas are object-coerced; MFJS has no exact `false` schema,
+ *    so both values become the permissive empty schema while local tool
+ *    validation remains authoritative.
  *
  * Out of scope (absent from the built-in tool surface, spec-ambiguous to
  * rewrite blindly): `allOf` intersection merging, external/recursive `$ref`,

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.0.2",
+	"version": "17.0.4",
 	"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.1",
-		"@oh-my-pi/pi-catalog": "17.0.2",
-		"@oh-my-pi/pi-utils": "17.0.2",
-		"@oh-my-pi/pi-wire": "17.0.2",
+		"@oh-my-pi/pi-catalog": "17.0.4",
+		"@oh-my-pi/pi-utils": "17.0.4",
+		"@oh-my-pi/pi-wire": "17.0.4",
 		"arktype": "2.2.3",
 		"zod": "^4"
 	},

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

@@ -1,9 +1,13 @@
 import { afterEach, describe, expect, it, vi } from "bun:test";
 import { getBundledModel } from "@oh-my-pi/pi-catalog";
+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 type { Context } from "../../types";
+import { streamSimple } from "../../stream";
+import type { Context, Model } from "../../types";
 import type { MessageCreateParamsStreaming } from "../anthropic-wire";
-import { streamKimi } from "../kimi";
+import { type KimiApiFormat, streamKimi } from "../kimi";
 import { streamOpenAIAnthropicShim } from "../openai-anthropic-shim";
 import {
 	applyChatCompletionsCompatPolicy,
@@ -38,10 +42,123 @@ 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("expresses disabled thinking explicitly for title-generator-style Kimi Code requests", () => {
 		const model = getBundledModel<"openai-completions">("kimi-code", "kimi-for-coding");

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");
@@ -431,7 +459,7 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 			} else {
 				h2Client = http2.connect(baseUrl);
 			}
-			h2Client.on("error", error => settleH2(error));
+			h2Client.on("error", error => settleH2(mapH2TransportError(error, baseUrl)));
 
 			h2Request = h2Client.request(requestHeaders);
 
@@ -573,7 +601,8 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 			});
 
 			h2Request.on("error", error => {
-				void closeDebugLog().finally(() => settleH2(error));
+				const mapped = mapH2TransportError(error, baseUrl);
+				void closeDebugLog().finally(() => settleH2(mapped));
 			});
 
 			if (options?.signal) {

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";
@@ -21,7 +21,7 @@ import {
 export type KimiApiFormat = OpenAIAnthropicApiFormat;
 
 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;
 }
 
@@ -36,7 +36,8 @@ export function streamKimi(
 ): AssistantMessageEventStream {
 	return streamOpenAIAnthropicShim(model, context, options, {
 		anthropicBaseUrl: model.baseUrl.replace(/\/v1\/?$/, ""),
-		defaultFormat: "anthropic",
+		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-responses.ts

@@ -38,6 +38,7 @@ import {
 	adaptSchemaForStrict,
 	findStrictToolSchemaViolation,
 	NO_STRICT,
+	normalizeSchemaForMoonshot,
 	sanitizeSchemaForOpenAIResponses,
 	toolWireSchema,
 } from "../utils/schema";
@@ -999,7 +1000,15 @@ export function convertTools(
 		}
 		const strict = !NO_STRICT && strictMode && tool.strict !== false;
 		const baseParameters = toolWireSchema(tool);
-		const responseParameters = sanitizeSchemaForOpenAIResponses(baseParameters);
+		// MFJS must run AFTER the Responses sanitizer: the sanitizer normalizes
+		// `{}` → `true` (issue #1179), and Moonshot's validator rejects boolean
+		// subschemas ("property schema … must be an object"), so the Moonshot
+		// pass re-coerces them last.
+		const sanitized = sanitizeSchemaForOpenAIResponses(baseParameters);
+		const responseParameters =
+			model.compat.toolSchemaFlavor === "moonshot-mfjs"
+				? (normalizeSchemaForMoonshot(sanitized) as Record<string, unknown>)
+				: sanitized;
 		const { schema: parameters, strict: effectiveStrict } = adaptSchemaForStrict(responseParameters, strict);
 		// Quarantine a tool whose emitted schema carries a provider-rejecting
 		// enum/const-vs-type contradiction: dropping just that tool keeps the rest

package/src/providers/openai-shared.ts

@@ -654,7 +654,7 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
 	top_k?: number;
 	min_p?: number;
 	repetition_penalty?: number;
-	thinking?: { type: "enabled" | "disabled"; keep?: "all" };
+	thinking?: { type: "enabled" | "disabled"; effort?: string; keep?: "all" };
 	enable_thinking?: boolean;
 	preserve_thinking?: boolean;
 	chat_template_kwargs?: { enable_thinking?: boolean; preserve_thinking?: boolean };
@@ -944,6 +944,11 @@ export function applyChatCompletionsCompatPolicy(params: OpenAICompletionsParams
 					encodeChatCompletionsDisabledReasoning(params, reasoning.disableMode);
 					return;
 				}
+				if (reasoning.dialect === "kimi" && reasoning.wireEffort !== undefined) {
+					params.thinking = { type: "enabled", effort: reasoning.wireEffort };
+					if (policy.compat.thinkingKeep) params.thinking.keep = policy.compat.thinkingKeep;
+					break;
+				}
 				params.thinking = { type: "enabled" };
 				if (policy.compat.thinkingKeep) params.thinking.keep = policy.compat.thinkingKeep;
 				if (policy.compat.supportsReasoningEffort && reasoning.wireEffort !== undefined) {
@@ -1734,6 +1739,21 @@ export function convertResponsesAssistantMessage<TApi extends Api>(
 	return outputItems;
 }
 
+const syntheticToolImageMessages = new WeakSet<object>();
+
+function insertResponsesToolOutput(messages: ResponseInput, output: ResponseInput[number]): void {
+	let index = messages.length;
+	while (index > 0) {
+		const previous = messages[index - 1];
+		if (typeof previous !== "object" || previous === null || !syntheticToolImageMessages.has(previous)) {
+			break;
+		}
+		index -= 1;
+	}
+	messages.splice(index, 0, output);
+}
+
+/** Appends one tool result while keeping consecutive outputs ahead of its synthetic image messages. */
 export function appendResponsesToolResultMessages<TApi extends Api>(
 	messages: ResponseInput,
 	toolResult: ToolResultMessage,
@@ -1780,13 +1800,13 @@ export function appendResponsesToolResultMessages<TApi extends Api>(
 		return;
 	}
 	if (supportsCustomToolCalls && customCallIds?.has(normalized.callId)) {
-		messages.push({
+		insertResponsesToolOutput(messages, {
 			type: "custom_tool_call_output",
 			call_id: normalized.callId,
 			output,
 		} as ResponseInput[number]);
 	} else {
-		messages.push({
+		insertResponsesToolOutput(messages, {
 			type: "function_call_output",
 			call_id: normalized.callId,
 			output,
@@ -1809,7 +1829,9 @@ export function appendResponsesToolResultMessages<TApi extends Api>(
 			} satisfies ResponseInputImage);
 		}
 	}
-	messages.push({ role: "user", content: contentParts });
+	const imageMessage = { role: "user", content: contentParts } satisfies ResponseInput[number];
+	syntheticToolImageMessages.add(imageMessage);
+	messages.push(imageMessage);
 }
 
 /**

package/src/registry/oauth/kimi.ts

@@ -7,7 +7,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { scheduler } from "node:timers/promises";
-import { $env, getAgentDir, isEnoent } from "@oh-my-pi/pi-utils";
+import { $env, getAgentDir } from "@oh-my-pi/pi-utils";
 import packageJson from "../../../package.json" with { type: "json" };
 import * as AIError from "../../error";
 import type { OAuthController, OAuthCredentials } from "./types";
@@ -57,21 +57,29 @@ function getDeviceModel(): string {
 	return formatDeviceModel(label, release, arch);
 }
 
+// Device id identifies this install to Kimi. Persistence is best-effort: a
+// missing/unwritable agent dir must never break header construction (and with
+// it every usage probe / request that spreads getKimiCommonHeaders()) — fall
+// back to a per-process ephemeral id instead.
 let getDeviceId = (): string => {
 	const deviceIdPath = path.join(getAgentDir(), DEVICE_ID_FILENAME);
 	try {
-		const existing = fs.readFileSync(deviceIdPath, "utf-8");
-		const trimmed = existing.trim();
-		if (trimmed) {
-			getDeviceId = () => trimmed;
-			return trimmed;
+		const existing = fs.readFileSync(deviceIdPath, "utf-8").trim();
+		if (existing) {
+			getDeviceId = () => existing;
+			return existing;
 		}
-	} catch (error) {
-		if (!isEnoent(error)) throw error;
+	} catch {
+		// Unreadable device-id file: regenerate below.
 	}
 
 	const deviceId = crypto.randomUUID().replace(/-/g, "");
-	fs.writeFileSync(deviceIdPath, `${deviceId}\n`, { mode: 0o600 });
+	try {
+		fs.mkdirSync(path.dirname(deviceIdPath), { recursive: true });
+		fs.writeFileSync(deviceIdPath, `${deviceId}\n`, { mode: 0o600 });
+	} catch {
+		// Persist failure → ephemeral id for this process.
+	}
 	getDeviceId = () => deviceId;
 	return deviceId;
 };

package/src/stream.ts

@@ -1178,12 +1178,17 @@ export function streamSimple<TApi extends Api>(
 
 	// Kimi Code - route to dedicated handler that wraps OpenAI or Anthropic API
 	if (isKimiModel(model)) {
-		// Pass raw SimpleStreamOptions - streamKimi handles mapping internally
-		return withProviderInFlightLimit(model, requestOptions, () =>
+		// streamKimi handles openai/anthropic format mapping internally, but the
+		// mandatory-reasoning clamp is a request-shaping concern owned here: K3's
+		// `supports_thinking_type: "only"` endpoint rejects disabled/omitted
+		// thinking, so clamp disabled requests to the lowest supported effort
+		// (mirrors the mapOptionsForApi path every other provider takes).
+		const kimiOptions = normalizeMandatoryReasoningOptions(model, requestOptions);
+		return withProviderInFlightLimit(model, kimiOptions, () =>
 			streamKimi(model as Model<"openai-completions">, context, {
-				...requestOptions,
+				...kimiOptions,
 				apiKey,
-				format: requestOptions?.kimiApiFormat ?? "anthropic",
+				format: kimiOptions?.kimiApiFormat,
 			}),
 		);
 	}

package/src/types.ts

@@ -539,7 +539,7 @@ export interface SimpleStreamOptions extends Omit<StreamOptions, "apiKey"> {
 	toolChoice?: ToolChoice;
 	/** OpenAI service tier for processing priority/cost control. Ignored by non-OpenAI providers. */
 	serviceTier?: ServiceTier;
-	/** API format for Kimi Code provider: "openai" or "anthropic" (default: "anthropic") */
+	/** Explicit Kimi Code API format override; omitted uses live per-model protocol metadata. */
 	kimiApiFormat?: "openai" | "anthropic";
 	/** API format for Synthetic provider: "openai" or "anthropic" (default: "openai") */
 	syntheticApiFormat?: "openai" | "anthropic";

package/src/usage/claude.ts

@@ -96,11 +96,6 @@ interface ParsedApiLimitEntry {
 	displayName?: string;
 }
 
-type ClaudeUsagePayload = {
-	payload: ClaudeUsageResponse;
-	orgId?: string;
-};
-
 function parseIsoTime(value: string | undefined): number | undefined {
 	if (!value) return undefined;
 	const parsed = Date.parse(value);
@@ -178,22 +173,17 @@ function getNestedPayloadString(payload: Record<string, unknown>, key: string, n
 	return isRecord(nested) ? getPayloadString(nested, nestedKey) : undefined;
 }
 
-function extractUsageIdentity(payload: ClaudeUsageResponse, orgId?: string): { accountId?: string; email?: string } {
-	if (!isRecord(payload)) return { accountId: orgId };
+function extractUsageIdentity(payload: ClaudeUsageResponse): { accountId?: string; email?: string } {
+	if (!isRecord(payload)) return {};
 	const accountId =
 		getPayloadString(payload, "account_id") ??
 		getPayloadString(payload, "accountId") ??
 		getPayloadString(payload, "user_id") ??
 		getPayloadString(payload, "userId") ??
-		getPayloadString(payload, "org_id") ??
-		getPayloadString(payload, "orgId") ??
 		getNestedPayloadString(payload, "account", "uuid") ??
 		getNestedPayloadString(payload, "account", "id") ??
-		getNestedPayloadString(payload, "organization", "uuid") ??
-		getNestedPayloadString(payload, "organization", "id") ??
 		getNestedPayloadString(payload, "user", "uuid") ??
-		getNestedPayloadString(payload, "user", "id") ??
-		orgId;
+		getNestedPayloadString(payload, "user", "id");
 	const email =
 		getPayloadString(payload, "email") ??
 		getPayloadString(payload, "user_email") ??
@@ -263,16 +253,13 @@ async function fetchUsagePayload(
 	headers: Record<string, string>,
 	ctx: UsageFetchContext,
 	signal?: AbortSignal,
-): Promise<ClaudeUsagePayload | null> {
+): Promise<ClaudeUsageResponse | null> {
 	if (signal?.aborted) return null;
 
 	let lastPayload: ClaudeUsageResponse | null = null;
-	let lastOrgId: string | undefined;
 	for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
 		try {
 			const response = await ctx.fetch(url, { headers, signal });
-			const orgId = response.headers.get("anthropic-organization-id")?.trim() || undefined;
-			lastOrgId = orgId ?? lastOrgId;
 
 			if (!response.ok) {
 				const retryable = isRetryableStatus(response.status);
@@ -292,7 +279,7 @@ async function fetchUsagePayload(
 			if (isRecord(parsed)) {
 				const payload = parsed as ClaudeUsageResponse;
 				lastPayload = payload;
-				if (hasUsageData(payload)) return { payload, orgId };
+				if (hasUsageData(payload)) return payload;
 			}
 
 			ctx.logger?.warn("Claude usage response missing usage data", {
@@ -311,7 +298,7 @@ async function fetchUsagePayload(
 		}
 	}
 
-	return lastPayload ? { payload: lastPayload, orgId: lastOrgId } : null;
+	return lastPayload;
 }
 
 interface ClaudeProfile {
@@ -507,9 +494,8 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 		authorization: `Bearer ${credential.accessToken}`,
 	};
 
-	const payloadResult = await fetchUsagePayload(url, headers, ctx, params.signal);
-	if (!payloadResult || !isRecord(payloadResult.payload)) return null;
-	const { payload, orgId } = payloadResult;
+	const payload = await fetchUsagePayload(url, headers, ctx, params.signal);
+	if (!payload || !isRecord(payload)) return null;
 
 	const apiLimitEntries = parseApiLimitEntries(payload.limits);
 	const fiveHour = parseBucket(payload.five_hour) ?? apiLimitEntries.find(entry => entry.kind === "session")?.bucket;
@@ -563,7 +549,7 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 	].filter((limit): limit is UsageLimit => limit !== null);
 
 	if (limits.length === 0) return null;
-	const identity = extractUsageIdentity(payload, orgId);
+	const identity = extractUsageIdentity(payload);
 	let accountId = identity.accountId ?? credential.accountId;
 	let email = identity.email ?? credential.email;
 	if ((!accountId || !email) && !params.signal?.aborted) {
@@ -580,7 +566,7 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 			endpoint: url,
 			...(accountId ? { accountId } : {}),
 			...(email ? { email } : {}),
-			...(orgId ? { orgId } : {}),
+			...(credential.orgId ? { orgId: credential.orgId } : {}),
 		},
 		raw: payload,
 	};

package/src/usage/kimi.ts

@@ -144,15 +144,21 @@ function buildUsageStatus(amount: UsageAmount): UsageStatus {
 }
 
 function toUsageLimit(row: KimiUsageRow, provider: string, index: number, accountId?: string): UsageLimit {
-	const window: UsageWindow | undefined =
-		row.window ??
-		(row.resetsAt
+	// Kimi puts `resetTime` on the limit `detail`, not on `window`, so a
+	// window built from `duration`/`timeUnit` alone carries no resetsAt.
+	// Fall back to the row-level reset so `omp usage` can render
+	// "resets in …" for the 5h window too.
+	const window: UsageWindow | undefined = row.window
+		? row.window.resetsAt !== undefined || row.resetsAt === undefined
+			? row.window
+			: { ...row.window, resetsAt: row.resetsAt }
+		: row.resetsAt
 			? {
 					id: "default",
 					label: "Usage window",
 					resetsAt: row.resetsAt,
 				}
-			: undefined);
+			: undefined;
 
 	const amount = buildUsageAmount(row);
 	return {

package/src/utils/event-stream.ts

@@ -195,3 +195,8 @@ export class AssistantMessageEventStream extends EventStream<AssistantMessageEve
 		this.endWaiting();
 	}
 }
+
+/** Create an assistant-message event stream for legacy extension providers. */
+export function createAssistantMessageEventStream(): AssistantMessageEventStream {
+	return new AssistantMessageEventStream();
+}

package/src/utils/schema/normalize.ts

@@ -29,8 +29,11 @@ import { decontaminateZodInstance } from "./zod-decontaminate";
 export type ResidualSchemaIncompatibility = "type-array" | "type-null" | "nullable" | "combiners" | "not";
 
 export interface NormalizeSchemaOptions {
-	/** Coerce JSON Schema boolean subschemas for providers whose wire cannot encode them. */
-	coerceBooleanSubschemas?: boolean;
+	/**
+	 * Coerce boolean subschemas to object forms. `standard` preserves `false`
+	 * with `not`; `permissive` uses `{}` when the provider cannot express it.
+	 */
+	coerceBooleanSubschemas?: "standard" | "permissive";
 	unsupportedFields: (key: string) => boolean;
 	normalizeFieldNames: boolean;
 	collapseNullFields: boolean;
@@ -284,12 +287,12 @@ function normalizeSchemaNode(value: unknown, options: NormalizeSchemaWalkOptions
 	}
 	if (typeof value === "boolean") {
 		// A bare boolean is a JSON Schema subschema only in a subschema slot.
-		// The Google/CCA protobuf Schema wire has no representation for it
-		// (issue #5604): `true` accepts anything -> `{}`, `false` accepts nothing
-		// -> `{ not: {} }`. In a keyword slot (`nullable`, `enum` entry, …) a
-		// boolean is a plain value and is left untouched.
-		if (!options.coerceBooleanSubschemas || !options.booleanIsSubschema) return value;
-		return value ? {} : { not: {} };
+		// Some provider wires have no boolean-schema representation: `true`
+		// becomes `{}`; `false` uses `not` when supported, or the permissive
+		// `{}` fallback when the provider cannot express an impossible schema.
+		const mode = options.coerceBooleanSubschemas;
+		if (!mode || !options.booleanIsSubschema) return value;
+		return value || mode === "permissive" ? {} : { not: {} };
 	}
 	if (!isJsonObject(value)) {
 		return value;
@@ -993,7 +996,7 @@ export function normalizeSchema(value: unknown, options: NormalizeSchemaOptions)
 
 export function normalizeSchemaForGoogle(value: unknown): unknown {
 	return normalizeSchema(value, {
-		coerceBooleanSubschemas: true,
+		coerceBooleanSubschemas: "standard",
 		unsupportedFields: isGoogleUnsupportedSchemaField,
 		normalizeFieldNames: true,
 		collapseNullFields: true,
@@ -1015,7 +1018,7 @@ export function normalizeSchemaForGoogle(value: unknown): unknown {
 
 export function normalizeSchemaForCCA(value: unknown): unknown {
 	return normalizeSchema(value, {
-		coerceBooleanSubschemas: true,
+		coerceBooleanSubschemas: "standard",
 		unsupportedFields: isGoogleUnsupportedSchemaField,
 		normalizeFieldNames: true,
 		collapseNullFields: false,
@@ -1080,6 +1083,9 @@ export function normalizeSchemaForMCP(value: unknown): unknown {
  *    `default` and `description` are MFJS Meta Data fields and are preserved.
  *  - `additionalProperties` (boolean or schema) and `type: "null"` (incl.
  *    inside `anyOf`) are kept.
+ *  - Boolean subschemas are object-coerced; MFJS has no exact `false` schema,
+ *    so both values become the permissive empty schema while local tool
+ *    validation remains authoritative.
  *
  * Out of scope (absent from the built-in tool surface, spec-ambiguous to
  * rewrite blindly): `allOf` intersection merging, external/recursive `$ref`,
@@ -1087,6 +1093,7 @@ export function normalizeSchemaForMCP(value: unknown): unknown {
  */
 export function normalizeSchemaForMoonshot(value: unknown): unknown {
 	return normalizeSchema(value, {
+		coerceBooleanSubschemas: "permissive",
 		unsupportedFields: isMoonshotUnsupportedSchemaField,
 		normalizeFieldNames: false,
 		collapseNullFields: false,