@linxiraos/pi-catalog 1.0.0

package/src/wire/alibaba-token-plan.ts

@@ -0,0 +1,54 @@
+/**
+ * International (Singapore) Token Plan endpoint. Default region; keys issued by
+ * the international product authenticate only here.
+ */
+export const ALIBABA_TOKEN_PLAN_BASE_URL = "https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1";
+/**
+ * China (Beijing) Token Plan endpoint (百炼 Token Plan). Keys are region-locked:
+ * a Beijing-issued key is rejected by the international endpoint with
+ * `invalid_api_key`, and vice versa (#6682).
+ */
+export const ALIBABA_TOKEN_PLAN_CN_BASE_URL = "https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1";
+
+export interface AlibabaTokenPlanCredential {
+	token: string;
+	cookie?: string;
+	/**
+	 * Region base URL the key authenticates against. Absent means the default
+	 * international endpoint ({@link ALIBABA_TOKEN_PLAN_BASE_URL}).
+	 */
+	baseUrl?: string;
+}
+
+const TOKEN_PATTERN = /^sk-[A-Za-z0-9._~+/-]+={0,2}$/;
+
+export function parseAlibabaTokenPlanCredential(value: string): AlibabaTokenPlanCredential | null {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	if (!trimmed.startsWith("{")) return TOKEN_PATTERN.test(trimmed) ? { token: trimmed } : null;
+	try {
+		const parsed = JSON.parse(trimmed) as { token?: unknown; cookie?: unknown; baseUrl?: unknown };
+		if (typeof parsed.token !== "string" || !TOKEN_PATTERN.test(parsed.token.trim())) return null;
+		if (parsed.cookie !== undefined && typeof parsed.cookie !== "string") return null;
+		if (parsed.baseUrl !== undefined && typeof parsed.baseUrl !== "string") return null;
+		const token = parsed.token.trim();
+		const cookie = parsed.cookie?.trim();
+		const baseUrl = parsed.baseUrl?.trim();
+		const credential: AlibabaTokenPlanCredential = { token };
+		if (cookie) credential.cookie = cookie;
+		if (baseUrl) credential.baseUrl = baseUrl;
+		return credential;
+	} catch {
+		return null;
+	}
+}
+
+export function serializeAlibabaTokenPlanCredential(token: string, cookie: string, baseUrl?: string): string {
+	const trimmedCookie = cookie.trim();
+	const trimmedBaseUrl = baseUrl?.trim();
+	if (!trimmedCookie && !trimmedBaseUrl) return token;
+	const payload: { token: string; cookie?: string; baseUrl?: string } = { token };
+	if (trimmedCookie) payload.cookie = trimmedCookie;
+	if (trimmedBaseUrl) payload.baseUrl = trimmedBaseUrl;
+	return JSON.stringify(payload);
+}

package/src/wire/codex.ts

@@ -0,0 +1,60 @@
+/**
+ * Constants for OpenAI Codex (ChatGPT OAuth) backend
+ */
+
+export const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+
+/**
+ * Pinned OpenAI Codex client version (corresponds to @openai/codex package version).
+ */
+export const CODEX_CLIENT_VERSION = "0.144.1";
+
+export const OPENAI_HEADERS = {
+	BETA: "OpenAI-Beta",
+	ACCOUNT_ID: "chatgpt-account-id",
+	ORIGINATOR: "originator",
+	VERSION: "version",
+	SESSION_ID: "session_id",
+	CONVERSATION_ID: "conversation_id",
+	SCOPED_SESSION_ID: "session-id",
+	THREAD_ID: "thread-id",
+	INSTALLATION_ID: "x-codex-installation-id",
+	WINDOW_ID: "x-codex-window-id",
+	TURN_METADATA: "x-codex-turn-metadata",
+	PARENT_THREAD_ID: "x-codex-parent-thread-id",
+	SUBAGENT: "x-openai-subagent",
+	/** Responses Lite transport marker (codex-rs `add_responses_lite_header`); value is always `"true"`. */
+	RESPONSES_LITE: "x-openai-internal-codex-responses-lite",
+	/** DeviceCheck attestation envelope (codex-rs `X_OAI_ATTESTATION_HEADER`); sent on ChatGPT-OAuth requests. */
+	ATTESTATION: "x-oai-attestation",
+} as const;
+
+export const OPENAI_HEADER_VALUES = {
+	BETA_RESPONSES: "responses=experimental",
+	BETA_RESPONSES_WEBSOCKETS_V2: "responses_websockets=2026-02-06",
+	ORIGINATOR_CODEX: "pi",
+} as const;
+
+export const URL_PATHS = {
+	RESPONSES: "/responses",
+	CODEX_RESPONSES: "/codex/responses",
+} as const;
+
+export const JWT_CLAIM_PATH = "https://api.openai.com/auth" as const;
+
+/**
+ * Extract account ID from a Codex JWT access token.
+ * Returns undefined if the token is not a valid Codex JWT.
+ */
+export function getCodexAccountId(accessToken: string): string | undefined {
+	try {
+		const parts = accessToken.split(".");
+		if (parts.length !== 3) return undefined;
+		const decoded = Buffer.from(parts[1] ?? "", "base64").toString("utf-8");
+		const payload = JSON.parse(decoded) as Record<string, unknown>;
+		const auth = payload[JWT_CLAIM_PATH] as { chatgpt_account_id?: string } | undefined;
+		return auth?.chatgpt_account_id ?? undefined;
+	} catch {
+		return undefined;
+	}
+}

package/src/wire/coreweave.ts

@@ -0,0 +1,51 @@
+export const COREWEAVE_PROJECT_HEADER = "OpenAI-Project" as const;
+
+export interface CoreWeaveProjectEnv {
+	[key: string]: string | undefined;
+	COREWEAVE_PROJECT?: string;
+	WANDB_INFERENCE_PROJECT?: string;
+	WANDB_ENTITY?: string;
+	WANDB_PROJECT?: string;
+}
+
+function cleanEnvValue(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+export function resolveCoreWeaveProject(env: CoreWeaveProjectEnv): string | undefined {
+	const explicitProject = cleanEnvValue(env.COREWEAVE_PROJECT) ?? cleanEnvValue(env.WANDB_INFERENCE_PROJECT);
+	if (explicitProject) {
+		return explicitProject;
+	}
+
+	const wandbProject = cleanEnvValue(env.WANDB_PROJECT);
+	if (!wandbProject) {
+		return undefined;
+	}
+	if (wandbProject.includes("/")) {
+		return wandbProject;
+	}
+
+	const wandbEntity = cleanEnvValue(env.WANDB_ENTITY);
+	return wandbEntity ? `${wandbEntity}/${wandbProject}` : undefined;
+}
+
+export function coreWeaveProjectHeaders(env: CoreWeaveProjectEnv): Record<string, string> | undefined {
+	const project = resolveCoreWeaveProject(env);
+	return project ? { [COREWEAVE_PROJECT_HEADER]: project } : undefined;
+}
+
+export function hasCoreWeaveProjectHeader(headers: Record<string, string>): boolean {
+	const normalized = COREWEAVE_PROJECT_HEADER.toLowerCase();
+	return Object.entries(headers).some(([header, value]) => header.toLowerCase() === normalized && value.trim() !== "");
+}
+
+export function removeBlankCoreWeaveProjectHeaders(headers: Record<string, string>): void {
+	const normalized = COREWEAVE_PROJECT_HEADER.toLowerCase();
+	for (const [header, value] of Object.entries(headers)) {
+		if (header.toLowerCase() === normalized && value.trim() === "") {
+			delete headers[header];
+		}
+	}
+}

package/src/wire/gemini-headers.ts

@@ -0,0 +1,74 @@
+/**
+ * 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+):
+ * GeminiCLI/VERSION/MODEL (PLATFORM; ARCH; SURFACE)
+ */
+export function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview"): string {
+	const version = process.env.PI_AI_GEMINI_CLI_VERSION || "0.46.0";
+	const platform = process.platform === "win32" ? "win32" : process.platform;
+	const arch = process.arch === "x64" ? "x64" : process.arch;
+	return `GeminiCLI/${version}/${modelId} (${platform}; ${arch}; terminal)`;
+}
+
+export const getGeminiCliHeaders = (modelId?: string) => ({
+	"User-Agent": getGeminiCliUserAgent(modelId),
+	"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.
+ */
+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;
+};
+
+/**
+ * Per-wire-id Antigravity Cloud Code Assist request constants, captured from the
+ * real `antigravity/hub` client against `daily-cloudcode-pa`. `modelEnum` is the
+ * opaque `labels.model_enum` token the client tags each request with — optional
+ * because Anthropic-backed wire ids (e.g. `claude-sonnet-4-6`,
+ * `claude-opus-4-6-thinking`) are accepted without one; the label is purely
+ * telemetry. `maxOutputTokens` is the fixed `generationConfig.maxOutputTokens`
+ * the backend enforces regardless of the thinking budget (Claude caps at
+ * 64000, Gemini accepts the discovered cap). Keyed by the routed upstream wire
+ * id (post effort-routing), not the collapsed logical id. Checkpoint-only ids
+ * (e.g. `gemini-3.1-flash-lite`) are intentionally absent — this provider only
+ * emits agent requests.
+ */
+export interface AntigravityModelWireProfile {
+	modelEnum?: string;
+	maxOutputTokens: number;
+}
+export const ANTIGRAVITY_MODEL_WIRE_PROFILES: Readonly<Record<string, AntigravityModelWireProfile>> = {
+	"gemini-3.5-flash-extra-low": { modelEnum: "MODEL_PLACEHOLDER_M187", maxOutputTokens: 65536 },
+	"gemini-3.5-flash-low": { modelEnum: "MODEL_PLACEHOLDER_M20", maxOutputTokens: 65536 },
+	"gemini-3-flash-agent": { modelEnum: "MODEL_PLACEHOLDER_M132", maxOutputTokens: 65536 },
+	"gemini-3.1-pro-low": { modelEnum: "MODEL_PLACEHOLDER_M36", maxOutputTokens: 65535 },
+	"gemini-pro-agent": { modelEnum: "MODEL_PLACEHOLDER_M16", maxOutputTokens: 65535 },
+	// Claude on `daily-cloudcode-pa` rejects `maxOutputTokens > 64000` with a
+	// 400 (`Request contains an invalid argument`). The model_enum label is
+	// untracked for these ids; the backend does not require it.
+	"claude-sonnet-4-6": { maxOutputTokens: 64000 },
+	"claude-opus-4-6-thinking": { maxOutputTokens: 64000 },
+};
+export function getAntigravityModelWireProfile(wireModelId: string): AntigravityModelWireProfile | undefined {
+	return ANTIGRAVITY_MODEL_WIRE_PROFILES[wireModelId];
+}

package/src/wire/github-copilot.ts

@@ -0,0 +1,115 @@
+/**
+ * GitHub Copilot wire metadata: API-key envelope parsing and endpoint
+ * derivation shared by catalog discovery and the pi-ai OAuth flow. The device
+ * login / token refresh flow lives in `@linxiraos/pi-ai`'s registry.
+ */
+
+export const COPILOT_USER_AGENT = "opencode/1.3.15" as const;
+
+export const OPENCODE_HEADERS = {
+	"User-Agent": COPILOT_USER_AGENT,
+} as const;
+
+/**
+ * Copilot API version sent on `api.githubcopilot.com` requests (`/models`,
+ * chat endpoints). Newer versions unlock tiered context metadata: `/models`
+ * reports the full long-context window in `capabilities.limits` plus per-tier
+ * boundaries/prices under `billing.token_prices.{default,long_context}`.
+ * Without it the endpoint serves default-tier limits only (e.g. 264k instead
+ * of 1M for Claude Opus). Never send this to `api.github.com` REST endpoints —
+ * they validate `X-GitHub-Api-Version` against the REST version vocabulary.
+ */
+export const COPILOT_API_VERSION = "2026-06-01" as const;
+
+/** Headers for `api.githubcopilot.com` (capi) requests: discovery, chat, policy. */
+export const COPILOT_API_HEADERS = {
+	...OPENCODE_HEADERS,
+	"X-GitHub-Api-Version": COPILOT_API_VERSION,
+} as const;
+
+type GitHubCopilotApiKeyPayload = {
+	token?: unknown;
+	enterpriseUrl?: unknown;
+	apiEndpoint?: unknown;
+};
+
+export type ParsedGitHubCopilotApiKey = {
+	accessToken: string;
+	enterpriseUrl?: string;
+	apiEndpoint?: string;
+};
+
+const PUBLIC_GITHUB_HOSTS = new Set(["api.github.com", "github.com", "www.github.com"]);
+
+export function isPublicGitHubHost(host: string): boolean {
+	return PUBLIC_GITHUB_HOSTS.has(host.trim().toLowerCase());
+}
+
+/** Canonical personal-Copilot API host. */
+export const PERSONAL_GITHUB_COPILOT_BASE_URL = "https://api.githubcopilot.com" as const;
+
+/** `true` when the resolved base URL is the canonical personal-Copilot host. */
+export function isPersonalGitHubCopilotBaseUrl(baseUrl: string | undefined): boolean {
+	return baseUrl === PERSONAL_GITHUB_COPILOT_BASE_URL;
+}
+
+export function normalizeGitHubCopilotEnterpriseDomain(input: string | undefined): string | undefined {
+	const trimmed = input?.trim();
+	if (!trimmed) return undefined;
+	const normalized = normalizeDomain(trimmed) ?? trimmed.toLowerCase();
+	if (!normalized || isPublicGitHubHost(normalized)) return undefined;
+	return normalized;
+}
+
+export function normalizeGitHubCopilotApiEndpoint(input: string | undefined): string | undefined {
+	const trimmed = input?.trim();
+	if (!trimmed?.startsWith("https://")) return undefined;
+	try {
+		const url = new URL(trimmed);
+		if (url.protocol !== "https:" || !url.hostname) return undefined;
+		return trimmed.replace(/\/+$/, "");
+	} catch {
+		return undefined;
+	}
+}
+
+export function parseGitHubCopilotApiKey(apiKeyRaw: string): ParsedGitHubCopilotApiKey {
+	try {
+		const parsed = JSON.parse(apiKeyRaw) as GitHubCopilotApiKeyPayload;
+		if (typeof parsed.token === "string") {
+			return {
+				accessToken: parsed.token,
+				enterpriseUrl:
+					typeof parsed.enterpriseUrl === "string"
+						? normalizeGitHubCopilotEnterpriseDomain(parsed.enterpriseUrl)
+						: undefined,
+				apiEndpoint:
+					typeof parsed.apiEndpoint === "string"
+						? normalizeGitHubCopilotApiEndpoint(parsed.apiEndpoint)
+						: undefined,
+			};
+		}
+	} catch {}
+
+	return { accessToken: apiKeyRaw };
+}
+
+export function normalizeDomain(input: string): string | null {
+	const trimmed = input.trim();
+	if (!trimmed) return null;
+	try {
+		const url = trimmed.includes("://") ? new URL(trimmed) : new URL(`https://${trimmed}`);
+		return url.hostname;
+	} catch {
+		return null;
+	}
+}
+
+export function getGitHubCopilotBaseUrl(enterpriseDomain?: string): string {
+	const normalizedEnterpriseDomain = normalizeGitHubCopilotEnterpriseDomain(enterpriseDomain);
+	if (!normalizedEnterpriseDomain) return "https://api.githubcopilot.com";
+	const host = normalizedEnterpriseDomain.startsWith("copilot-api.")
+		? normalizedEnterpriseDomain
+		: `copilot-api.${normalizedEnterpriseDomain}`;
+	return `https://${host}`;
+}