@gajae-code/ai 0.12.7 → 0.12.8

package/src/model-manager.ts

@@ -56,6 +56,8 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
 export interface ModelResolutionResult<TApi extends Api = Api> {
 	models: Model<TApi>[];
 	stale: boolean;
+	/** Whether this resolution successfully fetched dynamic models. */
+	fetched: boolean;
 }
 
 /**
@@ -147,13 +149,13 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 	) {
 		const cachedModels = passModelList<TApi>(cache.models);
 		if (!hasStaticTransportDrift(staticModels, cachedModels)) {
-			return { models: cachedModels, stale: false };
+			return { models: cachedModels, stale: false, fetched: false };
 		}
 		const repairedModels = mergeDynamicModels(staticModels, cachedModels);
 		if (options.canPublishCache?.() ?? true) {
 			writeModelCache(options.providerId, now(), repairedModels, true, staticFingerprint, dbPath);
 		}
-		return { models: repairedModels, stale: false };
+		return { models: repairedModels, stale: false, fetched: false };
 	}
 
 	const [fetchedModelsDevModels, fetchedDynamicModels] = shouldFetchFromNetwork
@@ -200,6 +202,7 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 	return {
 		models,
 		stale: !dynamicAuthoritative,
+		fetched: shouldFetchFromNetwork && dynamicFetchSucceeded,
 	};
 }
 

package/src/provider-models/descriptors.ts

@@ -48,7 +48,12 @@ import {
 	xiaomiModelManagerOptions,
 	zenmuxModelManagerOptions,
 } from "./openai-compat";
-import { cursorModelManagerOptions, glmZcodeModelManagerOptions, zaiModelManagerOptions } from "./special";
+import {
+	cursorModelManagerOptions,
+	glmZcodeModelManagerOptions,
+	openCodexModelManagerOptions,
+	zaiModelManagerOptions,
+} from "./special";
 
 /** Catalog discovery configuration for providers that support endpoint-based model listing. */
 export interface CatalogDiscoveryConfig {
@@ -139,6 +144,7 @@ export const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[] = [
 		catalog("Alibaba Token Plan", ["ALIBABA_TOKEN_PLAN_API_KEY"], { oauthProvider: "alibaba-token-plan" }),
 	),
 	descriptor("openai", "gpt-5.4", config => openaiModelManagerOptions(config)),
+	descriptor("opencodex", "gpt-5.4", () => openCodexModelManagerOptions(), { allowUnauthenticated: true }),
 	descriptor("groq", "openai/gpt-oss-120b", config => groqModelManagerOptions(config)),
 	catalogDescriptor(
 		"huggingface",

package/src/provider-models/special.ts

@@ -1,6 +1,14 @@
 import { once } from "@gajae-code/utils";
 import type { ModelManagerOptions } from "../model-manager";
+import { fetchOpenCodexModels, OPENCODEX_MODEL_CACHE_TTL_MS } from "../providers/openai-opencodex-responses";
 import { fetchCodexModels } from "../utils/discovery/codex";
+export function openCodexModelManagerOptions(): ModelManagerOptions<"openai-responses"> {
+	return {
+		providerId: "opencodex",
+		cacheTtlMs: OPENCODEX_MODEL_CACHE_TTL_MS,
+		fetchDynamicModels: fetchOpenCodexModels,
+	};
+}
 
 // ---------------------------------------------------------------------------
 // OpenAI code provider

package/src/providers/openai-codex/response-handler.ts

@@ -19,6 +19,9 @@ export type CodexErrorInfo = {
 	rateLimits?: CodexRateLimits;
 	raw?: string;
 };
+// Matches the gate's bare rejection body ("Request blocked." / "Request
+// blocked (…)") but never messages that merely mention blocking mid-text.
+const REQUEST_BLOCKED_MESSAGE_RE = /^\s*request blocked\b/i;
 
 export async function parseCodexError(response: Response): Promise<CodexErrorInfo> {
 	const raw = await response.text();
@@ -28,7 +31,7 @@ export async function parseCodexError(response: Response): Promise<CodexErrorInf
 	let code: string | undefined;
 
 	try {
-		const parsed = JSON.parse(raw) as { error?: Record<string, unknown> };
+		const parsed = JSON.parse(raw) as { error?: Record<string, unknown>; detail?: unknown };
 		const err = parsed?.error ?? {};
 
 		const headers = response.headers;
@@ -67,11 +70,30 @@ export async function parseCodexError(response: Response): Promise<CodexErrorInf
 		}
 
 		const errMessage = (err as { message?: string }).message;
-		message = errMessage || friendlyMessage || message;
+		// The chatgpt.com/backend-api gate rejects with a bare-`detail` body
+		// (`{"detail": "Request blocked."}`) that carries no `error.*` envelope.
+		const detail =
+			typeof parsed?.detail === "string"
+				? parsed.detail
+				: typeof (parsed?.detail as { message?: unknown } | undefined)?.message === "string"
+					? (parsed.detail as { message: string }).message
+					: undefined;
+		message = errMessage || detail || friendlyMessage || message;
 	} catch {
 		// raw body not JSON
 	}
 
+	// A bare "Request blocked" body (detail-shaped JSON or plain text) is the
+	// pre-model gate's form of the deterministic `invalid_prompt` content
+	// rejection. It never carries a structured code, so classify it explicitly
+	// here; otherwise `isInvalidPromptError`, the codex non-retryable event set,
+	// and the session-level circuit breaker all miss it and the failure surfaces
+	// as an unexplained, unrepairable "Request Blocked".
+	if (!code && REQUEST_BLOCKED_MESSAGE_RE.test(message)) {
+		code = "invalid_prompt";
+		friendlyMessage = `${message.trim().replace(/\.+$/, "")} (code=invalid_prompt)`;
+	}
+
 	return {
 		message,
 		status: response.status,

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

@@ -2823,7 +2823,7 @@ export function convertOpenAICodexResponsesTools(
 	model: Model<"openai-codex-responses">,
 ): CodexToolPayload[] {
 	const allowFreeform = supportsFreeformApplyPatchCodex(model);
-	return tools.map((tool): CodexToolPayload => {
+	const payloads = tools.map((tool): CodexToolPayload => {
 		if (allowFreeform && tool.customFormat) {
 			return {
 				type: "custom",
@@ -2847,6 +2847,10 @@ export function convertOpenAICodexResponsesTools(
 			...(effectiveStrict && { strict: true }),
 		};
 	});
+	// Tool definitions bypass the `input`/`instructions` sanitizers, so a
+	// leaked Harmony marker in an MCP/skill tool description or schema string
+	// makes the gate reject every request (bare `Request blocked`).
+	return neutralizeResponsesInputControlTokens(payloads);
 }
 
 function getString(value: unknown): string | undefined {

package/src/providers/openai-completions.ts

@@ -119,6 +119,69 @@ export function resolveOpenAICompletionsBaseUrlForTest(
 ): string {
 	return resolveOpenAIProviderBaseUrl(baseUrl, authCredentialType);
 }
+function appendUrlPath(baseUrl: string | undefined, path: string): string | undefined {
+	if (!baseUrl) return undefined;
+	const normalizedPath = path.replace(/^\/+/g, "");
+	try {
+		const parsed = new URL(baseUrl);
+		parsed.pathname = `${parsed.pathname.replace(/\/+$/g, "")}/${normalizedPath}`;
+		return parsed.toString();
+	} catch {
+		return `${baseUrl.replace(/\/+$/g, "")}/${normalizedPath}`;
+	}
+}
+
+type OpenAICompletionsQuery = string;
+
+function splitBaseUrlQuery(baseUrl: string | undefined): {
+	baseUrl: string | undefined;
+	query?: OpenAICompletionsQuery;
+} {
+	if (!baseUrl) return { baseUrl };
+	try {
+		const parsed = new URL(baseUrl);
+		if (!parsed.search) return { baseUrl };
+		const queryStart = baseUrl.indexOf("?");
+		const fragmentStart = baseUrl.indexOf("#", queryStart);
+		const query = baseUrl.slice(queryStart + 1, fragmentStart === -1 ? undefined : fragmentStart);
+		if (!query) return { baseUrl };
+		parsed.search = "";
+		return {
+			baseUrl: parsed.toString(),
+			query,
+		};
+	} catch {
+		return { baseUrl };
+	}
+}
+
+function hasQueryParameter(query: OpenAICompletionsQuery | undefined, name: string): boolean {
+	return query ? new URLSearchParams(query).has(name) : false;
+}
+
+function appendRawQuery(url: string, query: OpenAICompletionsQuery | undefined): string {
+	if (!query) return url;
+	const fragmentStart = url.indexOf("#");
+	const beforeFragment = fragmentStart === -1 ? url : url.slice(0, fragmentStart);
+	const fragment = fragmentStart === -1 ? "" : url.slice(fragmentStart);
+	return `${beforeFragment}${beforeFragment.includes("?") ? "&" : "?"}${query}${fragment}`;
+}
+
+function buildRequestUrl(
+	baseUrl: string | undefined,
+	path: string,
+	query?: OpenAICompletionsQuery,
+): string | undefined {
+	const url = appendUrlPath(baseUrl, path);
+	return url ? appendRawQuery(url, query) : undefined;
+}
+
+function appendQueryToRequest(input: string | URL | Request, query?: OpenAICompletionsQuery): string | URL | Request {
+	if (!query) return input;
+	const url = appendRawQuery(input instanceof Request ? input.url : String(input), query);
+	if (input instanceof Request) return new Request(url, input as unknown as RequestInit);
+	return url;
+}
 
 /**
  * Normalize tool call ID for Mistral.
@@ -466,6 +529,8 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				client,
 				copilotPremiumRequests,
 				baseUrl,
+				requestBaseUrl,
+				requestQuery,
 				requestHeaders,
 				getCapturedErrorResponse: captureErrorResponse,
 				clearCapturedErrorResponse,
@@ -511,7 +576,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 					api: output.api,
 					model: model.id,
 					method: "POST",
-					url: `${baseUrl}/chat/completions`,
+					url: buildRequestUrl(requestBaseUrl, "chat/completions", requestQuery),
 					headers: requestHeaders,
 					body: params,
 				};
@@ -1029,6 +1094,8 @@ async function createClient(
 	client: OpenAI;
 	copilotPremiumRequests: number | undefined;
 	baseUrl: string | undefined;
+	requestBaseUrl: string | undefined;
+	requestQuery: OpenAICompletionsQuery | undefined;
 	requestHeaders: Record<string, string>;
 	getCapturedErrorResponse: () => CapturedHttpErrorResponse | undefined;
 	clearCapturedErrorResponse: () => void;
@@ -1103,19 +1170,29 @@ async function createClient(
 	}
 	// Azure OpenAI requires /deployments/{id}/chat/completions?api-version=YYYY-MM-DD.
 	// The generic openai-completions path adds neither, producing silent 404s.
-	let azureDefaultQuery: Record<string, string> | undefined;
+	let azureQuery: OpenAICompletionsQuery | undefined;
 	if (baseUrl?.includes(".openai.azure.com")) {
-		const apiVersion = $env.AZURE_OPENAI_API_VERSION || "2024-10-21";
 		if (!baseUrl.includes("/deployments/")) {
-			baseUrl = `${baseUrl}/deployments/${model.id}`;
+			baseUrl = appendUrlPath(baseUrl, `deployments/${model.id}`) ?? baseUrl;
 		}
-		azureDefaultQuery = { "api-version": apiVersion };
 	}
+	const { baseUrl: clientBaseUrl, query: endpointQuery } = splitBaseUrlQuery(baseUrl);
+	if (baseUrl?.includes(".openai.azure.com") && !hasQueryParameter(endpointQuery, "api-version")) {
+		azureQuery = new URLSearchParams({
+			"api-version": $env.AZURE_OPENAI_API_VERSION || "2024-10-21",
+		}).toString();
+	}
+	const endpointRequestQuery = endpointQuery;
+	const requestQuery =
+		[endpointRequestQuery, azureQuery].filter((query): query is string => query !== undefined).join("&") || undefined;
 	let capturedErrorResponse: CapturedHttpErrorResponse | undefined;
 	const baseFetch = fetchOverride ?? fetch;
 	const wrappedFetch = Object.assign(
 		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
-			const response = await baseFetch(input, init);
+			const response = await baseFetch(
+				appendQueryToRequest(appendQueryToRequest(input, endpointRequestQuery), azureQuery),
+				init,
+			);
 			if (response.ok) {
 				capturedErrorResponse = undefined;
 				return response;
@@ -1171,16 +1248,17 @@ async function createClient(
 	return {
 		client: new OpenAI({
 			apiKey,
-			baseURL: baseUrl,
+			baseURL: clientBaseUrl,
 			dangerouslyAllowBrowser: true,
 			maxRetries: resolveRetryBudget(requestMaxRetries, 5),
 			defaultHeaders: headers,
-			defaultQuery: azureDefaultQuery,
 			fetch: debugFetch,
 			...(sdkTimeoutMs !== undefined ? { timeout: sdkTimeoutMs } : {}),
 		}),
 		copilotPremiumRequests,
 		baseUrl,
+		requestBaseUrl: clientBaseUrl,
+		requestQuery,
 		requestHeaders: headers,
 		getCapturedErrorResponse: () => capturedErrorResponse,
 		clearCapturedErrorResponse: () => {

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

@@ -0,0 +1,173 @@
+import * as fs from "node:fs/promises";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import type { Model } from "../types";
+
+export const OPENCODEX_DEFAULT_PORT = 10100;
+export const OPENCODEX_PROBE_TIMEOUT_MS = 750;
+export const OPENCODEX_MODEL_CACHE_TTL_MS = 5 * 60 * 1000;
+
+interface RuntimePortFile {
+	hostname?: unknown;
+	host?: unknown;
+	port?: unknown;
+}
+
+interface HealthPayload {
+	ok?: unknown;
+	pid?: unknown;
+	port?: unknown;
+	version?: unknown;
+}
+
+interface CatalogRow {
+	id?: unknown;
+	model?: unknown;
+	name?: unknown;
+	displayName?: unknown;
+	contextWindow?: unknown;
+	maxTokens?: unknown;
+	reasoning?: unknown;
+	input?: unknown;
+}
+
+export interface OpenCodexEndpoint {
+	baseUrl: string;
+}
+
+function timeoutSignal(signal?: AbortSignal): AbortSignal {
+	return signal
+		? AbortSignal.any([signal, AbortSignal.timeout(OPENCODEX_PROBE_TIMEOUT_MS)])
+		: AbortSignal.timeout(OPENCODEX_PROBE_TIMEOUT_MS);
+}
+
+function normalizeEndpoint(hostname: string, port: number): string | undefined {
+	if (!Number.isInteger(port) || port < 1 || port > 65535) return undefined;
+	const host = normalizeLoopbackHost(hostname);
+	if (!host) return undefined;
+	return `http://${formatEndpointHost(host)}:${port}`;
+}
+
+function normalizeLoopbackHost(hostname: string): string | undefined {
+	const host = hostname.trim().toLowerCase();
+	if (net.isIP(host) === 4 && host.startsWith("127.")) return host;
+	if (host === "::1") return host;
+	return undefined;
+}
+
+function formatEndpointHost(host: string): string {
+	return host.includes(":") ? `[${host}]` : host;
+}
+
+function healthPort(endpoint: string): number {
+	return Number(new URL(endpoint).port);
+}
+
+async function readRuntimeEndpoint(): Promise<string | undefined> {
+	const home = process.env.OPENCODEX_HOME?.trim() || path.join(os.homedir(), ".opencodex");
+	try {
+		const raw = JSON.parse(await fs.readFile(path.join(home, "runtime-port.json"), "utf8")) as RuntimePortFile;
+		const hostname =
+			typeof raw.hostname === "string" ? raw.hostname : typeof raw.host === "string" ? raw.host : "127.0.0.1";
+		const port = typeof raw.port === "number" ? raw.port : typeof raw.port === "string" ? Number(raw.port) : NaN;
+		return normalizeEndpoint(hostname, port);
+	} catch {
+		return undefined;
+	}
+}
+
+function candidateEndpoints(runtimeEndpoint: string | undefined): string[] {
+	const candidates = runtimeEndpoint ? [runtimeEndpoint] : [];
+	const fallback = normalizeEndpoint("127.0.0.1", OPENCODEX_DEFAULT_PORT);
+	if (fallback && !candidates.includes(fallback)) candidates.push(fallback);
+	return candidates;
+}
+
+async function fetchJson(url: string, signal?: AbortSignal): Promise<unknown> {
+	const response = await fetch(url, {
+		headers: { Accept: "application/json" },
+		redirect: "error",
+		signal: timeoutSignal(signal),
+	});
+	if (!response.ok) return undefined;
+	return response.json();
+}
+
+function isOpenCodexHealth(payload: unknown, expectedPort: number): boolean {
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+	const health = payload as HealthPayload;
+	return health.ok === true && health.version === "opencodex" && health.port === expectedPort;
+}
+
+export async function resolveOpenCodexEndpoint(signal?: AbortSignal): Promise<OpenCodexEndpoint | undefined> {
+	const runtimeEndpoint = await readRuntimeEndpoint();
+	for (const candidate of candidateEndpoints(runtimeEndpoint)) {
+		try {
+			const health = await fetchJson(`${candidate}/healthz`, signal);
+			if (isOpenCodexHealth(health, healthPort(candidate))) return { baseUrl: candidate };
+		} catch {
+			// An unavailable or foreign listener is a normal provider absence.
+		}
+	}
+	return undefined;
+}
+
+function asPositiveNumber(value: unknown, fallback: number): number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+function normalizeCatalogPayload(payload: unknown): CatalogRow[] {
+	if (Array.isArray(payload)) return payload as CatalogRow[];
+	if (payload && typeof payload === "object" && Array.isArray((payload as { models?: unknown }).models)) {
+		return (payload as { models: CatalogRow[] }).models;
+	}
+	return [];
+}
+
+function normalizeModel(row: CatalogRow, endpoint: OpenCodexEndpoint): Model<"openai-responses"> | 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 input =
+		Array.isArray(row.input) && row.input.every(value => value === "text" || value === "image")
+			? row.input
+			: ["text"];
+	return {
+		id: publicId,
+		wireModelId: rawId,
+		name: typeof row.displayName === "string" ? row.displayName : typeof row.name === "string" ? row.name : rawId,
+		api: "openai-responses",
+		provider: "opencodex",
+		baseUrl: `${endpoint.baseUrl}/v1`,
+		reasoning: row.reasoning !== false,
+		input,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: asPositiveNumber(row.contextWindow, 128_000),
+		maxTokens: asPositiveNumber(row.maxTokens, 16_384),
+	};
+}
+
+export async function fetchOpenCodexModels(): Promise<readonly Model<"openai-responses">[] | null> {
+	const endpoint = await resolveOpenCodexEndpoint();
+	if (!endpoint) return null;
+	try {
+		const rows = normalizeCatalogPayload(await fetchJson(`${endpoint.baseUrl}/api/models`));
+		const models = rows
+			.map(row => normalizeModel(row, endpoint))
+			.filter((model): model is Model<"openai-responses"> => model !== undefined);
+		return models.length > 0 ? models : null;
+	} catch {
+		return null;
+	}
+}
+
+export async function checkOpenCodexStatus(onProgress?: (message: string) => void): Promise<void> {
+	const endpoint = await resolveOpenCodexEndpoint();
+	if (endpoint) {
+		onProgress?.(`OpenCodex is available at ${endpoint.baseUrl}`);
+		return;
+	}
+	onProgress?.("OpenCodex is unavailable; no identity-checked local proxy was found.");
+}

package/src/providers/openai-responses.ts

@@ -172,6 +172,62 @@ export function resolveOpenAIProviderBaseUrlForTest(
 	return resolveOpenAIProviderBaseUrl(baseUrl, authCredentialType);
 }
 
+function appendUrlPath(baseUrl: string | undefined, path: string): string | undefined {
+	if (!baseUrl) return undefined;
+	const normalizedPath = path.replace(/^\/+/g, "");
+	try {
+		const parsed = new URL(baseUrl);
+		parsed.pathname = `${parsed.pathname.replace(/\/+$/g, "")}/${normalizedPath}`;
+		return parsed.toString();
+	} catch {
+		return `${baseUrl.replace(/\/+$/g, "")}/${normalizedPath}`;
+	}
+}
+
+type OpenAIResponsesQuery = string;
+
+function splitBaseUrlQuery(baseUrl: string | undefined): {
+	baseUrl: string | undefined;
+	query?: OpenAIResponsesQuery;
+} {
+	if (!baseUrl) return { baseUrl };
+	try {
+		const parsed = new URL(baseUrl);
+		if (!parsed.search) return { baseUrl };
+		const queryStart = baseUrl.indexOf("?");
+		const fragmentStart = baseUrl.indexOf("#", queryStart);
+		const query = baseUrl.slice(queryStart + 1, fragmentStart === -1 ? undefined : fragmentStart);
+		if (!query) return { baseUrl };
+		parsed.search = "";
+		return {
+			baseUrl: parsed.toString(),
+			query,
+		};
+	} catch {
+		return { baseUrl };
+	}
+}
+
+function appendRawQuery(url: string, query: OpenAIResponsesQuery | undefined): string {
+	if (!query) return url;
+	const fragmentStart = url.indexOf("#");
+	const beforeFragment = fragmentStart === -1 ? url : url.slice(0, fragmentStart);
+	const fragment = fragmentStart === -1 ? "" : url.slice(fragmentStart);
+	return `${beforeFragment}${beforeFragment.includes("?") ? "&" : "?"}${query}${fragment}`;
+}
+
+function buildRequestUrl(baseUrl: string | undefined, path: string, query?: OpenAIResponsesQuery): string | undefined {
+	const url = appendUrlPath(baseUrl, path);
+	return url ? appendRawQuery(url, query) : undefined;
+}
+
+function appendQueryToRequest(input: string | URL | Request, query?: OpenAIResponsesQuery): string | URL | Request {
+	if (!query) return input;
+	const url = appendRawQuery(input instanceof Request ? input.url : String(input), query);
+	if (input instanceof Request) return new Request(url, input as unknown as RequestInit);
+	return url;
+}
+
 const OPENAI_RESPONSES_PROGRESS_EVENT_TYPES = new Set([
 	"response.created",
 	"response.output_item.added",
@@ -272,7 +328,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 			// Keep request headers and prompt-cache routing on the same session-derived value.
 			const cacheSessionId = getOpenAIResponsesCacheSessionId(options);
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			const { client, copilotPremiumRequests, baseUrl } = createClient(
+			const { client, copilotPremiumRequests, baseUrl, requestBaseUrl, requestQuery } = createClient(
 				model,
 				context,
 				apiKey,
@@ -296,7 +352,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				api: output.api,
 				model: model.id,
 				method: "POST",
-				url: `${baseUrl}/responses`,
+				url: buildRequestUrl(requestBaseUrl, "responses", requestQuery),
 				body: params,
 			};
 			const openaiStream = await callWithCopilotModelRetry(
@@ -439,6 +495,8 @@ function createClient(
 	client: OpenAI;
 	copilotPremiumRequests: number | undefined;
 	baseUrl: string | undefined;
+	requestBaseUrl: string | undefined;
+	requestQuery: OpenAIResponsesQuery | undefined;
 } {
 	if (!apiKey) {
 		apiKey = $credentialEnv("OPENAI_API_KEY");
@@ -489,8 +547,15 @@ function createClient(
 		headers.session_id ??= sessionId;
 		headers["x-client-request-id"] ??= sessionId;
 	}
+	const { baseUrl: clientBaseUrl, query: endpointQuery } = splitBaseUrlQuery(baseUrl);
 	const baseFetch = fetchOverride ?? fetch;
-	const boundedFetch = wrapOpenAIFetchForBoundedRateLimits(baseFetch, maxRetryDelayMs);
+	const queryFetch = Object.assign(
+		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+			return baseFetch(appendQueryToRequest(input, endpointQuery), init);
+		},
+		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
+	);
+	const boundedFetch = wrapOpenAIFetchForBoundedRateLimits(queryFetch, maxRetryDelayMs);
 	const transformedFetch = wrapFetchForOpenAIRequestTransform(
 		boundedFetch,
 		model.requestTransform,
@@ -499,7 +564,7 @@ function createClient(
 	return {
 		client: new OpenAI({
 			apiKey,
-			baseURL: baseUrl,
+			baseURL: clientBaseUrl,
 			dangerouslyAllowBrowser: true,
 			maxRetries: resolveRetryBudget(requestMaxRetries, 5),
 			defaultHeaders: headers,
@@ -509,6 +574,8 @@ function createClient(
 		}),
 		copilotPremiumRequests,
 		baseUrl,
+		requestBaseUrl: clientBaseUrl,
+		requestQuery: endpointQuery,
 	};
 }
 
@@ -764,7 +831,7 @@ function isForcedOpenAIResponsesToolChoice(choice: unknown): boolean {
 /** @internal Exported for tests. */
 export function convertTools(tools: Tool[], strictMode: boolean, model: Model<"openai-responses">): OpenAITool[] {
 	const allowFreeform = supportsFreeformApplyPatch(model);
-	return tools.map(tool => {
+	const payloads = tools.map(tool => {
 		if (allowFreeform && tool.customFormat) {
 			return {
 				type: "custom",
@@ -792,4 +859,8 @@ export function convertTools(tools: Tool[], strictMode: boolean, model: Model<"o
 			...(effectiveStrict && { strict: true }),
 		} as OpenAITool;
 	});
+	// Tool definitions bypass the `input`/`instructions` sanitizers, so a
+	// leaked Harmony marker in an MCP/skill tool description or schema string
+	// rejects every gpt-5.x request (`Request blocked`).
+	return neutralizeResponsesInputControlTokens(payloads);
 }

package/src/stream.ts

@@ -326,7 +326,7 @@ export function stream<TApi extends Api>(
 		return streamBedrock(model as Model<"bedrock-converse-stream">, context, (options || {}) as BedrockOptions);
 	}
 
-	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+	const apiKey = options?.apiKey || (model.provider === "opencodex" ? "local" : getEnvApiKey(model.provider));
 	if (!apiKey) {
 		throw new Error(formatMissingApiKeyError(model.provider));
 	}

package/src/types.ts

@@ -124,6 +124,7 @@ export type KnownProvider =
 	| "google-vertex"
 	| "openai"
 	| "openai-codex"
+	| "opencodex"
 	| "kimi-code"
 	| "minimax-code"
 	| "minimax-code-cn"

package/src/utils/discovery/openai-compatible.ts

@@ -125,7 +125,7 @@ export async function fetchOpenAICompatibleModels<TApi extends Api>(
 	const fetchImpl = options.fetch ?? globalThis.fetch;
 	let response: Response;
 	try {
-		response = await fetchImpl(`${baseUrl}${MODELS_PATH}`, {
+		response = await fetchImpl(buildModelsUrl(baseUrl), {
 			method: "GET",
 			headers: requestHeaders,
 			signal: options.signal,
@@ -193,7 +193,23 @@ function normalizeBaseUrl(baseUrl: string): string {
 	if (!trimmed) {
 		return "";
 	}
-	return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+	try {
+		const parsed = new URL(trimmed);
+		parsed.pathname = parsed.pathname.replace(/\/+$/g, "");
+		return parsed.toString();
+	} catch {
+		return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+	}
+}
+
+function buildModelsUrl(baseUrl: string): string {
+	try {
+		const parsed = new URL(baseUrl);
+		parsed.pathname = `${parsed.pathname.replace(/\/+$/g, "")}${MODELS_PATH}`;
+		return parsed.toString();
+	} catch {
+		return `${baseUrl}${MODELS_PATH}`;
+	}
 }
 
 function extractModelEntries(payload: unknown): ParsedOpenAICompatibleModelRecord[] | null {

package/src/utils/http-inspector.ts

@@ -267,6 +267,7 @@ export function rewriteCopilotError(errorMessage: string, error: unknown, provid
 function sanitizeDump(dump: RawHttpRequestDump): RawHttpRequestDump {
 	return {
 		...dump,
+		url: redactRequestUrl(dump.url),
 		headers: redactHeaders(dump.headers),
 		body: sanitizeDumpBody(dump.body),
 	};

package/src/utils/oauth/index.ts

@@ -25,6 +25,11 @@ const builtInOAuthProviders: OAuthProviderInfo[] = [
 		name: "ChatGPT Plus/Pro (Codex Subscription)",
 		available: true,
 	},
+	{
+		id: "opencodex",
+		name: "OpenCodex (local proxy status)",
+		available: true,
+	},
 	{
 		id: "openai-codex-device",
 		name: "ChatGPT Plus/Pro (Codex, headless/device)",