@oh-my-pi/pi-catalog 18.0.0 → 18.0.1

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [18.0.1] - 2026-08-23
+
+### Added
+
+- Fixed `google-gemini-cli` model refresh returning only bundled models for Gemini Code Assist Standard accounts, whose credential is not authorized for the Antigravity `fetchAvailableModels` endpoint (HTTP 403). Discovery now falls back to the account's own `retrieveUserQuota` list on Cloud Code Assist, surfacing models such as `gemini-3.5-flash` ([#9315](https://github.com/can1357/oh-my-pi/issues/9315)).
+
+### Fixed
+
+- Fixed `opencode-go/ox-alpha-free` sending `reasoning_effort: "xhigh"` for the top thinking tier, which the OpenCode Go gateway rejects; the model now uses the gateway's wire-exact `low`/`high`/`max` ladder with mandatory thinking so `--thinking max` reaches the real max tier ([#9349](https://github.com/can1357/oh-my-pi/issues/9349)).
+- Fixed Venice-hosted Qwen models (e.g. `venice/qwen3-6-35b-a3b`) failing with `400 Invalid request parameters`. Reasoning levels now use the accepted OpenAI-style `reasoning_effort` field, while Thinking Off sends Venice's explicit `venice_parameters.disable_thinking` flag ([#9345](https://github.com/can1357/oh-my-pi/issues/9345)).
+- Fixed gateway-first OpenCode Zen and Go models missing context, output, image, and reasoning metadata by enriching live discovery from the current stencil catalog ([#9272](https://github.com/can1357/oh-my-pi/issues/9272)).
+- Fixed `opencode-go/deepseek-v4-flash` exposing the generic `minimal`/`low`/`medium`/`high`/`xhigh` thinking ladder instead of DeepSeek V4's real `low`/`high`/`max` tiers. The model is pinned to the Responses transport (the Go gateway serves it only at `/responses`), which the DeepSeek effort branch did not admit, so it fell through to the default ladder; the branch now covers the `openai-responses` transport like every other host ([#9134](https://github.com/can1357/oh-my-pi/issues/9134)).
+- Fixed protobuf map decoding corrupting entries when a key is `__proto__`, which dropped that argument and replayed spurious numeric arguments ([#9394](https://github.com/can1357/oh-my-pi/issues/9394)).
+
+### Added
+
+- Added Amazon Bedrock guardrail metadata to model definitions for Converse requests.
 ## [18.0.0] - 2026-08-22
 
 ### Added

package/dist/types/discovery/gemini-cli.d.ts

@@ -0,0 +1,33 @@
+import type { ModelSpec } from "../types.js";
+import { type VariantCollapseTable } from "../variant-collapse.js";
+/**
+ * Options for the Gemini CLI quota-based discovery fallback.
+ */
+export interface FetchGeminiCliQuotaModelsOptions {
+    /** OAuth access token sent as `Authorization: Bearer <token>`. */
+    token: string;
+    /** Cloud Code Assist endpoint. Defaults to `https://cloudcode-pa.googleapis.com`. */
+    endpoint?: string;
+    /** Pre-resolved GCP project id; otherwise discovered via `loadCodeAssist`. */
+    projectId?: string;
+    /** Optional abort signal for request cancellation. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation override for tests. */
+    fetcher?: typeof fetch;
+    /** Effort-tier collapse table applied to the discovered list. */
+    collapseTable?: VariantCollapseTable;
+}
+/**
+ * Discovers the Gemini models available to a `google-gemini-cli` credential via
+ * the account's own `retrieveUserQuota` endpoint on Cloud Code Assist.
+ *
+ * This is the fallback for accounts whose credential is not authorized for the
+ * Antigravity `fetchAvailableModels` endpoint (e.g. Gemini Code Assist Standard
+ * tiers, which return HTTP 403 there). Quota buckets carry only model ids, so
+ * metadata is filled from the bundled catalog where the id is known and
+ * synthesized with Gemini CLI defaults otherwise.
+ *
+ * Returns `null` on network/payload/auth failure (the caller keeps the bundled
+ * catalog). Returns `[]` when the quota response lists no usable Gemini models.
+ */
+export declare function fetchGeminiCliQuotaModels(options: FetchGeminiCliQuotaModelsOptions): Promise<ModelSpec<"google-gemini-cli">[] | null>;

package/dist/types/discovery/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./antigravity.js";
 export * from "./codex.js";
 export * from "./gemini.js";
+export * from "./gemini-cli.js";
 export * from "./gitlab-duo-workflow.js";
 export * from "./openai-compatible.js";
 export * from "./protobuf.js";

package/dist/types/hosts.d.ts

@@ -111,6 +111,11 @@ export declare const KNOWN_HOSTS: {
         readonly providers: readonly ["nvidia"];
         readonly urlMarkers: readonly ["integrate.api.nvidia.com"];
     };
+    /** Venice AI (`api.venice.ai`). OpenAI-compatible; drives reasoning via top-level `reasoning_effort` (and `venice_parameters.disable_thinking`), and rejects DashScope's top-level `enable_thinking` with a 400 (`additionalProperties: false` request schema). */
+    readonly venice: {
+        readonly providers: readonly ["venice"];
+        readonly urlMarkers: readonly ["api.venice.ai"];
+    };
     readonly moonshotNative: {
         readonly providers: readonly ["moonshot", "kimi-code"];
         readonly urlMarkers: readonly ["api.moonshot.ai", "api.kimi.com"];

package/dist/types/provider-models/google.d.ts

@@ -18,6 +18,8 @@ export interface GoogleAntigravityModelManagerConfig {
 }
 export interface GoogleGeminiCliModelManagerConfig {
     oauthToken?: string;
+    /** GCP project id required by Workspace/Standard credentials for quota discovery. */
+    projectId?: string;
     endpoint?: string;
     fetch?: FetchImpl;
 }

package/dist/types/types.d.ts

@@ -122,7 +122,7 @@ export interface Usage {
     };
 }
 export type OpenAIReasoningFormat = "openai" | "openrouter" | "zai" | "kimi" | "qwen" | "qwen-chat-template";
-export type OpenAIReasoningDisableMode = "omit" | "lowest-effort" | "none-effort" | "openrouter-enabled-false" | "zai-thinking-disabled" | "qwen-enable-thinking-false" | "qwen-template-false";
+export type OpenAIReasoningDisableMode = "omit" | "lowest-effort" | "none-effort" | "openrouter-enabled-false" | "venice-disable-thinking" | "zai-thinking-disabled" | "qwen-enable-thinking-false" | "qwen-template-false";
 export type OpenAIStreamMarkupHealingPattern = "kimi" | "dsml" | "qwen" | "thinking";
 /**
  * Compatibility settings for openai-completions API.
@@ -852,6 +852,18 @@ export interface Model<TApi extends Api = Api> {
      * `options.isOAuth = true` for the underlying provider call.
      */
     isOAuth?: boolean;
+    /**
+     * Amazon Bedrock Guardrail id or ARN attached to every Converse request for
+     * this model. Set from `providers.amazon-bedrock.guardrailIdentifier`; the
+     * streaming layer forwards it as `options.guardrailIdentifier` so accounts
+     * that gate `bedrock:InvokeModel*` on the `bedrock:GuardrailIdentifier`
+     * condition key stop returning an explicit deny.
+     */
+    guardrailIdentifier?: string;
+    /** Bedrock guardrail version. Defaults to `"DRAFT"` at request time when unset. */
+    guardrailVersion?: string;
+    /** Bedrock guardrail trace verbosity. */
+    guardrailTrace?: "enabled" | "disabled" | "enabled_full";
 }
 /**
  * A model as authored by configs, bundled catalogs, and discovery — the input

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "18.0.0",
+	"version": "18.0.1",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -34,11 +34,11 @@
 		"gen:proto": "bun scripts/generate-protocols.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.0.0",
-		"@oh-my-pi/pi-utils": "18.0.0"
+		"@oh-my-pi/omptype": "18.0.1",
+		"@oh-my-pi/pi-utils": "18.0.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/pi-ai": "18.0.0",
+		"@oh-my-pi/pi-ai": "18.0.1",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/compat/openai.ts

@@ -312,6 +312,7 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		modelMatchesHost(hostModel, "anthropic") || isClaudeModelId(spec.id) || isAnthropicNamespacedModelId(spec.id);
 	const isAlibaba = modelMatchesHost(hostModel, "alibabaDashscope");
 	const isNvidiaNim = modelMatchesHost(hostModel, "nvidia");
+	const isVenice = modelMatchesHost(hostModel, "venice");
 	const isQwen = isQwenModelId(spec.id);
 	// DeepSeek V4 (and other reasoning-capable DeepSeek models) reject follow-up requests in
 	// thinking mode unless prior assistant tool-call turns include `reasoning_content`. The
@@ -467,7 +468,7 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 				? "openrouter"
 				: isQwen && (isNvidiaNim || provider === "vllm")
 					? "qwen-chat-template"
-					: isQwen && isFireworks
+					: isQwen && (isFireworks || isVenice)
 						? "openai"
 						: isAlibaba || isQwen
 							? "qwen"
@@ -528,7 +529,7 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		// (issue #2299).
 		thinkingFormat,
 		kimiApiFormat: undefined,
-		reasoningDisableMode: resolveReasoningDisableMode(thinkingFormat),
+		reasoningDisableMode: isVenice ? "venice-disable-thinking" : resolveReasoningDisableMode(thinkingFormat),
 		omitReasoningEffort: false,
 		includeEncryptedReasoning: true,
 		filterReasoningHistory: isOpenRouter && isAnthropicModel,
@@ -648,7 +649,9 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 			? "omit"
 			: isDirectDeepseekReasoning
 				? "zai-thinking-disabled"
-				: resolveReasoningDisableMode(compat.thinkingFormat);
+				: isVenice
+					? "venice-disable-thinking"
+					: resolveReasoningDisableMode(compat.thinkingFormat);
 	}
 	if (spec.compat?.omitReasoningEffort === undefined && !compat.supportsReasoningEffort) {
 		compat.omitReasoningEffort = true;
@@ -666,7 +669,9 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		const variant: ResolvedOpenAICompat = { ...compat };
 		applyCompatOverrides(variant, whenThinkingPolicy);
 		if (whenThinkingPolicy.reasoningDisableMode === undefined) {
-			variant.reasoningDisableMode = resolveReasoningDisableMode(variant.thinkingFormat);
+			variant.reasoningDisableMode = isVenice
+				? "venice-disable-thinking"
+				: resolveReasoningDisableMode(variant.thinkingFormat);
 		}
 		if (whenThinkingPolicy.omitReasoningEffort === undefined && !variant.supportsReasoningEffort) {
 			variant.omitReasoningEffort = true;

package/src/discovery/gemini-cli.ts

@@ -0,0 +1,198 @@
+import { type } from "@oh-my-pi/omptype";
+import type { FetchImpl } from "@oh-my-pi/pi-utils";
+import { parseGeminiModel, semverGte } from "../identity/classify";
+import { isGeminiModelId } from "../identity/family";
+import { createBundledReferenceMap } from "../provider-models/bundled-references";
+import type { ModelSpec } from "../types";
+import { discoveryFetch } from "../utils";
+import {
+	collapseEffortVariants,
+	GEMINI_CLI_VARIANT_COLLAPSE_TABLE,
+	type VariantCollapseTable,
+} from "../variant-collapse";
+import { getGeminiCliHeaders } from "../wire/gemini-headers";
+
+const DEFAULT_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+const LOAD_CODE_ASSIST_PATH = "/v1internal:loadCodeAssist";
+const RETRIEVE_USER_QUOTA_PATH = "/v1internal:retrieveUserQuota";
+
+// All current Gemini CLI models ship a 1M-token context and 65,536-token
+// output ceiling; used only for quota-listed ids the bundled catalog does not
+// already describe. Ids present in the bundle keep their real limits.
+const DEFAULT_CONTEXT_WINDOW = 1_048_576;
+const DEFAULT_MAX_TOKENS = 65_536;
+
+/** Gemini generations that expose thinking on Cloud Code Assist. */
+const REASONING_MIN_VERSION = "2.5";
+
+const LoadCodeAssistResponseSchema = type({
+	"cloudaicompanionProject?": type("unknown").pipe(value => {
+		if (typeof value === "string") return value;
+		if (value && typeof value === "object" && "id" in value && typeof value.id === "string") {
+			return value.id;
+		}
+		return undefined;
+	}),
+});
+
+const QuotaBucketSchema = type({
+	"modelId?": type("unknown").pipe(value => (typeof value === "string" ? value : undefined)),
+});
+
+const RetrieveUserQuotaResponseSchema = type({
+	"buckets?": type("unknown").pipe(value => {
+		if (!Array.isArray(value)) return undefined;
+		const buckets: Array<{ modelId?: string }> = [];
+		for (const bucket of value) {
+			const parsed = QuotaBucketSchema(bucket);
+			if (!(parsed instanceof type.errors)) {
+				buckets.push(parsed);
+			}
+		}
+		return buckets;
+	}),
+});
+
+/**
+ * Options for the Gemini CLI quota-based discovery fallback.
+ */
+export interface FetchGeminiCliQuotaModelsOptions {
+	/** OAuth access token sent as `Authorization: Bearer <token>`. */
+	token: string;
+	/** Cloud Code Assist endpoint. Defaults to `https://cloudcode-pa.googleapis.com`. */
+	endpoint?: string;
+	/** Pre-resolved GCP project id; otherwise discovered via `loadCodeAssist`. */
+	projectId?: string;
+	/** Optional abort signal for request cancellation. */
+	signal?: AbortSignal;
+	/** Optional fetch implementation override for tests. */
+	fetcher?: typeof fetch;
+	/** Effort-tier collapse table applied to the discovered list. */
+	collapseTable?: VariantCollapseTable;
+}
+
+/**
+ * Discovers the Gemini models available to a `google-gemini-cli` credential via
+ * the account's own `retrieveUserQuota` endpoint on Cloud Code Assist.
+ *
+ * This is the fallback for accounts whose credential is not authorized for the
+ * Antigravity `fetchAvailableModels` endpoint (e.g. Gemini Code Assist Standard
+ * tiers, which return HTTP 403 there). Quota buckets carry only model ids, so
+ * metadata is filled from the bundled catalog where the id is known and
+ * synthesized with Gemini CLI defaults otherwise.
+ *
+ * Returns `null` on network/payload/auth failure (the caller keeps the bundled
+ * catalog). Returns `[]` when the quota response lists no usable Gemini models.
+ */
+export async function fetchGeminiCliQuotaModels(
+	options: FetchGeminiCliQuotaModelsOptions,
+): Promise<ModelSpec<"google-gemini-cli">[] | null> {
+	const fetcher = discoveryFetch(options.fetcher);
+	const endpoint = (options.endpoint?.trim() || DEFAULT_ENDPOINT).replace(/\/+$/, "");
+	const headers = {
+		Authorization: `Bearer ${options.token}`,
+		"Content-Type": "application/json",
+		...getGeminiCliHeaders(),
+	};
+
+	const projectId = options.projectId ?? (await loadProjectId(fetcher, endpoint, headers, options.signal));
+
+	let response: Response;
+	try {
+		response = await fetcher(`${endpoint}${RETRIEVE_USER_QUOTA_PATH}`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(projectId ? { project: projectId } : {}),
+			signal: options.signal,
+		});
+	} catch {
+		return null;
+	}
+
+	if (!response.ok) {
+		return null;
+	}
+
+	let payload: unknown;
+	try {
+		payload = await response.json();
+	} catch {
+		return null;
+	}
+
+	const parsed = RetrieveUserQuotaResponseSchema(payload);
+	if (parsed instanceof type.errors) {
+		return null;
+	}
+
+	const seen = new Set<string>();
+	const models: ModelSpec<"google-gemini-cli">[] = [];
+	const bundled = createBundledReferenceMap<"google-gemini-cli">("google-gemini-cli");
+
+	for (const bucket of parsed.buckets ?? []) {
+		const modelId = bucket.modelId?.trim();
+		if (!modelId || seen.has(modelId) || !isGeminiModelId(modelId)) {
+			continue;
+		}
+		seen.add(modelId);
+
+		const reference = bundled.get(modelId);
+		if (reference) {
+			models.push({ ...reference, baseUrl: endpoint });
+			continue;
+		}
+
+		const parsedId = parseGeminiModel(modelId);
+		models.push({
+			id: modelId,
+			name: modelId,
+			api: "google-gemini-cli",
+			provider: "google-gemini-cli",
+			baseUrl: endpoint,
+			reasoning: parsedId ? semverGte(parsedId.version, REASONING_MIN_VERSION) : false,
+			input: ["text", "image"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: DEFAULT_CONTEXT_WINDOW,
+			maxTokens: DEFAULT_MAX_TOKENS,
+		});
+	}
+
+	const collapsed = collapseEffortVariants(models, options.collapseTable ?? GEMINI_CLI_VARIANT_COLLAPSE_TABLE);
+	collapsed.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+	return collapsed;
+}
+
+async function loadProjectId(
+	fetcher: FetchImpl,
+	endpoint: string,
+	headers: Record<string, string>,
+	signal: AbortSignal | undefined,
+): Promise<string | undefined> {
+	let response: Response;
+	try {
+		response = await fetcher(`${endpoint}${LOAD_CODE_ASSIST_PATH}`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				metadata: { ideType: "IDE_UNSPECIFIED", platform: "PLATFORM_UNSPECIFIED", pluginType: "GEMINI" },
+			}),
+			signal,
+		});
+	} catch {
+		return undefined;
+	}
+
+	if (!response.ok) {
+		return undefined;
+	}
+
+	let payload: unknown;
+	try {
+		payload = await response.json();
+	} catch {
+		return undefined;
+	}
+
+	const parsed = LoadCodeAssistResponseSchema(payload);
+	return parsed instanceof type.errors ? undefined : parsed.cloudaicompanionProject;
+}

package/src/discovery/index.ts

@@ -1,6 +1,7 @@
 export * from "./antigravity";
 export * from "./codex";
 export * from "./gemini";
+export * from "./gemini-cli";
 export * from "./gitlab-duo-workflow";
 export * from "./openai-compatible";
 export * from "./protobuf";

package/src/discovery/protobuf.ts

@@ -374,7 +374,7 @@ function compileMapField(desc: MapFieldDesc): CompiledField {
 	return {
 		number,
 		initDefault(message) {
-			Reflect.set(message, name, {});
+			Reflect.set(message, name, Object.create(null));
 		},
 		encode(message, writer) {
 			const input = Reflect.get(message, name);
@@ -425,7 +425,7 @@ function compileMapField(desc: MapFieldDesc): CompiledField {
 		toJson(message, output) {
 			const input = Reflect.get(message, name);
 			if (!isMessageObject(input)) return;
-			const mapOutput: { [key: string]: JsonValue } = {};
+			const mapOutput: { [key: string]: JsonValue } = Object.create(null);
 			for (const entryKey in input) {
 				mapOutput[entryKey] = valCodec.toJson(input[entryKey]);
 			}
@@ -685,7 +685,7 @@ function arrayField(message: object, name: string): unknown[] {
 function mapField(message: object, name: string): Record<string, unknown> {
 	const value = Reflect.get(message, name);
 	if (isRecord(value)) return value;
-	const map: Record<string, unknown> = {};
+	const map: Record<string, unknown> = Object.create(null);
 	Reflect.set(message, name, map);
 	return map;
 }

package/src/hosts.ts

@@ -61,6 +61,8 @@ export const KNOWN_HOSTS = {
 	qwenPortal: { providers: ["qwen-portal"], urlMarkers: ["portal.qwen.ai"] },
 	/** NVIDIA NIM (`integrate.api.nvidia.com`). Qwen NIM endpoints take `chat_template_kwargs.enable_thinking`, never top-level `enable_thinking`. */
 	nvidia: { providers: ["nvidia"], urlMarkers: ["integrate.api.nvidia.com"] },
+	/** Venice AI (`api.venice.ai`). OpenAI-compatible; drives reasoning via top-level `reasoning_effort` (and `venice_parameters.disable_thinking`), and rejects DashScope's top-level `enable_thinking` with a 400 (`additionalProperties: false` request schema). */
+	venice: { providers: ["venice"], urlMarkers: ["api.venice.ai"] },
 	moonshotNative: { providers: ["moonshot", "kimi-code"], urlMarkers: ["api.moonshot.ai", "api.kimi.com"] },
 	/** Google AI Studio's OpenAI-compatible shim (`/v1beta/openai`) — a subset of chat-completions; rejects `store` with a 400. Native Gemini uses `google-generative-ai` api instead. */
 	googleAistudio: { providers: [], urlMarkers: ["generativelanguage.googleapis.com"] },

package/src/model-thinking.ts

@@ -33,6 +33,7 @@ import {
 	isMinimaxM2FamilyModelId,
 	isMinimaxM3FamilyModelId,
 	isOpenAIGptOssModelId,
+	isQwenModelId,
 	supportsAdaptiveThinkingDisplay,
 } from "./identity/family";
 import type {
@@ -186,7 +187,9 @@ function fillThinkingWireDefaults<TApi extends Api>(
 		supportsAdaptiveThinkingDisplay(spec.id);
 	const needsRequiresEffort =
 		thinking.requiresEffort === undefined &&
-		(impliesMandatoryReasoning(parsed, spec.id) || isQwenTemplateReasoningEffortCompat(compat));
+		(impliesMandatoryReasoning(parsed, spec.id) ||
+			isQwenTemplateReasoningEffortCompat(compat) ||
+			isOpenCodeGatewayOxAlphaModel(spec));
 	const needsDefaultLevel =
 		thinking.defaultLevel === undefined && (isKimiK3ModelId(spec.id) || isGlm53ReasoningEffortModelId(spec.id));
 	if (!effortsChanged && !shouldReplaceEffortMap && !needsDisplay && !needsRequiresEffort && !needsDefaultLevel) {
@@ -239,7 +242,11 @@ export function deriveThinking<TApi extends Api>(spec: ModelSpec<TApi>, compat:
 	) {
 		config.supportsDisplay = true;
 	}
-	if (impliesMandatoryReasoning(parsed, spec.id) || isQwenTemplateReasoningEffortCompat(compat)) {
+	if (
+		impliesMandatoryReasoning(parsed, spec.id) ||
+		isQwenTemplateReasoningEffortCompat(compat) ||
+		isOpenCodeGatewayOxAlphaModel(spec)
+	) {
 		config.requiresEffort = true;
 	}
 	return config;
@@ -359,6 +366,9 @@ function getModelDefinedEfforts<TApi extends Api>(
 	if (isKimiK3ModelId(spec.id)) {
 		return LOW_HIGH_MAX_REASONING_EFFORTS;
 	}
+	if (isOpenCodeGatewayOxAlphaModel(spec)) {
+		return LOW_HIGH_MAX_REASONING_EFFORTS;
+	}
 	if (isSakanaFuguReasoningModel(spec)) {
 		return HIGH_MAX_REASONING_EFFORTS;
 	}
@@ -391,9 +401,15 @@ function getModelDefinedEfforts<TApi extends Api>(
 		return QWEN38_TEMPLATE_REASONING_EFFORTS;
 	}
 	if (
-		(isOpenAICompatReasoningApi(spec.api) || (spec.api === "ollama-chat" && spec.provider === "ollama-cloud")) &&
+		(isOpenAICompatReasoningApi(spec.api) ||
+			spec.api === "openai-responses" ||
+			(spec.api === "ollama-chat" && spec.provider === "ollama-cloud")) &&
 		isDeepseekReasoningModel(spec)
 	) {
+		// The DeepSeek V4 effort ladder is a model property, not a transport one:
+		// `opencode-go/deepseek-v4-flash` is pinned to `openai-responses` (the Go
+		// gateway serves it only at /responses), yet carries the same wire-exact
+		// low/high/max scale — so the Responses transport is admitted here too.
 		// DeepSeek V4 (Flash and Pro) accepts the wire-exact low/high/max ladder
 		// on every first-party/aggregator host — the direct API, aggregators, and
 		// Ollama Cloud alike (medium/xhigh fold into high, max is a real wire
@@ -538,6 +554,22 @@ function isSakanaFuguReasoningModel<TApi extends Api>(spec: ModelSpec<TApi>): bo
 	return spec.provider === "sakana" && /^fugu(?:$|-)/i.test(spec.id);
 }
 
+/**
+ * "Ox Alpha" stealth models on the OpenCode gateways (`opencode-go` /
+ * `opencode-zen`) reason through the wire-exact `low`/`high`/`max` ladder with
+ * mandatory thinking: the gateway rejects `minimal`/`medium`/`xhigh`
+ * (`[1210] ... please use low, high, or max`), the same dialect it already
+ * serves for GLM-5.3 and Kimi K3. Other hosts proxying an `ox-alpha` SKU
+ * (Kilo, NanoGPT, Venice, OpenRouter) expose their own vocabularies and are
+ * left untouched. See issue #9349.
+ */
+function isOpenCodeGatewayOxAlphaModel<TApi extends Api>(spec: ModelSpec<TApi>): boolean {
+	return (
+		(spec.provider === "opencode-go" || spec.provider === "opencode-zen") &&
+		/(?:^|\/)ox-alpha(?:-|$)/i.test(bareModelId(spec.id))
+	);
+}
+
 function isDeepseekReasoningModel<TApi extends Api>(spec: ModelSpec<TApi>): boolean {
 	if (!spec.reasoning) return false;
 	const lowerId = spec.id.toLowerCase();
@@ -660,6 +692,13 @@ function inferFallbackEfforts<TApi extends Api>(spec: ModelSpec<TApi>, compat: C
 	}
 	if (isOpenAICompatReasoningApi(spec.api)) {
 		const resolved = compat as ResolvedOpenAICompat;
+		if (
+			resolved.thinkingFormat === "openai" &&
+			modelMatchesHost({ provider: spec.provider, baseUrl: spec.baseUrl ?? "" }, "venice") &&
+			isQwenModelId(spec.id)
+		) {
+			return DEFAULT_REASONING_EFFORTS;
+		}
 		if (resolved.thinkingFormat === "openai" && resolved.supportsReasoningEffort) {
 			return DEFAULT_REASONING_EFFORTS_WITH_XHIGH;
 		}