@gajae-code/ai 0.16.3 → 0.16.6

package/src/openai-completions-compat.ts

@@ -48,10 +48,57 @@ function parseHostname(baseUrl: string): string | undefined {
 	}
 }
 
+function isProductionXaiApiUrl(baseUrl: string): boolean {
+	if (
+		/[\u0000-\u0020\u007f]/u.test(baseUrl) ||
+		baseUrl.includes("?") ||
+		baseUrl.includes("#") ||
+		baseUrl.includes("\\")
+	) {
+		return false;
+	}
+	const authorityTail = baseUrl.slice("https://".length);
+	const authorityEnd = authorityTail.search(/[/?#]/u);
+	const authority = authorityTail.slice(0, authorityEnd === -1 ? undefined : authorityEnd);
+	if (!/^api\.x\.ai(?::443)?$/iu.test(authority)) return false;
+	try {
+		const url = new URL(baseUrl);
+		return (
+			url.protocol === "https:" &&
+			url.hostname.toLowerCase() === "api.x.ai" &&
+			url.port === "" &&
+			url.username === "" &&
+			url.password === "" &&
+			url.search === "" &&
+			url.hash === ""
+		);
+	} catch {
+		return false;
+	}
+}
+
 function hostnameMatches(hostname: string | undefined, suffix: string): boolean {
 	return hostname !== undefined && (hostname === suffix || hostname.endsWith(`.${suffix}`));
 }
 
+export type GrokGeneration = {
+	major: number;
+	minor: number;
+};
+
+function parseGrokGeneration(modelId: string): GrokGeneration | undefined {
+	const canonicalId = modelId.startsWith("x-ai/") ? modelId.slice("x-ai/".length) : modelId;
+	const match =
+		/^grok-([1-9]\d?)(?:\.(0|[1-9]\d?))?(?:-(latest|preview|\d{8}|reasoning|\d{4}-reasoning|beta-latest-reasoning|multi-agent-beta-latest))?$/.exec(
+			canonicalId,
+		);
+	if (!match) return undefined;
+	return {
+		major: Number(match[1]),
+		minor: match[2] === undefined ? 0 : Number(match[2]),
+	};
+}
+
 /** Returns whether the request endpoint is an audited reasoning-control transport. */
 export function isAuditedOpenAIReasoningTransport(
 	model: { provider: string; baseUrl?: string },
@@ -63,6 +110,32 @@ export function isAuditedOpenAIReasoningTransport(
 	return AUDITED_REASONING_EFFORT_HOST_SUFFIXES.some(suffix => hostnameMatches(hostname, suffix));
 }
 
+/**
+ * xAI's first-party API accepts `reasoning_effort` on Grok 4.5 and later.
+ * Provider labels are user-configurable, so both the provider and the official
+ * API origin must match. Unknown variants fail closed instead of inheriting a
+ * capability from a loose model-id prefix.
+ */
+export function parseDirectXaiReasoningEffortGeneration(
+	model: { provider: string; id: string; api?: string; baseUrl?: string },
+	resolvedBaseUrl?: string,
+): GrokGeneration | undefined {
+	if (model.provider !== "xai") return undefined;
+	if (model.api !== "openai-completions") return undefined;
+	if (!isProductionXaiApiUrl(resolvedBaseUrl ?? model.baseUrl ?? "")) return undefined;
+	if (model.id.includes("/")) return undefined;
+	const generation = parseGrokGeneration(model.id);
+	if (!generation) return undefined;
+	return generation.major > 4 || (generation.major === 4 && generation.minor >= 5) ? generation : undefined;
+}
+
+export function isDirectXaiReasoningEffortModel(
+	model: { provider: string; id: string; api?: string; baseUrl?: string },
+	resolvedBaseUrl?: string,
+): boolean {
+	return parseDirectXaiReasoningEffortGeneration(model, resolvedBaseUrl) !== undefined;
+}
+
 export type ResolvedOpenAICompat = Required<
 	Omit<
 		OpenAICompat,
@@ -184,8 +257,8 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		baseUrl.includes("chutes.ai") ||
 		baseUrl.includes("fireworks.ai") ||
 		isDirectDeepseekApi;
-	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-	const isDirectXaiReasoningEffortModel = provider === "xai" && (model.id === "grok-4.5" || model.id === "grok-4.6");
+	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai") || parseGrokGeneration(model.id) !== undefined;
+
 	const isMistral = provider === "mistral" || baseUrl.includes("mistral.ai");
 
 	// Hosts whose chat-completions endpoints are known to accept multiple
@@ -278,7 +351,8 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		supportsResponsesSessionAffinity: false,
 		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
 		supportsReasoningEffort:
-			hasAuditedReasoningEffortTransport && ((!isGrok && !isZai) || isDirectXaiReasoningEffortModel),
+			hasAuditedReasoningEffortTransport &&
+			((!isGrok && !isZai) || isOpenRouter || isDirectXaiReasoningEffortModel(model, resolvedBaseUrl)),
 		reasoningEffortMap,
 		supportsUsageInStreaming: !isCerebras,
 		disableReasoningOnForcedToolChoice: isKimiModel || isAnthropicModel || isOpenCodeGoReasoning,

package/src/providers/amazon-bedrock.d.ts

@@ -6,8 +6,9 @@
  * No `@aws-sdk/*`, no `@smithy/*`, no `proxy-agent`. Proxies are honored via
  * Bun's native `HTTPS_PROXY` support.
  */
+import { parseBedrockClaudeGeneration } from "../bedrock-claude-cache-policy";
 import type { Effort } from "../model-thinking";
-import type { StreamFunction, StreamOptions, ThinkingBudgets, Tool, ToolChoice } from "../types";
+import type { Model, StreamFunction, StreamOptions, ThinkingBudgets, Tool, ToolChoice } from "../types";
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 export interface BedrockOptions extends StreamOptions {
     region?: string;
@@ -51,10 +52,24 @@ interface WireToolConfig {
     toolChoice?: WireToolChoice;
 }
 export declare const streamBedrock: StreamFunction<"bedrock-converse-stream">;
+/**
+ * Check if the model supports prompt caching.
+ * Supported: Claude 3.5 Haiku, Claude 3.7 Sonnet, and every later Claude
+ * generation:
+ * https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
+ *
+ * For base models and system-defined inference profiles the model ID / ARN
+ * contains the model name, so we can decide locally.
+ *
+ * For application inference profiles (whose ARNs don't contain the model name),
+ * set AWS_BEDROCK_FORCE_CACHE=1 to enable cache points.  Amazon Nova models
+ * have automatic caching and don't need explicit cache points.
+ */
+export declare function supportsPromptCaching(model: Model<"bedrock-converse-stream">): boolean;
+export { parseBedrockClaudeGeneration };
 export declare function stripBedrockForcedToolChoiceForRetry<T extends {
     toolConfig?: {
         toolChoice?: unknown;
     };
 }>(body: T): T;
 export declare function convertToolConfig(tools: Tool[] | undefined, toolChoice: BedrockOptions["toolChoice"]): WireToolConfig | undefined;
-export {};

package/src/providers/amazon-bedrock.ts

@@ -9,6 +9,7 @@
 
 import { $credentialEnv, $env, $flag, extractHttpStatusFromError, fetchWithRetry } from "@gajae-code/utils";
 import { assertAwsRegionLabel } from "../adapter-internals/aws-region";
+import { parseBedrockClaudeGeneration, supportsBedrockClaudePromptCaching } from "../bedrock-claude-cache-policy";
 import type { Effort } from "../model-thinking";
 import {
 	mapEffortToAnthropicAdaptiveEffort,
@@ -219,7 +220,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				if (tc.any || tc.tool) additionalModelRequestFields = undefined;
 			}
 
-			const commandInput: ConverseStreamRequest = {
+			let commandInput: ConverseStreamRequest = {
 				messages: convertMessages(context, model, cacheRetention),
 				system: buildSystemPrompt(context.systemPrompt, model, cacheRetention),
 				inferenceConfig: {
@@ -230,7 +231,15 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				toolConfig,
 				additionalModelRequestFields,
 			};
-			options?.onPayload?.(commandInput, model, options?.attemptScope);
+			const replacementPayload = await options?.onPayload?.(
+				commandInput,
+				model,
+				options?.attemptScope,
+				options?.signal,
+			);
+			if (replacementPayload !== undefined) {
+				commandInput = replacementPayload as typeof commandInput;
+			}
 
 			const host = `bedrock-runtime.${region}.amazonaws.com`;
 			const url = `https://${host}/model/${encodeURIComponent(model.id)}/converse-stream`;
@@ -610,7 +619,9 @@ function handleContentBlockStop(
 
 /**
  * Check if the model supports prompt caching.
- * Supported: Anthropic model 3.5 Haiku, Anthropic model 3.7 Sonnet, Anthropic model 4.x+ models, Haiku 4.5+
+ * Supported: Claude 3.5 Haiku, Claude 3.7 Sonnet, and every later Claude
+ * generation:
+ * https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
  *
  * For base models and system-defined inference profiles the model ID / ARN
  * contains the model name, so we can decide locally.
@@ -619,21 +630,18 @@ function handleContentBlockStop(
  * set AWS_BEDROCK_FORCE_CACHE=1 to enable cache points.  Amazon Nova models
  * have automatic caching and don't need explicit cache points.
  */
-function supportsPromptCaching(model: Model<"bedrock-converse-stream">): boolean {
+export function supportsPromptCaching(model: Model<"bedrock-converse-stream">): boolean {
+	const claudeSupport = supportsBedrockClaudePromptCaching(model.id);
+	if (claudeSupport !== undefined) return claudeSupport;
 	if (model.cost.cacheRead || model.cost.cacheWrite) return true;
-	const id = model.id.toLowerCase();
-	// Anthropic model 4.x models (opus-4, sonnet-4, haiku-4)
-	if (id.includes("claude") && (id.includes("-4-") || id.includes("-4."))) return true;
-	// Anthropic model 3.5 Haiku, Anthropic model 3.7 Sonnet (legacy naming)
-	if (id.includes("claude-3-7-sonnet") || id.includes("claude-3-5-haiku")) return true;
-	// Anthropic model Haiku 4.5+ (new naming)
-	if (id.includes("claude-haiku")) return true;
 	// Application inference profiles don't contain the model name in the ARN.
 	// Allow users to force cache points via environment variable.
 	if (typeof process !== "undefined" && $flag("AWS_BEDROCK_FORCE_CACHE")) return true;
 	return false;
 }
 
+export { parseBedrockClaudeGeneration };
+
 /**
  * Check if the model supports thinking signatures in reasoningContent.
  * Only Anthropic Anthropic model models support the signature field.

package/src/providers/anthropic.d.ts

@@ -203,6 +203,7 @@ export type AnthropicClientOptionsArgs = {
     maxRetryDelayMs?: number;
     streamFirstEventTimeoutMs?: number;
     streamIdleTimeoutMs?: number;
+    providerSessionId?: string;
 };
 export type AnthropicClientOptionsResult = {
     isOAuthToken: boolean;

package/src/providers/anthropic.ts

@@ -111,6 +111,11 @@ import {
 	hasCopilotVisionInput,
 	resolveGitHubCopilotBaseUrl,
 } from "./github-copilot-headers";
+import {
+	applyOpenCodeGoSessionHeader,
+	resolveOpenCodeGoSessionId,
+	wrapFetchForOpenCodeGoSession,
+} from "./opencode-go-session";
 import { hasAdjacentPrivateThinkingBlocks, transformMessages } from "./transform-messages";
 import { NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard";
 
@@ -1126,6 +1131,7 @@ export type AnthropicClientOptionsArgs = {
 	maxRetryDelayMs?: number;
 	streamFirstEventTimeoutMs?: number;
 	streamIdleTimeoutMs?: number;
+	providerSessionId?: string;
 };
 
 export type AnthropicClientOptionsResult = {
@@ -1940,6 +1946,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					maxRetryDelayMs: options?.maxRetryDelayMs,
 					streamFirstEventTimeoutMs: options?.streamFirstEventTimeoutMs,
 					streamIdleTimeoutMs: options?.streamIdleTimeoutMs,
+					providerSessionId: options?.providerSessionId,
 				});
 				client = created.client;
 				isOAuthToken = created.isOAuthToken;
@@ -1992,7 +1999,12 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				if (dropFastMode) {
 					dropAnthropicFastMode(nextParams);
 				}
-				const replacementPayload = await options?.onPayload?.(nextParams, model, options?.attemptScope);
+				const replacementPayload = await options?.onPayload?.(
+					nextParams,
+					model,
+					options?.attemptScope,
+					options?.signal,
+				);
 				if (replacementPayload !== undefined) {
 					nextParams = replacementPayload as typeof nextParams;
 				}
@@ -3107,7 +3119,11 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 	const tlsFetchOptions = buildClaudeCodeTlsFetchOptions(model, baseUrl);
 	const baseFetch = args.fetch ?? fetch;
 	const boundedFetch = wrapAnthropicFetchForBoundedRateLimits(baseFetch, args.maxRetryDelayMs);
-	const debugFetch = onSseEvent ? wrapFetchForSseDebug(boundedFetch, event => onSseEvent(event, model)) : boundedFetch;
+	const openCodeGoSessionId = resolveOpenCodeGoSessionId(model, baseUrl, args.providerSessionId, "anthropic");
+	const providerScopedFetch = wrapFetchForOpenCodeGoSession(boundedFetch, openCodeGoSessionId);
+	const debugFetch = onSseEvent
+		? wrapFetchForSseDebug(providerScopedFetch, event => onSseEvent(event, model))
+		: providerScopedFetch;
 	// Bound the connect/headers phase. The first-event watchdog arms only after
 	// response headers arrive, so a request whose connection dies before headers
 	// was previously governed only by the Anthropic SDK's 10-minute default per
@@ -3124,16 +3140,19 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 		if (needsFineGrainedToolStreamingBeta) {
 			betaFeatures.push(fineGrainedToolStreamingBeta);
 		}
-		const defaultHeaders = mergeHeaders(
-			{
-				Accept: stream ? "text/event-stream" : "application/json",
-				"Anthropic-Dangerous-Direct-Browser-Access": "true",
-				Authorization: `Bearer ${copilotApiKey}`,
-				...(betaFeatures.length > 0 ? { "anthropic-beta": buildBetaHeader([], betaFeatures) } : {}),
-			},
-			model.headers,
-			dynamicHeaders,
-			headers,
+		const defaultHeaders = applyOpenCodeGoSessionHeader(
+			mergeHeaders(
+				{
+					Accept: stream ? "text/event-stream" : "application/json",
+					"Anthropic-Dangerous-Direct-Browser-Access": "true",
+					Authorization: `Bearer ${copilotApiKey}`,
+					...(betaFeatures.length > 0 ? { "anthropic-beta": buildBetaHeader([], betaFeatures) } : {}),
+				},
+				model.headers,
+				dynamicHeaders,
+				headers,
+			),
+			openCodeGoSessionId,
 		);
 
 		return {
@@ -3159,16 +3178,19 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 		betaFeatures.push(interleavedThinkingBeta);
 	}
 
-	const defaultHeaders = buildAnthropicHeaders({
-		apiKey,
-		baseUrl,
-		isOAuth: oauthToken,
-		extraBetas: betaFeatures,
-		stream,
-		modelHeaders: mergeHeaders(model.headers, foundryCustomHeaders, headers, dynamicHeaders),
-		isCloudflareAiGateway: model.provider === "cloudflare-ai-gateway",
-		zcodeSourceHeaders: model.provider === "glm-zcode",
-	});
+	const defaultHeaders = applyOpenCodeGoSessionHeader(
+		buildAnthropicHeaders({
+			apiKey,
+			baseUrl,
+			isOAuth: oauthToken,
+			extraBetas: betaFeatures,
+			stream,
+			modelHeaders: mergeHeaders(model.headers, foundryCustomHeaders, headers, dynamicHeaders),
+			isCloudflareAiGateway: model.provider === "cloudflare-ai-gateway",
+			zcodeSourceHeaders: model.provider === "glm-zcode",
+		}),
+		openCodeGoSessionId,
+	);
 
 	if (model.provider === "cloudflare-ai-gateway") {
 		return {

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

@@ -129,9 +129,12 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
 			const client = createClient(model, apiKey, options);
 			const { baseUrl } = resolveAzureConfig(model, options);
-			const params = buildParams(model, context, options, deploymentName, baseUrl);
+			let params = buildParams(model, context, options, deploymentName, baseUrl);
 			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
-			options?.onPayload?.(params, model, options?.attemptScope);
+			const replacementPayload = await options?.onPayload?.(params, model, options?.attemptScope, options?.signal);
+			if (replacementPayload !== undefined) {
+				params = replacementPayload as typeof params;
+			}
 			rawRequestDump = {
 				provider: model.provider,
 				api: output.api,

package/src/providers/cursor.ts

@@ -689,7 +689,7 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 			conversationUsageContextCache.set(conversationId, usageContext);
 			const reusableCachedState =
 				cachedState && canReuseCursorUsageContext(previousUsageContext, usageContext) ? cachedState : undefined;
-			const { requestBytes, conversationState } = buildGrpcRequest(model, context, options, {
+			const { requestBytes, conversationState } = await buildGrpcRequest(model, context, options, {
 				conversationId,
 				blobStore,
 				conversationState: reusableCachedState,
@@ -3459,7 +3459,7 @@ function extractImages(content: (TextContent | ImageContent)[]) {
 		);
 }
 
-function buildGrpcRequest(
+async function buildGrpcRequest(
 	model: Model<"cursor-agent">,
 	context: Context,
 	options: CursorOptions | undefined,
@@ -3468,11 +3468,11 @@ function buildGrpcRequest(
 		blobStore: Map<string, Uint8Array>;
 		conversationState?: ConversationStateStructure;
 	},
-): {
+): Promise<{
 	requestBytes: Uint8Array;
 	blobStore: Map<string, Uint8Array>;
 	conversationState: ConversationStateStructure;
-} {
+}> {
 	const blobStore = state.blobStore;
 
 	const systemPromptIds = buildCursorSystemPromptJsons(context.systemPrompt, model.id).map(json =>
@@ -3558,7 +3558,7 @@ function buildGrpcRequest(
 		displayName: model.name,
 	});
 
-	const runRequest = create(AgentRunRequestSchema, {
+	let runRequest = create(AgentRunRequestSchema, {
 		conversationState,
 		action,
 		modelDetails,
@@ -3573,7 +3573,13 @@ function buildGrpcRequest(
 			: {}),
 	});
 
-	options?.onPayload?.(runRequest, model, options?.attemptScope);
+	if (options?.onPayload) {
+		const payload = toJson(AgentRunRequestSchema, runRequest);
+		const replacement = await options.onPayload(payload, model, options.attemptScope, options.signal);
+		if (replacement !== undefined) {
+			runRequest = fromJson(AgentRunRequestSchema, replacement as JsonValue);
+		}
+	}
 
 	// Tools are sent later via requestContext (exec handshake)
 

package/src/providers/google-gemini-cli.ts

@@ -354,7 +354,12 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			const endpoints = baseUrl ? [baseUrl] : isAntigravity ? ANTIGRAVITY_ENDPOINT_FALLBACKS : [DEFAULT_ENDPOINT];
 
 			let requestBody = buildRequest(model, context, projectId, options, isAntigravity);
-			const replacementPayload = await options?.onPayload?.(requestBody, model, options?.attemptScope);
+			const replacementPayload = await options?.onPayload?.(
+				requestBody,
+				model,
+				options?.attemptScope,
+				options?.signal,
+			);
 			if (replacementPayload !== undefined) {
 				requestBody = replacementPayload as typeof requestBody;
 			}

package/src/providers/google-shared.ts

@@ -899,7 +899,7 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 		try {
 			const plan = await prepare();
 			let params = plan.params;
-			const replacement = await options?.onPayload?.(params, model, options?.attemptScope);
+			const replacement = await options?.onPayload?.(params, model, options?.attemptScope, options?.signal);
 			if (replacement !== undefined) {
 				params = replacement as GenerateContentParameters;
 			}

package/src/providers/kiro-api-key.ts

@@ -611,8 +611,11 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 			const configuredBaseUrl = model.baseUrl;
 			const usesExplicitBaseUrl = Boolean(configuredBaseUrl) && !isRegionDerivedKiroApiBaseUrl(configuredBaseUrl);
 			const endpoint = configuredBaseUrl || kiroApiBaseUrl(kiroApiRegion(options));
-			const request = buildApiKeyRequest(model, context, options);
-			options?.onPayload?.(request, model, options?.attemptScope);
+			let request = buildApiKeyRequest(model, context, options);
+			const replacementPayload = await options?.onPayload?.(request, model, options?.attemptScope, options?.signal);
+			if (replacementPayload !== undefined) {
+				request = replacementPayload;
+			}
 
 			const response = await fetch(endpoint, {
 				method: "POST",

package/src/providers/kiro-codewhisperer.ts

@@ -193,11 +193,19 @@ export const streamKiroCodeWhisperer: StreamFunction<"kiro-codewhisperer-stream"
 
 			// Build request
 			const conversationState = buildConversationState(context, model, options);
-			const requestBody: GenerateAssistantResponseRequest = {
+			let requestBody: GenerateAssistantResponseRequest = {
 				conversationState,
 			};
 
-			options?.onPayload?.(requestBody, model, options?.attemptScope);
+			const replacementPayload = await options?.onPayload?.(
+				requestBody,
+				model,
+				options?.attemptScope,
+				options?.signal,
+			);
+			if (replacementPayload !== undefined) {
+				requestBody = replacementPayload as typeof requestBody;
+			}
 
 			const host = `${STREAMING_SERVICE_NAME}.${region}.amazonaws.com`;
 			const url = `https://${host}/`;

package/src/providers/mock.ts

@@ -339,6 +339,7 @@ async function runMock(
 				},
 				model,
 				options.attemptScope,
+				options.signal,
 			);
 		} catch (err) {
 			stream.fail(err);

package/src/providers/ollama.ts

@@ -407,7 +407,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			const baseUrl = normalizeBaseUrl(model.baseUrl);
 			let body = createChatBody(model, context, options);
 			const sentForcedToolChoice = body.tool_choice === "required";
-			const replacementPayload = await options.onPayload?.(body, model, options?.attemptScope);
+			const replacementPayload = await options.onPayload?.(body, model, options?.attemptScope, options?.signal);
 			if (replacementPayload !== undefined) {
 				body = replacementPayload as typeof body;
 			}

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

@@ -25,7 +25,7 @@ const REQUEST_BLOCKED_MESSAGE_RE = /^\s*request blocked\b/i;
 
 export async function parseCodexError(response: Response): Promise<CodexErrorInfo> {
 	const raw = await response.text();
-	let message = raw || response.statusText || "Request failed";
+	let message = raw || response.statusText || `Codex request failed (HTTP ${response.status})`;
 	let friendlyMessage: string | undefined;
 	let rateLimits: CodexRateLimits | undefined;
 	let code: string | undefined;

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

@@ -717,8 +717,16 @@ async function buildCodexRequestContext(
 	const baseUrl = model.baseUrl || CODEX_BASE_URL;
 	const url = resolveCodexResponsesUrl(baseUrl);
 	const promptCacheKey = normalizeOpenAIResponsesPromptCacheKey(options?.sessionId);
-	const transformedBody = await buildTransformedCodexRequestBody(model, context, options);
-	options?.onPayload?.(transformedBody, model, options?.attemptScope);
+	let transformedBody = await buildTransformedCodexRequestBody(model, context, options);
+	const replacementPayload = await options?.onPayload?.(
+		transformedBody,
+		model,
+		options?.attemptScope,
+		options?.signal,
+	);
+	if (replacementPayload !== undefined) {
+		transformedBody = replacementPayload as typeof transformedBody;
+	}
 
 	const requestHeaders = { ...(model.headers ?? {}), ...(options?.headers ?? {}) };
 	const rawRequestDump: RawHttpRequestDump = {

package/src/providers/openai-completions-compat.d.ts

@@ -3,4 +3,4 @@
  * the core-safe module so model metadata can use it without loading provider
  * implementations during startup.
  */
-export { detectOpenAICompat, type ResolvedOpenAICompat, resolveOpenAICompat } from "../openai-completions-compat";
+export { detectOpenAICompat, type GrokGeneration, isDirectXaiReasoningEffortModel, parseDirectXaiReasoningEffortGeneration, type ResolvedOpenAICompat, resolveOpenAICompat, } from "../openai-completions-compat";

package/src/providers/openai-completions-compat.ts

@@ -3,4 +3,11 @@
  * the core-safe module so model metadata can use it without loading provider
  * implementations during startup.
  */
-export { detectOpenAICompat, type ResolvedOpenAICompat, resolveOpenAICompat } from "../openai-completions-compat";
+export {
+	detectOpenAICompat,
+	type GrokGeneration,
+	isDirectXaiReasoningEffortModel,
+	parseDirectXaiReasoningEffortGeneration,
+	type ResolvedOpenAICompat,
+	resolveOpenAICompat,
+} from "../openai-completions-compat";

package/src/providers/openai-completions.ts

@@ -100,6 +100,11 @@ import {
 	wrapFetchForOpenAIRequestTransform,
 } from "./openai-request-transform";
 import { createInitialResponsesAssistantMessage } from "./openai-responses-shared";
+import {
+	applyOpenCodeGoSessionHeader,
+	resolveOpenCodeGoSessionId,
+	wrapFetchForOpenCodeGoSession,
+} from "./opencode-go-session";
 import { transformMessages } from "./transform-messages";
 import { joinTextWithImagePlaceholder, NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard";
 
@@ -602,6 +607,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				options?.authCredentialType,
 				options?.requestMaxRetries,
 				options?.sessionId,
+				options?.providerSessionId,
 				options?.maxRetryDelayMs,
 				options?.attemptScope,
 			);
@@ -618,15 +624,24 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 			const createCompletionsStream = async (toolStrictModeOverride?: ToolStrictModeOverride) => {
 				clearCapturedErrorResponse();
 				const effectiveToolStrictModeOverride = disableStrictTools ? "none" : toolStrictModeOverride;
-				const { params, toolStrictMode } = buildParams(
+				const { params: builtParams, toolStrictMode } = buildParams(
 					model,
 					context,
 					options,
 					baseUrl,
 					effectiveToolStrictModeOverride,
 				);
+				let params = builtParams;
 				appliedToolStrictMode = toolStrictMode;
-				options?.onPayload?.(params, undefined, options?.attemptScope);
+				const replacementPayload = await options?.onPayload?.(
+					params,
+					undefined,
+					options?.attemptScope,
+					options?.signal,
+				);
+				if (replacementPayload !== undefined) {
+					params = replacementPayload as typeof params;
+				}
 				rawRequestDump = {
 					provider: model.provider,
 					api: output.api,
@@ -1259,6 +1274,7 @@ async function createClient(
 	authCredentialType?: OpenAICompletionsOptions["authCredentialType"],
 	requestMaxRetries?: number,
 	sessionId?: string,
+	providerSessionId?: string,
 	maxRetryDelayMs?: number,
 	attemptScope?: import("../types.js").AttemptScopeRef,
 ): Promise<{
@@ -1356,6 +1372,11 @@ async function createClient(
 	const endpointRequestQuery = endpointQuery;
 	const requestQuery =
 		[endpointRequestQuery, azureQuery].filter((query): query is string => query !== undefined).join("&") || undefined;
+	const openCodeGoSessionId = resolveOpenCodeGoSessionId(model, baseUrl, providerSessionId, "openai");
+	// Reserve the provider-specific header on every OpenAI-compatible route. Caller,
+	// model, and transform values are removed unless the exact OpenCode Go endpoint
+	// has an opaque identity owned by the agent's conversation lifecycle.
+	headers = applyOpenCodeGoSessionHeader(headers, openCodeGoSessionId);
 	let capturedErrorResponse: CapturedHttpErrorResponse | undefined;
 	const baseFetch = fetchOverride ?? fetch;
 	const wrappedFetch = Object.assign(
@@ -1389,8 +1410,9 @@ async function createClient(
 		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
 	);
 	const boundedFetch = wrapOpenAIFetchForBoundedRateLimits(wrappedFetch, maxRetryDelayMs);
+	const providerScopedFetch = wrapFetchForOpenCodeGoSession(boundedFetch, openCodeGoSessionId);
 	const transformedFetch = wrapFetchForOpenAIRequestTransform(
-		boundedFetch,
+		providerScopedFetch,
 		model.requestTransform,
 		`Gajae-Code/${packageJson.version}`,
 	);