@gajae-code/ai 0.12.7 → 0.12.10

package/src/providers/openai-completions.ts

@@ -1,5 +1,5 @@
 import { $credentialEnv, $env, extractHttpStatusFromError, logger } from "@gajae-code/utils";
-import OpenAI from "openai";
+import OpenAI, { APIConnectionTimeoutError } from "openai";
 import type {
 	ChatCompletionAssistantMessageParam,
 	ChatCompletionChunk,
@@ -47,6 +47,7 @@ import {
 	rewriteCopilotError,
 } from "../utils/http-inspector";
 import {
+	FirstEventTimeoutError,
 	getOpenAIStreamIdleTimeoutMs,
 	getProviderFirstEventTimeoutFallbackMs,
 	getStreamFirstEventTimeoutMs,
@@ -119,6 +120,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.
@@ -437,8 +501,6 @@ function getTrailingPartialDeepseekToken(text: string): string {
 	return tail;
 }
 
-const ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MS = 300_000;
-
 const OPENAI_COMPLETIONS_FIRST_EVENT_TIMEOUT_MESSAGE =
 	"OpenAI completions stream timed out while waiting for the first event";
 
@@ -452,6 +514,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 	(async () => {
 		const startTime = Date.now();
 		let firstTokenTime: number | undefined;
+		let streamConnected = false;
 		let getCapturedErrorResponse: (() => CapturedHttpErrorResponse | undefined) | undefined;
 
 		const output: AssistantMessage = createInitialResponsesAssistantMessage(model.api, model.provider, model.id);
@@ -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,
 				};
@@ -575,10 +640,8 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 					openaiStream = await createCompletionsStream("none");
 				}
 			}
-			const firstEventFallbackMs =
-				model.provider === "alibaba-token-plan"
-					? ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MS
-					: getProviderFirstEventTimeoutFallbackMs(model.provider);
+			streamConnected = true;
+			const firstEventFallbackMs = getProviderFirstEventTimeoutFallbackMs(model.provider);
 			const firstEventTimeoutMs =
 				options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs, firstEventFallbackMs);
 			if (premiumRequestsTotal !== undefined) {
@@ -984,20 +1047,25 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 		} catch (error) {
 			for (const block of output.content) delete (block as any).index;
 			const localAbortReason = abortTracker.getLocalAbortReason();
+			const normalizedError =
+				!streamConnected && model.provider === "alibaba-token-plan" && error instanceof APIConnectionTimeoutError
+					? new FirstEventTimeoutError(OPENAI_COMPLETIONS_FIRST_EVENT_TIMEOUT_MESSAGE)
+					: error;
 			const capturedErrorResponse = getCapturedErrorResponse?.();
 			output.stopReason = abortTracker.wasCallerAbort() ? "aborted" : "error";
 			output.errorStatus =
-				extractHttpStatusFromError(localAbortReason ?? error) ??
+				extractHttpStatusFromError(localAbortReason ?? normalizedError) ??
 				(localAbortReason ? undefined : capturedErrorResponse?.status);
 			output.transportFailure = localAbortReason
 				? transportFailureFacts(localAbortReason)
-				: transportFailureFacts(error, capturedErrorResponse);
+				: transportFailureFacts(normalizedError, capturedErrorResponse);
 			output.errorMessage =
-				localAbortReason?.message ?? (await finalizeErrorMessage(error, rawRequestDump, capturedErrorResponse));
+				localAbortReason?.message ??
+				(await finalizeErrorMessage(normalizedError, rawRequestDump, capturedErrorResponse));
 			// Some providers via OpenRouter include extra details here.
-			const rawMetadata = (error as { error?: { metadata?: { raw?: string } } })?.error?.metadata?.raw;
+			const rawMetadata = (normalizedError as { error?: { metadata?: { raw?: string } } })?.error?.metadata?.raw;
 			if (rawMetadata) output.errorMessage += `\n${rawMetadata}`;
-			output.errorMessage = rewriteCopilotError(output.errorMessage, error, model.provider);
+			output.errorMessage = rewriteCopilotError(output.errorMessage, normalizedError, model.provider);
 			if (hasContentFilterSafetyCode(capturedErrorResponse)) {
 				output.errorKind = "provider_safety_stop";
 			}
@@ -1029,6 +1097,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 +1173,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;
@@ -1158,29 +1238,35 @@ async function createClient(
 	// in the IIFE.
 	// A caller may raise `StreamOptions.streamFirstEventTimeoutMs` for a slow-
 	// before-headers provider; respect it so the SDK doesn't give up before the
-	// wrapping watchdog arms. An explicit `0` disables the first-event watchdog,
+	// wrapping watchdog arms. Provider-specific fallbacks apply only when the
+	// caller does not pin a value, so an explicit nonzero override must beat that
+	// fallback even when it is shorter. An explicit `0` disables the watchdog,
 	// and the SDK treats `timeout: 0` as an immediate timeout, so do not pass a
 	// request timeout in that case.
-	const envSdkTimeoutMs = getStreamFirstEventTimeoutMs(getOpenAIStreamIdleTimeoutMs());
+	const providerFirstEventFallbackMs = getProviderFirstEventTimeoutFallbackMs(model.provider);
+	const envSdkTimeoutMs = getStreamFirstEventTimeoutMs(getOpenAIStreamIdleTimeoutMs(), providerFirstEventFallbackMs);
 	const sdkTimeoutMs =
 		streamFirstEventTimeoutOverride === 0
 			? undefined
 			: streamFirstEventTimeoutOverride !== undefined
-				? Math.max(envSdkTimeoutMs ?? 0, streamFirstEventTimeoutOverride)
+				? providerFirstEventFallbackMs !== undefined
+					? streamFirstEventTimeoutOverride
+					: Math.max(envSdkTimeoutMs ?? 0, streamFirstEventTimeoutOverride)
 				: envSdkTimeoutMs;
 	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-shared.ts

@@ -960,20 +960,31 @@ export function populateResponsesUsageFromResponse(
 				input_tokens?: number | null;
 				output_tokens?: number | null;
 				total_tokens?: number | null;
-				input_tokens_details?: { cached_tokens?: number | null } | null;
+				input_tokens_details?: {
+					cached_tokens?: number | null;
+					cache_write_tokens?: number | null;
+				} | null;
 				output_tokens_details?: { reasoning_tokens?: number | null } | null;
 		  }
 		| null
 		| undefined,
 ): void {
 	if (!usage) return;
+	const inputTokens = usage.input_tokens || 0;
 	const cachedTokens = usage.input_tokens_details?.cached_tokens || 0;
+	const reportedCacheWrite = usage.input_tokens_details?.cache_write_tokens || 0;
+	const cacheWriteTokens =
+		Number.isSafeInteger(reportedCacheWrite) &&
+		reportedCacheWrite >= 0 &&
+		cachedTokens + reportedCacheWrite <= inputTokens
+			? reportedCacheWrite
+			: 0;
 	const reasoningTokens = usage.output_tokens_details?.reasoning_tokens || 0;
 	output.usage = {
-		input: (usage.input_tokens || 0) - cachedTokens,
+		input: Math.max(0, inputTokens - cachedTokens - cacheWriteTokens),
 		output: usage.output_tokens || 0,
 		cacheRead: cachedTokens,
-		cacheWrite: 0,
+		cacheWrite: cacheWriteTokens,
 		totalTokens: usage.total_tokens || 0,
 		...(reasoningTokens > 0 ? { reasoningTokens } : {}),
 		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },

package/src/providers/openai-responses.ts

@@ -1,5 +1,5 @@
 import { $credentialEnv, extractHttpStatusFromError, logger, structuredCloneJSON } from "@gajae-code/utils";
-import OpenAI from "openai";
+import OpenAI, { APIConnectionTimeoutError } from "openai";
 import type {
 	Tool as OpenAITool,
 	ResponseCreateParamsStreaming,
@@ -38,7 +38,9 @@ import { AssistantMessageEventStream } from "../utils/event-stream";
 import { transportFailureFacts } from "../utils/fallback-transport";
 import { finalizeErrorMessage, type RawHttpRequestDump, rewriteCopilotError } from "../utils/http-inspector";
 import {
+	FirstEventTimeoutError,
 	getOpenAIStreamIdleTimeoutMs,
+	getProviderFirstEventTimeoutFallbackMs,
 	getStreamFirstEventTimeoutMs,
 	iterateWithIdleTimeout,
 } from "../utils/idle-iterator";
@@ -124,7 +126,6 @@ export interface OpenAIResponsesOptions extends StreamOptions {
 }
 
 const OPENAI_RESPONSES_PROVIDER_SESSION_STATE_PREFIX = "openai-responses:";
-const ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MS = 300_000;
 const OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE =
 	"OpenAI responses stream timed out while waiting for the first event";
 const OPENAI_DEFAULT_BASE_URL = "https://api.openai.com/v1";
@@ -172,6 +173,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",
@@ -258,6 +315,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 	(async () => {
 		const startTime = Date.now();
 		let firstTokenTime: number | undefined;
+		let streamConnected = false;
 
 		const output: AssistantMessage = createInitialResponsesAssistantMessage(
 			"openai-responses",
@@ -272,7 +330,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 +354,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(
@@ -336,8 +394,8 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				await notifyProviderResponse(options, response, model, request_id);
 				return data;
 			});
-			const firstEventFallbackMs =
-				model.provider === "alibaba-token-plan" ? ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MS : undefined;
+			streamConnected = true;
+			const firstEventFallbackMs = getProviderFirstEventTimeoutFallbackMs(model.provider);
 			const firstEventTimeoutMs =
 				options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs, firstEventFallbackMs);
 			if (premiumRequestsTotal !== undefined) output.usage.premiumRequests = premiumRequestsTotal;
@@ -391,11 +449,16 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 		} catch (error) {
 			for (const block of output.content) delete (block as { index?: number }).index;
 			const localAbortReason = abortTracker.getLocalAbortReason();
+			const normalizedError =
+				!streamConnected && model.provider === "alibaba-token-plan" && error instanceof APIConnectionTimeoutError
+					? new FirstEventTimeoutError(OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE)
+					: error;
 			output.stopReason = abortTracker.wasCallerAbort() ? "aborted" : "error";
-			output.errorStatus = extractHttpStatusFromError(localAbortReason ?? error);
-			output.transportFailure = transportFailureFacts(localAbortReason ?? error);
-			output.errorMessage = localAbortReason?.message ?? (await finalizeErrorMessage(error, rawRequestDump));
-			output.errorMessage = rewriteCopilotError(output.errorMessage, error, model.provider);
+			output.errorStatus = extractHttpStatusFromError(localAbortReason ?? normalizedError);
+			output.transportFailure = transportFailureFacts(localAbortReason ?? normalizedError);
+			output.errorMessage =
+				localAbortReason?.message ?? (await finalizeErrorMessage(normalizedError, rawRequestDump));
+			output.errorMessage = rewriteCopilotError(output.errorMessage, normalizedError, model.provider);
 			// Explicitly mark the poisoned-history rejection so the shared
 			// `invalid_prompt` contract is present even when the SDK error surfaces
 			// only a message (no structured code). This keeps the responses
@@ -439,6 +502,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 +554,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 +571,7 @@ function createClient(
 	return {
 		client: new OpenAI({
 			apiKey,
-			baseURL: baseUrl,
+			baseURL: clientBaseUrl,
 			dangerouslyAllowBrowser: true,
 			maxRetries: resolveRetryBudget(requestMaxRetries, 5),
 			defaultHeaders: headers,
@@ -509,6 +581,8 @@ function createClient(
 		}),
 		copilotPremiumRequests,
 		baseUrl,
+		requestBaseUrl: clientBaseUrl,
+		requestQuery: endpointQuery,
 	};
 }
 
@@ -764,7 +838,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 +866,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);
 }