@gajae-code/ai 0.16.3 → 0.16.6

package/src/providers/openai-responses.ts

@@ -93,6 +93,11 @@ import {
 	processResponsesStream,
 	repairOrphanResponsesToolOutputs,
 } from "./openai-responses-shared";
+import {
+	applyOpenCodeGoSessionHeader,
+	resolveOpenCodeGoSessionId,
+	wrapFetchForOpenCodeGoSession,
+} from "./opencode-go-session";
 import { transformMessages } from "./transform-messages";
 
 /**
@@ -378,6 +383,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				options?.headers,
 				options?.initiatorOverride,
 				cacheSessionId,
+				options?.providerSessionId,
 				cacheRetention,
 				options?.onSseEvent,
 				options?.fetch,
@@ -389,9 +395,17 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 			);
 			const premiumRequestsTotal = copilotPremiumRequests;
 			const providerSessionState = getOpenAIResponsesProviderSessionState(model, options?.providerSessionState);
-			const { params } = buildParams(model, context, options, providerSessionState, cacheRetention, baseUrl);
+			let { params } = buildParams(model, context, options, providerSessionState, cacheRetention, baseUrl);
 			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs(model.provider, model.id);
-			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,
@@ -556,6 +570,7 @@ function createClient(
 	extraHeaders?: Record<string, string>,
 	initiatorOverride?: MessageAttribution,
 	sessionId?: string,
+	providerSessionId?: string,
 	cacheRetention?: CacheRetention,
 	onSseEvent?: OpenAIResponsesOptions["onSseEvent"],
 	fetchOverride?: FetchImpl,
@@ -618,6 +633,8 @@ function createClient(
 	}
 	headers = applyOpenAIRequestTransformHeaders(headers, model.requestTransform, `Gajae-Code/${packageJson.version}`);
 	const { baseUrl: clientBaseUrl, query: endpointQuery } = splitBaseUrlQuery(baseUrl);
+	const openCodeGoSessionId = resolveOpenCodeGoSessionId(model, baseUrl, providerSessionId, "openai");
+	headers = applyOpenCodeGoSessionHeader(headers, openCodeGoSessionId);
 	const baseFetch = fetchOverride ?? fetch;
 	const queryFetch = Object.assign(
 		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
@@ -626,8 +643,9 @@ function createClient(
 		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
 	);
 	const boundedFetch = wrapOpenAIFetchForBoundedRateLimits(queryFetch, maxRetryDelayMs);
+	const providerScopedFetch = wrapFetchForOpenCodeGoSession(boundedFetch, openCodeGoSessionId);
 	const transformedFetch = wrapFetchForOpenAIRequestTransform(
-		boundedFetch,
+		providerScopedFetch,
 		model.requestTransform,
 		`Gajae-Code/${packageJson.version}`,
 	);

package/src/providers/opencode-go-session.d.ts

@@ -0,0 +1,5 @@
+import type { FetchImpl, Model } from "../types";
+export type OpenCodeGoApiFamily = "openai" | "anthropic";
+export declare function resolveOpenCodeGoSessionId(model: Pick<Model, "provider">, baseUrl: string | undefined, providerSessionId: string | undefined, apiFamily: OpenCodeGoApiFamily): string | undefined;
+export declare function applyOpenCodeGoSessionHeader(headers: Record<string, string>, sessionId: string | undefined): Record<string, string>;
+export declare function wrapFetchForOpenCodeGoSession(baseFetch: FetchImpl, sessionId: string | undefined): FetchImpl;

package/src/providers/opencode-go-session.ts

@@ -0,0 +1,57 @@
+import type { FetchImpl, Model } from "../types";
+
+const OPENCODE_GO_ORIGIN = "https://opencode.ai";
+const OPENCODE_GO_OPENAI_BASE_PATH = "/zen/go/v1";
+const OPENCODE_GO_ANTHROPIC_BASE_PATH = "/zen/go";
+
+export type OpenCodeGoApiFamily = "openai" | "anthropic";
+
+function expectedBasePath(apiFamily: OpenCodeGoApiFamily): string {
+	return apiFamily === "openai" ? OPENCODE_GO_OPENAI_BASE_PATH : OPENCODE_GO_ANTHROPIC_BASE_PATH;
+}
+
+export function resolveOpenCodeGoSessionId(
+	model: Pick<Model, "provider">,
+	baseUrl: string | undefined,
+	providerSessionId: string | undefined,
+	apiFamily: OpenCodeGoApiFamily,
+): string | undefined {
+	if (model.provider !== "opencode-go" || !baseUrl || !providerSessionId) return undefined;
+	try {
+		const url = new URL(baseUrl);
+		if (url.origin !== OPENCODE_GO_ORIGIN) return undefined;
+		if (url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "") return undefined;
+		if (url.pathname.replace(/\/+$/u, "") !== expectedBasePath(apiFamily)) return undefined;
+		return providerSessionId;
+	} catch {
+		return undefined;
+	}
+}
+
+export function applyOpenCodeGoSessionHeader(
+	headers: Record<string, string>,
+	sessionId: string | undefined,
+): Record<string, string> {
+	const normalizedHeaders = new Headers(headers);
+	normalizedHeaders.delete("x-opencode-session");
+	if (sessionId) normalizedHeaders.set("x-opencode-session", sessionId);
+	return Object.fromEntries(normalizedHeaders.entries());
+}
+
+export function wrapFetchForOpenCodeGoSession(baseFetch: FetchImpl, sessionId: string | undefined): FetchImpl {
+	return Object.assign(
+		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+			if (input instanceof Request) {
+				const request = new Request(input, init);
+				request.headers.delete("x-opencode-session");
+				if (sessionId) request.headers.set("x-opencode-session", sessionId);
+				return baseFetch(request);
+			}
+			const headers = new Headers(init?.headers);
+			headers.delete("x-opencode-session");
+			if (sessionId) headers.set("x-opencode-session", sessionId);
+			return baseFetch(input, { ...init, headers });
+		},
+		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
+	);
+}

package/src/stream.ts

@@ -955,6 +955,7 @@ function mapOptionsForApi<TApi extends Api>(
 		streamMaxRetries: options?.fallbackManaged ? 0 : options?.streamMaxRetries,
 		metadata: options?.metadata,
 		sessionId: options?.sessionId,
+		providerSessionId: options?.providerSessionId,
 		providerSessionState: options?.providerSessionState,
 		onPayload: options?.onPayload,
 		onResponse: options?.onResponse,

package/src/types.d.ts

@@ -239,6 +239,13 @@ export interface StreamOptions {
      * session-aware features. Ignored by providers that don't support it.
      */
     sessionId?: string;
+    /**
+     * Opaque conversation identity owned by the calling agent/session lifecycle.
+     * Unlike `sessionId`, this MUST NOT be synthesized from prompts, credentials,
+     * paths, cache keys, or other request content. Providers with a dedicated
+     * conversation header may use this only when their endpoint policy permits it.
+     */
+    providerSessionId?: string;
     /**
      * Provider-scoped mutable state store for this agent session.
      * Providers can use this to persist transport/session state between turns.
@@ -249,12 +256,12 @@ export interface StreamOptions {
      * Return undefined to keep the payload unchanged.
      * The `scope` parameter carries the per-attempt identity for execution attribution.
      */
-    onPayload?: (payload: unknown, model?: Model<Api>, scope?: AttemptScopeRef) => unknown | undefined | Promise<unknown | undefined>;
+    onPayload?: (payload: unknown, model?: Model<Api>, scope?: AttemptScopeRef, signal?: AbortSignal) => unknown | undefined | Promise<unknown | undefined>;
     /**
      * Optional callback for provider response metadata after headers are received.
      * The `scope` parameter carries the per-attempt identity for execution attribution.
      */
-    onResponse?: (response: ProviderResponseMetadata, model?: Model<Api>, scope?: AttemptScopeRef) => void | Promise<void>;
+    onResponse?: (response: ProviderResponseMetadata, model?: Model<Api>, scope?: AttemptScopeRef, signal?: AbortSignal) => void | Promise<void>;
     /**
      * Internal dispatch-admission hook. Providers invoke this immediately before
      * submitting an outbound request; stream forwarding retains a first-response

package/src/types.ts

@@ -443,6 +443,13 @@ export interface StreamOptions {
 	 * session-aware features. Ignored by providers that don't support it.
 	 */
 	sessionId?: string;
+	/**
+	 * Opaque conversation identity owned by the calling agent/session lifecycle.
+	 * Unlike `sessionId`, this MUST NOT be synthesized from prompts, credentials,
+	 * paths, cache keys, or other request content. Providers with a dedicated
+	 * conversation header may use this only when their endpoint policy permits it.
+	 */
+	providerSessionId?: string;
 	/**
 	 * Provider-scoped mutable state store for this agent session.
 	 * Providers can use this to persist transport/session state between turns.
@@ -457,6 +464,7 @@ export interface StreamOptions {
 		payload: unknown,
 		model?: Model<Api>,
 		scope?: AttemptScopeRef,
+		signal?: AbortSignal,
 	) => unknown | undefined | Promise<unknown | undefined>;
 	/**
 	 * Optional callback for provider response metadata after headers are received.
@@ -466,6 +474,7 @@ export interface StreamOptions {
 		response: ProviderResponseMetadata,
 		model?: Model<Api>,
 		scope?: AttemptScopeRef,
+		signal?: AbortSignal,
 	) => void | Promise<void>;
 	/**
 	 * Internal dispatch-admission hook. Providers invoke this immediately before

package/src/utils/codex-entitlement.d.ts

@@ -6,6 +6,16 @@
  * authority for the account tier; this module only names the model policy and
  * keeps the provider's deterministic rejection wording in one place.
  */
+export type OpenAICodexProEntitlement = "entitled" | "denied" | "unknown";
+/**
+ * Classify a ChatGPT `plan_type` for strict Pro-tier Codex models.
+ *
+ * The usage endpoint remains authoritative: only exact, documented tier names
+ * are classified. Known Free/Plus tiers can be rejected locally, while missing
+ * or unfamiliar values stay unknown and reach the provider instead of being
+ * guessed from a substring.
+ */
+export declare function classifyOpenAICodexProEntitlement(planType: string | undefined): OpenAICodexProEntitlement;
 export declare function requiresOpenAICodexProModel(provider: string, modelId: string | undefined): boolean;
 export declare function requiresStrictOpenAICodexProModel(provider: string, modelId: string | undefined): boolean;
 export declare function isOpenAICodexChatGPTEntitlementError(message: string | undefined, code?: string): boolean;

package/src/utils/codex-entitlement.ts

@@ -7,6 +7,27 @@
  * keeps the provider's deterministic rejection wording in one place.
  */
 
+const OPENAI_CODEX_PRO_ENTITLED_PLAN_TYPES = new Set(["pro", "business", "enterprise", "team"]);
+const OPENAI_CODEX_PRO_DENIED_PLAN_TYPES = new Set(["free", "plus"]);
+
+export type OpenAICodexProEntitlement = "entitled" | "denied" | "unknown";
+
+/**
+ * Classify a ChatGPT `plan_type` for strict Pro-tier Codex models.
+ *
+ * The usage endpoint remains authoritative: only exact, documented tier names
+ * are classified. Known Free/Plus tiers can be rejected locally, while missing
+ * or unfamiliar values stay unknown and reach the provider instead of being
+ * guessed from a substring.
+ */
+export function classifyOpenAICodexProEntitlement(planType: string | undefined): OpenAICodexProEntitlement {
+	const normalized = planType?.trim().toLowerCase();
+	if (!normalized) return "unknown";
+	if (OPENAI_CODEX_PRO_ENTITLED_PLAN_TYPES.has(normalized)) return "entitled";
+	if (OPENAI_CODEX_PRO_DENIED_PLAN_TYPES.has(normalized)) return "denied";
+	return "unknown";
+}
+
 export function requiresOpenAICodexProModel(provider: string, modelId: string | undefined): boolean {
 	return (
 		provider === "openai-codex" &&

package/src/utils/discovery/antigravity.ts

@@ -180,6 +180,7 @@ export async function fetchAntigravityDiscoveryModels(
 	options: FetchAntigravityDiscoveryModelsOptions,
 ): Promise<Model<"google-gemini-cli">[] | null> {
 	const fetcher = options.fetcher ?? fetch;
+	const signal = options.signal ?? AbortSignal.timeout(5_000);
 	const targetProvider = options.targetProvider ?? "google-antigravity";
 	const endpoints = options.endpoint
 		? [trimTrailingSlashes(options.endpoint)]
@@ -196,7 +197,7 @@ export async function fetchAntigravityDiscoveryModels(
 					"User-Agent": options.userAgent ?? getAntigravityUserAgent(),
 				},
 				body: JSON.stringify({}),
-				signal: options.signal,
+				signal,
 			});
 		} catch {
 			continue;

package/src/utils/discovery/gemini.ts

@@ -72,6 +72,7 @@ export async function fetchGeminiModels(
 	const baseUrl = normalizeBaseUrl(options.baseUrl);
 	const pageSize = normalizePositiveInt(options.pageSize, DEFAULT_PAGE_SIZE);
 	const maxPages = normalizePositiveInt(options.maxPages, DEFAULT_MAX_PAGES);
+	const signal = options.signal ?? AbortSignal.timeout(5_000);
 
 	const bundledById = new Map(
 		getBundledModels("google").map(model => [model.id, model as Model<"google-generative-ai">]),
@@ -86,7 +87,7 @@ export async function fetchGeminiModels(
 		try {
 			response = await fetchImpl(requestUrl, {
 				method: "GET",
-				signal: options.signal,
+				signal,
 			});
 		} catch {
 			return null;

package/src/utils/provider-response.d.ts

@@ -3,4 +3,5 @@ export declare function normalizeProviderResponse(response: Response, requestId?
 export declare function notifyProviderResponse(options: {
     onResponse?: StreamOptions["onResponse"];
     attemptScope?: AttemptScopeRef;
+    signal?: AbortSignal;
 } | undefined, response: Response, model?: Model<Api>, requestId?: string | null, metadata?: Record<string, unknown>): Promise<void>;

package/src/utils/provider-response.ts

@@ -19,12 +19,19 @@ export function normalizeProviderResponse(
 }
 
 export async function notifyProviderResponse(
-	options: { onResponse?: StreamOptions["onResponse"]; attemptScope?: AttemptScopeRef } | undefined,
+	options:
+		| { onResponse?: StreamOptions["onResponse"]; attemptScope?: AttemptScopeRef; signal?: AbortSignal }
+		| undefined,
 	response: Response,
 	model?: Model<Api>,
 	requestId?: string | null,
 	metadata?: Record<string, unknown>,
 ): Promise<void> {
 	if (!options?.onResponse) return;
-	await options.onResponse(normalizeProviderResponse(response, requestId, metadata), model, options.attemptScope);
+	await options.onResponse(
+		normalizeProviderResponse(response, requestId, metadata),
+		model,
+		options.attemptScope,
+		options.signal,
+	);
 }