@mupt-ai/dari-gateway 0.2.1 → 0.3.1

package/README.md

@@ -64,7 +64,7 @@ docker run -p 8080:8080 \
 | `DARI_GATEWAY_DB` | SQLite database for subscriptions and conversation state. Default `dari-gateway.db`. It stores subscription tokens in plaintext; protect it like a secret. |
 | `DARI_AUTO_ROUTING_API_KEY` | Optional. Select among a router's models with Dari Auto Routing. |
 | `PORT` | Listen port. Default `8080`. |
-| Provider keys | Each provider's standard variable, such as `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, or `OPENROUTER_API_KEY`. |
+| Provider keys | Each provider's standard variable, such as `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `META_API_KEY`, or `OPENROUTER_API_KEY`. |
 
 ## Configure
 
@@ -88,13 +88,17 @@ providers:                 # endpoints outside the built-in catalog
 
 Model ids are `provider/model`. Clients send `model: "dari/routing"` to let the router choose, or `model: "dari/model/<id>"` to pin one of its models. A Claude Code subscription serves Anthropic models only for Claude Code itself; a ChatGPT subscription serves OpenAI models for every client.
 
+### Model catalog
+
+`GET /v1/models?detail=1` (any gateway key; optionally `&provider=openrouter,meta`) and `listModelCatalog({ providers?, fetch?, signal? })` list each provider's tool-capable models as `dari/model/<id>`-ready ids with context window, max output tokens, input modalities, accepted thinking levels, and list prices in USD per million tokens (input, output, cache read, cache write, long-context tiers) with `price_as_of`. OpenRouter and Vercel AI Gateway are read live from their public models endpoints; other providers (default: OpenAI, Anthropic, Meta, xAI, Fireworks) come from the bundled Pi catalog.
+
 ## Coding agents
 
 ```bash
 export DARI_GATEWAY_URL=http://localhost:8080
 export DARI_GATEWAY_KEY=<one of DARI_GATEWAY_KEYS>
 
-dari credentials subscription connect claude-code   # or codex; repeat to pool plans
+dari credentials subscription connect claude-code   # or codex or muse-code; repeat to pool plans
 dari claude
 ```
 
@@ -115,8 +119,8 @@ The root entry needs no Bun APIs, so any runtime with web-standard `fetch`, `Req
 
 Platforms can also:
 
-- implement `resolveProviderCredential({ provider, model, routerId, organizationId, apiKey })` to supply a per-request `{ apiKey, baseUrl?, headers? }`, such as a tenant's own key, in place of the router's resolved key;
-- resolve routers with `strict: true` to serve only the requested `dari/model/<id>` at the requested thinking level, with no selector, lease, fallback, or personal subscription;
+- implement `resolveProviderCredential({ provider, model, routerId, organizationId, apiKey, clientHarness? })` to supply a per-request `{ apiKey, baseUrl?, headers?, subscription? }`, such as a tenant's own key, in place of the router's resolved key. With `subscription` (`"openai_codex"`, `"anthropic_claude_code"`, or `"meta_muse"`), `apiKey` is that plan's access token: Codex's `auth.json` `tokens.access_token`, the token `claude setup-token` prints, or the Model API key a Meta sign-in mints. The platform keeps it fresh. Strict routers serve these supplied plans, but never subscriptions the gateway resolved itself. A plan serves only its own provider's models; a Claude Code plan serves only Claude Code clients, and a Muse Code plan only Muse Code clients (recognized by their `x-client-id`);
+- resolve routers with `strict: true` to serve only the requested `dari/model/<id>` at the requested thinking level, with no selector, lease, fallback, or personal subscription. Set `strict_providers: ["openai"]` on the resolved router to permit any bundled-catalog model from that provider without enumerating `enabled_models`. Use `dari/model/openai/gpt-5.5`; bare IDs and unknown models remain refused. This grant is ignored on non-strict routers and does not discover uncatalogued models;
 - read exact usage from `recordRequest`: the summary carries input, output, cache-read, and cache-write tokens and `total_cost_usd`, preferring the provider's billed cost (`cost_source: "provider"`, from OpenRouter and Vercel AI Gateway). Failed and aborted requests are recorded too;
 - attribute cost with `X-Dari-Tags: run=r1,trial=3`, which is parsed into `RequestRecord.tags` and the `recordUsage` payload's `tags`.
 

package/dist/context/pricing.js

@@ -1,8 +1,12 @@
+import { registeredModelPrice } from "../providers/pi.js";
 export function pricingLookupForRouter(credentials) {
     return (model) => modelPricingForRouter(credentials, model);
 }
 export function modelPricingForRouter(credentials, model) {
-    const price = credentials.model_prices?.[model];
+    // A model the platform neither prices nor configures is served from Pi's
+    // catalog (see buildModel), so its catalog price is the one it is billed at.
+    const price = credentials.model_prices?.[model]
+        ?? (credentials.model_configs?.[model] === undefined ? registeredModelPrice(model) : null);
     if (!price || typeof price.input !== "number" || typeof price.output !== "number")
         return null;
     // Null cached rates mean the provider publishes none: bill cached prompt

package/dist/http/handler.js

@@ -1,5 +1,6 @@
 import { handleResponses, handleResponsesWebSocketFallback, } from "../ingress/codex.js";
 import { handleModels } from "../ingress/models.js";
+import { handleMuseCodeModels } from "../ingress/muse_models.js";
 import { handleChatCompletions } from "../ingress/chat_completions.js";
 import { handleAnthropicMessages } from "../ingress/anthropic_messages.js";
 import { bindGatewayPlatform } from "../platform/platform.js";
@@ -19,6 +20,12 @@ export function createRequestHandler(options) {
             (url.pathname === "/healthz" || url.pathname === "/health")) {
             return Response.json({ status: "ok" });
         }
+        // Muse Code reads its model list from its base URL's origin; `dari muse`
+        // forwards it to the router's own path.
+        const museModels = url.pathname.match(/^(?:\/([^/]+))?\/muse-code\/models$/);
+        if (request.method === "GET" && museModels !== null) {
+            return await handleMuseCodeModels(request, museModels[1] ?? DEFAULT_ROUTER_ALIAS);
+        }
         // Claude Code probes this first-party endpoint before its Messages call
         // when ANTHROPIC_BASE_URL points at a compatible gateway.
         if (request.method === "HEAD" && url.pathname === "/api/hello") {

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { createRequestHandler, type GatewayHandlerOptions } from "./http/handler.js";
 export type { GatewayPlatform, OperationalErrorContext, PendingLeaseWrite, PrefixStateWrite, ProviderCredentialRequest, RequestErrorContext, RequestRecord, RequestSummary, RequestTags, ResolveRouterRequest, SubscriptionHold, } from "./platform/platform.js";
+export { DEFAULT_CATALOG_PROVIDERS, listModelCatalog, type CatalogModel, type CatalogModelPrice, type CatalogPriceTier, type ModelCatalogOptions, } from "./models/catalog.js";
 export { createAutoRoutingSelectorBackend } from "./strategies/auto_routing_selector.js";
 export { createPrioritySelectorBackend } from "./strategies/priority_selector.js";
 export { createLlmSelectorBackend, type SelectorBackend } from "./strategies/routing.js";
-export type { ProviderCredential, ResolvedRouter } from "./types.js";
+export type { ProviderCredential, ResolvedRouter, SubscriptionKind } from "./types.js";

package/dist/index.js

@@ -3,6 +3,7 @@
 // gateway with their own platform. This entry needs no Bun APIs; the Bun
 // server and the SQLite-backed self-hosted gateway live in `./bun`.
 export { createRequestHandler } from "./http/handler.js";
+export { DEFAULT_CATALOG_PROVIDERS, listModelCatalog, } from "./models/catalog.js";
 export { createAutoRoutingSelectorBackend } from "./strategies/auto_routing_selector.js";
 export { createPrioritySelectorBackend } from "./strategies/priority_selector.js";
 export { createLlmSelectorBackend } from "./strategies/routing.js";

package/dist/ingress/chat_completions.js

@@ -6,21 +6,28 @@ import { chatCompletionsToInteraction } from "../protocol/input/chat_completions
 import { handleRoutedCompletion } from "../runtime/routed_completion.js";
 import { chatCompletionsConversationIdentity, openCodeRequestContext, } from "../runtime/harness_identity/index.js";
 import { parseJsonRequest } from "./json.js";
+import { museCodeClientId } from "./muse_code.js";
 export async function handleChatCompletions(request, routerId, selectorBackend) {
     try {
         const apiKey = bearerToken(request.headers);
         const payload = await parseJsonRequest(request);
         const interaction = chatCompletionsToInteraction({ ...payload, source_protocol: "openai_chat" });
         const agentContext = openCodeRequestContext(request.headers);
+        const museClientId = museCodeClientId(request.headers);
         return await handleRoutedCompletion({
             request,
             routerId,
             apiKey,
-            payload: agentContext === undefined ? interaction : { ...interaction, agentContext },
+            payload: {
+                ...interaction,
+                ...(agentContext === undefined ? {} : { agentContext }),
+                ...(museClientId === undefined ? {} : { museCodeClientId: museClientId }),
+            },
             responseBody: chatCompletionResponse,
             streamBody: chatCompletionsSseStream,
             errorResponse,
             selectorBackend,
+            clientHarness: museClientId === undefined ? undefined : "muse_code",
             harnessConversationIdentity: chatCompletionsConversationIdentity(request.headers, payload.prompt_cache_key),
         });
     }

package/dist/ingress/codex.js

@@ -5,6 +5,7 @@ import { openAIResponsesResponse } from "../protocol/output/openai_responses.js"
 import { openAIResponsesSseStream } from "../protocol/output/openai_responses_stream.js";
 import { openAIResponsesToInteraction } from "../protocol/input/openai_responses.js";
 import { parseJsonRequest } from "./json.js";
+import { museCodeClientId } from "./muse_code.js";
 import { handleRoutedCompletion } from "../runtime/routed_completion.js";
 import { codexConversationIdentity, codexRequestPurpose, codexRequestContext, } from "../runtime/harness_identity/index.js";
 export async function handleResponses(request, routerId, selectorBackend) {
@@ -14,10 +15,12 @@ export async function handleResponses(request, routerId, selectorBackend) {
         const interaction = openAIResponsesToInteraction(rawPayload);
         const requestPurpose = codexRequestPurpose(request.headers, rawPayload);
         const agentContext = codexRequestContext(request.headers, rawPayload);
+        const museClientId = museCodeClientId(request.headers);
         const payload = {
             ...interaction,
             ...(requestPurpose === undefined ? {} : { requestPurpose }),
             ...(agentContext === undefined ? {} : { agentContext }),
+            ...(museClientId === undefined ? {} : { museCodeClientId: museClientId }),
         };
         const harnessConversationIdentity = codexConversationIdentity(request.headers, rawPayload);
         // Codex applies its global model_reasoning_effort setting to custom model
@@ -35,6 +38,7 @@ export async function handleResponses(request, routerId, selectorBackend) {
             streamBody: openAIResponsesSseStream,
             errorResponse,
             selectorBackend,
+            clientHarness: museClientId === undefined ? undefined : "muse_code",
             harnessConversationIdentity,
         });
     }

package/dist/ingress/models.js

@@ -2,11 +2,14 @@
    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.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";
@@ -23,6 +26,15 @@ export async function handleModels(request, routerId) {
         // 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/dist/ingress/muse_code.d.ts

@@ -0,0 +1,2 @@
+/** Muse Code's x-client-id when the request comes from Muse Code. */
+export declare function museCodeClientId(headers: Headers): string | undefined;

package/dist/ingress/muse_code.js

@@ -0,0 +1,8 @@
+// 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) {
+    const clientId = headers.get("x-client-id")?.trim().toLowerCase();
+    return clientId !== undefined && MUSE_CODE_CLIENT_IDS.has(clientId) ? clientId : undefined;
+}

package/dist/ingress/muse_models.d.ts

@@ -0,0 +1,9 @@
+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 declare function museCodeModelsResponse(router: Pick<ResolvedRouter, "enabled_models" | "autorouting_enabled">): Record<string, unknown>;
+export declare function handleMuseCodeModels(request: Request, routerId: string): Promise<Response>;

package/dist/ingress/muse_models.js

@@ -0,0 +1,32 @@
+import { bearerToken } from "../http/auth.js";
+import { errorResponse } from "../http/errors.js";
+import { resolveRouter } from "../strategies/routing.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) {
+    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, routerId) {
+    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/dist/interaction/types.d.ts

@@ -161,6 +161,7 @@ export type InteractionRequest = {
     requestPurpose?: InteractionRequestPurpose;
     agentContext?: AgentRequestContext;
     claudeCodeUserAgent?: string;
+    museCodeClientId?: string;
     anthropicSafeguards?: AnthropicSafeguards;
     model?: string;
     instructions?: string;

package/dist/models/catalog.d.ts

@@ -0,0 +1,35 @@
+import { type ReasoningEffort } from "@mupt-ai/dari-router/policy-engine";
+export type CatalogModel = {
+    id: string;
+    provider: string;
+    native_model_id: string;
+    name: string;
+    context_window: number | null;
+    max_output_tokens: number | null;
+    input_modalities: string[];
+    thinking_levels: ReasoningEffort[];
+    price: CatalogModelPrice | null;
+    price_as_of: string;
+};
+export type CatalogModelPrice = {
+    input: number;
+    output: number;
+    cached_input: number | null;
+    cache_write: number | null;
+    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?: readonly string[] | undefined;
+    fetch?: ((url: string, init?: RequestInit) => Promise<Response>) | undefined;
+    signal?: AbortSignal | undefined;
+};
+export declare const DEFAULT_CATALOG_PROVIDERS: readonly string[];
+/** List the agent-capable models of each requested provider. */
+export declare function listModelCatalog(options?: ModelCatalogOptions): Promise<CatalogModel[]>;

package/dist/models/catalog.js

@@ -0,0 +1,232 @@
+import { getSupportedThinkingLevels } from "@mupt-ai/pi-ai";
+import { getBuiltinModelDataGeneratedAt, getBuiltinModels, getBuiltinProviders, } from "@mupt-ai/pi-ai/providers/all";
+import { REASONING_EFFORTS, isReasoningEffort, isRecord, } from "@mupt-ai/dari-router/policy-engine";
+import { HttpError } from "../http/errors.js";
+export const DEFAULT_CATALOG_PROVIDERS = [
+    "openai",
+    "anthropic",
+    "meta",
+    "xai",
+    "fireworks",
+    "openrouter",
+    "vercel-ai-gateway",
+];
+const LIVE_LISTINGS = {
+    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 = {}) {
+    const providers = [...new Set(options.providers ?? DEFAULT_CATALOG_PROVIDERS)];
+    const builtin = new Set(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, options) {
+    let status;
+    let body = 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) {
+    const generatedAt = getBuiltinModelDataGeneratedAt();
+    const asOf = generatedAt === undefined ? "" : new Date(generatedAt).toISOString();
+    const models = getBuiltinModels(provider);
+    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) {
+    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, asOf) {
+    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) {
+    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, asOf) {
+    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) {
+    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();
+    for (const key of ["input", "output", "input_cache_read", "input_cache_write"]) {
+        const ranges = Array.isArray(pricing[`${key}_tiers`]) ? pricing[`${key}_tiers`] : [];
+        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, inputKey, outputKey, cacheRates = pricing) {
+    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) {
+    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) {
+    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) {
+    const accepted = new Set(levels.filter(isReasoningEffort));
+    return REASONING_EFFORTS.filter((effort) => accepted.has(effort));
+}
+function stringList(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : null;
+}

package/dist/models/execution_provider.d.ts

@@ -2,7 +2,8 @@ import type { ProviderKeySource, ResolvedRouter } from "../types.js";
 /** Actual serving provider for a canonical model on a resolved managed router. */
 export declare function executionProviderForModel(credentials: ResolvedRouter, model: string): string;
 /**
- * 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 declare function keySourceForModel(credentials: ResolvedRouter, model: string): ProviderKeySource;

package/dist/models/execution_provider.js

@@ -5,9 +5,13 @@ export function executionProviderForModel(credentials, model) {
     return configured || providerForModel(model);
 }
 /**
- * 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, model) {
+    const supplied = credentials.provider_credentials?.[model];
+    if (supplied)
+        return supplied.subscription ? "subscription" : "user";
     return credentials.provider_key_sources?.[executionProviderForModel(credentials, model)] ?? "user";
 }

package/dist/models/provider_defaults.js

@@ -28,6 +28,9 @@ const PROVIDER_BASE_URLS = {
     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/dist/models/runtime_overrides.d.ts

@@ -1,3 +1,6 @@
+export declare function providerThinkingLevelOverrides(provider: string): Record<string, string> | undefined;
+/** Registered Pi metadata with the serving provider's thinking level overrides. */
+export declare function withThinkingLevelOverrides(provider: string, registered: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
 export declare function offRequiresWireNone(modelId: string): boolean;
 export declare function contextWindowOverride(modelId: string): number | undefined;
 export declare function inputModalitiesOverride(modelId: string): string[] | undefined;

package/dist/models/runtime_overrides.js

@@ -161,6 +161,23 @@ const MODEL_OFF_WIRE_NONE = new Set([
     "deepseek-ai/DeepSeek-V4-Flash-0731",
     "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 = {
+    meta: { off: "none" },
+};
+export function providerThinkingLevelOverrides(provider) {
+    return PROVIDER_THINKING_LEVEL_OVERRIDES[provider];
+}
+/** Registered Pi metadata with the serving provider's thinking level overrides. */
+export function withThinkingLevelOverrides(provider, registered) {
+    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) {
     return MODEL_OFF_WIRE_NONE.has(canonicalModelId(modelId));
 }

package/dist/models/subscriptions.d.ts

@@ -0,0 +1,8 @@
+import { type RouterModelPrice } from "@mupt-ai/dari-router/policy-engine";
+import type { ClientHarness, ResolvedRouterModelConfig, SubscriptionKind } from "../types.js";
+/**
+ * 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 declare function subscriptionServes(kind: SubscriptionKind, model: string, clientHarness: ClientHarness | undefined): boolean;
+export declare function codexModelConfig(modelId: string, price: RouterModelPrice | null): ResolvedRouterModelConfig;

package/dist/models/subscriptions.js

@@ -0,0 +1,37 @@
+import { nativeModelId, providerForModel, } from "@mupt-ai/dari-router/policy-engine";
+const CODEX_BACKEND_URL = "https://chatgpt.com/backend-api";
+// The model provider whose models each kind of plan serves.
+const SUBSCRIPTION_MODEL_PROVIDERS = {
+    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 = {
+    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, model, clientHarness) {
+    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, price) {
+    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,
+    };
+}