@aryee337/aery-ai 0.2.27 → 0.2.29

package/src/utils/discovery/antigravity.ts

@@ -0,0 +1,261 @@
+import * as z from "zod/v4";
+import { getAntigravityUserAgent } from "../../providers/google-gemini-headers";
+import type { Model } from "../../types";
+import { toPositiveNumber } from "../../utils";
+
+const DEFAULT_ANTIGRAVITY_DISCOVERY_ENDPOINTS = [
+	"https://daily-cloudcode-pa.googleapis.com",
+	"https://daily-cloudcode-pa.sandbox.googleapis.com",
+] as const;
+const FETCH_AVAILABLE_MODELS_PATH = "/v1internal:fetchAvailableModels";
+
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+const DEFAULT_MAX_TOKENS = 64_000;
+const ANTIGRAVITY_DISCOVERY_DENYLIST = new Set([
+	"chat_20706",
+	"chat_23310",
+	"gemini-2.5-flash-thinking",
+	"gemini-3-pro-low",
+	"gemini-2.5-pro",
+]);
+
+/**
+ * Raw model metadata returned by Antigravity's `fetchAvailableModels` endpoint.
+ */
+export interface AntigravityDiscoveryApiModel {
+	displayName?: string;
+	supportsImages?: boolean;
+	supportsThinking?: boolean;
+	thinkingBudget?: number;
+	recommended?: boolean;
+	maxTokens?: number;
+	maxOutputTokens?: number;
+	model?: string;
+	apiProvider?: string;
+	modelProvider?: string;
+	isInternal?: boolean;
+	supportsVideo?: boolean;
+}
+
+/**
+ * Grouping metadata used by Antigravity to surface recommended model ids.
+ */
+export interface AntigravityDiscoveryAgentModelGroup {
+	modelIds?: string[];
+}
+
+/**
+ * Sort/group metadata used by Antigravity to surface recommended model ids.
+ */
+export interface AntigravityDiscoveryAgentModelSort {
+	groups?: AntigravityDiscoveryAgentModelGroup[];
+}
+
+/**
+ * Response payload returned by Antigravity's `fetchAvailableModels` endpoint.
+ */
+export interface AntigravityDiscoveryApiResponse {
+	models?: Record<string, AntigravityDiscoveryApiModel>;
+	agentModelSorts?: AntigravityDiscoveryAgentModelSort[];
+}
+const AntigravityDiscoveryApiModelSchema: z.ZodType<AntigravityDiscoveryApiModel> = z
+	.object({
+		displayName: z.preprocess(value => (typeof value === "string" ? value : undefined), z.string().optional()),
+		supportsImages: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
+		supportsThinking: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
+		thinkingBudget: z.preprocess(
+			value => (typeof value === "number" && Number.isFinite(value) ? value : undefined),
+			z.number().optional(),
+		),
+		recommended: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
+		maxTokens: z.preprocess(
+			value => (typeof value === "number" && Number.isFinite(value) ? value : undefined),
+			z.number().optional(),
+		),
+		maxOutputTokens: z.preprocess(
+			value => (typeof value === "number" && Number.isFinite(value) ? value : undefined),
+			z.number().optional(),
+		),
+		model: z.preprocess(value => (typeof value === "string" ? value : undefined), z.string().optional()),
+		apiProvider: z.preprocess(value => (typeof value === "string" ? value : undefined), z.string().optional()),
+		modelProvider: z.preprocess(value => (typeof value === "string" ? value : undefined), z.string().optional()),
+		isInternal: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
+		supportsVideo: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
+	})
+	.loose();
+const AntigravityDiscoveryAgentModelGroupSchema: z.ZodType<AntigravityDiscoveryAgentModelGroup> = z
+	.object({
+		modelIds: z.preprocess(
+			value =>
+				Array.isArray(value)
+					? value.filter((modelId): modelId is string => typeof modelId === "string")
+					: undefined,
+			z.array(z.string()).optional(),
+		),
+	})
+	.loose();
+const AntigravityDiscoveryAgentModelSortSchema: z.ZodType<AntigravityDiscoveryAgentModelSort> = z
+	.object({
+		groups: z.preprocess(
+			value => (Array.isArray(value) ? value : undefined),
+			z
+				.array(z.unknown())
+				.transform(groups =>
+					groups.flatMap(group => {
+						const parsedGroup = AntigravityDiscoveryAgentModelGroupSchema.safeParse(group);
+						return parsedGroup.success ? [parsedGroup.data] : [];
+					}),
+				)
+				.optional(),
+		),
+	})
+	.loose();
+const AntigravityDiscoveryApiResponseSchema: z.ZodType<AntigravityDiscoveryApiResponse> = z
+	.object({
+		models: z.preprocess(
+			value => (typeof value === "object" && value !== null ? value : undefined),
+			z
+				.record(z.string(), z.unknown())
+				.transform(models => {
+					const normalized: Record<string, AntigravityDiscoveryApiModel> = {};
+					for (const [modelId, modelValue] of Object.entries(models)) {
+						if (typeof modelValue !== "object" || modelValue === null) {
+							continue;
+						}
+						const parsedModel = AntigravityDiscoveryApiModelSchema.safeParse(modelValue);
+						if (parsedModel.success) {
+							normalized[modelId] = parsedModel.data;
+						}
+					}
+					return normalized;
+				})
+				.optional(),
+		),
+		agentModelSorts: z.preprocess(
+			value => (Array.isArray(value) ? value : undefined),
+			z
+				.array(z.unknown())
+				.transform(sorts =>
+					sorts.flatMap(sort => {
+						const parsedSort = AntigravityDiscoveryAgentModelSortSchema.safeParse(sort);
+						return parsedSort.success ? [parsedSort.data] : [];
+					}),
+				)
+				.optional(),
+		),
+	})
+	.loose();
+
+/**
+ * Options for fetching Antigravity discovery models.
+ */
+export interface FetchAntigravityDiscoveryModelsOptions {
+	/** OAuth access token used as `Authorization: Bearer <token>`. */
+	token: string;
+	/** Optional endpoint override. Defaults to Antigravity fallback endpoints. */
+	endpoint?: string;
+	/** Deprecated and ignored for antigravity discovery parity. */
+	project?: string;
+	/** Optional user agent override. */
+	userAgent?: string;
+	/** Optional abort signal for request cancellation. */
+	signal?: AbortSignal;
+	/** Optional fetch implementation override for tests. */
+	fetcher?: typeof fetch;
+}
+
+/**
+ * Fetches discoverable Antigravity models and normalizes them into canonical model entries.
+ *
+ * Returns `null` on network/payload/auth failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export async function fetchAntigravityDiscoveryModels(
+	options: FetchAntigravityDiscoveryModelsOptions,
+): Promise<Model<"google-gemini-cli">[] | null> {
+	const fetcher = options.fetcher ?? fetch;
+	const endpoints = options.endpoint
+		? [trimTrailingSlashes(options.endpoint)]
+		: DEFAULT_ANTIGRAVITY_DISCOVERY_ENDPOINTS.map(trimTrailingSlashes);
+
+	for (const endpoint of endpoints) {
+		let response: Response;
+		try {
+			response = await fetcher(`${endpoint}${FETCH_AVAILABLE_MODELS_PATH}`, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${options.token}`,
+					"Content-Type": "application/json",
+					"User-Agent": options.userAgent ?? getAntigravityUserAgent(),
+				},
+				body: JSON.stringify({}),
+				signal: options.signal,
+			});
+		} catch {
+			continue;
+		}
+
+		if (!response.ok) {
+			continue;
+		}
+
+		let payload: unknown;
+		try {
+			payload = await response.json();
+		} catch {
+			continue;
+		}
+
+		const parsed = parseAntigravityDiscoveryResponse(payload);
+		if (!parsed) {
+			continue;
+		}
+
+		const models: Model<"google-gemini-cli">[] = [];
+
+		for (const [modelId, model] of Object.entries(parsed.models ?? {})) {
+			if (ANTIGRAVITY_DISCOVERY_DENYLIST.has(modelId)) {
+				continue;
+			}
+			if (model.isInternal === true) {
+				continue;
+			}
+
+			const supportsImages = model.supportsImages === true;
+			models.push({
+				id: modelId,
+				name: model.displayName ? `${model.displayName} (Antigravity)` : modelId,
+				api: "google-gemini-cli",
+				provider: "google-antigravity",
+				baseUrl: endpoint,
+				reasoning: model.supportsThinking === true,
+				input: supportsImages ? ["text", "image"] : ["text"],
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				contextWindow: toPositiveNumber(model.maxTokens, DEFAULT_CONTEXT_WINDOW),
+				maxTokens: toPositiveNumber(model.maxOutputTokens, DEFAULT_MAX_TOKENS),
+			});
+		}
+
+		models.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+		return models;
+	}
+
+	return null;
+}
+
+function parseAntigravityDiscoveryResponse(value: unknown): AntigravityDiscoveryApiResponse | null {
+	const parsed = AntigravityDiscoveryApiResponseSchema.safeParse(value);
+	if (!parsed.success) {
+		return null;
+	}
+	return parsed.data;
+}
+
+function trimTrailingSlashes(value: string): string {
+	return value.replace(/\/+$/, "");
+}

package/src/utils/discovery/codex.ts

@@ -0,0 +1,371 @@
+import * as z from "zod/v4";
+import { CODEX_BASE_URL, OPENAI_HEADER_VALUES, OPENAI_HEADERS } from "../../providers/openai-codex/constants";
+import type { Model } from "../../types";
+import { isRecord } from "../../utils";
+
+const DEFAULT_MODEL_LIST_PATHS = ["/codex/models", "/models"] as const;
+const DEFAULT_CONTEXT_WINDOW = 272_000;
+const DEFAULT_MAX_TOKENS = 128_000;
+const DEFAULT_CODEX_CLIENT_VERSION = "0.99.0";
+const NPM_CODEX_LATEST_URL = "https://registry.npmjs.org/@openai%2Fcodex/latest";
+
+const codexReasoningPresetSchema = z
+	.object({
+		effort: z.unknown().optional(),
+	})
+	.loose();
+
+const codexModelEntrySchema = z
+	.object({
+		slug: z.unknown().optional(),
+		id: z.unknown().optional(),
+		display_name: z.unknown().optional(),
+		context_window: z.unknown().optional(),
+		default_reasoning_level: z.unknown().optional(),
+		supported_reasoning_levels: z.unknown().optional(),
+		input_modalities: z.unknown().optional(),
+		supported_in_api: z.unknown().optional(),
+		priority: z.unknown().optional(),
+		prefer_websockets: z.unknown().optional(),
+	})
+	.loose();
+
+const codexModelsResponseSchema = z
+	.object({
+		models: z.array(z.unknown()).optional(),
+		data: z.array(z.unknown()).optional(),
+	})
+	.loose();
+
+type CodexModelEntry = z.infer<typeof codexModelEntrySchema>;
+
+interface NormalizedCodexModel {
+	model: Model<"openai-codex-responses">;
+	priority: number;
+}
+
+/**
+ * Fetch options for OpenAI Codex model discovery.
+ */
+export interface CodexModelDiscoveryOptions {
+	/** OAuth access token used for `Authorization: Bearer ...`. */
+	accessToken: string;
+	/** ChatGPT account id value used for `chatgpt-account-id` header. */
+	accountId?: string;
+	/** Base URL for Codex backend. Defaults to `https://chatgpt.com/backend-api`. */
+	baseUrl?: string;
+	/** Optional client version attached as `client_version` query parameter. */
+	clientVersion?: string;
+	/** Optional endpoint path candidates. Defaults to `/codex/models`, then `/models`. */
+	paths?: readonly string[];
+	/** Additional headers merged on top of required Codex headers. */
+	headers?: Record<string, string>;
+	/** Abort signal for network request cancellation. */
+	signal?: AbortSignal;
+	/** Optional fetch implementation override for tests. */
+	fetchFn?: typeof fetch;
+	/** Optional registry fetch implementation override for client version lookup. */
+	registryFetchFn?: typeof fetch;
+}
+
+/**
+ * Normalized Codex discovery response.
+ */
+export interface CodexModelDiscoveryResult {
+	models: Model<"openai-codex-responses">[];
+	etag?: string;
+}
+
+/**
+ * Fetches model metadata from Codex backend and normalizes it for aery model management.
+ *
+ * Returns `null` when no supported model-list route can be fetched/parsed.
+ * Returns `{ models: [] }` when a route succeeds but yields no usable models.
+ */
+export async function fetchCodexModels(options: CodexModelDiscoveryOptions): Promise<CodexModelDiscoveryResult | null> {
+	const fetchFn = options.fetchFn ?? fetch;
+	const baseUrl = normalizeBaseUrl(options.baseUrl);
+	const paths = normalizePaths(options.paths);
+	const headers = buildCodexHeaders(options);
+	const clientVersion = await resolveCodexClientVersion(
+		options.clientVersion,
+		options.registryFetchFn ?? fetchFn,
+		options.signal,
+	);
+
+	let sawSuccessfulResponse = false;
+	for (const path of paths) {
+		const requestUrl = buildModelsUrl(baseUrl, path, clientVersion);
+		let response: Response;
+		try {
+			response = await fetchFn(requestUrl, {
+				method: "GET",
+				headers,
+				signal: options.signal,
+			});
+		} catch {
+			continue;
+		}
+
+		if (!response.ok) {
+			continue;
+		}
+
+		let payload: unknown;
+		try {
+			payload = await response.json();
+		} catch {
+			continue;
+		}
+
+		const models = normalizeCodexModels(payload, baseUrl);
+		if (models === null) {
+			continue;
+		}
+		sawSuccessfulResponse = true;
+		const etag = getResponseEtag(response.headers);
+		return etag ? { models, etag } : { models };
+	}
+	return sawSuccessfulResponse ? { models: [] } : null;
+}
+
+function normalizeBaseUrl(baseUrl: string | undefined): string {
+	const raw = (baseUrl ?? CODEX_BASE_URL).trim();
+	if (!raw) {
+		return CODEX_BASE_URL;
+	}
+	return raw.replace(/\/+$/, "");
+}
+
+function normalizePaths(paths: readonly string[] | undefined): string[] {
+	if (!paths || paths.length === 0) {
+		return [...DEFAULT_MODEL_LIST_PATHS];
+	}
+	const normalized = paths
+		.map(path => path.trim())
+		.filter(path => path.length > 0)
+		.map(path => (path.startsWith("/") ? path : `/${path}`));
+	return normalized.length > 0 ? normalized : [...DEFAULT_MODEL_LIST_PATHS];
+}
+
+function buildModelsUrl(baseUrl: string, path: string, clientVersion: string | undefined): string {
+	const url = new URL(`${baseUrl}${path}`);
+	if (clientVersion && clientVersion.trim().length > 0) {
+		url.searchParams.set("client_version", clientVersion.trim());
+	}
+	return url.toString();
+}
+
+function buildCodexHeaders(options: CodexModelDiscoveryOptions): Headers {
+	const headers = new Headers(options.headers);
+	headers.set("Authorization", `Bearer ${options.accessToken}`);
+	if (options.accountId && options.accountId.trim().length > 0) {
+		headers.set(OPENAI_HEADERS.ACCOUNT_ID, options.accountId);
+	}
+	headers.set(OPENAI_HEADERS.BETA, OPENAI_HEADER_VALUES.BETA_RESPONSES);
+	headers.set(OPENAI_HEADERS.ORIGINATOR, OPENAI_HEADER_VALUES.ORIGINATOR_CODEX);
+	headers.set("accept", "application/json");
+	return headers;
+}
+
+async function resolveCodexClientVersion(
+	clientVersion: string | undefined,
+	fetchFn: typeof fetch,
+	signal: AbortSignal | undefined,
+): Promise<string> {
+	const normalizedClientVersion = normalizeClientVersion(clientVersion);
+	if (normalizedClientVersion) {
+		return normalizedClientVersion;
+	}
+	try {
+		const response = await fetchFn(NPM_CODEX_LATEST_URL, {
+			method: "GET",
+			headers: { Accept: "application/json" },
+			signal,
+		});
+		if (!response.ok) {
+			return DEFAULT_CODEX_CLIENT_VERSION;
+		}
+		const payload: unknown = await response.json();
+		if (!isRecord(payload)) {
+			return DEFAULT_CODEX_CLIENT_VERSION;
+		}
+		const npmVersion = normalizeClientVersion(payload.version);
+		return npmVersion ?? DEFAULT_CODEX_CLIENT_VERSION;
+	} catch (error) {
+		if (isAbortError(error)) {
+			throw error;
+		}
+		return DEFAULT_CODEX_CLIENT_VERSION;
+	}
+}
+
+function normalizeClientVersion(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	if (!/^\d+\.\d+\.\d+$/.test(trimmed)) {
+		return undefined;
+	}
+	return trimmed;
+}
+
+function isAbortError(error: unknown): error is Error {
+	return error instanceof Error && error.name === "AbortError";
+}
+
+function normalizeCodexModels(payload: unknown, baseUrl: string): Model<"openai-codex-responses">[] | null {
+	const parsedResponse = codexModelsResponseSchema.safeParse(payload);
+	if (!parsedResponse.success) {
+		return null;
+	}
+
+	const entries = parsedResponse.data.models ?? parsedResponse.data.data ?? [];
+	const normalized: NormalizedCodexModel[] = [];
+	for (const entry of entries) {
+		const model = normalizeCodexModelEntry(entry, baseUrl);
+		if (model) {
+			normalized.push(model);
+		}
+	}
+
+	normalized.sort((left, right) => {
+		if (left.priority !== right.priority) {
+			return left.priority - right.priority;
+		}
+		return left.model.id.localeCompare(right.model.id);
+	});
+
+	return normalized.map(item => item.model);
+}
+
+function normalizeCodexModelEntry(entry: unknown, baseUrl: string): NormalizedCodexModel | null {
+	const parsedEntry = codexModelEntrySchema.safeParse(entry);
+	if (!parsedEntry.success) {
+		return null;
+	}
+
+	const payload: CodexModelEntry = parsedEntry.data;
+	const slug = toNonEmptyString(payload.slug) ?? toNonEmptyString(payload.id);
+	if (!slug) {
+		return null;
+	}
+
+	const supportedInApi = toBoolean(payload.supported_in_api);
+	if (supportedInApi === false) {
+		return null;
+	}
+
+	const name = toNonEmptyString(payload.display_name) ?? slug;
+	const contextWindow = toPositiveInt(payload.context_window) ?? DEFAULT_CONTEXT_WINDOW;
+	const maxTokens = Math.min(DEFAULT_MAX_TOKENS, contextWindow);
+	const reasoning = supportsReasoning(payload.default_reasoning_level, payload.supported_reasoning_levels);
+	const input = normalizeInputModalities(payload.input_modalities);
+	const preferWebsockets = toBoolean(payload.prefer_websockets) === true;
+	const priority = toFiniteNumber(payload.priority) ?? Number.MAX_SAFE_INTEGER;
+
+	return {
+		priority,
+		model: {
+			id: slug,
+			name,
+			api: "openai-codex-responses",
+			provider: "openai-codex",
+			baseUrl,
+			reasoning,
+			input,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow,
+			maxTokens,
+			...(preferWebsockets ? { preferWebsockets: true } : {}),
+			...(priority !== Number.MAX_SAFE_INTEGER ? { priority } : {}),
+		},
+	};
+}
+
+function supportsReasoning(defaultReasoningLevel: unknown, supportedReasoningLevels: unknown): boolean {
+	const defaultLevel = toNonEmptyString(defaultReasoningLevel)?.toLowerCase();
+	if (defaultLevel && defaultLevel !== "none") {
+		return true;
+	}
+
+	if (!Array.isArray(supportedReasoningLevels)) {
+		return false;
+	}
+
+	for (const level of supportedReasoningLevels) {
+		const parsedLevel = codexReasoningPresetSchema.safeParse(level);
+		if (!parsedLevel.success) {
+			continue;
+		}
+		const effort = toNonEmptyString(parsedLevel.data.effort)?.toLowerCase();
+		if (effort && effort !== "none") {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function normalizeInputModalities(inputModalities: unknown): ("text" | "image")[] {
+	if (!Array.isArray(inputModalities)) {
+		return ["text", "image"];
+	}
+
+	const set = new Set<"text" | "image">();
+	for (const modality of inputModalities) {
+		const normalized = toNonEmptyString(modality)?.toLowerCase();
+		if (normalized === "text" || normalized === "image") {
+			set.add(normalized);
+		}
+	}
+
+	if (set.size === 0) {
+		return ["text", "image"];
+	}
+
+	const canonical: ("text" | "image")[] = ["text", "image"];
+	return canonical.filter(modality => set.has(modality));
+}
+
+function getResponseEtag(headers: Headers): string | undefined {
+	const etag = headers.get("etag");
+	if (!etag) {
+		return undefined;
+	}
+	const trimmed = etag.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function toNonEmptyString(value: unknown): string | null {
+	if (typeof value !== "string") {
+		return null;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+
+function toPositiveInt(value: unknown): number | null {
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		return null;
+	}
+	if (value <= 0) {
+		return null;
+	}
+	return Math.trunc(value);
+}
+
+function toFiniteNumber(value: unknown): number | null {
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		return null;
+	}
+	return value;
+}
+
+function toBoolean(value: unknown): boolean | null {
+	if (typeof value !== "boolean") {
+		return null;
+	}
+	return value;
+}