@linxiraos/pi-catalog 1.1.7 → 1.1.8

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

@@ -0,0 +1,36 @@
+/**
+ * Devin (Codeium Cascade) wire constants shared by catalog discovery, the pi-ai
+ * provider, and account usage. This module deliberately stays free of the
+ * generated protobuf runtime so the synchronous model seed can import it
+ * without pulling devin-gen into the boot path.
+ */
+/** Base host for Codeium/Windsurf's Cascade API (Connect protocol over HTTP/1.1). */
+export declare const DEVIN_DEFAULT_BASE_URL = "https://server.codeium.com";
+/** Session token as the wire format carries it: the scheme prefix is required. */
+export declare function normalizeDevinSessionToken(apiKey: string | undefined): string;
+/**
+ * Fields for `Metadata` on released-CLI calls (`GetUserJwt`, `AssignModel`,
+ * `GetChatMessage`, `GetUserStatus`). `userJwt` stays empty for the calls the
+ * CLI makes with the session token alone (auth, model assignment, usage).
+ */
+export declare function devinCliMetadata(apiKey: string | undefined, userJwt?: string): {
+    ideName: "devin-cli";
+    ideType: "chisel";
+    ideVersion: "3000.6.2";
+    extensionName: "chisel";
+    extensionVersion: "3000.6.2";
+    locale: "en";
+    os: "darwin" | "linux" | "windows";
+    apiKey: string;
+    userJwt: string;
+};
+/** Fields for `Metadata` on the dev-channel `GetCliModelConfigs` call. */
+export declare function devinDiscoveryMetadata(apiKey: string | undefined): {
+    ideName: "chisel";
+    ideVersion: "0.0.0-dev";
+    extensionName: "chisel";
+    extensionVersion: "0.0.0-dev";
+    locale: "en";
+    os: "darwin" | "linux" | "windows";
+    apiKey: string;
+};

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

@@ -1,12 +1,15 @@
 import type { FetchImpl } from "../types.js";
-/**
- * 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";
+/** Headers sent by Copilot CLI to GitHub API and OAuth endpoints. */
+export declare const COPILOT_GITHUB_HEADERS: {
+    readonly "User-Agent": "copilot/1.0.82";
+};
+/** Copilot CLI identity sent to the Copilot API. */
+export declare const COPILOT_CAPI_IDENTITY_HEADERS: {
+    readonly "User-Agent": "copilot/1.0.82";
+    readonly "Editor-Version": "copilot/1.0.82";
+    readonly "Copilot-Integration-Id": "copilot-developer-cli";
+    readonly "Copilot-Harness-Id": "copilot-sdk";
+    readonly "Openai-Intent": "conversation-agent";
 };
 /**
  * Copilot API version sent on `api.githubcopilot.com` requests (`/models`,
@@ -17,12 +20,28 @@ export declare const OPENCODE_HEADERS: {
  * 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_VERSION: "2026-08-01";
+/** Headers shared by Copilot API model requests and model definitions. */
 export declare const COPILOT_API_HEADERS: {
-    readonly "User-Agent": "opencode/1.3.15";
-    readonly "X-GitHub-Api-Version": "2026-06-01";
+    readonly "User-Agent": "copilot/1.0.82";
+    readonly "Editor-Version": "copilot/1.0.82";
+    readonly "Copilot-Integration-Id": "copilot-developer-cli";
+    readonly "Copilot-Harness-Id": "copilot-sdk";
+    readonly "Openai-Intent": "conversation-agent";
+    readonly "X-GitHub-Api-Version": "2026-08-01";
+};
+/** Copilot CLI headers for user-initiated model discovery. */
+export declare const COPILOT_DISCOVERY_HEADERS: {
+    readonly "User-Agent": "copilot/1.0.82";
+    readonly "Editor-Version": "copilot/1.0.82";
+    readonly "Copilot-Integration-Id": "copilot-developer-cli";
+    readonly "Copilot-Harness-Id": "copilot-sdk";
+    readonly "Openai-Intent": "conversation-agent";
+    readonly "X-GitHub-Api-Version": "2026-08-01";
+    readonly "X-Initiator": "user";
 };
+/** Preserve model-specific headers while enforcing the current Copilot API identity. */
+export declare function mergeCopilotApiHeaders(headers?: Readonly<Record<string, string>>): Record<string, string>;
 export type ParsedGitHubCopilotApiKey = {
     accessToken: string;
     enterpriseUrl?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@linxiraos/pi-catalog",
-	"version": "1.1.7",
+	"version": "1.1.8",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://linxira-os.github.io/zeta/",
 	"author": "Can Boluk",
@@ -31,14 +31,16 @@
 		"fix": "biome check --write --unsafe .",
 		"fmt": "biome format --write .",
 		"gen:models": "bun scripts/generate-models.ts",
+		"gen:compat": "bun scripts/compile-compat.ts",
 		"gen:proto": "bun scripts/generate-protocols.ts"
 	},
 	"dependencies": {
-		"@linxiraos/pi-omptype": "1.1.7",
-		"@linxiraos/pi-utils": "1.1.7"
+		"@linxiraos/pi-omptype": "1.1.8",
+		"@linxiraos/pi-utils": "1.1.8"
 	},
 	"devDependencies": {
-		"@linxiraos/pi-ai": "1.1.7",
+		"@bgotink/kdl": "0.4.0",
+		"@linxiraos/pi-ai": "1.1.8",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/build.ts

@@ -1,26 +1,149 @@
 /**
- * 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);
+ * The single Model constructor. Resolution runs through the compat engine
+ * (`compat/resolve`): identity classification, cascade-rule axes, host
+ * detection, and spec overrides materialize exactly once per spec.
  *
  * 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 { bareModelId, parseOpenAIModel, semverGte } from "./identity/classify";
-import { isClaudeModelId } from "./identity/family";
-import { resolveModelThinking } from "./model-thinking";
+import { resolveModelPolicy } from "./compat/resolve";
+import type { ModelIdentity } from "./compat/types";
 import { resolveModelTokenizer } from "./model-tokenizer";
-import type { Api, CompatOf, Model, ModelSpec } from "./types";
+import type { Api, Model, ModelSpec } from "./types";
 import { cleanModelName } from "./utils";
 
+function numberField(source: object, key: string): number | undefined {
+	const value: unknown = Reflect.get(source, key);
+	return typeof value === "number" ? value : undefined;
+}
+
+/** Narrow an unknown compiled-axis payload to an object payload. */
+function objectPayload(value: unknown): object | undefined {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+
+/** Narrow a compiled `input-modalities` axis value to the model input union. */
+function isInputModalities(value: unknown): value is ("text" | "image")[] {
+	return Array.isArray(value) && value.every(entry => entry === "text" || entry === "image");
+}
+
+/**
+ * Applies resolved catalog-data axes onto the model: reviewed metadata
+ * corrections (`cost-patch`, `limits-patch`, `long-context-cost`,
+ * `context-window-floor`) overwrite upstream values; selection metadata
+ * (`priority`, `apply-patch-tool-type`, `service-tier-cost`,
+ * `requires-cursor-tool-schema-projection`) is rule-owned;
+ * `context-promotion-target` fills only when the spec left it unset.
+ */
+function applyCatalogAssignments<TApi extends Api>(model: Model<TApi>, catalog: Record<string, unknown>): void {
+	const serviceTierCost = objectPayload(catalog.serviceTierCost);
+	if (serviceTierCost !== undefined) {
+		const flex = numberField(serviceTierCost, "flex");
+		const priorityTier = numberField(serviceTierCost, "priority");
+		model.serviceTierCost = {
+			...(flex !== undefined && { flex }),
+			...(priorityTier !== undefined && { priority: priorityTier }),
+		};
+	}
+	const priority = catalog.priority;
+	if (typeof priority === "number") model.priority = priority;
+	const applyPatchToolType = catalog.applyPatchToolType;
+	if (applyPatchToolType === "freeform" || applyPatchToolType === "function") {
+		model.applyPatchToolType = applyPatchToolType;
+	}
+	const requiresCursorToolSchemaProjection = catalog.requiresCursorToolSchemaProjection;
+	if (requiresCursorToolSchemaProjection === true) {
+		model.requiresCursorToolSchemaProjection = true;
+	} else {
+		delete model.requiresCursorToolSchemaProjection;
+	}
+	const contextPromotionTarget = catalog.contextPromotionTarget;
+	if (typeof contextPromotionTarget === "string" && model.contextPromotionTarget === undefined) {
+		model.contextPromotionTarget = contextPromotionTarget;
+	}
+}
+
+/**
+ * Applies reviewed catalog-data value corrections (`cost-patch`,
+ * `limits-patch`, `long-context-cost`, `context-window-floor`,
+ * `input-modalities`) onto an upstream-sourced spec. Applied by
+ * `buildModel` to every upstream-sourced spec; user-authored overrides are
+ * recomposed after building by the override applicators, so explicit user
+ * limits and pricing still win.
+ */
+export function applyCatalogCorrections(
+	model: Pick<ModelSpec<Api>, "cost" | "contextWindow" | "maxTokens" | "input">,
+	catalog: Record<string, unknown>,
+): void {
+	const longContext = objectPayload(catalog.longContext);
+	if (longContext !== undefined) {
+		const inputThreshold = numberField(longContext, "inputThreshold");
+		const inclusive = Reflect.get(longContext, "inputThresholdInclusive") === true;
+		const multiplier = numberField(longContext, "multiplier");
+		const input = numberField(longContext, "input");
+		const output = numberField(longContext, "output");
+		const cacheRead = numberField(longContext, "cacheRead");
+		const cacheWrite = numberField(longContext, "cacheWrite");
+		const base = model.cost;
+		const hasTokenPrice = base.input !== 0 || base.output !== 0 || base.cacheRead !== 0 || base.cacheWrite !== 0;
+		if (inputThreshold !== undefined && multiplier !== undefined && hasTokenPrice) {
+			// Multiplier form: tier rates derive from the row's live list price.
+			model.cost = {
+				...base,
+				longContext: {
+					inputThreshold,
+					...(inclusive && { inputThresholdInclusive: true }),
+					input: base.input * multiplier,
+					output: base.output * multiplier,
+					cacheRead: base.cacheRead * multiplier,
+					cacheWrite: base.cacheWrite * multiplier,
+				},
+			};
+		} else if (
+			inputThreshold !== undefined &&
+			input !== undefined &&
+			output !== undefined &&
+			cacheRead !== undefined &&
+			cacheWrite !== undefined
+		) {
+			model.cost = { ...model.cost, longContext: { inputThreshold, input, output, cacheRead, cacheWrite } };
+		}
+	}
+	const patch = objectPayload(catalog.costPatch);
+	if (patch !== undefined) {
+		model.cost = { ...model.cost };
+		const input = numberField(patch, "input");
+		if (input !== undefined) model.cost.input = input;
+		const output = numberField(patch, "output");
+		if (output !== undefined) model.cost.output = output;
+		const cacheRead = numberField(patch, "cacheRead");
+		if (cacheRead !== undefined) model.cost.cacheRead = cacheRead;
+		const cacheWrite = numberField(patch, "cacheWrite");
+		if (cacheWrite !== undefined) model.cost.cacheWrite = cacheWrite;
+	}
+	const limitsPatch = objectPayload(catalog.limitsPatch);
+	if (limitsPatch !== undefined) {
+		const contextWindow = numberField(limitsPatch, "contextWindow");
+		if (contextWindow !== undefined) model.contextWindow = contextWindow;
+		const maxTokens = numberField(limitsPatch, "maxTokens");
+		if (maxTokens !== undefined) model.maxTokens = maxTokens;
+	}
+	const contextWindowFloor = catalog.contextWindowFloor;
+	if (typeof contextWindowFloor === "number") {
+		model.contextWindow = Math.max(model.contextWindow ?? 0, contextWindowFloor);
+	}
+	const inputModalities = catalog.inputModalities;
+	if (isInputModalities(inputModalities)) {
+		model.input = inputModalities;
+	}
+}
+
+/**
+ * Direct first-party OpenAI Responses endpoints (api.openai.com, Azure OpenAI
+ * deployments). Gates GA computer-use detection; identity supplies the model
+ * generation.
+ */
 function isDirectOpenAIResponsesEndpoint(spec: ModelSpec<Api>): boolean {
 	if (spec.api === "openai-responses") {
 		if (spec.provider !== "openai") return false;
@@ -48,16 +171,27 @@ function isDirectOpenAIResponsesEndpoint(spec: ModelSpec<Api>): boolean {
 }
 
 function explicitComputerUseConfig(spec: ModelSpec<Api>): boolean | undefined {
-	return "supportsComputerUseConfig" in spec
-		? (spec as Model<Api>).supportsComputerUseConfig
-		: spec.supportsComputerUse;
+	if (!("supportsComputerUseConfig" in spec)) return spec.supportsComputerUse;
+	const value: unknown = Reflect.get(spec, "supportsComputerUseConfig");
+	return typeof value === "boolean" ? value : undefined;
+}
+
+function revisionAtLeast(identity: ModelIdentity, major: number, minor: number): boolean {
+	if (identity.revision === undefined) return false;
+	const [revMajor = 0, revMinor = 0] = identity.revision.split(".").map(Number);
+	return revMajor > major || (revMajor === major && revMinor >= minor);
 }
 
-function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>, explicitSupport: boolean | undefined): boolean {
+function supportsOpenAIGAComputerUse(
+	spec: ModelSpec<Api>,
+	identity: ModelIdentity,
+	explicitSupport: boolean | undefined,
+): boolean {
 	if (explicitSupport !== undefined) return explicitSupport;
 	if (!isDirectOpenAIResponsesEndpoint(spec)) return false;
-	const parsed = parseOpenAIModel(bareModelId(spec.requestModelId ?? spec.id));
-	return parsed !== null && semverGte(parsed.version, "5.4");
+	const wireIdentity =
+		spec.requestModelId === undefined ? identity : resolveModelPolicy({ ...spec, id: spec.requestModelId }).identity;
+	return wireIdentity.class === "openai" && revisionAtLeast(wireIdentity, 5, 4);
 }
 
 /**
@@ -66,38 +200,21 @@ function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>, explicitSupport: bool
  * this only runs for discovered/custom/override specs.
  */
 export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi> {
-	const compat = buildCompat(spec) as CompatOf<TApi>;
+	const policy = resolveModelPolicy(spec);
 	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
-	return {
+	const model: Model<TApi> = {
 		...spec,
 		name: cleanModelName(spec.name),
-		requiresGlyphTokenization: isClaudeModelId(spec.id),
+		identity: policy.identity,
+		requiresGlyphTokenization: policy.identity.class === "anthropic",
 		tokenizer: spec.tokenizer ?? resolveModelTokenizer(spec.requestModelId ?? spec.id),
-		thinking: resolveModelThinking(spec, compat),
-		supportsComputerUse: supportsOpenAIGAComputerUse(spec, supportsComputerUseConfig),
+		thinking: policy.thinking,
+		supportsComputerUse: supportsOpenAIGAComputerUse(spec, policy.identity, supportsComputerUseConfig),
 		supportsComputerUseConfig,
-		compat,
+		compat: policy.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;
-	}
+	};
+	applyCatalogAssignments(model, policy.catalog);
+	applyCatalogCorrections(model, policy.catalog);
+	return model;
 }

package/src/cline-pass-model-id.ts

@@ -0,0 +1,11 @@
+const CLINEPASS_WIRE_PREFIX = "cline-pass/";
+
+/** Convert a public ClinePass catalog id to the gateway's wire id. */
+export function toClinePassWireModelId(modelId: string): string {
+	return modelId.startsWith(CLINEPASS_WIRE_PREFIX) ? modelId : `${CLINEPASS_WIRE_PREFIX}${modelId}`;
+}
+
+/** Convert a gateway ClinePass wire id to the public catalog id. */
+export function toClinePassPublicModelId(modelId: string): string {
+	return modelId.startsWith(CLINEPASS_WIRE_PREFIX) ? modelId.slice(CLINEPASS_WIRE_PREFIX.length) : modelId;
+}

package/src/compat/anthropic.ts

@@ -1,18 +1,11 @@
 /**
- * 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.
+ * Anthropic endpoint-shape predicates: which URLs are the official first-party
+ * API, and which non-official hosts enforce Anthropic's thinking-signature
+ * protocol on replay. Compat resolution (`./resolve`) and runtime routing in
+ * pi-ai both consume these; URL matching is the one detection surface that
+ * stays in code.
  */
-import { hostMatchesUrl, modelMatchesHost } from "../hosts";
-import {
-	hasOpus47ApiRestrictions,
-	isAnthropicFableOrMythosModel,
-	isKimiK3ModelId,
-	supportsMidConversationSystemMessages,
-} from "../identity/family";
-import type { ModelSpec, ResolvedAnthropicCompat } from "../types";
-import { applyCompatOverrides } from "./apply";
+import { hostMatchesUrl } from "../hosts";
 
 const OFFICIAL_ANTHROPIC_URL = "https://api.anthropic.com";
 
@@ -29,75 +22,25 @@ export function isOfficialAnthropicApiUrl(baseUrl?: string): boolean {
 	return lower === OFFICIAL_ANTHROPIC_URL || lower.startsWith(`${OFFICIAL_ANTHROPIC_URL}/`);
 }
 
-/**
- * Kimi models whose native endpoints (api.kimi.com, api.moonshot.ai) keep
- * thinking enabled server-side no matter what the request carries: they
- * reject disabled thinking (#3852) AND reject forced tool_choice
- * (`tool_choice 'specified' is incompatible with thinking enabled`), so compat
- * must keep thinking on and downgrade forced choices to `auto`. Covers the
- * K2.7 Code family — public id, its Highspeed variant, and the kimi-code
- * `kimi-for-coding[-highspeed]` aliases — plus K3 (`kimi-k3`, bare `k3` on
- * kimi-code). Broader than the `compat/openai.ts` mirror: the OpenAI surface
- * has its own per-dialect policies (K3 forced-choice guard, explicit disable
- * shapes), while this surface has no working way to force a tool.
- * Native-only host gating is the caller's responsibility.
- */
-const KIMI_K27_CODE_MODEL_PATTERN = /(?:^|\/)kimi[-._]?k2(?:[._-]?|p)7[-._]?code(?:[-._]?highspeed)?$/i;
-
-function matchesKimiMandatoryThinkingModel(spec: ModelSpec<"anthropic-messages">): boolean {
-	if (KIMI_K27_CODE_MODEL_PATTERN.test(spec.id)) return true;
-	if (spec.id === "kimi-for-coding" || spec.id === "kimi-for-coding-highspeed") return true;
-	return isKimiK3ModelId(spec.id) || spec.id === "k3";
-}
-
 const CLOUDFLARE_ANTHROPIC_GATEWAY_URL_MARKER = /gateway\.ai\.cloudflare\.com\/.+\/anthropic(?:\/|$)/i;
 const VERTEX_ANTHROPIC_URL_MARKER = /aiplatform\.googleapis\.com\/.+\/publishers\/anthropic\//i;
 const BEDROCK_ANTHROPIC_URL_MARKER = /(?:^|\/\/|\.)bedrock-runtime\.[a-z0-9-]+\.amazonaws\.com/i;
 const AZURE_ANTHROPIC_URL_MARKER = /(?:^|\/\/|\.)[a-z0-9-]+\.(?:inference|services)\.ai\.azure\.com/i;
 
-/**
- * Cloudflare AI Gateway's `/anthropic` route forwards to signature-enforcing
- * Anthropic (same failure class as GitHub Copilot #2851 / ZenMux #4192).
- * Detection is by baseUrl marker rather than provider id: users routinely
- * declare `provider: "custom"` (or other free-form ids) in `models.yml` for
- * their own Cloudflare gateway account.
- */
-function isCloudflareAnthropicGateway(baseUrl?: string): boolean {
-	return baseUrl !== undefined && CLOUDFLARE_ANTHROPIC_GATEWAY_URL_MARKER.test(baseUrl);
-}
-
-/**
- * Google Vertex's `publishers/anthropic/models/…:streamRawPredict` route
- * proxies Claude through Google's identity layer and returns full thinking
- * signatures, so it is a SIGNING endpoint.
- */
-function isVertexAnthropicRoute(baseUrl?: string): boolean {
-	return baseUrl !== undefined && VERTEX_ANTHROPIC_URL_MARKER.test(baseUrl);
-}
-
-/**
- * AWS Bedrock's Anthropic route (`bedrock-runtime.<region>.amazonaws.com`)
- * forwards Claude requests through Anthropic's signature protocol. Users can
- * front Bedrock with a custom `anthropic-messages` provider entry in
- * `models.yml`; the URL marker makes those signing by default without
- * requiring a provider-id list.
- */
-function isBedrockAnthropicRoute(baseUrl?: string): boolean {
-	return baseUrl !== undefined && BEDROCK_ANTHROPIC_URL_MARKER.test(baseUrl);
-}
-
 /**
  * Azure AI Inference / Foundry Anthropic route
  * (`<resource>.inference.ai.azure.com`, `<resource>.services.ai.azure.com`).
  * Fronts Claude behind Azure identity and enforces Anthropic signatures on
- * replay.
+ * replay; it also rejects the top-level `strict` tool field.
  */
-function isAzureAnthropicRoute(baseUrl?: string): boolean {
+export function isAzureAnthropicRoute(baseUrl?: string): boolean {
 	return baseUrl !== undefined && AZURE_ANTHROPIC_URL_MARKER.test(baseUrl);
 }
 
 /**
- * Known non-official URLs that enforce Anthropic thinking signatures on replay.
+ * Known non-official URLs that enforce Anthropic thinking signatures on replay
+ * (GitHub Copilot, ZenMux, Cloudflare AI Gateway `/anthropic`, Google Vertex
+ * `publishers/anthropic`, AWS Bedrock, Azure Foundry).
  *
  * 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.
@@ -106,74 +49,10 @@ export function isAnthropicSigningProxyUrl(baseUrl?: string): boolean {
 	return (
 		hostMatchesUrl(baseUrl, "githubCopilot") ||
 		hostMatchesUrl(baseUrl, "zenmux") ||
-		isCloudflareAnthropicGateway(baseUrl) ||
-		isVertexAnthropicRoute(baseUrl) ||
-		isBedrockAnthropicRoute(baseUrl) ||
+		(baseUrl !== undefined &&
+			(CLOUDFLARE_ANTHROPIC_GATEWAY_URL_MARKER.test(baseUrl) ||
+				VERTEX_ANTHROPIC_URL_MARKER.test(baseUrl) ||
+				BEDROCK_ANTHROPIC_URL_MARKER.test(baseUrl))) ||
 		isAzureAnthropicRoute(baseUrl)
 	);
 }
-
-/** 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-messages` 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");
-	// ZenMux's `anthropic-messages` route (zenmux.ai/api/anthropic) forwards to
-	// signature-enforcing Anthropic — same failure class as GitHub Copilot #2851
-	// (issue #4192).
-	const isZenmux = modelMatchesHost(spec, "zenmux");
-	const requiresThinkingEnabled = modelMatchesHost(spec, "moonshotNative") && matchesKimiMandatoryThinkingModel(spec);
-	const isAzure = isAzureAnthropicRoute(baseUrl);
-	const signingEndpoint = official || isCopilot || isZenmux || isAnthropicSigningProxyUrl(baseUrl);
-	const compat: ResolvedAnthropicCompat = {
-		officialEndpoint: official,
-		signingEndpoint,
-		disableStrictTools: isAzure,
-		disableAdaptiveThinking: false,
-		allowAnthropicHeaderOverrides: false,
-		supportsEagerToolInputStreaming: official,
-		// 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 and Anthropic-compatible signing proxies enforce
-		// signature-based thinking-chain integrity, so unsigned thinking blocks
-		// must stay text there. Every other `anthropic-messages` reasoning
-		// endpoint replays unsigned thinking natively so the reasoning chain
-		// survives continuation and doesn't destabilize the next tool-call
-		// arguments (#2005, #2257, #2265, #3288, #3433, #3434). Opaque custom
-		// signing proxies remain the reporter's responsibility to mark with
-		// `compat.replayUnsignedThinking: false`; the transport surfaces a
-		// pointed remediation the first time the signing 400 fires (#4297).
-		//
-		// Known signing Anthropic-messages hosts (Copilot, ZenMux, Cloudflare
-		// AI Gateway `/anthropic`, Google Vertex `publishers/anthropic`, AWS
-		// Bedrock `bedrock-runtime.<region>.amazonaws.com`, and Azure
-		// AI Inference / Foundry `<res>.(inference|services).ai.azure.com`)
-		// are excluded automatically because they can be recognised by provider
-		// id or baseUrl marker.
-		replayUnsignedThinking: !signingEndpoint && (Boolean(spec.reasoning) || modelMatchesHost(spec, "deepseekFamily")),
-		escapeBuiltinToolNames: modelMatchesHost(spec, "umans"),
-		streamIdleTimeoutMs: spec.compat?.streamIdleTimeoutMs,
-	};
-	applyCompatOverrides(compat, spec.compat);
-	return compat;
-}