@oh-my-pi/pi-catalog 18.2.11 → 18.3.1

package/src/compat/server-side-fallback.ts

@@ -0,0 +1,13 @@
+import type { Model } from "../types";
+import { resolveCatalogPolicy } from "./catalog-policy";
+
+/**
+ * Ordered model ids for Anthropic's server-side refusal `fallbacks` chain,
+ * authored on the `server-side-fallback-models` catalog axis. Empty when no
+ * rule assigns a chain (the model or host does not support the feature).
+ */
+export function serverSideFallbackModels(model: Model): readonly string[] {
+	const value = resolveCatalogPolicy(model).serverSideFallbackModels;
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry): entry is string => typeof entry === "string");
+}

package/src/compat/types.ts

@@ -552,6 +552,10 @@ export interface CompiledAuthProvider {
 	name: string;
 	env?: { vars: string[] } | { hook: string };
 	allowsMissingApiKey?: boolean;
+	/** Qualify credential and usage-report identity by org when an email may have multiple subscriptions. */
+	orgScopedIdentity?: boolean;
+	/** Environment variables carrying this provider's own OAuth bearer, excluding borrowed API-key aliases. */
+	oauthTokenEnv?: string[];
 	/** APIs whose provider transport resolves credentials without a stored account. */
 	nativeAuthApis?: string[];
 	available?: boolean;

package/src/discovery/codex.ts

@@ -70,6 +70,7 @@ const codexModelEntrySchema = type({
 	"prefer_websockets?": "unknown",
 	"use_responses_lite?": "unknown",
 	"tool_mode?": "unknown",
+	"available_access_programs?": "unknown",
 });
 
 const codexModelsResponseSchema = type({
@@ -161,7 +162,7 @@ export async function fetchCodexModels(options: CodexModelDiscoveryOptions): Pro
 			continue;
 		}
 
-		const models = normalizeCodexModels(payload, baseUrl);
+		const models = normalizeCodexModels(payload, baseUrl, options.accountId);
 		if (models === null) {
 			continue;
 		}
@@ -223,7 +224,11 @@ function normalizeClientVersion(value: unknown): string | undefined {
 	return trimmed;
 }
 
-function normalizeCodexModels(payload: unknown, baseUrl: string): ModelSpec<"openai-codex-responses">[] | null {
+function normalizeCodexModels(
+	payload: unknown,
+	baseUrl: string,
+	accountId: string | undefined,
+): ModelSpec<"openai-codex-responses">[] | null {
 	const parsedResponse = codexModelsResponseSchema(payload);
 	if (parsedResponse instanceof type.errors) {
 		return null;
@@ -250,10 +255,10 @@ function normalizeCodexModels(payload: unknown, baseUrl: string): ModelSpec<"ope
 	const normalized: NormalizedCodexModel[] = [];
 	for (const parsed of parsedEntries) {
 		const canonicalSlug = plainCounterpartForWorkerSlug(parsed.slug, bundledCodexModelIds) ?? parsed.slug;
-		normalized.push(buildNormalizedCodexModel(parsed, parsed.slug, canonicalSlug, baseUrl));
+		normalized.push(buildNormalizedCodexModel(parsed, parsed.slug, canonicalSlug, baseUrl, accountId));
 		const plainSlug = canonicalSlug !== parsed.slug ? canonicalSlug : null;
 		if (plainSlug && !advertisedSlugs.has(plainSlug)) {
-			normalized.push(buildNormalizedCodexModel(parsed, plainSlug, canonicalSlug, baseUrl));
+			normalized.push(buildNormalizedCodexModel(parsed, plainSlug, canonicalSlug, baseUrl, accountId));
 		}
 	}
 
@@ -288,6 +293,7 @@ function plainCounterpartForWorkerSlug(slug: string, bundledCodexModelIds: Reado
 
 interface ParsedCodexModelEntry {
 	slug: string;
+	cyberPrograms: string[] | undefined;
 	name: string;
 	contextWindow: number | null;
 	maxContextWindow: number | null;
@@ -316,8 +322,19 @@ function parseCodexModelEntry(entry: unknown): ParsedCodexModelEntry | null {
 		return null;
 	}
 
+	const programs = payload.available_access_programs;
+	let cyberPrograms: string[] | undefined;
+	if (programs !== null && typeof programs === "object" && "cyber" in programs && Array.isArray(programs.cyber)) {
+		cyberPrograms = [];
+		for (const program of programs.cyber) {
+			const name = toNonEmptyString(program);
+			if (name) cyberPrograms.push(name);
+		}
+	}
+
 	return {
 		slug,
+		cyberPrograms,
 		name: toNonEmptyString(payload.display_name) ?? slug,
 		contextWindow: toPositiveInt(payload.context_window),
 		maxContextWindow: toPositiveInt(payload.max_context_window),
@@ -342,6 +359,7 @@ function buildNormalizedCodexModel(
 	slug: string,
 	canonicalSlug: string,
 	baseUrl: string,
+	accountId: string | undefined,
 ): NormalizedCodexModel {
 	// Codex discovery historically omitted `context_window` for GPT-5.6-family
 	// SKUs (#5705); luna/sol/terra additionally floor the reported value because
@@ -371,6 +389,13 @@ function buildNormalizedCodexModel(
 			api: "openai-codex-responses",
 			provider: "openai-codex",
 			baseUrl,
+			...(accountId && accountId.trim().length > 0
+				? {
+						accountAccess: {
+							[accountId]: parsed.cyberPrograms === undefined ? {} : { cyberPrograms: parsed.cyberPrograms },
+						},
+					}
+				: {}),
 			reasoning: parsed.reasoning,
 			input: parsed.input,
 			// Codex discovery omits pricing; documented subscription credit-equivalent

package/src/discovery/cursor-proto.ts

@@ -1,7 +1,7 @@
 // @generated by packages/catalog/scripts/proto-parser.ts - DO NOT EDIT
 
 /**
- * Cursor agent protocol declarations used by Oh My Pi.
+ * Cursor agent protocol declarations used by omp.
  *
  * Each declaration retains only fields consumed by the client or its protocol tests.
  */

package/src/discovery/devin-proto.ts

@@ -1,7 +1,7 @@
 // @generated by packages/catalog/scripts/proto-parser.ts - DO NOT EDIT
 
 /**
- * Devin protocol declarations used by Oh My Pi.
+ * Devin protocol declarations used by omp.
  *
  * Each declaration retains only fields consumed by the client or its protocol tests.
  */

package/src/discovery/devin.ts

@@ -453,6 +453,51 @@ function devinModelSpec(
 	return spec;
 }
 
+/**
+ * Lead chat uid of a Fusion pairing `fusion-<lead>[-fast]-sidekick-<sidekick>`.
+ * An exact live lead uid wins, so leads whose own uid ends in `-fast`
+ * (`swe-1-6-fast`) route as written. Otherwise `-fast` selects the lead's
+ * priority lane when the server lists one, then the standard lane.
+ *
+ * Returns `undefined` for uids that are not pairings and `null` for pairings
+ * whose lead is not live: the composite uid itself is never servable.
+ */
+function devinFusionLeadUid(uid: string, liveUids: ReadonlyMap<string, unknown>): string | null | undefined {
+	if (!uid.startsWith("fusion-")) return undefined;
+	const cut = uid.indexOf("-sidekick-");
+	if (cut <= "fusion-".length) return undefined;
+	const lead = uid.slice("fusion-".length, cut);
+	if (liveUids.has(lead)) return lead;
+	if (lead.endsWith("-fast")) {
+		const base = lead.slice(0, -"-fast".length);
+		if (liveUids.has(`${base}-priority`)) return `${base}-priority`;
+		if (liveUids.has(base)) return base;
+	}
+	return null;
+}
+
+/**
+ * Point a Fusion pairing at its lead. omp runs only the lead (the sidekick is
+ * paired by the native client), so the limits and pricing a caller budgets
+ * against are the lead's, not the composite card's.
+ */
+function routeDevinFusionLead(spec: ModelSpec<"devin-agent">, lead: ModelSpec<"devin-agent">): void {
+	spec.requestModelId = lead.id;
+	spec.reasoning = lead.reasoning;
+	spec.input = lead.input;
+	spec.supportsTools = lead.supportsTools;
+	spec.cost = lead.cost;
+	spec.contextWindow = lead.contextWindow;
+	spec.maxTokens = lead.maxTokens;
+	if (lead.compat?.supportsParallelToolCalls) {
+		spec.compat = { ...spec.compat, supportsParallelToolCalls: true };
+	} else if (spec.compat?.supportsParallelToolCalls) {
+		const { supportsParallelToolCalls: _, ...rest } = spec.compat;
+		if (Object.keys(rest).length > 0) spec.compat = rest;
+		else delete spec.compat;
+	}
+}
+
 function normalizeDevinModels(
 	configs: readonly ClientModelConfig[],
 	baseUrlOverride: string | undefined,
@@ -461,6 +506,11 @@ function normalizeDevinModels(
 	const specs: ModelSpec<"devin-agent">[] = [];
 	const seen = new Set<string>();
 	const lanes = new Map<string, DevinFamilyLane>();
+	const liveConfigs = new Map<string, ClientModelConfig>();
+	for (const config of configs) {
+		const uid = config.modelUid.trim();
+		if (!config.disabled && uid && !liveConfigs.has(uid)) liveConfigs.set(uid, config);
+	}
 
 	for (const config of configs) {
 		if (config.disabled) {
@@ -482,7 +532,16 @@ function normalizeDevinModels(
 		// `fusion-sidekick-*`) that are themselves valid chat uids. Only the
 		// former take the `AssignModel` path — sending a composite uid there 404s.
 		const isAssignModelRouter = isRouter && (config.modelInfo?.harnessUids.length ?? 0) === 0;
-		specs.push(devinModelSpec(config, uid, baseUrl, isAssignModelRouter));
+		// Fusion pairings are orchestrated by the native client: it runs the lead
+		// model as an ordinary chat uid and pairs a sidekick locally. The server
+		// has no provider for the composite uid itself (`permission_denied: no API
+		// providers are available`), so the chat request carries the lead uid and
+		// a pairing without a live lead is not listed.
+		const lead = devinFusionLeadUid(uid, liveConfigs);
+		if (lead === null) continue;
+		const spec = devinModelSpec(config, uid, baseUrl, isAssignModelRouter);
+		if (lead !== undefined) routeDevinFusionLead(spec, devinModelSpec(liveConfigs.get(lead)!, lead, baseUrl, false));
+		specs.push(spec);
 		// A router is a server-side dispatcher, not an effort tier: it stays a
 		// standalone model even when upstream files it under a family.
 		if (!isRouter) {