@linxiraos/pi-catalog 1.0.0 → 1.0.2

package/src/types.ts

@@ -155,6 +155,7 @@ export type OpenAIReasoningFormat = "openai" | "openrouter" | "zai" | "kimi" | "
 export type OpenAIReasoningDisableMode =
 	| "omit"
 	| "lowest-effort"
+	| "none-effort"
 	| "openrouter-enabled-false"
 	| "zai-thinking-disabled"
 	| "qwen-enable-thinking-false"
@@ -190,13 +191,6 @@ export interface OpenAICompat {
 	reasoningEffortMap?: Partial<Record<Effort, string>>;
 	/** Whether the provider supports `stream_options: { include_usage: true }` for token usage in streaming responses. Default: true. */
 	supportsUsageInStreaming?: boolean;
-	/**
-	 * Enable the Gemini thinking-loop guard (pi-ai stream layer) for this model.
-	 * Defaults to true when the model id classifies as the gemini family. Set
-	 * explicitly to cover an opaque OpenAI-compat proxy alias (e.g. `my-model`)
-	 * that routes to Gemini, or to false to opt a gemini-family id out.
-	 */
-	enableGeminiThinkingLoopGuard?: boolean;
 	/** Which field to use for max tokens. Default: auto-detected from URL. */
 	maxTokensField?: "max_completion_tokens" | "max_tokens";
 	/** Whether tool results require the `name` field. Default: auto-detected from URL. */
@@ -627,8 +621,6 @@ export interface ResolvedOpenAISharedCompat {
 	isOpenRouterHost: boolean;
 	/** Whether this endpoint needs a max-token field even when caller did not set one. */
 	alwaysSendMaxTokens: boolean;
-	/** See {@link OpenAICompat.enableGeminiThinkingLoopGuard}. Set by the builder from the family classifier. */
-	enableGeminiThinkingLoopGuard?: boolean;
 	openRouterRouting?: OpenAICompat["openRouterRouting"];
 	/** Provider-specific wire model-id transform applied to the base id. */
 	wireModelIdMode: "raw" | "firepass" | "fireworks" | "openrouter";
@@ -697,7 +689,6 @@ export type ResolvedOpenAICompat = ResolvedOpenAISharedCompat &
 			| "thinkingKeep"
 			| "strictResponsesPairing"
 			| "supportsImageDetailOriginal"
-			| "enableGeminiThinkingLoopGuard"
 			| "whenThinking"
 		>
 	> & {
@@ -819,6 +810,28 @@ export interface RemoteCompactionConfig<TApi extends Api = Api> {
 	model?: string;
 }
 
+/** Per-million-token rates for one model pricing tier. */
+export interface TokenCost {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+}
+
+/**
+ * Rates applied to the full request when its prompt exceeds `inputThreshold`.
+ * Prompt input is the sum of uncached, cached-read, cache-write, and
+ * provider-orchestration input tokens.
+ */
+export interface LongContextTokenCost extends TokenCost {
+	inputThreshold: number;
+}
+
+/** Base token rates plus an optional long-context tier. */
+export interface ModelCost extends TokenCost {
+	longContext?: LongContextTokenCost;
+}
+
 // Model interface for the unified model system
 export interface Model<TApi extends Api = Api> {
 	id: string;
@@ -864,12 +877,7 @@ export interface Model<TApi extends Api = Api> {
 	gitlabDuoWorkflowRootNamespaceId?: string;
 	/** Cursor `max_mode` request flag returned by `GetUsableModels` for premium models that require max mode. */
 	cursorMaxMode?: boolean;
-	cost: {
-		input: number; // $/million tokens
-		output: number; // $/million tokens
-		cacheRead: number; // $/million tokens
-		cacheWrite: number; // $/million tokens
-	};
+	cost: ModelCost;
 	/** Premium Copilot requests charged per user-initiated request (defaults to 1). */
 	premiumMultiplier?: number;
 	contextWindow: number | null;

package/src/variant-collapse.ts

@@ -265,22 +265,32 @@ function geminiFlashFamily(mode: "budget" | "google-level"): EffortVariantFamily
 	};
 }
 
-const GEMINI_36_FLASH_FAMILY: EffortVariantFamily = {
-	id: "gemini-3.6-flash",
-	name: "Gemini 3.6 Flash",
-	members: ["gemini-3.6-flash-low", "gemini-3.6-flash-medium", "gemini-3.6-flash-high", "gemini-3.6-flash-tiered"],
-	routing: {
-		[Effort.Minimal]: "gemini-3.6-flash-low",
-		[Effort.Low]: "gemini-3.6-flash-low",
-		[Effort.Medium]: "gemini-3.6-flash-medium",
-		[Effort.High]: "gemini-3.6-flash-high",
-	},
-	thinking: {
-		mode: "google-level",
-		efforts: GEMINI_3_FLASH_FAMILY_EFFORTS,
-		requiresEffort: true,
-	},
-};
+/**
+ * Gemini 3.6+ Flash exposes one mandatory-reasoning wire id per thinking
+ * level. Some generations retain additional discovery-only aliases.
+ */
+function geminiLevelFlashFamily(version: "3.6" | "3.7", ...additionalMembers: string[]): EffortVariantFamily {
+	const id = `gemini-${version}-flash`;
+	return {
+		id,
+		name: `Gemini ${version} Flash`,
+		members: [`${id}-low`, `${id}-medium`, `${id}-high`, ...additionalMembers],
+		routing: {
+			[Effort.Minimal]: `${id}-low`,
+			[Effort.Low]: `${id}-low`,
+			[Effort.Medium]: `${id}-medium`,
+			[Effort.High]: `${id}-high`,
+		},
+		thinking: {
+			mode: "google-level",
+			efforts: GEMINI_3_FLASH_FAMILY_EFFORTS,
+			requiresEffort: true,
+		},
+	};
+}
+
+const GEMINI_36_FLASH_FAMILY = geminiLevelFlashFamily("3.6", "gemini-3.6-flash-tiered");
+const GEMINI_37_FLASH_FAMILY = geminiLevelFlashFamily("3.7");
 
 function geminiProFamily(mode: "budget" | "google-level"): EffortVariantFamily {
 	const budget = mode === "budget";
@@ -364,13 +374,20 @@ const SHARED_CCA_FAMILIES: readonly EffortVariantFamily[] = [
 
 /** `google-antigravity` Gemini families, using each generation's native transport. */
 export const ANTIGRAVITY_VARIANT_COLLAPSE_TABLE: VariantCollapseTable = {
-	families: [GEMINI_36_FLASH_FAMILY, geminiFlashFamily("budget"), geminiProFamily("budget"), ...SHARED_CCA_FAMILIES],
+	families: [
+		GEMINI_36_FLASH_FAMILY,
+		GEMINI_37_FLASH_FAMILY,
+		geminiFlashFamily("budget"),
+		geminiProFamily("budget"),
+		...SHARED_CCA_FAMILIES,
+	],
 };
 
 /** `google-gemini-cli` Gemini families on the official CLI's level transport. */
 export const GEMINI_CLI_VARIANT_COLLAPSE_TABLE: VariantCollapseTable = {
 	families: [
 		GEMINI_36_FLASH_FAMILY,
+		GEMINI_37_FLASH_FAMILY,
 		geminiFlashFamily("google-level"),
 		geminiProFamily("google-level"),
 		...SHARED_CCA_FAMILIES,

package/src/wire/gemini-headers.ts

@@ -1,3 +1,5 @@
+import type { FetchImpl } from "@linxiraos/pi-utils";
+
 /**
  * Build a User-Agent string that identifies as Gemini CLI to unlock higher rate limits.
  * Uses the same format as the official Gemini CLI (v0.35+):
@@ -15,30 +17,89 @@ export const getGeminiCliHeaders = (modelId?: string) => ({
 	"Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI",
 });
 
-export const ANTIGRAVITY_SYSTEM_INSTRUCTION =
-	"You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding." +
-	"You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question." +
-	"**Absolute paths only**" +
-	"**Proactiveness**";
 /**
  * Antigravity / Cloud Code Assist user agent. Lives in its own file so discovery
  * and usage code can read it without pulling the heavy google-gemini-cli provider
  * (and its @google/genai → google-auth-library dependency chain) into the startup
  * parse graph.
+ *
+ * Format captured from the real 2.8.0 `antigravity/hub` client:
+ * `antigravity/hub/2.8.0 (aidev_client; os_type=darwin; arch=arm64; cl=963137146)`.
+ * The backend gates newer models (e.g. gemini-3.7-flash) on the client version,
+ * so the version tracks the latest Antigravity release via the update manifest
+ * (see {@link ensureAntigravityVersion}) with `DEFAULT_ANTIGRAVITY_VERSION` as
+ * the offline fallback. os_type/arch are pinned to the darwin/arm64 reference
+ * client the version and manifest are captured from, independent of the host
+ * platform. Overrides: PI_AI_ANTIGRAVITY_VERSION / _CL / _OS / _ARCH.
  */
-export let getAntigravityUserAgent = () => {
-	const DEFAULT_ANTIGRAVITY_VERSION = "2.1.4";
-	const version = process.env.PI_AI_ANTIGRAVITY_VERSION || DEFAULT_ANTIGRAVITY_VERSION;
-	// Map Node.js platform/arch to Antigravity's expected format.
-	// Verified against Antigravity source: _qn() and wqn() in main.js.
-	// process.platform: win32→windows, others pass through (darwin, linux)
-	// process.arch:     x64→amd64, ia32→386, others pass through (arm64)
-	const os = process.platform === "win32" ? "windows" : process.platform;
-	const arch = process.arch === "x64" ? "amd64" : process.arch === "ia32" ? "386" : process.arch;
-	const userAgent = `antigravity/hub/${version} ${os}/${arch}`;
-	getAntigravityUserAgent = () => userAgent;
-	return userAgent;
-};
+export const DEFAULT_ANTIGRAVITY_VERSION = "2.8.0";
+
+const ANTIGRAVITY_VERSION_MANIFEST_URL =
+	"https://antigravity-hub-auto-updater-974169037036.us-central1.run.app/manifest/latest-arm64-mac.yml";
+const ANTIGRAVITY_VERSION_FETCH_TIMEOUT_MS = 5_000;
+
+let discoveredAntigravityVersion: string | null = null;
+let antigravityVersionFetch: Promise<void> | null = null;
+
+/** Current Antigravity client version: env override → manifest-discovered → pinned fallback. */
+export function getAntigravityVersion(): string {
+	return process.env.PI_AI_ANTIGRAVITY_VERSION || discoveredAntigravityVersion || DEFAULT_ANTIGRAVITY_VERSION;
+}
+
+/**
+ * Extracts the client version from an electron-builder update manifest.
+ * Returns null when no well-formed `version:` line is present.
+ */
+export function parseAntigravityManifestVersion(yamlText: string): string | null {
+	for (const line of yamlText.split(/\r?\n/)) {
+		const match = /^\s*version\s*:\s*(?:"([^"]*)"|'([^']*)'|([^\s#]+))\s*(?:#.*)?$/.exec(line);
+		if (!match) continue;
+		const version = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+		return /^\d+\.\d+\.\d+$/.test(version) ? version : null;
+	}
+	return null;
+}
+
+/**
+ * Resolves the latest Antigravity release from the official update manifest.
+ * Success is cached for the process lifetime; failures are silent (the pinned
+ * fallback stays valid) and clear the in-flight cache so a later call retries.
+ * Skipped entirely when PI_AI_ANTIGRAVITY_VERSION is set.
+ */
+export function ensureAntigravityVersion(fetcher: FetchImpl = fetch, signal?: AbortSignal): Promise<void> {
+	if (process.env.PI_AI_ANTIGRAVITY_VERSION || discoveredAntigravityVersion) return Promise.resolve();
+	if (antigravityVersionFetch) return antigravityVersionFetch;
+
+	antigravityVersionFetch = (async () => {
+		try {
+			const timeoutSignal = AbortSignal.timeout(ANTIGRAVITY_VERSION_FETCH_TIMEOUT_MS);
+			const response = await fetcher(ANTIGRAVITY_VERSION_MANIFEST_URL, {
+				headers: { "Cache-Control": "no-cache", "User-Agent": "electron-builder" },
+				signal: signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal,
+			});
+			if (response.ok) {
+				discoveredAntigravityVersion = parseAntigravityManifestVersion(await response.text());
+			}
+		} catch {
+			// Silent: the pinned fallback remains valid when version discovery fails.
+		} finally {
+			if (!discoveredAntigravityVersion) antigravityVersionFetch = null;
+		}
+	})();
+	return antigravityVersionFetch;
+}
+
+/** Antigravity `User-Agent` header value; rebuilt when the discovered version changes. */
+export function getAntigravityUserAgent(): string {
+	const version = getAntigravityVersion();
+	// The backend does not validate `cl` (verified live: stale, zero, and absent
+	// cl all pass model gating on daily-cloudcode-pa; only the version gates).
+	// The update manifest carries no changelist, so the captured value stays.
+	const cl = process.env.PI_AI_ANTIGRAVITY_CL || "963137146";
+	const os = process.env.PI_AI_ANTIGRAVITY_OS || "darwin";
+	const arch = process.env.PI_AI_ANTIGRAVITY_ARCH || "arm64";
+	return `antigravity/hub/${version} (aidev_client; os_type=${os}; arch=${arch}; cl=${cl})`;
+}
 
 /**
  * Per-wire-id Antigravity Cloud Code Assist request constants, captured from the

package/dist/types/build.d.ts

@@ -1,14 +0,0 @@
-/**
- * The single Model constructor. Resolution order is a dependency chain, each
- * step materialized exactly once per spec:
- *
- *   1. compat   — URL/provider/id detection resolved into a complete record;
- *   2. thinking — derived from identity + resolved compat (or trusted verbatim
- *                 when the spec carries explicit metadata);
- *
- * Request handlers read fields — they never detect, parse ids, or allocate
- * compat per request.
- */
-import type { Api, CompatOf, Model, ModelSpec } from "./types.js";
-export declare function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi>;
-export declare function buildCompat(spec: ModelSpec<Api>): CompatOf<Api>;

package/dist/types/compat/anthropic.d.ts

@@ -1,18 +0,0 @@
-import type { ModelSpec, ResolvedAnthropicCompat } from "../types.js";
-/**
- * Official first-party Anthropic API. A missing baseUrl is official on purpose:
- * request dispatch falls back to `https://api.anthropic.com`. This is the one
- * auth-sensitive host check — OAuth credentials are attached based on it — so
- * it requires the exact origin or a path boundary (`/`) after it; a bare
- * prefix check would accept lookalikes like `https://api.anthropic.com.evil.com`.
- */
-export declare function isOfficialAnthropicApiUrl(baseUrl?: string): boolean;
-/**
- * Known non-official URLs that enforce Anthropic thinking signatures on replay.
- *
- * Runtime routing calls this with the effective URL because a model's resolved
- * compat can be stale after Foundry or a provider base-URL override reroutes it.
- */
-export declare function isAnthropicSigningProxyUrl(baseUrl?: string): boolean;
-/** Build the resolved anthropic-messages compat record for a model spec. */
-export declare function buildAnthropicCompat(spec: ModelSpec<"anthropic-messages">): ResolvedAnthropicCompat;

package/dist/types/compat/apply.d.ts

@@ -1,7 +0,0 @@
-/**
- * Assign defined override values onto a freshly-built resolved compat record,
- * in place. Keys the record doesn't declare are ignored (loosely-typed config
- * may carry junk). `buildModel` is the only intended caller — the record being
- * mutated is the single per-model allocation; nothing here runs per request.
- */
-export declare function applyCompatOverrides(compat: object, overrides: object | undefined): void;

package/dist/types/compat/bedrock.d.ts

@@ -1,3 +0,0 @@
-import type { ModelSpec, ResolvedBedrockCompat } from "../types.js";
-/** Resolve Bedrock Converse prompt-cache and stream-watchdog compat once per model. */
-export declare function buildBedrockCompat(spec: ModelSpec<"bedrock-converse-stream">): ResolvedBedrockCompat;

package/dist/types/compat/devin.d.ts

@@ -1,9 +0,0 @@
-import type { ModelSpec, ResolvedDevinCompat } from "../types.js";
-/**
- * Resolve devin-agent (Codeium Cascade) compat. Cascade has no wire
- * reasoning/effort field — effort is selected by routing to a sibling model id
- * (the `thinking.effortRouting` baked by variant-collapse). So the thinking
- * deriver must never fabricate an effort ladder from identity for these models;
- * only explicit routed metadata counts.
- */
-export declare function buildDevinCompat(_spec: ModelSpec<"devin-agent">): ResolvedDevinCompat;

package/dist/types/compat/openai.d.ts

@@ -1,26 +0,0 @@
-import type { ModelSpec, OpenAICompat, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat, ResolvedOpenRouterCompat } from "../types.js";
-/**
- * Build the resolved chat-completions compat record for a model spec.
- * Provider takes precedence over URL-based detection since it's explicitly configured.
- */
-export declare function buildOpenAICompat(spec: ModelSpec<"openai-completions">): ResolvedOpenAICompat;
-interface OpenAIResponsesSpecLike {
-    id?: string;
-    provider: string;
-    name: string;
-    baseUrl: string;
-    reasoning?: boolean;
-    compat?: OpenAICompat;
-}
-/**
- * Build the resolved Responses-API compat record. Most shared OpenAI-compatible
- * capability defaults intentionally mirror chat-completions, while Responses-
- * only behavior (developer role, prompt cache, pairing strictness, image detail)
- * keeps endpoint-specific detection. Azure is detected by provider id as well
- * as URL — bundled `azure` models carry no baseUrl (the deployment host is per-
- * resource, resolved at runtime) — while OpenAI/Copilot developer-role and
- * prompt-cache detection stay URL-keyed, as the historical call sites were.
- */
-export declare function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): ResolvedOpenAIResponsesCompat;
-export declare function buildOpenRouterCompat(spec: ModelSpec<"openrouter">): ResolvedOpenRouterCompat;
-export {};

package/dist/types/discovery/antigravity.d.ts

@@ -1,70 +0,0 @@
-import type { ModelSpec } from "../types.js";
-import { type VariantCollapseTable } from "../variant-collapse.js";
-export declare const ANTIGRAVITY_PRIMARY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
-export declare const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
-/**
- * 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[];
-}
-/**
- * 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;
-    /**
-     * Hand collapse table to apply to the discovered list. Defaults to the
-     * Antigravity (budget-transport) table; `googleGeminiCli` passes the
-     * level-transport table so cloudcode-pa keeps `thinkingLevel`.
-     */
-    collapseTable?: VariantCollapseTable;
-}
-/**
- * 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 declare function fetchAntigravityDiscoveryModels(options: FetchAntigravityDiscoveryModelsOptions): Promise<ModelSpec<"google-gemini-cli">[] | null>;

package/dist/types/discovery/codex.d.ts

@@ -1,36 +0,0 @@
-import type { FetchImpl, ModelSpec } from "../types.js";
-/**
- * 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?: FetchImpl;
-}
-/**
- * Normalized Codex discovery response.
- */
-export interface CodexModelDiscoveryResult {
-    models: ModelSpec<"openai-codex-responses">[];
-    etag?: string;
-}
-/**
- * Fetches model metadata from Codex backend and normalizes it for pi 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 declare function fetchCodexModels(options: CodexModelDiscoveryOptions): Promise<CodexModelDiscoveryResult | null>;