jeopi-catalog 16.2.13

package/dist/types/utils.d.ts

@@ -0,0 +1,20 @@
+import { type FetchImpl } from "jeopi-utils";
+export { isRecord } from "jeopi-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";
+import type { Api, Model, ModelSpec, Provider, ThinkingConfig } from "./types";
+/**
+ * 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` (daily-cloudcode-pa): Gemini 3.x on the budget transport. */
+export declare const ANTIGRAVITY_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+/** `google-gemini-cli` (cloudcode-pa): Gemini 3.x on the level transport (official CLI parity). */
+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/codex.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Constants for OpenAI Codex (ChatGPT OAuth) backend
+ */
+export declare const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+export declare const OPENAI_HEADERS: {
+    readonly BETA: "OpenAI-Beta";
+    readonly ACCOUNT_ID: "chatgpt-account-id";
+    readonly ORIGINATOR: "originator";
+    readonly SESSION_ID: "session_id";
+    readonly CONVERSATION_ID: "conversation_id";
+};
+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,45 @@
+/**
+ * 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 `jeopi-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. The business
+ * (`api.business.githubcopilot.com`) and enterprise (`copilot-api.{domain}`)
+ * endpoints respond with HTTP 400 "vision is not supported" on image inputs,
+ * so catalog discovery and capability gates MUST honour the upstream's
+ * `supports.vision` flag only for this exact base URL.
+ */
+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": "jeopi-catalog",
+	"version": "16.2.13",
+	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
+	"homepage": "https://github.com/akillness/jeopi",
+	"author": "Can Boluk",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/akillness/jeopi.git",
+		"directory": "packages/catalog"
+	},
+	"bugs": {
+		"url": "https://github.com/akillness/jeopi/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"
+	},
+	"dependencies": {
+		"@bufbuild/protobuf": "^2.12.0",
+		"jeopi-utils": "16.2.13",
+		"arktype": "^2.2.0",
+		"zod": "^4"
+	},
+	"devDependencies": {
+		"jeopi-ai": "16.2.13",
+		"@types/bun": "^1.3.14"
+	},
+	"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,47 @@
+/**
+ * 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 { 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";
+
+export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi> {
+	const compat = buildCompat(spec) as CompatOf<TApi>;
+	return {
+		...spec,
+		name: cleanModelName(spec.name),
+		thinking: resolveModelThinking(spec, compat),
+		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 "devin-agent":
+			return buildDevinCompat(spec as ModelSpec<"devin-agent">);
+		default:
+			return undefined;
+	}
+}

package/src/compat/anthropic.ts

@@ -0,0 +1,93 @@
+/**
+ * Anthropic-messages compat builder — the anthropic-side analogue of
+ * `./openai`. Runs exactly once per model (from `buildModel`); detect-time
+ * defaults come from provider ids, strict host checks, and model-id
+ * classification, with explicit spec overrides assigned on top.
+ */
+import { modelMatchesHost } from "../hosts";
+import {
+	hasOpus47ApiRestrictions,
+	isAnthropicFableOrMythosModel,
+	supportsMidConversationSystemMessages,
+} from "../identity/family";
+import type { ModelSpec, ResolvedAnthropicCompat } from "../types";
+import { applyCompatOverrides } from "./apply";
+
+const OFFICIAL_ANTHROPIC_URL = "https://api.anthropic.com";
+
+/**
+ * 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 function isOfficialAnthropicApiUrl(baseUrl?: string): boolean {
+	if (!baseUrl) return true;
+	const lower = baseUrl.toLowerCase();
+	return lower === OFFICIAL_ANTHROPIC_URL || lower.startsWith(`${OFFICIAL_ANTHROPIC_URL}/`);
+}
+
+/** Mirrors `compat/openai.ts`; native-only host gating is the caller's responsibility. */
+const KIMI_K27_CODE_MODEL_PATTERN = /(?:^|\/)kimi[-._]?k2(?:[._-]?|p)7[-._]?code(?:[-._]?highspeed)?$/i;
+
+function matchesKimiK27CodeFamily(spec: ModelSpec<"anthropic-messages">): boolean {
+	if (KIMI_K27_CODE_MODEL_PATTERN.test(spec.id)) return true;
+	return spec.id === "kimi-for-coding" && /k2\.?7 code/i.test(spec.name ?? "");
+}
+
+/** Build the resolved anthropic-messages compat record for a model spec. */
+export function buildAnthropicCompat(spec: ModelSpec<"anthropic-messages">): ResolvedAnthropicCompat {
+	const baseUrl = spec.baseUrl;
+	const official = isOfficialAnthropicApiUrl(baseUrl);
+	// Z.AI's Anthropic-compatible proxy lives at `api.z.ai/api/anthropic`.
+	const isZai = modelMatchesHost(spec, "zai");
+	// GitHub Copilot's Anthropic-compatible proxy (api.githubcopilot.com/v1/messages)
+	// rejects the per-tool `eager_input_streaming` field with
+	// `tools.0.custom.eager_input_streaming: Extra inputs are not permitted` and
+	// doesn't whitelist the `fine-grained-tool-streaming-2025-05-14` beta either
+	// (issue #2558), so eager tool-input streaming is unavailable on this host.
+	const isCopilot = modelMatchesHost(spec, "githubCopilot");
+	const requiresThinkingEnabled = modelMatchesHost(spec, "moonshotNative") && matchesKimiK27CodeFamily(spec);
+	const compat: ResolvedAnthropicCompat = {
+		officialEndpoint: official,
+		disableStrictTools: false,
+		disableAdaptiveThinking: false,
+		supportsEagerToolInputStreaming: !isCopilot,
+		// Long cache retention is only sent to the official API by default;
+		// proxies opt in explicitly via `compat.supportsLongCacheRetention: true`.
+		supportsLongCacheRetention: official,
+		// First-party Claude API only. Bedrock/Vertex/Foundry and other
+		// Anthropic-compatible gateways reject mid-conversation system roles, so
+		// detection requires the canonical api.anthropic.com host plus a
+		// supported model id.
+		supportsMidConversationSystem: official && supportsMidConversationSystemMessages(spec.id),
+		supportsForcedToolChoice: !requiresThinkingEnabled && !isAnthropicFableOrMythosModel(spec.id),
+		// Opus 4.7+ and Fable/Mythos reject temperature/top_p/top_k with a 400.
+		supportsSamplingParams: !hasOpus47ApiRestrictions(spec.id),
+		// Z.AI workaround (issue #814): its proxy deserializes tool_result blocks
+		// into a class that reads `.id`.
+		requiresToolResultId: isZai,
+		requiresThinkingEnabled,
+		// Official Anthropic enforces signature-based thinking-chain integrity, so
+		// unsigned thinking blocks must stay text there. Anthropic-compatible
+		// reasoning endpoints commonly emit unsigned thinking blocks while still
+		// expecting them back as `type: "thinking"` on continuation; demoting them
+		// loses the reasoning chain and can destabilize the next tool-call
+		// arguments (#2005). Known non-signing hosts (Z.AI, DeepSeek) are also
+		// preserved for compatibility.
+		//
+		// GitHub Copilot's `anthropic-messages` proxy is excluded: it forwards to
+		// signature-enforcing Anthropic and returns full thinking signatures, so it
+		// is a SIGNING endpoint. Replaying a stripped/unsigned thinking block as
+		// `signature: ""` there 400s the whole request ("Invalid signature") — most
+		// visibly when a checkpoint/branch-return turn's end_turn-bound signature is
+		// stripped on replay (issue #2851). Treating it like official Anthropic
+		// degrades such blocks to text instead, which the API accepts.
+		replayUnsignedThinking:
+			!isCopilot && (isZai || modelMatchesHost(spec, "deepseekFamily") || (spec.reasoning && !official)),
+		escapeBuiltinToolNames: modelMatchesHost(spec, "umans"),
+	};
+	applyCompatOverrides(compat, spec.compat);
+	return compat;
+}

package/src/compat/apply.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 function applyCompatOverrides(compat: object, overrides: object | undefined): void {
+	if (!overrides) return;
+	for (const key in overrides) {
+		const value = (overrides as Record<string, unknown>)[key];
+		if (value !== undefined && key in compat) {
+			(compat as Record<string, unknown>)[key] = value;
+		}
+	}
+}

package/src/compat/devin.ts

@@ -0,0 +1,12 @@
+import type { ModelSpec, ResolvedDevinCompat } from "../types";
+
+/**
+ * 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 function buildDevinCompat(_spec: ModelSpec<"devin-agent">): ResolvedDevinCompat {
+	return { trustExplicitThinkingOnly: true };
+}