@linxiraos/pi-catalog 1.0.0

package/dist/types/utils.d.ts

@@ -0,0 +1,20 @@
+import { type FetchImpl } from "@linxiraos/pi-utils";
+export { isRecord } from "@linxiraos/pi-utils";
+/**
+ * Fetch implementation for catalog discovery probes: the caller's override
+ * when given, otherwise global fetch wrapped for `NODE_EXTRA_CA_CERTS`.
+ */
+export declare function discoveryFetch(override?: FetchImpl): FetchImpl;
+export declare function toNumber(value: unknown): number | undefined;
+export declare function toPositiveNumber(value: unknown, fallback: number): number;
+export declare function toPositiveNumber(value: unknown, fallback: number | null): number | null;
+/** Positive finite number, or `null` when the value is missing/non-positive. */
+export declare function toPositiveNumberOrNull(value: unknown): number | null;
+export declare function toBoolean(value: unknown): boolean | undefined;
+export declare function isAnthropicOAuthToken(key: string): boolean;
+/**
+ * Normalize a model display name: drop the gateway author prefix and
+ * model-extrinsic decorations. Returns the input verbatim when nothing
+ * matches (or when stripping would leave an empty name).
+ */
+export declare function cleanModelName(name: string): string;

package/dist/types/variant-collapse.d.ts

@@ -0,0 +1,133 @@
+import { Effort } from "./effort.js";
+import type { Api, Model, ModelSpec, Provider, ThinkingConfig } from "./types.js";
+/**
+ * Structural bound for collapse inputs: both raw `ModelSpec`s and built
+ * `Model`s qualify. (`Model.compat` is the resolved record, not the sparse
+ * config, so the two are not mutually assignable — collapsing never touches
+ * `compat`.)
+ */
+export type VariantSpecLike = Omit<ModelSpec<Api>, "compat"> & {
+    compat?: unknown;
+};
+/** One collapsed family: logical id + member wire ids + per-effort routing. */
+export interface EffortVariantFamily {
+    /** Collapsed logical id (may equal a member id — e.g. bare/thinking pairs). */
+    id: string;
+    /** Final display name, no tier marker. */
+    name: string;
+    /**
+     * Member wire ids in priority order. The first member present in the input
+     * becomes the collapsed spec's default wire id (`requestModelId`; omitted
+     * when it equals the logical id).
+     */
+    members: readonly string[];
+    /**
+     * Wire ids upstream no longer serves (e.g. a deployment killed while
+     * discovery still advertises it). Fresh collapsing never routes to them,
+     * and stale collapsed snapshots (bundled catalog, cache rows,
+     * previous-generation fallbacks) get routing/`requestModelId` entries that
+     * target them re-pointed through `routing`. Keep retired ids in `members`
+     * so the raw upstream spec is still consumed and aliased.
+     */
+    retiredMembers?: readonly string[];
+    /**
+     * Per-effort upstream wire id; `"off"` applies when thinking is disabled.
+     * Entries whose target member is absent from the input are dropped — those
+     * efforts fall back to `requestModelId ?? id`.
+     */
+    routing: Readonly<Partial<Record<Effort | "off", string>>>;
+    /** Explicit capability surface for the collapsed spec — no inference. */
+    thinking: Readonly<Omit<ThinkingConfig, "effortRouting" | "suppressWhenOff">>;
+    /** Thinking-off requests must explicitly suppress thinking on the wire. */
+    suppressWhenOff?: boolean;
+    /**
+     * Preserve non-off effort routes even when discovery omits the backing member.
+     * Used for Cloud Code Assist `X`/`X-thinking` pairs where upstream accepts
+     * the `-thinking` wire id but the model-list endpoint may advertise only the
+     * bare id.
+     */
+    preserveAbsentEffortRoutes?: boolean;
+    /** Retired/recycled selector ids that alias to this family without being members. */
+    extraAliases?: readonly string[];
+}
+export interface VariantCollapseTable {
+    families: readonly EffortVariantFamily[];
+}
+/** `google-antigravity` Gemini families, using each generation's native transport. */
+export declare const ANTIGRAVITY_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+/** `google-gemini-cli` Gemini families on the official CLI's level transport. */
+export declare const GEMINI_CLI_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+export declare const DEVIN_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+/** Provider id → hand collapse table. The CCA providers diverge on thinking transport. */
+export declare const VARIANT_COLLAPSE_TABLES: Readonly<Record<string, VariantCollapseTable>>;
+/**
+ * The global automatic rule: derive an `X` + `X-thinking` family for every
+ * pair where both ids are live in `specs` (trailing or infix token). Gates:
+ * - both members share the same `api`,
+ * - known pricing must match — all-zero cost rows count as unknown
+ *   (aggregators routinely ship them), but twins that BOTH carry real,
+ *   differing prices are distinct SKUs and never merge,
+ * - ids claimed by the provider's hand `table` are skipped (curation wins).
+ * The capability surface prefers the thinking member's metadata, then the
+ * bare member's, then the canonical deriver (aggregators often ship
+ * `reasoning: false` and no thinking config on the twin), then a budget
+ * default. `off` routes to the bare id; every supported effort routes to the
+ * thinking id.
+ */
+export declare function deriveThinkingPairFamilies<TSpec extends VariantSpecLike>(specs: readonly TSpec[], table?: VariantCollapseTable): EffortVariantFamily[];
+/**
+ * True when `spec` is the output of collapsing rather than a raw upstream
+ * member. `thinking.effortRouting` is written only by collapsing; the
+ * `requestModelId` arm is scoped to the provider's hand-table family ids so
+ * unrelated carriers (GitHub Copilot `-1m` context variants) never match.
+ */
+export declare function isVariantCollapsedSpec(spec: VariantSpecLike): boolean;
+/**
+ * Collapse every family in `table` found in `specs`. Non-member specs pass
+ * through verbatim (by reference), order preserved; the collapsed spec
+ * replaces the first occurrence of its family.
+ */
+export declare function collapseEffortVariants<TSpec extends VariantSpecLike>(specs: readonly TSpec[], table: VariantCollapseTable): TSpec[];
+/**
+ * Collapse a full mixed-provider list: per provider, the hand table (when
+ * registered) plus the automatic `X`/`X-thinking` pair rule. Used by the
+ * catalog generator; the runtime equivalent lives at the model-manager merge
+ * point. Output is regrouped by provider — callers re-sort.
+ */
+export declare function collapseEffortVariantsAcrossProviders<TSpec extends VariantSpecLike>(specs: readonly TSpec[]): TSpec[];
+/**
+ * Runtime entry point for already-built `Model` lists (the model-manager
+ * merge point, coding-agent registry custom providers): collapses hand
+ * tables plus derived pairs, then re-runs `buildModel` on freshly created
+ * logical specs so thinking wire defaults stay resolved. Untouched entries
+ * pass through by reference.
+ */
+export declare function collapseBuiltModelVariants<TApi extends Api>(models: readonly Model<TApi>[]): Model<TApi>[];
+/**
+ * Resolve a retired effort-tier variant id (collapsed member, recycled id) to
+ * its replacement model id for `provider` via the hand table. Returns
+ * `undefined` when the id is not a known alias; derived `X-thinking` members
+ * resolve through `stripThinkingVariantToken` instead. Callers must try an
+ * exact model lookup first — a live model always wins over an alias.
+ */
+export declare function resolveVariantAlias(provider: Provider, modelId: string): string | undefined;
+/** Bare-id alias hit: replacement id plus the providers declaring it. */
+export interface BareVariantAliasHit {
+    id: string;
+    /** Providers whose table declares the alias — candidates from these win ties. */
+    providers: readonly Provider[];
+}
+/**
+ * Provider-agnostic hand-table alias lookup for bare-id selectors. Returns
+ * the declaring providers so callers can prefer their models when the
+ * replacement id exists on unrelated providers too (e.g. a retired Cursor
+ * tier id must not resolve to `openai/gpt-5.4`).
+ */
+export declare function resolveBareVariantAlias(modelId: string): BareVariantAliasHit | undefined;
+/**
+ * Reverse alias lookup: the retired ids that resolve to `modelId` for
+ * `provider` via the hand table. Used to re-key config keyed by raw member
+ * ids (models.yml `modelOverrides`, suppressed selectors) onto the collapsed
+ * model. Empty for providers without a table.
+ */
+export declare function getVariantAliasSources(provider: Provider, modelId: string): readonly string[];

package/dist/types/wire/alibaba-token-plan.d.ts

@@ -0,0 +1,22 @@
+/**
+ * International (Singapore) Token Plan endpoint. Default region; keys issued by
+ * the international product authenticate only here.
+ */
+export declare 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 declare 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;
+}
+export declare function parseAlibabaTokenPlanCredential(value: string): AlibabaTokenPlanCredential | null;
+export declare function serializeAlibabaTokenPlanCredential(token: string, cookie: string, baseUrl?: string): string;

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

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

package/dist/types/wire/coreweave.d.ts

@@ -0,0 +1,12 @@
+export declare const COREWEAVE_PROJECT_HEADER: "OpenAI-Project";
+export interface CoreWeaveProjectEnv {
+    [key: string]: string | undefined;
+    COREWEAVE_PROJECT?: string;
+    WANDB_INFERENCE_PROJECT?: string;
+    WANDB_ENTITY?: string;
+    WANDB_PROJECT?: string;
+}
+export declare function resolveCoreWeaveProject(env: CoreWeaveProjectEnv): string | undefined;
+export declare function coreWeaveProjectHeaders(env: CoreWeaveProjectEnv): Record<string, string> | undefined;
+export declare function hasCoreWeaveProjectHeader(headers: Record<string, string>): boolean;
+export declare function removeBlankCoreWeaveProjectHeaders(headers: Record<string, string>): void;

package/dist/types/wire/gemini-headers.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 declare function getGeminiCliUserAgent(modelId?: string): string;
+export declare const getGeminiCliHeaders: (modelId?: string) => {
+    "User-Agent": string;
+    "Client-Metadata": string;
+};
+export declare const ANTIGRAVITY_SYSTEM_INSTRUCTION: string;
+/**
+ * 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 declare let getAntigravityUserAgent: () => string;
+/**
+ * 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 declare const ANTIGRAVITY_MODEL_WIRE_PROFILES: Readonly<Record<string, AntigravityModelWireProfile>>;
+export declare function getAntigravityModelWireProfile(wireModelId: string): AntigravityModelWireProfile | undefined;

package/dist/types/wire/github-copilot.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 declare const COPILOT_USER_AGENT: "opencode/1.3.15";
+export declare const OPENCODE_HEADERS: {
+    readonly "User-Agent": "opencode/1.3.15";
+};
+/**
+ * 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 declare const COPILOT_API_VERSION: "2026-06-01";
+/** Headers for `api.githubcopilot.com` (capi) requests: discovery, chat, policy. */
+export declare const COPILOT_API_HEADERS: {
+    readonly "User-Agent": "opencode/1.3.15";
+    readonly "X-GitHub-Api-Version": "2026-06-01";
+};
+export type ParsedGitHubCopilotApiKey = {
+    accessToken: string;
+    enterpriseUrl?: string;
+    apiEndpoint?: string;
+};
+export declare function isPublicGitHubHost(host: string): boolean;
+/** Canonical personal-Copilot API host. */
+export declare const PERSONAL_GITHUB_COPILOT_BASE_URL: "https://api.githubcopilot.com";
+/** `true` when the resolved base URL is the canonical personal-Copilot host. */
+export declare function isPersonalGitHubCopilotBaseUrl(baseUrl: string | undefined): boolean;
+export declare function normalizeGitHubCopilotEnterpriseDomain(input: string | undefined): string | undefined;
+export declare function normalizeGitHubCopilotApiEndpoint(input: string | undefined): string | undefined;
+export declare function parseGitHubCopilotApiKey(apiKeyRaw: string): ParsedGitHubCopilotApiKey;
+export declare function normalizeDomain(input: string): string | null;
+export declare function getGitHubCopilotBaseUrl(enterpriseDomain?: string): string;

package/package.json

@@ -0,0 +1,101 @@
+{
+	"type": "module",
+	"name": "@linxiraos/pi-catalog",
+	"version": "1.0.0",
+	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
+	"homepage": "https://linxira-os.github.io",
+	"author": "Can Boluk",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Linxira-OS/linxira-zeta.git",
+		"directory": "packages/catalog"
+	},
+	"bugs": {
+		"url": "https://github.com/can1357/oh-my-pi/issues"
+	},
+	"keywords": [
+		"ai",
+		"llm",
+		"models",
+		"catalog",
+		"discovery"
+	],
+	"main": "./src/index.ts",
+	"types": "./dist/types/index.d.ts",
+	"scripts": {
+		"check": "biome check . && bun run check:types",
+		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"lint": "biome lint .",
+		"test": "bun test --parallel",
+		"fix": "biome check --write --unsafe .",
+		"fmt": "biome format --write .",
+		"gen:models": "bun scripts/generate-models.ts",
+		"gen:cursor-proto": "protoc --plugin=protoc-gen-es=../../node_modules/.bin/protoc-gen-es --es_out=src/discovery/cursor-gen --es_opt=target=ts -I ../ai/src/providers/cursor/proto ../ai/src/providers/cursor/proto/agent.proto"
+	},
+	"dependencies": {
+		"@bufbuild/protobuf": "^2.12.1",
+		"@linxiraos/pi-omptype": "1.0.0",
+		"@linxiraos/pi-utils": "1.0.0"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.3.14",
+		"@linxiraos/pi-ai": "1.0.0"
+	},
+	"engines": {
+		"bun": ">=1.3.14"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"CHANGELOG.md",
+		"dist/types"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/types/index.d.ts",
+			"import": "./src/index.ts"
+		},
+		"./models.json": {
+			"types": "./dist/types/models.json.d.d.ts",
+			"import": "./src/models.json"
+		},
+		"./provider-models": {
+			"types": "./dist/types/provider-models/index.d.ts",
+			"import": "./src/provider-models/index.ts"
+		},
+		"./provider-models/*": {
+			"types": "./dist/types/provider-models/*.d.ts",
+			"import": "./src/provider-models/*.ts"
+		},
+		"./discovery": {
+			"types": "./dist/types/discovery/index.d.ts",
+			"import": "./src/discovery/index.ts"
+		},
+		"./discovery/*": {
+			"types": "./dist/types/discovery/*.d.ts",
+			"import": "./src/discovery/*.ts"
+		},
+		"./identity": {
+			"types": "./dist/types/identity/index.d.ts",
+			"import": "./src/identity/index.ts"
+		},
+		"./identity/*": {
+			"types": "./dist/types/identity/*.d.ts",
+			"import": "./src/identity/*.ts"
+		},
+		"./wire/*": {
+			"types": "./dist/types/wire/*.d.ts",
+			"import": "./src/wire/*.ts"
+		},
+		"./compat/*": {
+			"types": "./dist/types/compat/*.d.ts",
+			"import": "./src/compat/*.ts"
+		},
+		"./*": {
+			"types": "./dist/types/*.d.ts",
+			"import": "./src/*.ts"
+		},
+		"./*.js": "./src/*.ts"
+	}
+}

package/src/build.ts

@@ -0,0 +1,94 @@
+/**
+ * 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 { buildAnthropicCompat } from "./compat/anthropic";
+import { buildBedrockCompat } from "./compat/bedrock";
+import { buildDevinCompat } from "./compat/devin";
+import { buildOpenAICompat, buildOpenAIResponsesCompat, buildOpenRouterCompat } from "./compat/openai";
+import { resolveModelThinking } from "./model-thinking";
+import type { Api, CompatOf, Model, ModelSpec } from "./types";
+import { cleanModelName } from "./utils";
+
+const OPENAI_GA_COMPUTER_MODEL_RE = /^gpt-5\.(?:[4-9]|[1-9]\d)(?:[.-]|$)/i;
+
+function isDirectOpenAIResponsesEndpoint(spec: ModelSpec<Api>): boolean {
+	if (spec.api === "openai-responses") {
+		if (spec.provider !== "openai") return false;
+		if (!spec.baseUrl) return true;
+		try {
+			const url = new URL(spec.baseUrl);
+			return url.protocol === "https:" && url.hostname === "api.openai.com";
+		} catch {
+			return false;
+		}
+	}
+	if (spec.api !== "azure-openai-responses" || (spec.provider !== "azure" && spec.provider !== "azure-openai")) {
+		return false;
+	}
+	if (!spec.baseUrl) return true;
+	try {
+		const url = new URL(spec.baseUrl);
+		return (
+			url.protocol === "https:" &&
+			(url.hostname.endsWith(".openai.azure.com") || url.hostname === "models.inference.ai.azure.com")
+		);
+	} catch {
+		return false;
+	}
+}
+
+function explicitComputerUseConfig(spec: ModelSpec<Api>): boolean | undefined {
+	return "supportsComputerUseConfig" in spec
+		? (spec as Model<Api>).supportsComputerUseConfig
+		: spec.supportsComputerUse;
+}
+
+function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>, explicitSupport: boolean | undefined): boolean {
+	if (explicitSupport !== undefined) return explicitSupport;
+	if (!isDirectOpenAIResponsesEndpoint(spec)) return false;
+	return OPENAI_GA_COMPUTER_MODEL_RE.test(spec.requestModelId ?? spec.id);
+}
+
+export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi> {
+	const compat = buildCompat(spec) as CompatOf<TApi>;
+	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
+	return {
+		...spec,
+		name: cleanModelName(spec.name),
+		thinking: resolveModelThinking(spec, compat),
+		supportsComputerUse: supportsOpenAIGAComputerUse(spec, supportsComputerUseConfig),
+		supportsComputerUseConfig,
+		compat,
+		compatConfig: spec.compat,
+	} as Model<TApi>;
+}
+
+export function buildCompat(spec: ModelSpec<Api>): CompatOf<Api> {
+	switch (spec.api) {
+		case "openrouter":
+			return buildOpenRouterCompat(spec as ModelSpec<"openrouter">);
+		case "openai-completions":
+			return buildOpenAICompat(spec as ModelSpec<"openai-completions">);
+		case "openai-responses":
+		case "azure-openai-responses":
+		case "openai-codex-responses":
+			return buildOpenAIResponsesCompat(spec as ModelSpec<"openai-responses">);
+		case "anthropic-messages":
+			return buildAnthropicCompat(spec as ModelSpec<"anthropic-messages">);
+		case "bedrock-converse-stream":
+			return buildBedrockCompat(spec as ModelSpec<"bedrock-converse-stream">);
+		case "devin-agent":
+			return buildDevinCompat(spec as ModelSpec<"devin-agent">);
+		default:
+			return undefined;
+	}
+}