@oh-my-pi/pi-ai 17.3.8 → 17.4.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [17.4.0] - 2026-08-20
+
+### Added
+
+- Added model metadata fields (`context_length`, `max_output_tokens`, `input_modalities`, etc.) to auth gateway model listing responses
+
+### Fixed
+
+- Fixed tool-argument repair applying lossy transformations (such as stringifying objects or stripping unrecognized keys) when validating union schemas (`anyOf`/`oneOf`), preventing corrupted tool call and subagent payloads
+- Fixed 400 errors when communicating with local OpenAI-compatible inference servers that reject `chat_template_kwargs.reasoning_effort` by improving reasoning effort parameter fallback and compatibility handling
+- Fixed DeepSeek-family models on hosts like Fireworks losing reasoning whenever tools were offered: a redundant `tool_choice: "auto"` is now omitted so the provider keeps thinking enabled; forced and `"none"` selectors still take priority ([#1207](https://github.com/can1357/oh-my-pi/issues/1207))
+
 ## [17.3.8] - 2026-08-19
 
 ### Changed

package/dist/types/providers/cursor/exec-modern.d.ts

@@ -9,7 +9,7 @@
  * `ExecClientMessage` carrying a result with an unset oneof is a fake success
  * the server reads as "the tool ran and produced nothing".
  */
-import { type ExecuteHookRequest, type ExecuteHookResult, type McpStateExecResult, type McpToolDefinition, type PiBashExecResult, type PiEditExecResult, type PiFindExecResult, type PiGrepExecResult, type PiLsExecResult, type PiReadExecResult, type PiTruncation, type PiWriteExecResult } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
+import { type ExecuteHookRequest, type ExecuteHookResult, type McpStateExecResult, type McpToolDefinition, type PiBashExecResult, type PiEditExecResult, type PiFindExecResult, type PiGrepExecResult, type PiLsExecResult, type PiReadExecResult, type PiTruncation, type PiWriteExecResult } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
 import type { ToolResultMessage } from "../../types.js";
 /**
  * The pure arg translation lives in `../cursor-pi-args` so the legacy pi shim

package/dist/types/providers/cursor/interaction-query.d.ts

@@ -1,5 +1,5 @@
 import type http2 from "node:http2";
-import { type InteractionQuery } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
+import { type InteractionQuery } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
 /**
  * Answer a Cursor `interaction_query` so the Run RPC can continue.
  *

package/dist/types/providers/cursor-pi-args.d.ts

@@ -9,7 +9,7 @@
  *
  * Kept apart from `cursor/exec-modern.ts` on purpose: these are pure
  * string/path functions with no protobuf coupling, while that module pulls in
- * `@bufbuild/protobuf` and the generated `agent_pb` graph. The legacy shim is
+ * the generated cursor protobuf graph. The legacy shim is
  * compiled into the bundled virtual module registry, so importing it from a
  * nested path would drag the whole exec implementation in with it — and
  * `./providers/*` is a single-segment wildcard export that cannot serve a

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

@@ -1,7 +1,7 @@
 import http2 from "node:http2";
-import { type JsonValue } from "@bufbuild/protobuf";
-import type { McpToolDefinition } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
-import { type AgentServerMessage, type ConversationStateStructure } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
+import type { McpToolDefinition } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
+import { type AgentServerMessage, type ConversationStateStructure } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
+import { type JsonValue } from "@oh-my-pi/pi-catalog/discovery/protobuf";
 import type { AssistantMessage, Context, CursorExecHandlerResult, CursorExecHandlers, CursorExecPairing, CursorTodoSyncHandler, CursorToolResultHandler, Message, Model, StreamFunction, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage } from "../types.js";
 import { kCursorExecResolved, kStreamingBlockIndex, kStreamingBlockKind, kStreamingEnvelopeId, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";

package/dist/types/providers/openai-reasoning-fallback.d.ts

@@ -1,6 +1,14 @@
 import type { CapturedHttpErrorResponse } from "../utils/http-inspector.js";
-/** @internal */
-export type OpenAIReasoningEffortFallback = string | null;
+/**
+ * Fallback marker: the server rejected the `chat_template_kwargs.reasoning_effort`
+ * spelling itself (strict kwargs whitelists — Ninfer-style servers), not the
+ * effort value. Apply strips the kwarg and hoists the value onto the top-level
+ * `reasoning_effort` field when that spelling is absent.
+ * @internal
+ */
+export declare const STRIP_TEMPLATE_KWARG_REASONING_EFFORT: unique symbol;
+/** @internal */
+export type OpenAIReasoningEffortFallback = string | null | typeof STRIP_TEMPLATE_KWARG_REASONING_EFFORT;
 /** @internal */
 export interface OpenAIReasoningEffortFallbackState {
     reasoningEffortFallbacks: Map<string, OpenAIReasoningEffortFallback>;

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

@@ -315,6 +315,20 @@ export interface OpenAICompatPolicy {
 export declare function mapOpenAIReasoningEffort(model: Pick<Model, "thinking">, compat: {
     reasoningEffortMap?: Partial<Record<Effort, string>>;
 } | undefined, effort: string): string;
+/**
+ * Whether a redundant `tool_choice: "auto"` should be dropped to keep
+ * reasoning alive. Hosts with `disableReasoningOnToolChoice` (DeepSeek family
+ * on e.g. Fireworks) silently turn reasoning off whenever any `tool_choice`
+ * is present. "auto" is already the provider default, so omitting it is
+ * wire-neutral for tool selection; forced and "none" choices are semantic and
+ * still win over reasoning (#1207).
+ */
+export declare function shouldDropAutoToolChoiceForReasoning(model: Pick<Model, "reasoning">, compat: {
+    disableReasoningOnToolChoice: boolean;
+}, toolChoice: unknown, options: {
+    reasoning?: string;
+    disableReasoning?: boolean;
+} | undefined): boolean;
 export declare function resolveOpenAICompatPolicy<TApi extends Api>(model: Model<TApi>, options: ResolveOpenAICompatPolicyOptions): OpenAICompatPolicy;
 export declare function applyChatCompletionsCompatPolicy(params: OpenAICompletionsParams, policy: OpenAICompatPolicy): void;
 export declare function applyChatCompletionsReasoningParams(params: OpenAICompletionsParams, model: Model<"openai-completions">, compat: ResolvedOpenAICompat, options: (ChatCompletionsReasoningOptions & {

package/dist/types/types.d.ts

@@ -1,7 +1,7 @@
 export * from "@oh-my-pi/pi-catalog/effort";
 export * from "@oh-my-pi/pi-catalog/types";
 import type { Type } from "@oh-my-pi/omptype";
-import type { DeleteArgs, DeleteResult, DiagnosticsArgs, DiagnosticsResult, GrepArgs, GrepResult, LsArgs, LsResult, McpResult, PiBashExecArgs, PiBashExecResult, PiEditExecArgs, PiEditExecResult, PiFindExecArgs, PiFindExecResult, PiGrepExecArgs, PiGrepExecResult, PiLsExecArgs, PiLsExecResult, PiReadExecArgs, PiReadExecResult, PiWriteExecArgs, PiWriteExecResult, ReadArgs, ReadResult, ShellArgs, ShellResult, WriteArgs, WriteResult } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
+import type { DeleteArgs, DeleteResult, DiagnosticsArgs, DiagnosticsResult, GrepArgs, GrepResult, LsArgs, LsResult, McpResult, PiBashExecArgs, PiBashExecResult, PiEditExecArgs, PiEditExecResult, PiFindExecArgs, PiFindExecResult, PiGrepExecArgs, PiGrepExecResult, PiLsExecArgs, PiLsExecResult, PiReadExecArgs, PiReadExecResult, PiWriteExecArgs, PiWriteExecResult, ReadArgs, ReadResult, ShellArgs, ShellResult, WriteArgs, WriteResult } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import type { Api, FetchImpl, Model, Provider, ThinkingBudgets, Usage } from "@oh-my-pi/pi-catalog/types";
 import type { ApiKey } from "./auth-retry.js";

package/dist/types/utils/schema/json-schema-validator.d.ts

@@ -4,11 +4,11 @@ export interface JsonSchemaValidationIssue {
     expectedTypes?: string[];
     keyword?: string;
     /**
-     * Marks issues that originate inside a failed `anyOf` / `oneOf` branch.
-     * Consumers such as the tool-argument coercion layer use this to avoid
-     * applying type repairs (e.g. singleton-array wrapping) that would be
-     * authoritative outside of a combinator but are only one candidate
-     * branch's expectation here.
+     * Marks issues surfaced from a failed `anyOf` / `oneOf` branch (at any
+     * depth). Such a diagnosis is one candidate branch's guess, not
+     * authoritative: the tool-argument coercion layer keeps lossy repairs
+     * (container stringification, unrecognized-key deletion, singleton-array
+     * wrapping) off for these while still applying lossless ones.
      */
     fromUnionBranch?: boolean;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.3.8",
+	"version": "17.4.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -37,14 +37,12 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/omptype": "17.3.8",
-		"@oh-my-pi/pi-catalog": "17.3.8",
-		"@oh-my-pi/pi-utils": "17.3.8",
-		"@oh-my-pi/pi-wire": "17.3.8"
+		"@oh-my-pi/omptype": "17.4.0",
+		"@oh-my-pi/pi-catalog": "17.4.0",
+		"@oh-my-pi/pi-utils": "17.4.0",
+		"@oh-my-pi/pi-wire": "17.4.0"
 	},
 	"devDependencies": {
-		"@bufbuild/protoc-gen-es": "^2.12.1",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/auth-gateway/server.ts

@@ -730,19 +730,45 @@ async function handleCredentialsCheck(storage: AuthStorage, signal: AbortSignal)
 	return json(200, { generatedAt: Date.now(), credentials });
 }
 
+/**
+ * Row shape for `GET /v1/models`. Beyond the OpenAI-standard `id`/`object`/
+ * `owned_by`, rows advertise the catalog metadata OpenAI-compatible clients
+ * (omp's own proxy discovery, Zed's openai_compatible provider, ...) read to
+ * size and capability-gate discovered models: `context_length`,
+ * `max_output_tokens`, `input_modalities`, and `supports_tools` (only emitted
+ * when the catalog explicitly reports `false`; absent means usable).
+ */
+interface ModelListRow {
+	id: string;
+	object: "model";
+	owned_by: string;
+	api: Api;
+	display_name: string;
+	context_length?: number;
+	max_output_tokens?: number;
+	input_modalities: ("text" | "image")[];
+	supports_tools?: boolean;
+}
+
 function handleModelsList(opts: AuthGatewayBootOptions): Response {
 	const seen = new Set<string>();
-	const data: Array<{ id: string; object: "model"; owned_by: string; api: Api }> = [];
+	const data: ModelListRow[] = [];
 	for (const model of opts.listModels?.() ?? []) {
 		const id = `${model.provider}/${model.id}`;
 		if (seen.has(id)) continue;
 		seen.add(id);
-		data.push({
+		const row: ModelListRow = {
 			id,
 			object: "model",
 			owned_by: model.provider,
 			api: model.api,
-		});
+			display_name: model.name,
+			input_modalities: model.input,
+		};
+		if (model.contextWindow != null) row.context_length = model.contextWindow;
+		if (model.maxTokens != null) row.max_output_tokens = model.maxTokens;
+		if (model.supportsTools === false) row.supports_tools = false;
+		data.push(row);
 	}
 	return json(200, { object: "list", data });
 }

package/src/providers/cursor/exec-modern.ts

@@ -10,7 +10,6 @@
  * the server reads as "the tool ran and produced nothing".
  */
 
-import { create } from "@bufbuild/protobuf";
 import {
 	AfterAgentResponseRequestResponseSchema,
 	AfterAgentThoughtRequestResponseSchema,
@@ -64,7 +63,8 @@ import {
 	StopRequestResponseSchema,
 	SubagentStartRequestResponseSchema,
 	SubagentStopRequestResponseSchema,
-} from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
+} from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
+import { create } from "@oh-my-pi/pi-catalog/discovery/protobuf";
 import type { ToolResultMessage } from "../../types";
 
 /**

package/src/providers/cursor/interaction-query.ts

@@ -1,5 +1,4 @@
 import type http2 from "node:http2";
-import { create, toBinary } from "@bufbuild/protobuf";
 import {
 	AgentClientMessageSchema,
 	AskQuestionInteractionResponseSchema,
@@ -21,7 +20,8 @@ import {
 	WebFetchRequestResponseSchema,
 	WebSearchRequestResponse_ApprovedSchema,
 	WebSearchRequestResponseSchema,
-} from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
+} from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
+import { create, toBinary } from "@oh-my-pi/pi-catalog/discovery/protobuf";
 import { $env } from "@oh-my-pi/pi-utils";
 
 const NOT_IMPLEMENTED_SUFFIX = "not implemented by this client";

package/src/providers/cursor-pi-args.ts

@@ -9,7 +9,7 @@
  *
  * Kept apart from `cursor/exec-modern.ts` on purpose: these are pure
  * string/path functions with no protobuf coupling, while that module pulls in
- * `@bufbuild/protobuf` and the generated `agent_pb` graph. The legacy shim is
+ * the generated cursor protobuf graph. The legacy shim is
  * compiled into the bundled virtual module registry, so importing it from a
  * nested path would drag the whole exec implementation in with it — and
  * `./providers/*` is a single-segment wildcard export that cannot serve a

package/src/providers/cursor.ts

@@ -1,9 +1,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
 import http2 from "node:http2";
-import { create, fromBinary, fromJson, type JsonValue, toBinary, toJson } from "@bufbuild/protobuf";
-import { ValueSchema } from "@bufbuild/protobuf/wkt";
-import type { ConversationStep, McpToolDefinition } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
+import type { ConversationStep, McpToolDefinition } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
 import {
 	AgentClientMessageSchema,
 	AgentConversationTurnStructureSchema,
@@ -139,11 +137,21 @@ import {
 	WriteShellStdinErrorSchema,
 	WriteShellStdinResultSchema,
 	WriteSuccessSchema,
-} from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
+} from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
+import {
+	create,
+	decodeJsonValue,
+	encodeJsonValue,
+	fromBinary,
+	type JsonValue,
+	toBinary,
+	toJson,
+} from "@oh-my-pi/pi-catalog/discovery/protobuf";
 import { isKimiK3ModelId } from "@oh-my-pi/pi-catalog/identity";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
 import {
 	$env,
+	isRecord,
 	logger,
 	parseJsonWithRepair,
 	parseStreamingJson,
@@ -3099,8 +3107,7 @@ function parseToolArgsJson(text: string): unknown {
 
 function decodeMcpArgValue(value: Uint8Array): unknown {
 	try {
-		const parsedValue = fromBinary(ValueSchema, value);
-		const jsonValue = toJson(ValueSchema, parsedValue) as JsonValue;
+		const jsonValue = decodeJsonValue(value);
 		if (typeof jsonValue === "string") {
 			return parseToolArgsJson(jsonValue);
 		}
@@ -4212,10 +4219,10 @@ export function buildMcpToolDefinitions(tools: Tool[] | undefined): McpToolDefin
 	return forwarded.map(tool => {
 		const jsonSchema = toolWireSchema(tool);
 		const schemaValue: JsonValue =
-			jsonSchema && typeof jsonSchema === "object"
-				? (jsonSchema as JsonValue)
+			jsonSchema !== null && !Array.isArray(jsonSchema) && isJsonValue(jsonSchema)
+				? jsonSchema
 				: { type: "object", properties: {}, required: [] };
-		const inputSchema = toBinary(ValueSchema, fromJson(ValueSchema, schemaValue));
+		const inputSchema = encodeJsonValue(schemaValue);
 		return create(McpToolDefinitionSchema, {
 			name: tool.name,
 			description: tool.description || "",
@@ -4463,17 +4470,11 @@ function buildRootPromptMessagesJson(
 	return entries;
 }
 
-function isPlainRecord(value: unknown): value is Record<string, unknown> {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-}
-
 function isJsonValue(value: unknown): value is JsonValue {
 	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
 	if (typeof value === "number") return Number.isFinite(value);
 	if (Array.isArray(value)) return value.every(isJsonValue);
-	if (!isPlainRecord(value)) return false;
+	if (!isRecord(value)) return false;
 	for (const key in value) {
 		if (!isJsonValue(value[key])) return false;
 	}
@@ -4488,7 +4489,7 @@ function encodeCursorMcpArguments(toolCall: ToolCall): Record<string, Uint8Array
 		if (!isJsonValue(value)) {
 			throw new AIError.ValidationError(`Cursor tool argument ${toolCall.name}.${name} is not JSON-serializable`);
 		}
-		encoded[name] = toBinary(ValueSchema, fromJson(ValueSchema, value));
+		encoded[name] = encodeJsonValue(value);
 	}
 	return encoded;
 }

package/src/providers/devin.ts

@@ -1,32 +1,26 @@
 import { gunzipSync, gzipSync } from "node:zlib";
-import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
-import {
-	ChatMessageRequestType,
-	GetChatMessageRequestSchema,
-	GetChatMessageResponseSchema,
-} from "@oh-my-pi/pi-catalog/discovery/devin-gen/exa/api_server_pb/api_server_pb";
-import {
-	GetUserJwtRequestSchema,
-	GetUserJwtResponseSchema,
-} from "@oh-my-pi/pi-catalog/discovery/devin-gen/exa/auth_pb/auth_pb";
 import {
 	CacheControlType,
 	type ChatMessagePrompt,
 	ChatMessagePromptSchema,
-	ChatToolChoiceSchema,
-	ChatToolDefinitionSchema,
-	PromptCacheOptionsSchema,
-} from "@oh-my-pi/pi-catalog/discovery/devin-gen/exa/chat_pb/chat_pb";
-import {
+	ChatMessageRequestType,
 	ChatMessageSource,
 	type ChatToolCall,
 	ChatToolCallSchema,
+	ChatToolChoiceSchema,
+	ChatToolDefinitionSchema,
 	CompletionConfigurationSchema,
 	ConversationalPlannerMode,
+	GetChatMessageRequestSchema,
+	GetChatMessageResponseSchema,
+	GetUserJwtRequestSchema,
+	GetUserJwtResponseSchema,
 	ImageDataSchema,
 	MetadataSchema,
+	PromptCacheOptionsSchema,
 	StopReason,
-} from "@oh-my-pi/pi-catalog/discovery/devin-gen/exa/codeium_common_pb/codeium_common_pb";
+} from "@oh-my-pi/pi-catalog/discovery/devin-proto";
+import { create, fromBinary, toBinary } from "@oh-my-pi/pi-catalog/discovery/protobuf";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
 import { logger, parseStreamingJson, parseStreamingJsonThrottled } from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";

package/src/providers/openai-completions.ts

@@ -106,6 +106,7 @@ import {
 	resolveOpenAICompletionsOutputClamp,
 	resolveOpenAIOutputTokenParam,
 	resolveOpenAIRequestSetup,
+	shouldDropAutoToolChoiceForReasoning,
 	shouldRetryWithoutStrictTools,
 } from "./openai-shared";
 import { transformMessages } from "./transform-messages";
@@ -1692,6 +1693,10 @@ function buildParams(
 		delete params.tool_choice;
 	}
 
+	if (shouldDropAutoToolChoiceForReasoning(model, initialCompat, params.tool_choice, options)) {
+		delete params.tool_choice;
+	}
+
 	const finalPolicy = resolveOpenAICompatPolicy(model, {
 		endpoint: "chat-completions",
 		reasoning: options?.reasoning,

package/src/providers/openai-reasoning-fallback.ts

@@ -1,8 +1,17 @@
 import { extractHttpStatusFromError } from "@oh-my-pi/pi-utils";
 import type { CapturedHttpErrorResponse } from "../utils/http-inspector";
 
+/**
+ * Fallback marker: the server rejected the `chat_template_kwargs.reasoning_effort`
+ * spelling itself (strict kwargs whitelists — Ninfer-style servers), not the
+ * effort value. Apply strips the kwarg and hoists the value onto the top-level
+ * `reasoning_effort` field when that spelling is absent.
+ * @internal
+ */
+export const STRIP_TEMPLATE_KWARG_REASONING_EFFORT = Symbol("strip-template-kwarg-reasoning-effort");
+
 /** @internal */
-export type OpenAIReasoningEffortFallback = string | null;
+export type OpenAIReasoningEffortFallback = string | null | typeof STRIP_TEMPLATE_KWARG_REASONING_EFFORT;
 
 /** @internal */
 export interface OpenAIReasoningEffortFallbackState {
@@ -73,7 +82,23 @@ export function readOpenAIReasoningEffort(params: unknown): string | undefined {
 	if (!isRecord(params)) return undefined;
 	if (typeof params.reasoning_effort === "string") return params.reasoning_effort;
 	const reasoning = params.reasoning;
-	return isRecord(reasoning) && typeof reasoning.effort === "string" ? reasoning.effort : undefined;
+	if (isRecord(reasoning) && typeof reasoning.effort === "string") return reasoning.effort;
+	return readTemplateKwargReasoningEffort(params);
+}
+
+function readTemplateKwargReasoningEffort(params: Record<string, unknown>): string | undefined {
+	const kwargs = params.chat_template_kwargs;
+	return isRecord(kwargs) && typeof kwargs.reasoning_effort === "string" ? kwargs.reasoning_effort : undefined;
+}
+
+/** Remove `chat_template_kwargs.reasoning_effort`, dropping the kwargs object when it becomes empty. */
+function deleteTemplateKwargReasoningEffort(kwargs: Record<string, unknown>, parent: Record<string, unknown>): void {
+	delete kwargs.reasoning_effort;
+	for (const key in kwargs) {
+		void key;
+		return;
+	}
+	delete parent.chat_template_kwargs;
 }
 
 function deleteReasoningEffort(reasoning: Record<string, unknown>, parent: Record<string, unknown>): boolean {
@@ -89,6 +114,17 @@ function deleteReasoningEffort(reasoning: Record<string, unknown>, parent: Recor
 /** @internal */
 export function applyOpenAIReasoningEffortFallback(params: unknown, fallback: OpenAIReasoningEffortFallback): boolean {
 	if (!isRecord(params)) return false;
+	if (fallback === STRIP_TEMPLATE_KWARG_REASONING_EFFORT) {
+		const kwargs = params.chat_template_kwargs;
+		if (!isRecord(kwargs) || typeof kwargs.reasoning_effort !== "string") return false;
+		const effort = kwargs.reasoning_effort;
+		deleteTemplateKwargReasoningEffort(kwargs, params);
+		// The `qwen-chat-template` dialect rides kwargs alone; keep the effort
+		// selection alive on the standard OpenAI field (Ninfer-style servers
+		// accept it, vLLM-style renderers ignore it).
+		if (typeof params.reasoning_effort !== "string") params.reasoning_effort = effort;
+		return true;
+	}
 	let changed = false;
 	if (typeof params.reasoning_effort === "string") {
 		if (fallback === null) {
@@ -107,6 +143,17 @@ export function applyOpenAIReasoningEffortFallback(params: unknown, fallback: Op
 			changed = true;
 		}
 	}
+	// Keep the Qwen template kwarg twin in lockstep — a value remap or drop
+	// must not leave a stale effort for kwargs-reading renderers.
+	const kwargs = params.chat_template_kwargs;
+	if (isRecord(kwargs) && typeof kwargs.reasoning_effort === "string") {
+		if (fallback === null) {
+			deleteTemplateKwargReasoningEffort(kwargs, params);
+		} else {
+			kwargs.reasoning_effort = fallback;
+		}
+		changed = true;
+	}
 	return changed;
 }
 
@@ -165,13 +212,17 @@ function isInvalidReasoningEffortError(
 	if (/reasoning[_ ]content/i.test(message) && !REASONING_EFFORT_FIELD_PATTERN.test(message)) return false;
 	if (/invalid[^\n]*(?:reasoning[_. ]effort|reasoning value)/i.test(message)) return true;
 	if (
-		/(?:reasoning[_. ]effort|reasoning value)[^\n]*(?:invalid|unsupported|not supported|must be|expected)/i.test(
+		/(?:reasoning[_. ]effort|reasoning value)[^\n]*(?:invalid|unsupported|not supported|not permitted|must be|expected|unknown|unexpected|unrecognized)/i.test(
 			message,
 		)
 	) {
 		return true;
 	}
-	if (/(?:unsupported|not supported)[^\n]*(?:reasoning[_. ]effort|reasoning value)/i.test(message)) {
+	if (
+		/(?:unsupported|not supported|not permitted|unknown|unexpected|unrecognized|extra)[^\n]*(?:reasoning[_. ]effort|reasoning value)/i.test(
+			message,
+		)
+	) {
 		return true;
 	}
 	// Gateways put the rejected value first (`level "none" not supported`), the
@@ -258,6 +309,35 @@ function nearestEnabledReasoningFallback(currentEffort: string, allowed: Set<str
 	return best;
 }
 
+/**
+ * Text that identifies a rejection of the kwargs spelling itself: the server
+ * names `chat_template_kwargs` together with `reasoning_effort` (Ninfer-style
+ * strict kwargs whitelists: `chat_template_kwargs.reasoning_effort is not
+ * supported`).
+ */
+const TEMPLATE_KWARG_EFFORT_PATTERN =
+	/chat_template_kwargs[^\n]{0,120}reasoning[_. ]effort|reasoning[_. ]effort[^\n]{0,120}chat_template_kwargs/i;
+const FIELD_REJECTION_PATTERN =
+	/invalid|unsupported|not supported|not permitted|unknown|unexpected|unrecognized|rejected|extra input/i;
+
+function resolveStripTemplateKwargFallback(
+	error: unknown,
+	captured: CapturedHttpErrorResponse | undefined,
+	params: unknown,
+): typeof STRIP_TEMPLATE_KWARG_REASONING_EFFORT | undefined {
+	if (!isRecord(params)) return undefined;
+	const effort = readTemplateKwargReasoningEffort(params);
+	if (effort === undefined) return undefined;
+	const status = extractHttpStatusFromError(error) ?? captured?.status;
+	if (status !== 400 && status !== 422) return undefined;
+	const message = collectMessageParts(error, captured);
+	if (!TEMPLATE_KWARG_EFFORT_PATTERN.test(message) || !FIELD_REJECTION_PATTERN.test(message)) return undefined;
+	// A value-level rejection listing allowed levels wants the value remapped
+	// (in every spelling) by the ordinary flow, not the kwarg stripped.
+	if (parseAllowedReasoningValues(message, effort) !== undefined) return undefined;
+	return STRIP_TEMPLATE_KWARG_REASONING_EFFORT;
+}
+
 /** @internal */
 export function resolveOpenAIReasoningEffortFallback(
 	error: unknown,
@@ -265,6 +345,8 @@ export function resolveOpenAIReasoningEffortFallback(
 	params: unknown,
 	options?: { explicitDisable?: boolean },
 ): OpenAIReasoningEffortFallback | undefined {
+	const strip = resolveStripTemplateKwargFallback(error, captured, params);
+	if (strip !== undefined) return strip;
 	const currentEffort = readOpenAIReasoningEffort(params);
 	if (!currentEffort || !KNOWN_REASONING_VALUE[currentEffort.toLowerCase()]) return undefined;
 	if (!isInvalidReasoningEffortError(error, captured, currentEffort)) return undefined;

package/src/providers/openai-responses.ts

@@ -99,6 +99,7 @@ import {
 	resolveOpenAIOutputTokenParam,
 	resolveOpenAIRequestSetup,
 	resolveOpenAIResponsesOutputClamp,
+	shouldDropAutoToolChoiceForReasoning,
 	shouldRetryWithoutStrictTools,
 } from "./openai-shared";
 
@@ -1276,6 +1277,10 @@ export function buildParams(
 		}
 	}
 
+	if (shouldDropAutoToolChoiceForReasoning(model, model.compat, params.tool_choice, options)) {
+		delete params.tool_choice;
+	}
+
 	const reasoningPolicy = resolveOpenAICompatPolicy(model, {
 		endpoint: "responses",
 		reasoning: options?.reasoning,

package/src/providers/openai-shared.ts

@@ -844,6 +844,29 @@ function isImplicitDisableWhenNotRequested(disableMode: OpenAIReasoningDisableMo
 	);
 }
 
+/**
+ * Whether a redundant `tool_choice: "auto"` should be dropped to keep
+ * reasoning alive. Hosts with `disableReasoningOnToolChoice` (DeepSeek family
+ * on e.g. Fireworks) silently turn reasoning off whenever any `tool_choice`
+ * is present. "auto" is already the provider default, so omitting it is
+ * wire-neutral for tool selection; forced and "none" choices are semantic and
+ * still win over reasoning (#1207).
+ */
+export function shouldDropAutoToolChoiceForReasoning(
+	model: Pick<Model, "reasoning">,
+	compat: { disableReasoningOnToolChoice: boolean },
+	toolChoice: unknown,
+	options: { reasoning?: string; disableReasoning?: boolean } | undefined,
+): boolean {
+	return (
+		toolChoice === "auto" &&
+		compat.disableReasoningOnToolChoice &&
+		Boolean(model.reasoning) &&
+		options?.reasoning !== undefined &&
+		!options.disableReasoning
+	);
+}
+
 export function resolveOpenAICompatPolicy<TApi extends Api>(
 	model: Model<TApi>,
 	options: ResolveOpenAICompatPolicyOptions,

package/src/stream.ts

@@ -40,7 +40,7 @@ import type { OpenAICompletionsOptions } from "./providers/openai-completions";
 import { streamPiNative } from "./providers/pi-native-client";
 // Heavy provider stream functions are imported lazily via register-builtins,
 // which wraps each provider module in a dynamic import. This keeps the
-// AWS SDK, google-auth-library, @google/genai, @bufbuild/protobuf, and
+// AWS SDK, google-auth-library, @google/genai, and
 // other provider SDKs out of the CLI startup parse graph. The
 // gitlab-duo / kimi / synthetic providers stay eager because their modules
 // export routing predicates (isGitLabDuoModel, isKimiModel, isSyntheticModel)

package/src/types.ts

@@ -32,7 +32,7 @@ import type {
 	ShellResult,
 	WriteArgs,
 	WriteResult,
-} from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
+} from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { isOpenAIModelId } from "@oh-my-pi/pi-catalog/identity/family";
 import type { Api, FetchImpl, KnownApi, Model, Provider, ThinkingBudgets, Usage } from "@oh-my-pi/pi-catalog/types";

package/src/utils/schema/json-schema-validator.ts

@@ -21,11 +21,11 @@ export interface JsonSchemaValidationIssue {
 	expectedTypes?: string[];
 	keyword?: string;
 	/**
-	 * Marks issues that originate inside a failed `anyOf` / `oneOf` branch.
-	 * Consumers such as the tool-argument coercion layer use this to avoid
-	 * applying type repairs (e.g. singleton-array wrapping) that would be
-	 * authoritative outside of a combinator but are only one candidate
-	 * branch's expectation here.
+	 * Marks issues surfaced from a failed `anyOf` / `oneOf` branch (at any
+	 * depth). Such a diagnosis is one candidate branch's guess, not
+	 * authoritative: the tool-argument coercion layer keeps lossy repairs
+	 * (container stringification, unrecognized-key deletion, singleton-array
+	 * wrapping) off for these while still applying lossless ones.
 	 */
 	fromUnionBranch?: boolean;
 }
@@ -68,6 +68,35 @@ function getValueIdentity(ctx: ValidationContext, value: object): number {
 function isJsonObject(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/**
+ * Whether `value` matches every `const`/`enum` discriminator property the
+ * branch declares (with at least one such property present and matching).
+ * A uniquely tag-selected branch's validation issues are authoritative — the
+ * model named its intended variant — so the coercion layer may apply lossy
+ * repairs to them; without a unique tag, branch issues are guesses.
+ */
+function isTagSelectedBranch(branch: unknown, value: unknown): boolean {
+	if (!isJsonObject(branch) || !isJsonObject(value)) return false;
+	const props = branch.properties;
+	if (!isJsonObject(props)) return false;
+	let matched = false;
+	for (const key in props) {
+		const propSchema = props[key];
+		if (!isJsonObject(propSchema)) continue;
+		const hasConst = Object.hasOwn(propSchema, "const");
+		const enumValues = Array.isArray(propSchema.enum) ? propSchema.enum : undefined;
+		if (!hasConst && !enumValues) continue;
+		if (!Object.hasOwn(value, key)) return false;
+		const candidate = value[key];
+		if (hasConst) {
+			if (!areJsonValuesEqual(candidate, propSchema.const)) return false;
+		} else if (enumValues && !enumValues.some(entry => areJsonValuesEqual(entry, candidate))) {
+			return false;
+		}
+		matched = true;
+	}
+	return matched;
+}
 
 function pushIssue(
 	issues: JsonSchemaValidationIssue[],
@@ -239,27 +268,35 @@ function validateSchemaNode(
 
 		let matches = 0;
 		let firstIssues: JsonSchemaValidationIssue[] | undefined;
+		let selectedIssues: JsonSchemaValidationIssue[] | undefined;
+		let selectedCount = 0;
 		for (const branch of branches) {
 			const branchIssues: JsonSchemaValidationIssue[] = [];
 			if (validateSchemaNode(branch, value, path, ctx, branchIssues)) {
 				matches += 1;
-			} else if (!firstIssues) {
-				firstIssues = branchIssues;
+				continue;
+			}
+			if (!firstIssues) firstIssues = branchIssues;
+			if (isTagSelectedBranch(branch, value)) {
+				selectedCount += 1;
+				if (selectedCount === 1) selectedIssues = branchIssues;
 			}
 		}
 		const branchValid = keyword === "anyOf" ? matches > 0 : matches === 1;
 		if (!branchValid) {
-			if (matches === 0 && firstIssues && firstIssues.length > 0) {
-				// Only tag issues that sit at the combinator's own path as
-				// union-branch; deeper issues describe a specific field within
-				// the failed branch and should remain individually repairable.
-				const unionDepth = path.length;
+			if (matches === 0 && selectedCount === 1 && selectedIssues && selectedIssues.length > 0) {
+				// A const/enum discriminator uniquely identifies the intended
+				// variant, so its diagnosis is authoritative: surface untagged and
+				// keep every repair (including lossy ones) available.
+				issues.push(...selectedIssues);
+			} else if (matches === 0 && firstIssues && firstIssues.length > 0) {
+				// No variant matched and no tag picks one: everything reported is
+				// the first failing branch's guess — another variant may accept the
+				// value as-is. Surface all issues (deep ones remain individually
+				// repairable by lossless coercions) but mark their provenance so
+				// lossy repairs (stringify, key deletion, singleton wrap) stay off.
 				for (const branchIssue of firstIssues) {
-					if (branchIssue.path.length === unionDepth) {
-						issues.push({ ...branchIssue, fromUnionBranch: true });
-					} else {
-						issues.push(branchIssue);
-					}
+					issues.push(branchIssue.fromUnionBranch ? branchIssue : { ...branchIssue, fromUnionBranch: true });
 				}
 			} else {
 				pushIssue(

package/src/utils/validation.ts

@@ -136,12 +136,20 @@ function tryCoerceBooleanToNumber(value: unknown, expectedTypes: string[]): { va
 	return { value: value ? 1 : 0, changed: true };
 }
 
-function tryCoerceString(value: unknown, expectedTypes: string[]): { value: unknown; changed: boolean } {
+function tryCoerceString(
+	value: unknown,
+	expectedTypes: string[],
+	allowLossy: boolean,
+): { value: unknown; changed: boolean } {
 	if (!expectedTypes.includes("string") || typeof value === "string" || value === null || value === undefined) {
 		return { value, changed: false };
 	}
 
 	if (Array.isArray(value) || typeof value === "object") {
+		// JSON.stringify is irreversible (downstream consumers receive encoded
+		// text where they expected structure), so it requires an authoritative
+		// diagnosis — never a union-branch guess.
+		if (!allowLossy) return { value, changed: false };
 		try {
 			const stringified = JSON.stringify(value);
 			if (stringified === undefined) return { value, changed: false };
@@ -158,7 +166,16 @@ function tryCoerceString(value: unknown, expectedTypes: string[]): { value: unkn
 	return { value: String(value), changed: true };
 }
 
-function tryCoerceForExpectedTypes(value: unknown, expectedTypes: string[]): { value: unknown; changed: boolean } {
+/**
+ * Schema-directed value repair for a single type issue. `allowLossy` gates the
+ * irreversible repairs (container→string stringification); lossless repairs
+ * (JSON parsing, boolean spellings, scalar stringification) always apply.
+ */
+function tryCoerceForExpectedTypes(
+	value: unknown,
+	expectedTypes: string[],
+	allowLossy: boolean,
+): { value: unknown; changed: boolean } {
 	if (typeof value === "string") {
 		const parsed = tryParseJsonForTypes(value, expectedTypes);
 		if (parsed.changed) return parsed;
@@ -171,7 +188,7 @@ function tryCoerceForExpectedTypes(value: unknown, expectedTypes: string[]): { v
 	const numericCoercion = tryCoerceBooleanToNumber(value, expectedTypes);
 	if (numericCoercion.changed) return numericCoercion;
 
-	return tryCoerceString(value, expectedTypes);
+	return tryCoerceString(value, expectedTypes, allowLossy);
 }
 
 function tryParseLeadingJsonContainer(value: string): unknown | undefined {
@@ -1576,9 +1593,11 @@ function coerceArgsFromIssues(args: unknown, issues: FlatIssue[]): { value: unkn
 	// a type coercion actually needs to write into a leaf.
 	let owned = false;
 	let nextArgs: unknown = args;
-
 	for (const issue of issues) {
+		// Failed union branches still contribute schema-directed type repairs.
+		// Container-to-string conversion remains enabled for string branches.
 		if (issue.keyword === "unrecognized") {
+			if (issue.unionBranch) continue;
 			const previous = nextArgs;
 			nextArgs = deleteValueAtPointer(nextArgs, issue.instancePath);
 			if (nextArgs !== previous) changed = true;
@@ -1588,7 +1607,7 @@ function coerceArgsFromIssues(args: unknown, issues: FlatIssue[]): { value: unkn
 		if (issue.expectedTypes.length === 0) continue;
 
 		const currentValue = getValueAtPointer(nextArgs, issue.instancePath);
-		const result = tryCoerceForExpectedTypes(currentValue, issue.expectedTypes);
+		const result = tryCoerceForExpectedTypes(currentValue, issue.expectedTypes, true);
 		let coercedValue = result.changed ? result.value : undefined;
 		if (
 			coercedValue === undefined &&

package/src/providers/cursor/proto/buf.gen.yaml

@@ -1,6 +0,0 @@
-version: v2
-plugins:
-   - local: /work/pi/node_modules/.bin/protoc-gen-es
-     out: ../gen
-     opt:
-        - target=ts

package/src/providers/cursor/proto/buf.yaml

@@ -1,17 +0,0 @@
-version: v2
-modules:
-   - path: .
-lint:
-   use:
-      - STANDARD
-   except:
-      - COMMENT_FIELD
-      - COMMENT_MESSAGE
-      - COMMENT_ENUM
-      - COMMENT_ENUM_VALUE
-      - COMMENT_RPC
-      - COMMENT_SERVICE
-      - COMMENT_ONEOF
-breaking:
-   use:
-      - FILE

package/src/providers/devin/proto/buf.gen.yaml

@@ -1,33 +0,0 @@
-version: v2
-# Codegen is scoped to the api_server.proto transitive closure (the RPCs the
-# devin provider actually uses). The rest of the reverse-engineered Codeium
-# corpus is kept in this directory for reference/maintenance but is NOT
-# generated. Vendored google/* WKTs are intentionally absent — buf bundles them.
-inputs:
-   - directory: .
-     paths:
-        - buf/validate/validate.proto
-        - exa/analytics_pb/analytics.proto
-        - exa/api_server_pb/api_server.proto
-        - exa/auth_pb/auth.proto
-        - exa/auto_cascade_common_pb/auto_cascade_common.proto
-        - exa/bug_checker_pb/bug_checker.proto
-        - exa/cascade_plugins_pb/cascade_plugins.proto
-        - exa/chat_pb/chat.proto
-        - exa/code_edit/code_edit_pb/code_edit.proto
-        - exa/codeium_common_pb/codeium_common.proto
-        - exa/context_module_pb/context_module.proto
-        - exa/cortex_pb/cortex.proto
-        - exa/diff_action_pb/diff_action.proto
-        - exa/index_pb/index.proto
-        - exa/knowledge_base_pb/knowledge_base.proto
-        - exa/language_server_pb/language_server.proto
-        - exa/opensearch_clients_pb/opensearch_clients.proto
-        - exa/prompt_pb/prompt.proto
-        - exa/reactive_component_pb/reactive_component.proto
-        - exa/trust_pb/trust.proto
-plugins:
-   - local: ../../../../../../node_modules/.bin/protoc-gen-es
-     out: ../../../../../catalog/src/discovery/devin-gen
-     opt:
-        - target=ts

package/src/providers/devin/proto/buf.yaml

@@ -1,17 +0,0 @@
-version: v2
-modules:
-   - path: .
-lint:
-   use:
-      - STANDARD
-   except:
-      - COMMENT_FIELD
-      - COMMENT_MESSAGE
-      - COMMENT_ENUM
-      - COMMENT_ENUM_VALUE
-      - COMMENT_RPC
-      - COMMENT_SERVICE
-      - COMMENT_ONEOF
-breaking:
-   use:
-      - FILE