@mupt-ai/dari-gateway 0.2.0 → 0.3.0

package/src/ingress/models.ts

@@ -2,17 +2,20 @@
    Codex reads the Codex catalog; Anthropic-SDK clients (Claude Desktop /
    Cowork gateway probes, Claude Code) read the Anthropic list shape. The
    handler detects the caller, authenticates in that protocol's auth shape,
-   and selects the matching catalog adapter. */
+   and selects the matching catalog adapter. `?detail=1` instead returns the
+   model catalog (models/catalog.ts), optionally narrowed with
+   `provider=<id>[,<id>...]`. */
 
-import { anthropicToken, bearerToken } from "../http/auth";
-import { errorResponse } from "../http/errors";
-import { captureRequestError } from "../observability/errors";
-import { anthropicErrorResponse } from "./anthropic_messages";
-import { modelSupportsImageInput } from "../providers/model_capabilities";
-import { modelMetadataLookup } from "../providers/pi";
-import { resolveRouter } from "../strategies/routing";
-import { anthropicModelsResponse } from "./anthropic_models";
-import { codexModelsResponse } from "./codex_models";
+import { anthropicToken, bearerToken } from "../http/auth.js";
+import { errorResponse } from "../http/errors.js";
+import { captureRequestError } from "../observability/errors.js";
+import { anthropicErrorResponse } from "./anthropic_messages.js";
+import { listModelCatalog } from "../models/catalog.js";
+import { modelSupportsImageInput } from "../providers/model_capabilities.js";
+import { modelMetadataLookup } from "../providers/pi.js";
+import { resolveRouter } from "../strategies/routing.js";
+import { anthropicModelsResponse } from "./anthropic_models.js";
+import { codexModelsResponse } from "./codex_models.js";
 
 export async function handleModels(request: Request, routerId: string): Promise<Response> {
   // Anthropic SDK clients always send anthropic-version, and API-key probes
@@ -26,6 +29,15 @@ export async function handleModels(request: Request, routerId: string): Promise<
     // Resolution authenticates the key and confirms the router exists even
     // when the response body (Anthropic shape) does not depend on it.
     const router = await resolveRouter({ routerId, apiKey });
+    const query = new URL(request.url).searchParams;
+    if (query.get("detail") === "1") {
+      const providers = query.get("provider")?.split(",").map((id) => id.trim()).filter(Boolean);
+      const data = await listModelCatalog({
+        ...(providers?.length ? { providers } : {}),
+        signal: request.signal,
+      });
+      return Response.json({ object: "list", data }, { headers: { "Cache-Control": "no-store" } });
+    }
     if (anthropicClient) {
       return Response.json(anthropicModelsResponse(), {
         headers: {

package/src/ingress/muse_code.ts

@@ -0,0 +1,9 @@
+// Muse Code names its surface (TUI, `muse exec`, desktop, `muse serve`) in
+// x-client-id on every model request.
+const MUSE_CODE_CLIENT_IDS = new Set(["tbh:tui", "tbh:exec", "tbh:desktop", "tbh:serve"]);
+
+/** Muse Code's x-client-id when the request comes from Muse Code. */
+export function museCodeClientId(headers: Headers): string | undefined {
+  const clientId = headers.get("x-client-id")?.trim().toLowerCase();
+  return clientId !== undefined && MUSE_CODE_CLIENT_IDS.has(clientId) ? clientId : undefined;
+}

package/src/ingress/muse_models.ts

@@ -0,0 +1,36 @@
+import { bearerToken } from "../http/auth.js";
+import { errorResponse } from "../http/errors.js";
+import { resolveRouter } from "../strategies/routing.js";
+import type { ResolvedRouter } from "../types.js";
+
+/**
+ * Muse Code fetches its model list from its base URL's origin
+ * (`/muse-code/models`) before its first request. A list of only the router's
+ * models lets Muse Code pick from them and start on the first; `dari/routing`
+ * leads it only on the Autorouting plan.
+ */
+export function museCodeModelsResponse(
+  router: Pick<ResolvedRouter, "enabled_models" | "autorouting_enabled">,
+): Record<string, unknown> {
+  const ids = [
+    ...(router.autorouting_enabled === false ? [] : ["dari/routing"]),
+    ...router.enabled_models.map((model) => `dari/model/${model}`),
+  ];
+  return {
+    data: ids.map((id, index) => ({
+      id,
+      display_label: id === "dari/routing" ? "Dari Routing" : id.slice("dari/model/".length),
+      is_default: index === 0,
+    })),
+  };
+}
+
+export async function handleMuseCodeModels(request: Request, routerId: string): Promise<Response> {
+  try {
+    // Only Muse Code fetches this list, so its plans apply even without a Meta key.
+    const router = await resolveRouter({ routerId, apiKey: bearerToken(request.headers), clientHarness: "muse_code" });
+    return Response.json(museCodeModelsResponse(router), { headers: { "Cache-Control": "no-store" } });
+  } catch (error) {
+    return errorResponse(error);
+  }
+}

package/src/interaction/capabilities.ts

@@ -1,5 +1,5 @@
 import type { HardCapability } from "@mupt-ai/dari-router/policy-engine";
-import type { InteractionItem, InteractionRequest } from "./types";
+import type { InteractionItem, InteractionRequest } from "./types.js";
 
 export function requiredCapabilitiesFor(
   request: Pick<InteractionRequest, "items" | "responseFormat" | "toolChoice" | "tools">

package/src/interaction/portable_reasoning_state.ts

@@ -4,7 +4,7 @@ import {
   type PortableReasoningState,
 } from "@mupt-ai/dari-router/protocols";
 
-import { rethrowFrameworkErrorAsHttp } from "../http/errors";
+import { rethrowFrameworkErrorAsHttp } from "../http/errors.js";
 
 export type { PortableReasoningState } from "@mupt-ai/dari-router/protocols";
 

package/src/interaction/provider_continuation_state.ts

@@ -6,7 +6,7 @@ import {
   type ProviderIdentity,
 } from "@mupt-ai/dari-router/protocols";
 
-import { rethrowFrameworkErrorAsHttp } from "../http/errors";
+import { rethrowFrameworkErrorAsHttp } from "../http/errors.js";
 
 export type { ProviderContinuationState, ProviderIdentity } from "@mupt-ai/dari-router/protocols";
 export { compatibleProviderContinuation, isAnthropicEffort, sameProviderIdentity } from "@mupt-ai/dari-router/protocols";

package/src/interaction/tool_identity.ts

@@ -1,5 +1,5 @@
-import { HttpError } from "../http/errors";
-import type { InteractionTool, ProviderIdentity } from "./types";
+import { HttpError } from "../http/errors.js";
+import type { InteractionTool, ProviderIdentity } from "./types.js";
 
 export const TOOL_CALL_ID_MAX_LENGTH = 512;
 

package/src/interaction/types.ts

@@ -235,6 +235,8 @@ export type InteractionRequest = {
   agentContext?: AgentRequestContext;
   // Claude Code's own user agent; Anthropic gates subscription models on it.
   claudeCodeUserAgent?: string;
+  // Muse Code's own x-client-id, which Meta attributes its requests by.
+  museCodeClientId?: string;
   anthropicSafeguards?: AnthropicSafeguards;
   model?: string;
   instructions?: string;

package/src/models/catalog.ts

@@ -0,0 +1,310 @@
+import { getSupportedThinkingLevels, type Api, type Model } from "@mupt-ai/pi-ai";
+import {
+  getBuiltinModelDataGeneratedAt,
+  getBuiltinModels,
+  getBuiltinProviders,
+} from "@mupt-ai/pi-ai/providers/all";
+import {
+  REASONING_EFFORTS,
+  isReasoningEffort,
+  isRecord,
+  type ReasoningEffort,
+} from "@mupt-ai/dari-router/policy-engine";
+import { HttpError } from "../http/errors.js";
+
+// The models each provider can serve to a coding agent, with the limits,
+// thinking levels, and list prices a caller needs to pick and price one.
+// Gateways (OpenRouter, Vercel AI Gateway) are listed live from their public
+// models endpoints; model providers come from the bundled Pi catalog.
+
+export type CatalogModel = {
+  // Canonical `provider/native-id`; request it as `dari/model/<id>`.
+  id: string;
+  provider: string;
+  native_model_id: string;
+  name: string;
+  context_window: number | null;
+  max_output_tokens: number | null;
+  input_modalities: string[];
+  // Accepted thinking levels; ["off"] for models that do not reason.
+  thinking_levels: ReasoningEffort[];
+  // List price in USD per million tokens; null when the source publishes
+  // none, e.g. meta-routers whose price depends on the model they pick.
+  price: CatalogModelPrice | null;
+  // When the price was read: the fetch time for gateways, the catalog's
+  // generation time for model providers.
+  price_as_of: string;
+};
+
+export type CatalogModelPrice = {
+  input: number;
+  output: number;
+  cached_input: number | null;
+  cache_write: number | null;
+  // Long-context rates, each applying to prompts above its token threshold.
+  tiers: CatalogPriceTier[];
+};
+
+export type CatalogPriceTier = {
+  input_tokens_above: number;
+  input: number;
+  output: number;
+  cached_input: number | null;
+  cache_write: number | null;
+};
+
+export type ModelCatalogOptions = {
+  // Providers to list; defaults to DEFAULT_CATALOG_PROVIDERS. Any Pi built-in
+  // provider id is accepted.
+  providers?: readonly string[] | undefined;
+  fetch?: ((url: string, init?: RequestInit) => Promise<Response>) | undefined;
+  signal?: AbortSignal | undefined;
+};
+
+export const DEFAULT_CATALOG_PROVIDERS: readonly string[] = [
+  "openai",
+  "anthropic",
+  "meta",
+  "xai",
+  "fireworks",
+  "openrouter",
+  "vercel-ai-gateway",
+];
+
+type LiveListing = {
+  url: string;
+  models: (data: unknown[], asOf: string) => CatalogModel[];
+};
+
+const LIVE_LISTINGS: Record<string, LiveListing> = {
+  openrouter: { url: "https://openrouter.ai/api/v1/models", models: openRouterModels },
+  "vercel-ai-gateway": { url: "https://ai-gateway.vercel.sh/v1/models", models: vercelModels },
+};
+
+/** List the agent-capable models of each requested provider. */
+export async function listModelCatalog(options: ModelCatalogOptions = {}): Promise<CatalogModel[]> {
+  const providers = [...new Set(options.providers ?? DEFAULT_CATALOG_PROVIDERS)];
+  const builtin = new Set<string>(getBuiltinProviders());
+  for (const provider of providers) {
+    if (LIVE_LISTINGS[provider] === undefined && !builtin.has(provider)) {
+      throw new HttpError(400, `Unknown catalog provider '${provider}'.`, "unknown_provider", "provider");
+    }
+  }
+  const lists = await Promise.all(providers.map(async (provider) => {
+    const listing = LIVE_LISTINGS[provider];
+    return listing === undefined
+      ? piModels(provider)
+      : listing.models(await fetchListing(listing.url, options), new Date().toISOString());
+  }));
+  return lists.flat();
+}
+
+async function fetchListing(url: string, options: ModelCatalogOptions): Promise<unknown[]> {
+  let status: number | undefined;
+  let body: unknown = null;
+  // Network errors, aborts, and unparseable bodies are upstream failures
+  // too: all of them surface as catalog_unavailable rather than a raw 500.
+  try {
+    const response = await (options.fetch ?? fetch)(url, {
+      headers: { accept: "application/json" },
+      ...(options.signal ? { signal: options.signal } : {}),
+    });
+    status = response.status;
+    body = response.ok ? await response.json() : null;
+  } catch {
+    // Leaves body null.
+  }
+  if (!isRecord(body) || !Array.isArray(body.data)) {
+    const detail = status === undefined ? "could not be reached" : `returned no model list (HTTP ${status})`;
+    throw new HttpError(502, `${url} ${detail}.`, "catalog_unavailable");
+  }
+  return body.data;
+}
+
+function piModels(provider: string): CatalogModel[] {
+  const generatedAt = getBuiltinModelDataGeneratedAt();
+  const asOf = generatedAt === undefined ? "" : new Date(generatedAt).toISOString();
+  const models = getBuiltinModels(provider as never) as unknown as Model<Api>[];
+  return models.map((model) => ({
+    id: `${provider}/${model.id}`,
+    provider,
+    native_model_id: model.id,
+    name: model.name,
+    context_window: model.contextWindow,
+    max_output_tokens: model.maxTokens,
+    input_modalities: [...model.input],
+    thinking_levels: orderedEfforts(getSupportedThinkingLevels(model)),
+    price: piPrice(model.cost),
+    price_as_of: asOf,
+  }));
+}
+
+function piPrice(cost: Model<Api>["cost"]): CatalogModelPrice {
+  return {
+    input: cost.input,
+    output: cost.output,
+    cached_input: cost.cacheRead,
+    cache_write: cost.cacheWrite,
+    tiers: (cost.tiers ?? []).map((tier) => ({
+      input_tokens_above: tier.inputTokensAbove,
+      input: tier.input,
+      output: tier.output,
+      cached_input: tier.cacheRead,
+      cache_write: tier.cacheWrite,
+    })),
+  };
+}
+
+// https://openrouter.ai/docs/api/api-reference/models/get-models
+function openRouterModels(data: unknown[], asOf: string): CatalogModel[] {
+  return data.filter(isRecord).flatMap((model) => {
+    const architecture = isRecord(model.architecture) ? model.architecture : {};
+    const parameters = stringList(model.supported_parameters);
+    if (typeof model.id !== "string" || !parameters.includes("tools")) return [];
+    if (!stringList(architecture.output_modalities).includes("text")) return [];
+    const reasoning = isRecord(model.reasoning) ? model.reasoning : {};
+    const topProvider = isRecord(model.top_provider) ? model.top_provider : {};
+    return [{
+      id: `openrouter/${model.id}`,
+      provider: "openrouter",
+      native_model_id: model.id,
+      name: typeof model.name === "string" ? model.name : model.id,
+      context_window: positiveInteger(model.context_length),
+      max_output_tokens: positiveInteger(topProvider.max_completion_tokens),
+      input_modalities: stringList(architecture.input_modalities),
+      thinking_levels: gatewayThinkingLevels({
+        reasons: parameters.includes("reasoning"),
+        efforts: Array.isArray(reasoning.supported_efforts) ? stringList(reasoning.supported_efforts) : null,
+        canDisable: reasoning.mandatory !== true,
+      }),
+      price: isRecord(model.pricing) ? openRouterPrice(model.pricing) : null,
+      price_as_of: asOf,
+    }];
+  });
+}
+
+function openRouterPrice(pricing: Record<string, unknown>): CatalogModelPrice | null {
+  const base = rates(pricing, "prompt", "completion");
+  if (base === null) return null;
+  // Overrides restate only the rates they change; time-of-day overrides are
+  // not context tiers.
+  const tiers = (Array.isArray(pricing.overrides) ? pricing.overrides : [])
+    .filter(isRecord)
+    .flatMap((override) => {
+      const threshold = positiveInteger(override.min_prompt_tokens);
+      if (threshold === null || "utc_days" in override || "utc_start" in override || "utc_end" in override) {
+        return [];
+      }
+      const tier = rates({ ...pricing, ...override }, "prompt", "completion", override);
+      return tier === null ? [] : [{ input_tokens_above: threshold, ...tier }];
+    });
+  return { ...base, tiers };
+}
+
+// https://vercel.com/docs/ai-gateway/models-and-providers
+function vercelModels(data: unknown[], asOf: string): CatalogModel[] {
+  return data.filter(isRecord).flatMap((model) => {
+    const modalities = isRecord(model.modalities) ? model.modalities : {};
+    const parameters = stringList(model.supported_parameters);
+    if (typeof model.id !== "string" || model.type !== "language" || !parameters.includes("tools")) return [];
+    if (!stringList(modalities.output).includes("text")) return [];
+    const options = Array.isArray(model.reasoning_options) ? model.reasoning_options.filter(isRecord) : [];
+    const effort = options.find((option) => option.type === "effort");
+    return [{
+      id: `vercel-ai-gateway/${model.id}`,
+      provider: "vercel-ai-gateway",
+      native_model_id: model.id,
+      name: typeof model.name === "string" ? model.name : model.id,
+      context_window: positiveInteger(model.context_window),
+      max_output_tokens: positiveInteger(model.max_tokens),
+      input_modalities: stringList(modalities.input),
+      thinking_levels: gatewayThinkingLevels({
+        reasons: parameters.includes("reasoning") || options.length > 0,
+        efforts: effort === undefined ? null : stringList(effort.values),
+        canDisable: options.length === 0 || options.some((option) => option.type === "toggle"),
+      }),
+      price: isRecord(model.pricing) ? vercelPrice(model.pricing) : null,
+      price_as_of: asOf,
+    }];
+  });
+}
+
+function vercelPrice(pricing: Record<string, unknown>): CatalogModelPrice | null {
+  const base = rates(pricing, "input", "output");
+  if (base === null) return null;
+  // Each rate lists its own {cost, min, max} ranges; a range covers prompts of
+  // at least `min` tokens, so it is the tier above `min - 1`.
+  const ranged = new Map<number, Record<string, unknown>>();
+  for (const key of ["input", "output", "input_cache_read", "input_cache_write"]) {
+    const ranges = Array.isArray(pricing[`${key}_tiers`]) ? pricing[`${key}_tiers`] as unknown[] : [];
+    for (const range of ranges.filter(isRecord)) {
+      const start = positiveInteger(range.min);
+      if (start === null || range.cost == null) continue;
+      ranged.set(start - 1, { ...ranged.get(start - 1), [key]: range.cost });
+    }
+  }
+  const tiers = [...ranged.entries()]
+    .sort(([left], [right]) => left - right)
+    .flatMap(([threshold, stated]) => {
+      const tier = rates({ ...pricing, ...stated }, "input", "output", stated);
+      return tier === null ? [] : [{ input_tokens_above: threshold, ...tier }];
+    });
+  return { ...base, tiers };
+}
+
+// Base rates from per-token strings. A tier inherits input and output from
+// the base price but states its own cache rates, or has none.
+function rates(
+  pricing: Record<string, unknown>,
+  inputKey: string,
+  outputKey: string,
+  cacheRates: Record<string, unknown> = pricing,
+): Omit<CatalogPriceTier, "input_tokens_above"> | null {
+  const input = perMillion(pricing[inputKey]);
+  const output = perMillion(pricing[outputKey]);
+  // Meta-routers with variable prices list negative rates.
+  if (input === null || output === null) return null;
+  return {
+    input,
+    output,
+    cached_input: perMillion(cacheRates.input_cache_read),
+    cache_write: perMillion(cacheRates.input_cache_write),
+  };
+}
+
+// USD per token as a decimal string -> USD per million tokens. Shifting the
+// exponent in the string keeps "0.000001" exactly 1.
+function perMillion(value: unknown): number | null {
+  const rate = typeof value === "string" ? Number(`${value.trim()}e6`)
+    : typeof value === "number" ? value * 1_000_000
+    : Number.NaN;
+  return Number.isFinite(rate) && rate >= 0 ? rate : null;
+}
+
+// Gateways forward `reasoning.effort`; models that reason without a stated
+// effort list take the standard low/medium/high levels.
+function gatewayThinkingLevels(args: {
+  reasons: boolean;
+  efforts: string[] | null;
+  canDisable: boolean;
+}): ReasoningEffort[] {
+  if (!args.reasons) return ["off"];
+  const efforts = args.efforts ?? ["low", "medium", "high"];
+  return orderedEfforts([
+    ...efforts.map((effort) => effort === "none" ? "off" : effort),
+    ...(args.canDisable ? ["off"] : []),
+  ]);
+}
+
+function orderedEfforts(levels: readonly string[]): ReasoningEffort[] {
+  const accepted = new Set(levels.filter(isReasoningEffort));
+  return REASONING_EFFORTS.filter((effort) => accepted.has(effort));
+}
+
+function stringList(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
+}
+
+function positiveInteger(value: unknown): number | null {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : null;
+}

package/src/models/context_limits.ts

@@ -1,4 +1,4 @@
-import type { ResolvedRouterModelConfig } from "../types";
+import type { ResolvedRouterModelConfig } from "../types.js";
 
 export function effectiveContextWindow(config: ResolvedRouterModelConfig | undefined, allowLongContext = false): number | null {
   const window = config?.context_window;

package/src/models/execution_provider.ts

@@ -1,5 +1,5 @@
 import { providerForModel } from "@mupt-ai/dari-router/policy-engine";
-import type { ProviderKeySource, ResolvedRouter } from "../types";
+import type { ProviderKeySource, ResolvedRouter } from "../types.js";
 
 /** Actual serving provider for a canonical model on a resolved managed router. */
 export function executionProviderForModel(
@@ -11,12 +11,15 @@ export function executionProviderForModel(
 }
 
 /**
- * The key that serves a model on a resolved router. Missing declarations are
+ * The key that serves a model on a resolved router: a platform-supplied
+ * credential first, then the resolved provider key. Missing declarations are
  * user-owned so unknown platform data cannot trigger managed-key billing.
  */
 export function keySourceForModel(
   credentials: ResolvedRouter,
   model: string,
 ): ProviderKeySource {
+  const supplied = credentials.provider_credentials?.[model];
+  if (supplied) return supplied.subscription ? "subscription" : "user";
   return credentials.provider_key_sources?.[executionProviderForModel(credentials, model)] ?? "user";
 }

package/src/models/ids.ts

@@ -1,5 +1,5 @@
 import { providerForModel } from "@mupt-ai/dari-router/policy-engine";
-import { HttpError } from "../http/errors";
+import { HttpError } from "../http/errors.js";
 
 export function requireCandidateModels(value: unknown): string[] {
   if (!Array.isArray(value) || value.length === 0) {

package/src/models/provider_defaults.ts

@@ -1,4 +1,4 @@
-import { gatewayFor } from "./gateways";
+import { gatewayFor } from "./gateways.js";
 
 // Built-in model provider presentation and endpoint defaults; gateways carry
 // their own. Mirrors the hosted Dari model catalog's provider defaults; keep
@@ -33,6 +33,9 @@ const PROVIDER_BASE_URLS: Record<string, string> = {
   anthropic: "https://api.anthropic.com",
   fireworks: "https://api.fireworks.ai/inference/v1",
   xai: "https://api.x.ai/v1",
+  // Meta's Model API serves OpenAI Responses and Chat Completions here, and
+  // Anthropic Messages at https://api.meta.ai.
+  meta: "https://api.meta.ai/v1",
   // Pi-ai derives the effective AWS region from the endpoint unless the
   // model config overrides base_url or the native id is an inference profile
   // ARN, so this default only pins us-east-1 when nothing else is configured.

package/src/models/runtime_overrides.ts

@@ -1,6 +1,6 @@
 import { canonicalModelId, isRecord } from "@mupt-ai/dari-router/policy-engine";
 
-import { gatewayFor } from "./gateways";
+import { gatewayFor } from "./gateways.js";
 
 const MODEL_CONTEXT_OVERRIDES: Record<string, number> = {
   // Selector and title models are not router candidate configs, so their
@@ -169,6 +169,28 @@ const MODEL_OFF_WIRE_NONE: ReadonlySet<string> = new Set([
   "deepseek-ai/DeepSeek-V4.1-Flash-1017",
 ]);
 
+// Wire values a provider's API accepts for thinking levels the Pi registry
+// leaves unmapped. Meta's Model API takes reasoning effort "none" on every
+// Muse model (dev.meta.ai/docs/coding-agents).
+const PROVIDER_THINKING_LEVEL_OVERRIDES: Record<string, Record<string, string>> = {
+  meta: { off: "none" },
+};
+
+export function providerThinkingLevelOverrides(provider: string): Record<string, string> | undefined {
+  return PROVIDER_THINKING_LEVEL_OVERRIDES[provider];
+}
+
+/** Registered Pi metadata with the serving provider's thinking level overrides. */
+export function withThinkingLevelOverrides(
+  provider: string,
+  registered: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+  const override = providerThinkingLevelOverrides(provider);
+  if (registered === undefined || override === undefined) return registered;
+  const map = isRecord(registered.thinkingLevelMap) ? registered.thinkingLevelMap : {};
+  return { ...registered, thinkingLevelMap: { ...map, ...override } };
+}
+
 export function offRequiresWireNone(modelId: string): boolean {
   return MODEL_OFF_WIRE_NONE.has(canonicalModelId(modelId));
 }

package/src/models/subscriptions.ts

@@ -0,0 +1,54 @@
+import {
+  nativeModelId,
+  providerForModel,
+  type RouterModelPrice,
+} from "@mupt-ai/dari-router/policy-engine";
+
+import type { ClientHarness, ResolvedRouterModelConfig, SubscriptionKind } from "../types.js";
+
+const CODEX_BACKEND_URL = "https://chatgpt.com/backend-api";
+
+// The model provider whose models each kind of plan serves.
+const SUBSCRIPTION_MODEL_PROVIDERS: Record<SubscriptionKind, string> = {
+  openai_codex: "openai",
+  anthropic_claude_code: "anthropic",
+  meta_muse: "meta",
+};
+
+// The client each plan is limited to, as its provider limits it: a Claude Code
+// plan serves only Claude Code, and a Muse Code plan only Muse Code.
+const SUBSCRIPTION_CLIENTS: Partial<Record<SubscriptionKind, ClientHarness>> = {
+  anthropic_claude_code: "claude_code",
+  meta_muse: "muse_code",
+};
+
+/**
+ * Whether a plan may serve a model for this client: each plan serves only its
+ * own provider's models, and only to the client its provider allows.
+ */
+export function subscriptionServes(
+  kind: SubscriptionKind,
+  model: string,
+  clientHarness: ClientHarness | undefined,
+): boolean {
+  if (SUBSCRIPTION_MODEL_PROVIDERS[kind] !== providerForModel(model)) return false;
+  const client = SUBSCRIPTION_CLIENTS[kind];
+  return client === undefined || clientHarness === client;
+}
+
+// A ChatGPT plan serves OpenAI models as the `openai-codex` provider through
+// the Codex backend.
+export function codexModelConfig(
+  modelId: string,
+  price: RouterModelPrice | null,
+): ResolvedRouterModelConfig {
+  return {
+    provider: "openai-codex",
+    native_model_id: nativeModelId(modelId),
+    api: "openai-codex-responses",
+    base_url: CODEX_BACKEND_URL,
+    // A plan bills no tokens; the catalog price only feeds cost estimates.
+    cost: price ?? { input: 0, output: 0 },
+    fast_mode: false,
+  };
+}

package/src/observability/errors.ts

@@ -2,9 +2,9 @@ import {
   gatewayPlatform,
   type OperationalErrorContext,
   type RequestErrorContext,
-} from "../platform/platform";
+} from "../platform/platform.js";
 
-export type { OperationalErrorCode } from "../platform/platform";
+export type { OperationalErrorCode } from "../platform/platform.js";
 
 export function captureRequestError(
   error: unknown,

package/src/platform/platform.ts

@@ -3,15 +3,15 @@ import type {
   ReasoningEffort,
   RoutingStrategy,
 } from "@mupt-ai/dari-router/policy-engine";
-import type { HarnessConversationIdentity } from "../runtime/harness_identity";
-import type { InteractionRequest, SourceProtocol } from "../interaction/types";
-import type { SubscriptionUsageLimit } from "../providers/subscription_limits";
+import type { HarnessConversationIdentity } from "../runtime/harness_identity/index.js";
+import type { InteractionRequest, SourceProtocol } from "../interaction/types.js";
+import type { SubscriptionUsageLimit } from "../providers/subscription_limits.js";
 import type {
   ClientHarness,
   ProviderCredential,
   ProviderKeySource,
   ResolvedRouter,
-} from "../types";
+} from "../types.js";
 
 /**
  * Everything the gateway runtime needs from the deployment around it: router
@@ -33,7 +33,10 @@ export type GatewayPlatform = {
    * Optional. Supply the credential for one enabled model of this request,
    * consulted after `resolveRouter` and before its provider keys (for the
    * self-hosted gateway, its environment keys), so an embedder can serve
-   * per-tenant keys from its own store. Undefined keeps the resolved key.
+   * per-tenant keys from its own store. Undefined keeps the resolved key. A
+   * credential with `subscription` serves the model on that plan, even on a
+   * strict router; a plan that cannot serve the model for this client (see
+   * SubscriptionKind) is ignored.
    */
   resolveProviderCredential?(
     request: ProviderCredentialRequest,
@@ -74,6 +77,7 @@ export type ProviderCredentialRequest = {
   organizationId: string;
   // The gateway key the request authenticated with.
   apiKey: string;
+  clientHarness?: ClientHarness;
 };
 
 export type PrefixStateWrite = {