@oh-my-pi/pi-catalog 15.11.1 → 15.11.3

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [15.11.3] - 2026-06-11
+### Added
+
+- Added `requestModelId` on `Model` to represent the upstream model id used when a catalog entry is a local variant
+- Added synthetic GitHub Copilot long-context model variants with `-1m` suffixes when tiered token pricing is advertised
+
+### Changed
+
+- Changed GitHub Copilot discovery to request `X-GitHub-Api-Version: 2026-06-01` from `api.githubcopilot.com`
+- Changed GitHub Copilot discovery to cap base model `contextWindow` to the default token tier and keep long-context access as the separate `-1m` model entry
+- Changed Copilot model mapping to omit non-chat `/models` entries and enable image input for models whose capabilities indicate vision support
+
+### Fixed
+
+- Fixed long-context variant pricing to use `billing.token_prices.long_context` rates instead of default model pricing
+- Fixed `mapModel` handling in OpenAI-compatible discovery so returning `null` now skips a model entry rather than falling back to defaults
+- Fixed model ID precedence so a real upstream Copilot model id is kept when it conflicts with a synthesized `-1m` variant
+
 ## [15.11.1] - 2026-06-11
 
 ### Fixed
@@ -62,4 +80,4 @@
 
 ### Removed
 
-- Removed the runtime enrichment layer: `enrichModelThinking` (and its non-enumerable memo-slot cache), `refreshModelThinking`, `modelOmitsReasoningEffort`, and the `model-thinking` re-exports of generator-only policies. Thinking metadata is resolved exactly once inside `buildModel`; runtime helpers (`getSupportedEfforts`, `clampThinkingLevelForModel`, `requireSupportedEffort`, the effort mappers) are pure field reads.
+- Removed the runtime enrichment layer: `enrichModelThinking` (and its non-enumerable memo-slot cache), `refreshModelThinking`, `modelOmitsReasoningEffort`, and the `model-thinking` re-exports of generator-only policies. Thinking metadata is resolved exactly once inside `buildModel`; runtime helpers (`getSupportedEfforts`, `clampThinkingLevelForModel`, `requireSupportedEffort`, the effort mappers) are pure field reads.

package/dist/types/provider-models/openai-compat.d.ts

@@ -334,6 +334,8 @@ export interface GithubCopilotModelManagerConfig {
     baseUrl?: string;
     fetch?: FetchImpl;
 }
+/** Local id/name suffixes for synthesized Copilot long-context variants. */
+export declare const COPILOT_LONG_CONTEXT_ID_SUFFIX = "-1m";
 export declare function githubCopilotModelManagerOptions(config?: GithubCopilotModelManagerConfig): ModelManagerOptions<Api>;
 export interface AnthropicModelManagerConfig {
     apiKey?: string;

package/dist/types/types.d.ts

@@ -319,6 +319,15 @@ export type CompatConfigOf<TApi extends Api> = TApi extends "openai-completions"
 export type CompatOf<TApi extends Api> = TApi extends "openai-completions" ? ResolvedOpenAICompat : TApi extends "openai-responses" | "azure-openai-responses" | "openai-codex-responses" ? ResolvedOpenAIResponsesCompat : TApi extends "anthropic-messages" ? ResolvedAnthropicCompat : undefined;
 export interface Model<TApi extends Api = Api> {
     id: string;
+    /**
+     * Model id to send on the wire when it differs from `id`. Used by catalog
+     * variants that present one upstream model under several local entries —
+     * e.g. GitHub Copilot long-context variants (`claude-opus-4.7-1m` requests
+     * upstream `claude-opus-4.7`; the tier is a client-side context budget, not
+     * a served model id). Providers MUST serialize `requestModelId ?? id`;
+     * everything local (selection, caching, usage attribution) keys on `id`.
+     */
+    requestModelId?: string;
     name: string;
     api: TApi;
     provider: Provider;

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

@@ -7,6 +7,21 @@ 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;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "15.11.1",
+	"version": "15.11.3",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -34,11 +34,11 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-utils": "15.11.1",
+		"@oh-my-pi/pi-utils": "15.11.3",
 		"zod": "4.4.3"
 	},
 	"devDependencies": {
-		"@oh-my-pi/pi-ai": "15.11.1",
+		"@oh-my-pi/pi-ai": "15.11.3",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/discovery/openai-compatible.ts

@@ -169,7 +169,9 @@ export async function fetchOpenAICompatibleModels<TApi extends Api>(
 			maxTokens: UNK_MAX_TOKENS,
 		};
 
-		const mapped = options.mapModel?.(entry, defaults, context) ?? defaults;
+		// `mapModel` returning null skips the entry (documented contract); only a
+		// missing mapper falls back to the defaults.
+		const mapped = options.mapModel ? options.mapModel(entry, defaults, context) : defaults;
 		if (!mapped || typeof mapped.id !== "string" || mapped.id.length === 0) {
 			continue;
 		}

package/src/provider-models/openai-compat.ts

@@ -9,7 +9,7 @@ import type { ModelManagerOptions } from "../model-manager";
 import { getBundledModels } from "../models";
 import type { Api, FetchImpl, Model, ModelSpec, Provider, ThinkingConfig } from "../types";
 import { isAnthropicOAuthToken, isRecord, toBoolean, toNumber, toPositiveNumber } from "../utils";
-import { getGitHubCopilotBaseUrl, OPENCODE_HEADERS, parseGitHubCopilotApiKey } from "../wire/github-copilot";
+import { COPILOT_API_HEADERS, getGitHubCopilotBaseUrl, parseGitHubCopilotApiKey } from "../wire/github-copilot";
 import { createBundledReferenceMap, createReferenceResolver, toModelSpec } from "./bundled-references";
 import { UNK_CONTEXT_WINDOW, UNK_MAX_TOKENS } from "./discovery-constants";
 
@@ -2371,7 +2371,7 @@ export interface GithubCopilotModelManagerConfig {
 	fetch?: FetchImpl;
 }
 
-const COPILOT_ANTHROPIC_MODEL_PATTERN = /^claude-(haiku|sonnet|opus)-4([.-]|$)/;
+const COPILOT_ANTHROPIC_MODEL_PATTERN = /^claude-(haiku|sonnet|opus|fable|mythos)-\d/;
 const isCopilotResponsesModelId = (modelId: string): boolean =>
 	modelId.startsWith("gpt-5") || modelId.startsWith("oswe");
 
@@ -2406,6 +2406,122 @@ function extractCopilotLimits(entry: OpenAICompatibleModelRecord): {
 	};
 }
 
+/** Local id/name suffixes for synthesized Copilot long-context variants. */
+export const COPILOT_LONG_CONTEXT_ID_SUFFIX = "-1m";
+const COPILOT_LONG_CONTEXT_NAME_SUFFIX = " (1M)";
+
+/** One tier of Copilot token pricing (`billing.token_prices.{default,long_context}`). Prices are hundredths of a dollar per 1M tokens. */
+interface CopilotTokenPriceTier {
+	contextMax?: number;
+	inputPrice?: number;
+	outputPrice?: number;
+	cachePrice?: number;
+}
+
+function parseCopilotTokenPriceTier(value: unknown): CopilotTokenPriceTier | undefined {
+	if (!isRecord(value)) {
+		return undefined;
+	}
+	return {
+		contextMax: toNumber(value.context_max),
+		inputPrice: toNumber(value.input_price),
+		outputPrice: toNumber(value.output_price),
+		cachePrice: toNumber(value.cache_price),
+	};
+}
+
+/**
+ * Tiered context boundaries/prices from `billing.token_prices`. Served only
+ * when discovery requests `X-GitHub-Api-Version` ≥ 2026-06-01; absent on the
+ * legacy response shape (where `capabilities.limits` is already tier-capped).
+ */
+function extractCopilotTokenPrices(entry: OpenAICompatibleModelRecord): {
+	defaultTier?: CopilotTokenPriceTier;
+	longContext?: CopilotTokenPriceTier;
+} {
+	if (!isRecord(entry.billing)) {
+		return {};
+	}
+	const tokenPrices = entry.billing.token_prices;
+	if (!isRecord(tokenPrices)) {
+		return {};
+	}
+	return {
+		defaultTier: parseCopilotTokenPriceTier(tokenPrices.default),
+		longContext: parseCopilotTokenPriceTier(tokenPrices.long_context),
+	};
+}
+
+function extractCopilotSupportsVision(entry: OpenAICompatibleModelRecord): boolean | undefined {
+	if (!isRecord(entry.capabilities)) {
+		return undefined;
+	}
+	const supports = entry.capabilities.supports;
+	if (!isRecord(supports)) {
+		return undefined;
+	}
+	return toBoolean(supports.vision);
+}
+
+/** Copilot's `/models` mixes chat and embedding models; only `type: "chat"` entries are usable here. */
+function isCopilotChatModel(entry: OpenAICompatibleModelRecord): boolean {
+	if (!isRecord(entry.capabilities)) {
+		return true;
+	}
+	const type = entry.capabilities.type;
+	return typeof type !== "string" || type === "chat";
+}
+
+function copilotTierCost(
+	tier: CopilotTokenPriceTier | undefined,
+): Omit<ModelSpec<Api>["cost"], "cacheWrite"> | undefined {
+	if (tier?.inputPrice === undefined || tier.outputPrice === undefined) {
+		return undefined;
+	}
+	return {
+		input: tier.inputPrice / 100,
+		output: tier.outputPrice / 100,
+		cacheRead: (tier.cachePrice ?? 0) / 100,
+	};
+}
+
+/**
+ * Synthesize the opt-in long-context sibling for a Copilot model that reports
+ * a `billing.token_prices.long_context` tier (e.g. Claude Opus 200k → 1M, as
+ * selectable in copilot-cli). The variant is a local catalog entry: it keeps
+ * the upstream model id on the wire via `requestModelId` — the tier is purely
+ * a client-side context budget with its own pricing, not a served model id.
+ * The base entry stays on the default tier so nobody silently pays
+ * long-context rates.
+ */
+function createCopilotLongContextVariant(
+	base: ModelSpec<Api>,
+	fullContextWindow: number,
+	maxTokens: number,
+	longContext: CopilotTokenPriceTier | undefined,
+): ModelSpec<Api> | undefined {
+	const longContextMax = longContext?.contextMax;
+	if (longContextMax === undefined || longContextMax <= 0) {
+		return undefined;
+	}
+	const variantWindow = Math.min(fullContextWindow, longContextMax + maxTokens);
+	if (variantWindow <= base.contextWindow) {
+		return undefined;
+	}
+	const longCost = copilotTierCost(longContext);
+	return {
+		...base,
+		id: `${base.id}${COPILOT_LONG_CONTEXT_ID_SUFFIX}`,
+		requestModelId: base.id,
+		name: `${base.name}${COPILOT_LONG_CONTEXT_NAME_SUFFIX}`,
+		contextWindow: variantWindow,
+		// Long-context tier has its own token prices (Gemini/GPT bill ~2x above
+		// the default boundary). cacheWrite is not reported per tier; inherit.
+		...(longCost && { cost: { ...longCost, cacheWrite: base.cost.cacheWrite } }),
+		contextPromotionTarget: undefined,
+	};
+}
+
 export function githubCopilotModelManagerOptions(config?: GithubCopilotModelManagerConfig): ModelManagerOptions<Api> {
 	const rawApiKey = config?.apiKey;
 	const configuredBaseUrl = config?.baseUrl ?? "https://api.githubcopilot.com";
@@ -2420,18 +2536,22 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 	return {
 		providerId: "github-copilot",
 		...(apiKey && {
-			fetchDynamicModels: () =>
-				fetchOpenAICompatibleModels<Api>({
+			fetchDynamicModels: async () => {
+				const longContextVariants: ModelSpec<Api>[] = [];
+				const models = await fetchOpenAICompatibleModels<Api>({
 					api: "openai-completions",
 					provider: "github-copilot",
 					baseUrl,
 					apiKey,
-					headers: OPENCODE_HEADERS,
+					headers: COPILOT_API_HEADERS,
 					mapModel: (
 						entry: OpenAICompatibleModelRecord,
 						defaults: ModelSpec<Api>,
 						_context: OpenAICompatibleModelMapperContext<Api>,
-					): ModelSpec<Api> => {
+					): ModelSpec<Api> | null => {
+						if (!isCopilotChatModel(entry)) {
+							return null;
+						}
 						const reference = resolveReference(defaults.id);
 						const copilotLimits = extractCopilotLimits(entry);
 						// Copilot exposes token limits under capabilities.limits.*.
@@ -2463,48 +2583,91 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 								? entry.name
 								: (reference?.name ?? defaults.name);
 						const api = inferCopilotApi(defaults.id);
-						if (reference) {
-							return {
-								...reference,
-								api,
-								provider: "github-copilot",
-								baseUrl,
-								name,
-								contextWindow,
-								maxTokens,
-								headers: { ...OPENCODE_HEADERS, ...(providerRefs.get(defaults.id)?.headers ?? {}) },
-								...(api === "openai-completions"
-									? {
-											compat: {
-												supportsStore: false,
-												supportsDeveloperRole: false,
-												supportsReasoningEffort: false,
-											},
-										}
-									: {}),
-							};
-						}
-						return {
-							...defaults,
-							api,
-							baseUrl,
-							name,
+						const supportsVision = extractCopilotSupportsVision(entry);
+						const input: ModelSpec<Api>["input"] = supportsVision
+							? ["text", "image"]
+							: (reference?.input ?? defaults.input);
+						// With COPILOT_API_HEADERS the served window is the long-context
+						// ceiling; the default tier ends at token_prices.default.context_max
+						// prompt tokens. Cap the base entry to the default tier — the long
+						// tier is the opt-in `-1m` sibling below.
+						const tokenPrices = extractCopilotTokenPrices(entry);
+						const defaultContextMax = tokenPrices.defaultTier?.contextMax;
+						const defaultTierWindow =
+							defaultContextMax !== undefined && defaultContextMax > 0
+								? Math.min(contextWindow, defaultContextMax + maxTokens)
+								: contextWindow;
+						const base: ModelSpec<Api> = reference
+							? {
+									...reference,
+									api,
+									provider: "github-copilot",
+									baseUrl,
+									name,
+									input,
+									contextWindow: defaultTierWindow,
+									maxTokens,
+									headers: { ...COPILOT_API_HEADERS, ...(providerRefs.get(defaults.id)?.headers ?? {}) },
+									...(api === "openai-completions"
+										? {
+												compat: {
+													supportsStore: false,
+													supportsDeveloperRole: false,
+													supportsReasoningEffort: false,
+												},
+											}
+										: {}),
+								}
+							: {
+									...defaults,
+									api,
+									baseUrl,
+									name,
+									input,
+									contextWindow: defaultTierWindow,
+									maxTokens,
+									headers: { ...COPILOT_API_HEADERS },
+									...(api === "openai-completions"
+										? {
+												compat: {
+													supportsStore: false,
+													supportsDeveloperRole: false,
+													supportsReasoningEffort: false,
+												},
+											}
+										: {}),
+								};
+						const variant = createCopilotLongContextVariant(
+							base,
 							contextWindow,
 							maxTokens,
-							headers: { ...OPENCODE_HEADERS },
-							...(api === "openai-completions"
-								? {
-										compat: {
-											supportsStore: false,
-											supportsDeveloperRole: false,
-											supportsReasoningEffort: false,
-										},
-									}
-								: {}),
-						};
+							tokenPrices.longContext,
+						);
+						if (variant) {
+							longContextVariants.push(variant);
+							// Overflowing the default tier promotes into the 1M sibling
+							// unless the reference already pins a target.
+							base.contextPromotionTarget ??= `github-copilot/${variant.id}`;
+						}
+						return base;
 					},
 					fetch: config?.fetch,
-				}),
+				});
+				if (models === null) {
+					return null;
+				}
+				// Append synthesized tiers; a real upstream id always wins over a
+				// local variant with the same id.
+				const takenIds = new Set(models.map(model => model.id));
+				for (const variant of longContextVariants) {
+					if (takenIds.has(variant.id)) {
+						continue;
+					}
+					takenIds.add(variant.id);
+					models.push(variant);
+				}
+				return models.sort((left, right) => left.id.localeCompare(right.id));
+			},
 		}),
 	};
 }
@@ -3077,7 +3240,7 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_SPECIALIZED: readonly ModelsDevProviderDes
 	openAiCompletionsDescriptor("github-copilot", "github-copilot", COPILOT_BASE_URL, {
 		defaultContextWindow: 128000,
 		defaultMaxTokens: 8192,
-		headers: { ...OPENCODE_HEADERS },
+		headers: { ...COPILOT_API_HEADERS },
 		filterModel: filterActiveToolCallModels,
 		resolveApi: (modelId, raw) =>
 			resolveApiByRules(modelId, raw, COPILOT_API_RESOLUTION_RULES, COPILOT_DEFAULT_RESOLUTION),

package/src/types.ts

@@ -383,6 +383,15 @@ export type CompatOf<TApi extends Api> = TApi extends "openai-completions"
 // Model interface for the unified model system
 export interface Model<TApi extends Api = Api> {
 	id: string;
+	/**
+	 * Model id to send on the wire when it differs from `id`. Used by catalog
+	 * variants that present one upstream model under several local entries —
+	 * e.g. GitHub Copilot long-context variants (`claude-opus-4.7-1m` requests
+	 * upstream `claude-opus-4.7`; the tier is a client-side context budget, not
+	 * a served model id). Providers MUST serialize `requestModelId ?? id`;
+	 * everything local (selection, caching, usage attribution) keys on `id`.
+	 */
+	requestModelId?: string;
 	name: string;
 	api: TApi;
 	provider: Provider;

package/src/wire/github-copilot.ts

@@ -10,6 +10,23 @@ 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;