@mupt-ai/dari-gateway 0.2.1 → 0.3.0

package/dist/self_host/subscriptions/oauth.js

@@ -2,13 +2,17 @@ import { createHash, randomBytes } from "node:crypto";
 export const SUBSCRIPTION_PROVIDERS = [
     "anthropic_claude_code",
     "openai_codex",
+    "meta_muse",
 ];
 /** The provider refused or could not be reached (HTTP 502 at the edge). */
 export class SubscriptionOAuthProviderError extends Error {
     status;
-    constructor(message, status) {
+    errorCode;
+    // `errorCode` is the provider's OAuth `error` code, such as `authorization_pending`.
+    constructor(message, status, errorCode) {
         super(message);
         this.status = status;
+        this.errorCode = errorCode;
         this.name = "SubscriptionOAuthProviderError";
     }
 }
@@ -36,6 +40,20 @@ const CODEX_TOKEN_URL = `${OPENAI_AUTH_BASE_URL}/oauth/token`;
 const CODEX_REDIRECT_URI = `${OPENAI_AUTH_BASE_URL}/deviceauth/callback`;
 const CODEX_ACCOUNT_CLAIM = "https://api.openai.com/auth";
 export const CODEX_APPROVAL_PENDING = "OpenAI approval is still pending. Enter the code at OpenAI, finish approval, then try again.";
+// Muse Code's own device sign-in (`muse login`), as its public launcher runs it.
+export const MUSE_CODE_CLIENT_ID = "1031625952748946";
+const META_AUTH_BASE_URL = "https://auth.meta.com";
+const META_DEVICE_AUTHORIZATION_URL = `${META_AUTH_BASE_URL}/oidc/device/authorization/`;
+const META_TOKEN_URL = `${META_AUTH_BASE_URL}/oidc/device/token/`;
+// Muse Code mints its subscription's Model API key from the sign-in token here.
+const MUSE_MINT_URL = "https://api.meta.ai/muse-code/key";
+// Meta states no lifetime for a minted key, and Muse Code mints a fresh one at
+// every start, so the key is minted again on this cadence.
+const MUSE_KEY_LIFETIME_MS = 12 * 60 * 60_000;
+// Marks a stored sign-in refresh token, which is exchanged for a fresh sign-in
+// token before each mint. Without it the stored value is the sign-in token.
+const MUSE_SIGN_IN_REFRESH_PREFIX = "refresh:";
+export const META_APPROVAL_PENDING = "Meta approval is still pending. Enter the code at Meta, finish approval, then try again.";
 export async function startOAuth(provider, options) {
     const expiresAt = new Date((options.now ?? new Date()).getTime() + FLOW_TIMEOUT_MS);
     if (provider === "anthropic_claude_code") {
@@ -60,6 +78,18 @@ export async function startOAuth(provider, options) {
             flow: { code_verifier: verifier, state },
         };
     }
+    if (provider === "meta_muse") {
+        const payload = await postForm(options.fetch, META_DEVICE_AUTHORIZATION_URL, { client_id: MUSE_CODE_CLIENT_ID }, "Meta device code request");
+        const complete = payload.verification_uri_complete;
+        return {
+            authorizationUrl: typeof complete === "string" && complete.startsWith("https://")
+                ? complete
+                : requiredString(payload, "verification_uri"),
+            expiresAt,
+            userCode: requiredString(payload, "user_code"),
+            flow: { device_code: requiredString(payload, "device_code") },
+        };
+    }
     const payload = await postJson(options.fetch, `${CODEX_DEVICE_AUTH_URL}/usercode`, { client_id: CODEX_CLIENT_ID }, "OpenAI device code request");
     const userCode = requiredString({ user_code: payload.user_code || payload.usercode }, "user_code");
     return {
@@ -71,7 +101,7 @@ export async function startOAuth(provider, options) {
 }
 /**
  * Finish a flow. Claude Code needs the pasted authorization response; the
- * device-code flow ignores it and asks OpenAI whether the user approved.
+ * device-code flows ignore it and ask the provider whether the user approved.
  */
 export async function completeOAuth(provider, flow, authorizationResponse, options) {
     const now = options.now ?? new Date();
@@ -95,6 +125,31 @@ export async function completeOAuth(provider, flow, authorizationResponse, optio
         }, "Anthropic subscription token exchange");
         return claudeTokens(token, now, null);
     }
+    if (provider === "meta_muse") {
+        let token;
+        try {
+            token = await postForm(options.fetch, META_TOKEN_URL, {
+                grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                device_code: requiredString(flow, "device_code"),
+                client_id: MUSE_CODE_CLIENT_ID,
+            }, "Meta device approval check");
+        }
+        catch (error) {
+            if (error instanceof SubscriptionOAuthProviderError) {
+                if (error.errorCode === "authorization_pending" || error.errorCode === "slow_down") {
+                    throw new SubscriptionOAuthInputError(META_APPROVAL_PENDING);
+                }
+                if (error.errorCode === "access_denied") {
+                    throw new SubscriptionOAuthInputError("The sign-in was declined on Meta. Start again to retry.");
+                }
+                if (error.errorCode === "expired_token") {
+                    throw new SubscriptionOAuthInputError("The Meta sign-in code expired. Start again.");
+                }
+            }
+            throw error;
+        }
+        return await museTokens(requiredString(token, "access_token"), museRefreshToken(token), options.fetch, now);
+    }
     // The provider, not user-supplied input, supplies the authorization code.
     let approval;
     try {
@@ -129,6 +184,23 @@ export async function refreshOAuth(credential, options) {
         }, "Anthropic subscription token refresh");
         return claudeTokens(token, now, credential.refreshToken);
     }
+    if (credential.provider === "meta_muse") {
+        let stored = credential.refreshToken;
+        let signInToken = stored;
+        if (stored.startsWith(MUSE_SIGN_IN_REFRESH_PREFIX)) {
+            const token = await postForm(options.fetch, META_TOKEN_URL, {
+                grant_type: "refresh_token",
+                refresh_token: stored.slice(MUSE_SIGN_IN_REFRESH_PREFIX.length),
+                client_id: MUSE_CODE_CLIENT_ID,
+            }, "Meta sign-in refresh");
+            signInToken = requiredString(token, "access_token");
+            stored = museRefreshToken(token) ?? stored;
+        }
+        // A lapsed plan fails routing like any other refresh failure.
+        return await museTokens(signInToken, stored, options.fetch, now).catch((error) => {
+            throw error instanceof SubscriptionOAuthInputError ? new SubscriptionOAuthProviderError(error.message) : error;
+        });
+    }
     const token = await postJson(options.fetch, CODEX_TOKEN_URL, {
         grant_type: "refresh_token",
         refresh_token: credential.refreshToken,
@@ -171,6 +243,27 @@ function claudeTokens(payload, now, fallbackRefreshToken) {
         accountEmail: typeof email === "string" && email ? email : null,
     };
 }
+function museRefreshToken(token) {
+    const value = token.refresh_token;
+    return typeof value === "string" && value ? MUSE_SIGN_IN_REFRESH_PREFIX + value : null;
+}
+// Mints the plan's Model API key from the Meta sign-in token.
+async function museTokens(signInToken, refreshToken, fetch, now) {
+    const minted = await requestJson(fetch, MUSE_MINT_URL, "{}", "application/json", "Muse Code subscription key mint", { Authorization: `Bearer ${signInToken}`, "x-api-version": "1.0.0" });
+    // A key minted without an active plan bills Model API pay-as-you-go.
+    if (minted.is_subs_active !== true) {
+        throw new SubscriptionOAuthInputError("This Meta account has no active Muse Code subscription. Subscribe at https://accountscenter.meta.com/muse_code/, then connect again.");
+    }
+    const email = minted.user_email;
+    return {
+        provider: "meta_muse",
+        accessToken: requiredString(minted, "api_key"),
+        refreshToken: refreshToken ?? signInToken,
+        expiresAt: new Date(now.getTime() + MUSE_KEY_LIFETIME_MS),
+        accountId: null,
+        accountEmail: typeof email === "string" && email ? email : null,
+    };
+}
 function codexTokens(payload, now, fallbackRefreshToken, fallbackAccountId) {
     const accessToken = requiredString(payload, "access_token");
     const refreshToken = refreshTokenFrom(payload, fallbackRefreshToken);
@@ -242,12 +335,12 @@ function postJson(fetch, url, payload, operation) {
 function postForm(fetch, url, payload, operation) {
     return requestJson(fetch, url, new URLSearchParams(payload).toString(), "application/x-www-form-urlencoded", operation);
 }
-async function requestJson(fetch, url, body, contentType, operation) {
+async function requestJson(fetch, url, body, contentType, operation, headers = {}) {
     let response;
     try {
         response = await fetch(url, {
             method: "POST",
-            headers: { Accept: "application/json", "Content-Type": contentType, "User-Agent": "Dari/1.0" },
+            headers: { Accept: "application/json", "Content-Type": contentType, "User-Agent": "Dari/1.0", ...headers },
             body,
             signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
         });
@@ -256,8 +349,10 @@ async function requestJson(fetch, url, body, contentType, operation) {
         throw new SubscriptionOAuthProviderError(`${operation} could not reach the provider.`);
     }
     if (!response.ok) {
-        await response.body?.cancel();
-        throw new SubscriptionOAuthProviderError(`${operation} failed with provider status ${response.status}.`, response.status);
+        // Only the RFC 6749 `error` code is kept; the rest may carry provider detail.
+        const failure = await response.json().catch(() => undefined);
+        const errorCode = isRecord(failure) && typeof failure.error === "string" ? failure.error : undefined;
+        throw new SubscriptionOAuthProviderError(`${operation} failed with provider status ${response.status}.`, response.status, errorCode);
     }
     let decoded;
     try {

package/dist/self_host/subscriptions/store.js

@@ -2,6 +2,7 @@ import { randomBytes, randomUUID } from "node:crypto";
 const BASE_NAMES = {
     anthropic_claude_code: "ANTHROPIC_CLAUDE_CODE_OAUTH_TOKEN",
     openai_codex: "OPENAI_CODEX_OAUTH_TOKEN",
+    meta_muse: "META_MUSE_OAUTH_TOKEN",
 };
 export class SubscriptionStore {
     db;

package/dist/types.d.ts

@@ -18,10 +18,12 @@ export type AwsAssumeRoleProviderAuth = {
     region: string;
 };
 export type ResolvedProviderAuth = BearerProviderAuth | AwsSigV4ProviderAuth;
+export type SubscriptionKind = "openai_codex" | "anthropic_claude_code" | "meta_muse";
 export type ProviderCredential = {
     apiKey: string;
     baseUrl?: string;
     headers?: Record<string, string>;
+    subscription?: SubscriptionKind;
 };
 export type ProviderAuth = ResolvedProviderAuth | AwsAssumeRoleProviderAuth;
 export type AwsProviderAuth = AwsSigV4ProviderAuth | AwsAssumeRoleProviderAuth;
@@ -39,7 +41,7 @@ export type PublicEvalCatalogCard = Omit<RouterEval, "scores"> & {
     updated_at: string | null;
     scores: PublicEvalCatalogScore[];
 };
-export type ClientHarness = "claude_code";
+export type ClientHarness = "claude_code" | "muse_code";
 export type ResolvedRouterModelConfig = {
     provider: string;
     native_model_id: string;
@@ -74,6 +76,7 @@ export type ResolvedRouter = {
     speculative_routing?: boolean;
     primary_retries?: number;
     strict?: boolean;
+    strict_providers?: string[];
     model_fallback_enabled?: boolean;
     fallback_requires_different_provider?: boolean;
     evals?: RouterEval[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mupt-ai/dari-gateway",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Self-hostable LLM gateway for coding agents and APIs: one endpoint for Anthropic Messages, OpenAI Chat Completions, and OpenAI Responses, with subscription pooling, failover, and prompt-cache-aware routing.",
   "license": "Apache-2.0",
   "repository": {
@@ -49,7 +49,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-sts": "3.1063.0",
-    "@mupt-ai/dari-router": "0.2.4",
+    "@mupt-ai/dari-router": "0.2.5",
     "@mupt-ai/pi-ai": "1.4.0-mupt.1"
   },
   "devDependencies": {

package/src/context/pricing.ts

@@ -1,7 +1,7 @@
 import type { ModelPricing, PricingLookup } from "@mupt-ai/dari-router/policy-engine";
+import { registeredModelPrice } from "../providers/pi.js";
 import type { ResolvedRouter } from "../types.js";
 
-
 export function pricingLookupForRouter(credentials: ResolvedRouter): PricingLookup {
   return (model: string): ModelPricing | null => modelPricingForRouter(credentials, model);
 }
@@ -10,7 +10,10 @@ export function modelPricingForRouter(
   credentials: ResolvedRouter,
   model: string,
 ): ModelPricing | null {
-  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
   // buckets at the input rate, never for free.

package/src/http/handler.ts

@@ -3,6 +3,7 @@ import {
   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, type GatewayPlatform } from "../platform/platform.js";
@@ -31,6 +32,12 @@ export function createRequestHandler(options: GatewayHandlerOptions) {
     ) {
       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/src/index.ts

@@ -16,7 +16,15 @@ export type {
   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/src/ingress/chat_completions.ts

@@ -11,6 +11,7 @@ import {
   openCodeRequestContext,
 } from "../runtime/harness_identity/index.js";
 import { parseJsonRequest } from "./json.js";
+import { museCodeClientId } from "./muse_code.js";
 
 export async function handleChatCompletions(
   request: Request,
@@ -22,15 +23,21 @@ export async function handleChatCompletions(
     const payload = await parseJsonRequest<ChatCompletionRequest>(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/src/ingress/codex.ts

@@ -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 type { SelectorBackend } from "../strategies/routing.js";
 import {
@@ -24,10 +25,12 @@ export async function handleResponses(
     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,
@@ -47,6 +50,7 @@ export async function handleResponses(
       streamBody: openAIResponsesSseStream,
       errorResponse,
       selectorBackend,
+      clientHarness: museClientId === undefined ? undefined : "muse_code",
       harnessConversationIdentity,
     });
   } catch (error) {

package/src/ingress/models.ts

@@ -2,12 +2,15 @@
    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";
@@ -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/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;