@gajae-code/ai 0.17.1 → 0.17.2

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [0.17.2] - 2026-09-18
+
+### Added
+
+- Union Alpha Free on OpenCode Go and Zen with Anthropic Messages routing, image input, reasoning, and the published free-tier limits.
+
+### Fixed
+
+- Share Cursor HTTP/2 write error and close listeners across pending frames to avoid listener-limit warnings during write bursts while preserving write-failure and drain-timeout handling.
+
+- Discover local OpenCodex models through the public `/v1/models` endpoint instead of the admin-only management API, preserving public context, input, and reasoning capabilities.
+
+- Preserve OpenCode protocol-specific base URLs during model discovery and recover reviewed Union Alpha limits from pre-catalogue discovery caches.
+
 ## [0.17.1] - 2026-09-17
 
 ## [0.17.0] - 2026-09-17

package/dist/types/model-thinking.d.ts

@@ -28,14 +28,18 @@ export declare function enrichModelThinking<TApi extends Api>(model: ApiModel<TA
  * canonical rules, replacing any existing `thinking`.
  */
 export declare function refreshModelThinking<TApi extends Api>(model: ApiModel<TApi>): ApiModel<TApi>;
+/**
+ * Native MiniMax thinking semantics, scoped to first-party regional routes.
+ * M3 supports adaptive/disabled; M2.x always thinks, even when disabled is sent.
+ * https://platform.minimax.io/docs/api-reference/text-openai-api#thinking-control
+ * https://platform.minimax.io/docs/api-reference/text-anthropic-api#thinking-control
+ */
+export declare function getMiniMaxThinkingMode(model: ApiModel<Api>, resolvedBaseUrl?: string): "toggle" | "always-on" | undefined;
 /**
  * Returns whether the configured transport has an audited user-facing reasoning control.
- *
- * Custom OpenAI-compatible endpoints fail closed: declaring a model as reasoning-capable
- * is not enough to prove that the proxy accepts OpenAI reasoning parameters. Unknown
- * endpoints must opt in with `compat.supportsReasoningEffort: true`; providers using a
- * non-OpenAI request shape must also declare `compat.thinkingFormat`. Bundled providers
- * remain governed by their catalog and compatibility metadata.
+ * Custom OpenAI-compatible endpoints must opt in with supportsReasoningEffort and,
+ * for non-OpenAI request shapes, thinkingFormat. Native MiniMax switches are
+ * separate from reasoning_effort, which those endpoints do not support.
  */
 export declare function modelSupportsReasoningControl<TApi extends Api>(model: ApiModel<TApi>, resolvedBaseUrl?: string): boolean;
 /**

package/dist/types/provider-models/openai-compat.d.ts

@@ -97,8 +97,8 @@ export interface OpenCodeModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
 }
-export declare function opencodeZenModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<"openai-completions">;
-export declare function opencodeGoModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export declare function opencodeZenModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
+export declare function opencodeGoModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
 export declare function commandCodeModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
 export interface OllamaModelManagerConfig {
     apiKey?: string;

package/dist/types/utils/h2-fetch.d.ts

@@ -12,7 +12,12 @@
  * advertise h2 via ALPN but then refuse or reset the connection at the HTTP/2
  * framing layer. Bun surfaces these as `ConnectionRefused`, `ConnectionReset`,
  * or `ConnectionClosed` rather than `HTTP2Unsupported`, so we treat those
- * codes as h2-fallback triggers as well.
+ * codes as h2-fallback triggers as well. `ConnectionRefused` is raised before
+ * the request is written, but a reset or a close does not prove the peer never
+ * consumed the body — it may have processed the request and died before
+ * answering. Replaying those two on h1 would duplicate the side effect, so
+ * `ConnectionReset` and `ConnectionClosed` fall back only for replay-safe
+ * methods; anything else rethrows the original error.
  *
  * ALPN-refusing hosts (notably zcode.z.ai, the GLM ZCode OAuth broker) abort
  * the TLS handshake entirely when the client offers ALPN h2. Bun reports that

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.17.1",
+	"version": "0.17.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -41,8 +41,8 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/natives": "0.17.1",
-		"@gajae-code/utils": "0.17.1",
+		"@gajae-code/natives": "0.17.2",
+		"@gajae-code/utils": "0.17.2",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/model-manager.ts

@@ -553,15 +553,18 @@ function fingerprintStatic<TApi extends Api>(models: readonly Model<TApi>[]): st
 
 function mergeDynamicModel<TApi extends Api>(existingModel: Model<TApi>, dynamicModel: Model<TApi>): Model<TApi> {
 	const supportsImage = existingModel.input.includes("image") || dynamicModel.input.includes("image");
-	// Before this exact Go model was curated, ID-only discovery cached the
+	// Before these exact OpenCode models were curated, ID-only discovery cached the
 	// non-reasoning Completions defaults. A fresh authoritative cache can skip
 	// discovery after an upgrade, so recover its limits from reviewed static
-	// Responses metadata here. Do not reinterpret individual numeric limits or
+	// metadata here. Do not reinterpret individual numeric limits or
 	// apply this correction to reviewed discovery rows or other model IDs.
-	const hasPreReviewMuseLimits =
-		existingModel.provider === "opencode-go" &&
-		existingModel.id === "muse-spark-1.3-contributor" &&
-		existingModel.api === "openai-responses" &&
+	const hasPreReviewOpenCodeLimits =
+		((existingModel.provider === "opencode-go" &&
+			existingModel.id === "muse-spark-1.3-contributor" &&
+			existingModel.api === "openai-responses") ||
+			((existingModel.provider === "opencode-go" || existingModel.provider === "opencode-zen") &&
+				existingModel.id === "union-alpha" &&
+				existingModel.api === "anthropic-messages")) &&
 		existingModel.reasoning &&
 		dynamicModel.api === "openai-completions" &&
 		!dynamicModel.reasoning &&
@@ -594,10 +597,10 @@ function mergeDynamicModel<TApi extends Api>(existingModel: Model<TApi>, dynamic
 			cacheRead: preferDiscoveryCost(dynamicModel.cost.cacheRead, existingModel.cost.cacheRead),
 			cacheWrite: preferDiscoveryCost(dynamicModel.cost.cacheWrite, existingModel.cost.cacheWrite),
 		},
-		contextWindow: hasPreReviewMuseLimits
+		contextWindow: hasPreReviewOpenCodeLimits
 			? existingModel.contextWindow
 			: preferDiscoveryLimit(dynamicModel.contextWindow, existingModel.contextWindow),
-		maxTokens: hasPreReviewMuseLimits
+		maxTokens: hasPreReviewOpenCodeLimits
 			? existingModel.maxTokens
 			: preferDiscoveryLimit(dynamicModel.maxTokens, existingModel.maxTokens),
 		headers: dynamicModel.headers ? { ...existingModel.headers, ...dynamicModel.headers } : existingModel.headers,

package/src/model-thinking.d.ts

@@ -28,14 +28,18 @@ export declare function enrichModelThinking<TApi extends Api>(model: ApiModel<TA
  * canonical rules, replacing any existing `thinking`.
  */
 export declare function refreshModelThinking<TApi extends Api>(model: ApiModel<TApi>): ApiModel<TApi>;
+/**
+ * Native MiniMax thinking semantics, scoped to first-party regional routes.
+ * M3 supports adaptive/disabled; M2.x always thinks, even when disabled is sent.
+ * https://platform.minimax.io/docs/api-reference/text-openai-api#thinking-control
+ * https://platform.minimax.io/docs/api-reference/text-anthropic-api#thinking-control
+ */
+export declare function getMiniMaxThinkingMode(model: ApiModel<Api>, resolvedBaseUrl?: string): "toggle" | "always-on" | undefined;
 /**
  * Returns whether the configured transport has an audited user-facing reasoning control.
- *
- * Custom OpenAI-compatible endpoints fail closed: declaring a model as reasoning-capable
- * is not enough to prove that the proxy accepts OpenAI reasoning parameters. Unknown
- * endpoints must opt in with `compat.supportsReasoningEffort: true`; providers using a
- * non-OpenAI request shape must also declare `compat.thinkingFormat`. Bundled providers
- * remain governed by their catalog and compatibility metadata.
+ * Custom OpenAI-compatible endpoints must opt in with supportsReasoningEffort and,
+ * for non-OpenAI request shapes, thinkingFormat. Native MiniMax switches are
+ * separate from reasoning_effort, which those endpoints do not support.
  */
 export declare function modelSupportsReasoningControl<TApi extends Api>(model: ApiModel<TApi>, resolvedBaseUrl?: string): boolean;
 /**

package/src/model-thinking.ts

@@ -181,7 +181,7 @@ export function enrichModelThinking<TApi extends Api>(model: ApiModel<TApi>): Ap
 	if (cached !== undefined) {
 		return cached as ApiModel<TApi>;
 	}
-	const normalizedThinking = normalizeThinkingConfig(model.thinking);
+	const normalizedThinking = getMiniMaxThinkingMode(model) ? undefined : normalizeThinkingConfig(model.thinking);
 	let result: ApiModel<TApi>;
 	if (isGroqCompoundReasoningUnsupported(model)) {
 		result =
@@ -228,20 +228,61 @@ export function refreshModelThinking<TApi extends Api>(model: ApiModel<TApi>): A
 	return { ...model, thinking: inferModelThinking(model) };
 }
 
+/**
+ * Native MiniMax thinking semantics, scoped to first-party regional routes.
+ * M3 supports adaptive/disabled; M2.x always thinks, even when disabled is sent.
+ * https://platform.minimax.io/docs/api-reference/text-openai-api#thinking-control
+ * https://platform.minimax.io/docs/api-reference/text-anthropic-api#thinking-control
+ */
+export function getMiniMaxThinkingMode(
+	model: ApiModel<Api>,
+	resolvedBaseUrl?: string,
+): "toggle" | "always-on" | undefined {
+	const isDirectRoute =
+		(model.api === "anthropic-messages" && (model.provider === "minimax" || model.provider === "minimax-cn")) ||
+		(model.api === "openai-completions" &&
+			(model.provider === "minimax-code" || model.provider === "minimax-code-cn"));
+	if (!isDirectRoute) return undefined;
+	// Provider identity survives baseUrl overrides. Only the normalized native
+	// endpoint, not a provider label or a matching hostname suffix, proves this contract.
+	try {
+		const endpoint = new URL(resolvedBaseUrl ?? model.baseUrl);
+		const host = model.provider.endsWith("-cn") ? "api.minimaxi.com" : "api.minimax.io";
+		const path = endpoint.pathname.replace(/\/+$/, "");
+		const validPath =
+			model.api === "anthropic-messages" ? path === "/anthropic" || path === "/anthropic/v1" : path === "/v1";
+		if (
+			endpoint.origin !== `https://${host}` ||
+			!validPath ||
+			endpoint.username ||
+			endpoint.password ||
+			endpoint.search ||
+			endpoint.hash
+		)
+			return undefined;
+	} catch {
+		return undefined;
+	}
+	if (model.id === "MiniMax-M3" || model.id === "MiniMax-M3[1m]") return "toggle";
+	if (/^MiniMax-M2(?:[.\-[]|$)/.test(model.id)) return "always-on";
+	return undefined;
+}
+
 /**
  * Returns whether the configured transport has an audited user-facing reasoning control.
- *
- * Custom OpenAI-compatible endpoints fail closed: declaring a model as reasoning-capable
- * is not enough to prove that the proxy accepts OpenAI reasoning parameters. Unknown
- * endpoints must opt in with `compat.supportsReasoningEffort: true`; providers using a
- * non-OpenAI request shape must also declare `compat.thinkingFormat`. Bundled providers
- * remain governed by their catalog and compatibility metadata.
+ * Custom OpenAI-compatible endpoints must opt in with supportsReasoningEffort and,
+ * for non-OpenAI request shapes, thinkingFormat. Native MiniMax switches are
+ * separate from reasoning_effort, which those endpoints do not support.
  */
 export function modelSupportsReasoningControl<TApi extends Api>(
 	model: ApiModel<TApi>,
 	resolvedBaseUrl?: string,
 ): boolean {
 	if (!model.reasoning) return false;
+	// MiniMax's native thinking switch is not OpenAI reasoning_effort. M2.x
+	// always thinks; M3 supports adaptive/disabled, but no effort or budget.
+	const miniMaxMode = getMiniMaxThinkingMode(model, resolvedBaseUrl);
+	if (miniMaxMode) return miniMaxMode === "toggle";
 	if (model.api === "openai-completions") {
 		const completionsModel = model as ApiModel<"openai-completions">;
 		const explicitSupport = completionsModel.compat?.supportsReasoningEffort;
@@ -777,6 +818,11 @@ function inferDefaultEffort<TApi extends Api>(model: ApiModel<TApi>, parsedModel
 }
 
 function inferModelThinking<TApi extends Api>(model: ApiModel<TApi>): ThinkingConfig {
+	if (getMiniMaxThinkingMode(model) === "toggle") {
+		// The existing persisted effort value represents the single enabled state;
+		// UI consumers label it "on", and transports send no effort or budget.
+		return { mode: "effort", minLevel: Effort.High, maxLevel: Effort.High };
+	}
 	const parsedModel = parseKnownModel(model.id);
 	const efforts = inferSupportedEfforts(parsedModel, model);
 	const minLevel = efforts[0];

package/src/models.json

@@ -66611,6 +66611,31 @@
 				"minLevel": "minimal",
 				"maxLevel": "xhigh"
 			}
+		},
+		"union-alpha": {
+			"id": "union-alpha",
+			"name": "Union Alpha Free",
+			"api": "anthropic-messages",
+			"provider": "opencode-go",
+			"baseUrl": "https://opencode.ai/zen/go",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 262144,
+			"maxTokens": 131072,
+			"thinking": {
+				"mode": "budget",
+				"minLevel": "minimal",
+				"maxLevel": "xhigh"
+			}
 		}
 	},
 	"opencode-zen": {
@@ -68629,6 +68654,31 @@
 			},
 			"contextWindow": 131072,
 			"maxTokens": 131072
+		},
+		"union-alpha": {
+			"id": "union-alpha",
+			"name": "Union Alpha Free",
+			"api": "anthropic-messages",
+			"provider": "opencode-zen",
+			"baseUrl": "https://opencode.ai/zen",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 262144,
+			"maxTokens": 131072,
+			"thinking": {
+				"mode": "budget",
+				"minLevel": "minimal",
+				"maxLevel": "xhigh"
+			}
 		}
 	},
 	"opengateway": {

package/src/provider-models/openai-compat.ts

@@ -856,44 +856,41 @@ export interface OpenCodeModelManagerConfig {
 }
 
 function openCodeModelManagerOptions(
-	providerId: "opencode-go" | "opencode-zen" | "commandcode-goat",
+	providerId: "opencode-go" | "opencode-zen",
 	defaultBaseUrl: string,
 	config?: OpenCodeModelManagerConfig,
-): ModelManagerOptions<"openai-completions"> {
+): ModelManagerOptions<Api> {
 	const apiKey = config?.apiKey;
 	const baseUrl = config?.baseUrl ?? defaultBaseUrl;
-	const references =
-		providerId === "opencode-go" ? createBundledReferenceMap<"openai-completions">(providerId) : undefined;
+	const references = createBundledReferenceMap<Api>(providerId);
 	return {
 		providerId,
 		...(apiKey && {
 			fetchDynamicModels: () =>
-				fetchOpenAICompatibleModels({
+				fetchOpenAICompatibleModels<Api>({
 					api: "openai-completions",
 					provider: providerId,
 					baseUrl,
 					apiKey,
-					...(providerId === "opencode-go" && {
-						mapModel: (entry, defaults) => {
-							const reference = references?.get(defaults.id);
-							const model = mapWithBundledReference(entry, defaults, reference);
-							return applyOpenCodeGoOfficialMetadata(model);
-						},
-					}),
+					mapModel: (entry, defaults) => {
+						const model = mapWithBundledReference(entry, defaults, references.get(defaults.id));
+						// Discovery uses /v1/models, but the Anthropic client appends
+						// /v1/messages itself. Preserve the configured origin, not /v1/v1.
+						if (model.api === "anthropic-messages") {
+							model.baseUrl = model.baseUrl.replace(/\/v1\/?$/u, "");
+						}
+						return providerId === "opencode-go" ? applyOpenCodeGoOfficialMetadata(model) : model;
+					},
 				}),
 		}),
 	};
 }
 
-export function opencodeZenModelManagerOptions(
-	config?: OpenCodeModelManagerConfig,
-): ModelManagerOptions<"openai-completions"> {
+export function opencodeZenModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api> {
 	return openCodeModelManagerOptions("opencode-zen", "https://opencode.ai/zen/v1", config);
 }
 
-export function opencodeGoModelManagerOptions(
-	config?: OpenCodeModelManagerConfig,
-): ModelManagerOptions<"openai-completions"> {
+export function opencodeGoModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api> {
 	return openCodeModelManagerOptions("opencode-go", "https://opencode.ai/zen/go/v1", config);
 }
 
@@ -2378,7 +2375,9 @@ function createOpenCodeApiResolution(
 }
 
 const OPENCODE_GO_BASE_PATH = "https://opencode.ai/zen/go";
-const OPENCODE_ZEN_API_RESOLUTION = createOpenCodeApiResolution("https://opencode.ai/zen");
+const OPENCODE_ZEN_API_RESOLUTION = createOpenCodeApiResolution("https://opencode.ai/zen", {
+	"union-alpha": "anthropic-messages",
+});
 const OPENCODE_GO_CHAT_COMPLETIONS_MODEL_IDS = [
 	"deepseek-v4-flash",
 	"deepseek-v4-flash-vision-exp",
@@ -2401,6 +2400,7 @@ const OPENCODE_GO_MESSAGES_MODEL_IDS = [
 	"qwen3.7-max",
 	"qwen3.7-plus",
 	"qwen3.8-flash",
+	"union-alpha",
 ] as const;
 const OPENCODE_GO_API_OVERRIDES: Readonly<Record<string, Api>> = {
 	...Object.fromEntries(OPENCODE_GO_CHAT_COMPLETIONS_MODEL_IDS.map(id => [id, "openai-completions"])),
@@ -2658,6 +2658,14 @@ interface OpenCodeGoOfficialModelMetadata {
 }
 
 const OPENCODE_GO_OFFICIAL_MODELS: Readonly<Record<string, OpenCodeGoOfficialModelMetadata>> = {
+	"union-alpha": {
+		name: "Union Alpha Free",
+		contextWindow: 262_144,
+		maxTokens: 131_072,
+		input: ["text", "image"],
+		reasoning: true,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	},
 	"deepseek-v4-flash": {
 		name: "DeepSeek V4 Flash",
 		contextWindow: 1_000_000,

package/src/providers/anthropic.ts

@@ -26,6 +26,7 @@ import {
 	PROVIDER_SAFETY_STOP_ADAPTER_CAPABILITY,
 } from "../adapter-internals/provider-safety-stop";
 import {
+	getMiniMaxThinkingMode,
 	hasOpus47ApiRestrictions,
 	mapEffortToAnthropicAdaptiveEffort,
 	supportsAnthropicAdaptiveThinkingDisplay as supportsAdaptiveThinkingDisplay,
@@ -3610,7 +3611,14 @@ function buildParams(
 		);
 	}
 
-	if (model.reasoning) {
+	const miniMaxMode = getMiniMaxThinkingMode(model, baseUrl);
+	if (model.reasoning && miniMaxMode === "toggle") {
+		// MiniMax's Messages endpoint defaults to off and only supports a
+		// switch. Claude budget_tokens/output_config.effort do not apply.
+		if (options?.thinkingEnabled !== undefined) {
+			params.thinking = { type: options.thinkingEnabled ? "adaptive" : "disabled" };
+		}
+	} else if (model.reasoning && miniMaxMode !== "always-on") {
 		if (options?.thinkingEnabled) {
 			const mode = model.thinking?.mode;
 			const requestedEffort = options.reasoning;

package/src/providers/cursor.ts

@@ -676,6 +676,12 @@ const CURSOR_WRITE_DRAIN_TIMEOUT_MS = 5_000;
 const CURSOR_MAX_PENDING_SHELL_WRITE_BYTES = 1024 * 1024;
 const pendingCursorWrites = new WeakMap<object, Set<Promise<void>>>();
 const cursorWriteErrors = new WeakMap<object, unknown>();
+interface CursorWriteListeners {
+	finishes: Set<(error?: unknown) => void>;
+	onError: (error: unknown) => void;
+	onClose: () => void;
+}
+const cursorWriteListeners = new WeakMap<object, CursorWriteListeners>();
 
 function closeStalledCursorRequest(request: http2.ClientHttp2Stream): void {
 	// A request whose peer stopped reading may never invoke a write callback. Close
@@ -833,25 +839,44 @@ function writeCursorFrame(request: http2.ClientHttp2Stream, frame: Uint8Array):
 	// late transport error cannot surface as an unhandled rejection in the gap.
 	completion.promise.catch(() => {});
 	pending.add(completion.promise);
+	let listeners = cursorWriteListeners.get(request);
+	if (!listeners) {
+		const finishes = new Set<(error?: unknown) => void>();
+		const onError = (error: unknown) => {
+			for (const finish of [...finishes]) finish(error);
+		};
+		listeners = {
+			finishes,
+			onError,
+			onClose: () => onError(new Error("Cursor request closed before write completed")),
+		};
+		cursorWriteListeners.set(request, listeners);
+	}
+	const shared = listeners;
 	const finish = (error?: unknown) => {
 		if (completed) return;
 		completed = true;
 		pending.delete(completion.promise);
 		if (error != null && !cursorWriteErrors.has(request)) cursorWriteErrors.set(request, error);
-		if (typeof request.removeListener === "function") {
-			request.removeListener("close", onClose);
-			request.removeListener("error", finish);
+		shared.finishes.delete(finish);
+		if (shared.finishes.size === 0) {
+			if (typeof request.removeListener === "function") {
+				request.removeListener("close", shared.onClose);
+				request.removeListener("error", shared.onError);
+			}
+			cursorWriteListeners.delete(request);
+			// Keep the pending set and first error until the final drain observes them.
 		}
 		if (error == null) completion.resolve();
 		else completion.reject(error);
 	};
-	const onClose = () => finish(new Error("Cursor request closed before write completed"));
+	shared.finishes.add(finish);
 	try {
 		// The real HTTP/2 stream always exposes EventEmitter methods. Keep the
 		// test seam tolerant of a minimal writer stub as well.
-		if (typeof request.once === "function") {
-			request.once("close", onClose);
-			request.once("error", finish);
+		if (shared.finishes.size === 1 && typeof request.once === "function") {
+			request.once("close", shared.onClose);
+			request.once("error", shared.onError);
 		}
 		return request.write(frame, finish) !== false;
 	} catch (error) {

package/src/providers/openai-completions.ts

@@ -18,6 +18,7 @@ import {
 } from "../adapter-internals/provider-safety-stop";
 import {
 	type Effort,
+	getMiniMaxThinkingMode,
 	getSupportedEfforts,
 	isGroqCompoundReasoningUnsupported,
 	modelSupportsReasoningControl,
@@ -364,7 +365,7 @@ type OpenAICompletionsParams = Omit<OpenAI.Chat.Completions.ChatCompletionCreate
 	top_k?: number;
 	min_p?: number;
 	repetition_penalty?: number;
-	thinking?: { type: "enabled" | "disabled" };
+	thinking?: { type: "enabled" | "disabled" | "adaptive" };
 	enable_thinking?: boolean;
 	chat_template_kwargs?: { enable_thinking: boolean };
 	reasoning?: { effort?: string } | { enabled: false };
@@ -1576,7 +1577,12 @@ function buildParams(
 		delete params.tool_choice;
 	}
 
-	if (supportsReasoningParams && compat.thinkingFormat === "zai" && model.reasoning) {
+	if (supportsReasoningParams && getMiniMaxThinkingMode(model, resolvedBaseUrl) === "toggle") {
+		// MiniMax-M3 accepts an on/off switch, not reasoning_effort. Omitting
+		// the switch preserves the OpenAI-compatible endpoint's default (on).
+		if (options?.disableReasoning) params.thinking = { type: "disabled" };
+		else if (options?.reasoning) params.thinking = { type: "adaptive" };
+	} else if (supportsReasoningParams && compat.thinkingFormat === "zai" && model.reasoning) {
 		// Z.ai uses binary thinking: { type: "enabled" | "disabled" }
 		// Must explicitly disable since z.ai defaults to thinking enabled.
 		const enabled = options?.reasoning && !options?.disableReasoning;

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

@@ -31,6 +31,11 @@ interface CatalogRow {
 	maxTokens?: unknown;
 	reasoning?: unknown;
 	input?: unknown;
+	capabilities?: {
+		context_length?: unknown;
+		input_modalities?: unknown;
+		supports_reasoning?: unknown;
+	};
 }
 
 export interface OpenCodexEndpoint {
@@ -120,6 +125,9 @@ function asPositiveNumber(value: unknown, fallback: number): number {
 
 function normalizeCatalogPayload(payload: unknown): CatalogRow[] {
 	if (Array.isArray(payload)) return payload as CatalogRow[];
+	if (payload && typeof payload === "object" && Array.isArray((payload as { data?: unknown }).data)) {
+		return (payload as { data: CatalogRow[] }).data;
+	}
 	if (payload && typeof payload === "object" && Array.isArray((payload as { models?: unknown }).models)) {
 		return (payload as { models: CatalogRow[] }).models;
 	}
@@ -127,12 +135,14 @@ function normalizeCatalogPayload(payload: unknown): CatalogRow[] {
 }
 
 function normalizeModel(row: CatalogRow, endpoint: OpenCodexEndpoint): Model<"openai-responses"> | undefined {
+	if (!row || typeof row !== "object") return undefined;
 	const rawId = typeof row.id === "string" ? row.id.trim() : typeof row.model === "string" ? row.model.trim() : "";
 	if (!rawId || rawId.includes("\n")) return undefined;
 	const publicId = `opencodex/${rawId}`;
+	const modalities = row.input ?? row.capabilities?.input_modalities;
 	const input =
-		Array.isArray(row.input) && row.input.every(value => value === "text" || value === "image")
-			? row.input
+		Array.isArray(modalities) && modalities.every(value => value === "text" || value === "image")
+			? modalities
 			: ["text"];
 	return {
 		id: publicId,
@@ -142,10 +152,10 @@ function normalizeModel(row: CatalogRow, endpoint: OpenCodexEndpoint): Model<"op
 		provider: "opencodex",
 		baseUrl: `${endpoint.baseUrl}/v1`,
 		compat: { supportsServiceTier: true },
-		reasoning: row.reasoning !== false,
+		reasoning: (row.reasoning ?? row.capabilities?.supports_reasoning) !== false,
 		input,
 		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-		contextWindow: asPositiveNumber(row.contextWindow, 128_000),
+		contextWindow: asPositiveNumber(row.contextWindow ?? row.capabilities?.context_length, 128_000),
 		maxTokens: asPositiveNumber(row.maxTokens, 16_384),
 	};
 }
@@ -154,7 +164,7 @@ export async function fetchOpenCodexModels(): Promise<readonly Model<"openai-res
 	const endpoint = await resolveOpenCodexEndpoint();
 	if (!endpoint) return null;
 	try {
-		const rows = normalizeCatalogPayload(await fetchJson(`${endpoint.baseUrl}/api/models`));
+		const rows = normalizeCatalogPayload(await fetchJson(`${endpoint.baseUrl}/v1/models`));
 		const models = rows
 			.map(row => normalizeModel(row, endpoint))
 			.filter((model): model is Model<"openai-responses"> => model !== undefined);

package/src/stream.ts

@@ -27,6 +27,7 @@ function markManagedAttemptValidated<T extends object>(options: T): T {
 import { getCustomApi } from "./api-registry";
 import type { Effort } from "./model-thinking";
 import {
+	getMiniMaxThinkingMode,
 	mapEffortToAnthropicAdaptiveEffort,
 	mapEffortToGoogleThinkingLevel,
 	requireSupportedEffort,
@@ -978,6 +979,16 @@ function mapOptionsForApi<TApi extends Api>(
 
 	switch (model.api) {
 		case "anthropic-messages": {
+			const miniMaxMode = getMiniMaxThinkingMode(model);
+			if (miniMaxMode) {
+				return castApi<"anthropic-messages">({
+					...base,
+					thinkingEnabled:
+						miniMaxMode === "toggle" ? !!options?.reasoning && !options?.disableReasoning : undefined,
+					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
+					serviceTier: options?.serviceTier,
+				});
+			}
 			// Explicitly disable thinking when reasoning is not specified or model doesn't support it
 			const reasoning = options?.reasoning;
 			if (!reasoning || !model.reasoning) {
@@ -1094,7 +1105,12 @@ function mapOptionsForApi<TApi extends Api>(
 			return castApi<"openai-completions">({
 				...base,
 				reasoning: resolveOpenAiReasoningEffort(model, options),
-				disableReasoning: options?.disableReasoning,
+				// Agent-level off is represented by an absent effort. MiniMax's
+				// native OpenAI endpoint defaults to on, so send an explicit switch.
+				disableReasoning:
+					getMiniMaxThinkingMode(model) === "toggle"
+						? !options?.reasoning || options?.disableReasoning
+						: options?.disableReasoning,
 				toolChoice: mapOpenAiToolChoice(options?.toolChoice),
 				serviceTier: options?.serviceTier,
 			});

package/src/utils/h2-fetch.ts

@@ -12,7 +12,12 @@
  * advertise h2 via ALPN but then refuse or reset the connection at the HTTP/2
  * framing layer. Bun surfaces these as `ConnectionRefused`, `ConnectionReset`,
  * or `ConnectionClosed` rather than `HTTP2Unsupported`, so we treat those
- * codes as h2-fallback triggers as well.
+ * codes as h2-fallback triggers as well. `ConnectionRefused` is raised before
+ * the request is written, but a reset or a close does not prove the peer never
+ * consumed the body — it may have processed the request and died before
+ * answering. Replaying those two on h1 would duplicate the side effect, so
+ * `ConnectionReset` and `ConnectionClosed` fall back only for replay-safe
+ * methods; anything else rethrows the original error.
  *
  * ALPN-refusing hosts (notably zcode.z.ai, the GLM ZCode OAuth broker) abort
  * the TLS handshake entirely when the client offers ALPN h2. Bun reports that
@@ -47,12 +52,16 @@ export function installH2Fetch(): void {
 		// code; the h1 fallback below re-verifies the certificate itself.
 		"UNKNOWN_CERTIFICATE_VERIFICATION_ERROR",
 	]);
+	/** Fallback codes that may fire *after* the peer consumed the body — replay only when safe. */
+	const replayGatedCodes: ReadonlySet<string> = new Set(["ConnectionReset", "ConnectionClosed"]);
 	const wrapper = async function h2fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> {
 		if (!isHttps(input)) return original(input, init);
 		try {
 			return await original(input, { ...init, protocol: "http2" });
 		} catch (err) {
-			if (!h2FallbackCodes.has((err as { code?: string }).code ?? "")) throw err;
+			const code = (err as { code?: string }).code ?? "";
+			if (!h2FallbackCodes.has(code)) throw err;
+			if (replayGatedCodes.has(code) && !isReplaySafeRequest(input, init)) throw err;
 			return original(input, init);
 		}
 	} as typeof fetch & PatchedFetch;
@@ -63,6 +72,21 @@ export function installH2Fetch(): void {
 	globalThis.fetch = wrapper;
 }
 
+/** Methods a transport-layer retry cannot turn into a second side effect. */
+const replaySafeMethods: ReadonlySet<string> = new Set(["GET", "HEAD", "OPTIONS"]);
+
+/**
+ * Whether replaying this request on a fresh connection is side-effect free.
+ *
+ * PR #5614 introduces an identically-named helper with the same semantics for
+ * `HTTP2StreamReset`; whichever of the two lands second should collapse into
+ * this one rather than leaving the repo with two devices doing the same job.
+ */
+function isReplaySafeRequest(input: string | URL | Request, init?: RequestInit): boolean {
+	const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+	return replaySafeMethods.has(method.toUpperCase());
+}
+
 function isHttps(input: string | URL | Request): boolean {
 	if (typeof input === "string") return input.startsWith("https:");
 	if (input instanceof URL) return input.protocol === "https:";

package/src/utils/http-inspector.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { APP_NAME, extractHttpStatusFromError, getLogsDir } from "@gajae-code/utils";
+import { APP_NAME, extractHttpStatusFromError, getEffectiveLogsDir } from "@gajae-code/utils";
 import { isCopilotTransientModelError } from "./retry.js";
 import { formatErrorMessageWithRetryAfter } from "./retry-after.js";
 
@@ -109,7 +109,7 @@ const MAX_RETAINED_DUMPS = 50;
 
 /** Directory holding the retained HTTP 400 dumps. */
 export function httpRequestDumpDir(): string {
-	return path.join(getLogsDir(), "http-400-requests");
+	return path.join(getEffectiveLogsDir(), "http-400-requests");
 }
 
 /**