@mupt-ai/dari-gateway 0.2.0 → 0.3.0

package/src/runtime/routed_runtime.ts

@@ -8,8 +8,8 @@ import {
   type RoutingDecision,
 } from "@mupt-ai/dari-router/policy-engine";
 
-import { buildRoutingContext } from "../context/routing_context";
-import type { InteractionRequest } from "../interaction/types";
+import { buildRoutingContext } from "../context/routing_context.js";
+import type { InteractionRequest } from "../interaction/types.js";
 import {
   completeNonStreaming,
   executeNonStreaming,
@@ -17,7 +17,7 @@ import {
   prepareStreamingExecution,
   type CompletedNonStreamingExecution,
   type ProviderChoice,
-} from "../providers/execution";
+} from "../providers/execution.js";
 import {
   prepareProviderExecution,
   startProviderCompletion,
@@ -25,16 +25,16 @@ import {
   type ProviderExecution,
   type StartedCompletion,
   type StartedStream,
-} from "../providers/provider_call";
-import type { SelectorBackend } from "../strategies/routing";
-import { routeDecision, type RoutedDecision } from "../strategies/route_decision";
-import { executionProviderForModel } from "../models/execution_provider";
-import { trackBackgroundTelemetry } from "../telemetry/background";
-import { estimateBenchmarkReplay } from "../telemetry/benchmark_replay";
-import { buildCompletedPrefixHit } from "../telemetry/prefix_state";
-import { scrubSecrets } from "../telemetry/scrub";
-import type { ResolvedRouter } from "../types";
-import type { PreparedRoutedCompletion } from "./prepare_routed_completion";
+} from "../providers/provider_call.js";
+import type { SelectorBackend } from "../strategies/routing.js";
+import { routeDecision, type RoutedDecision } from "../strategies/route_decision.js";
+import { executionProviderForModel } from "../models/execution_provider.js";
+import { trackBackgroundTelemetry } from "../telemetry/background.js";
+import { estimateBenchmarkReplay } from "../telemetry/benchmark_replay.js";
+import { buildCompletedPrefixHit } from "../telemetry/prefix_state.js";
+import { scrubSecrets } from "../telemetry/scrub.js";
+import type { ResolvedRouter } from "../types.js";
+import type { PreparedRoutedCompletion } from "./prepare_routed_completion.js";
 import { auxiliaryDecision } from "./claude_code/auxiliary_routing.js";
 import { explicitModelDecision, strictModelDecision } from "./explicit_model.js";
 import {
@@ -47,12 +47,12 @@ import {
   prefetchNextLease,
   selectorNegotiatesLeases,
 } from "./routing_lease.js";
-import type { RoutedProtocol } from "./routed_protocol";
+import type { RoutedProtocol } from "./routed_protocol.js";
 import {
   createExperimentRoutedRuntimeReporter,
   type RoutedRuntimeReporter,
-} from "./runtime_reporter";
-import { HttpError } from "../http/errors";
+} from "./runtime_reporter.js";
+import { HttpError } from "../http/errors.js";
 
 type SpeculativeExecution = {
   decision: RoutingDecision;
@@ -113,12 +113,12 @@ export type {
   SelectorAdapterArgs,
   SelectorBackend,
   SelectorRun,
-} from "../strategies/routing";
+} from "../strategies/routing.js";
 export type {
   ExperimentRoutedRuntimeReporter,
   RoutedRuntimeReporter,
-} from "./runtime_reporter";
-export { createExperimentRoutedRuntimeReporter } from "./runtime_reporter";
+} from "./runtime_reporter.js";
+export { createExperimentRoutedRuntimeReporter } from "./runtime_reporter.js";
 
 export async function runPreparedRoutedCompletion(args: {
   prepared: PreparedRoutedCompletion;
@@ -709,6 +709,7 @@ const inProcessProtocol: RoutedProtocol = {
       selected_model: args.routing.selectedModel,
       reasoning_effort: args.routing.reasoningEffort,
       reason: args.routing.reason,
+      request_id: args.id,
       ...(args.conversationId ? { conversation_id: args.conversationId } : {}),
     },
   }),

package/src/runtime/routing_lease.ts

@@ -6,16 +6,16 @@ import {
   type RoutingDecision,
 } from "@mupt-ai/dari-router/policy-engine";
 
-import { deriveFallbackDecision } from "../strategies/fallback_decision";
-import { executionProviderForModel } from "../models/execution_provider";
-import type { SelectorBackend } from "../strategies/routing";
+import { deriveFallbackDecision } from "../strategies/fallback_decision.js";
+import { executionProviderForModel } from "../models/execution_provider.js";
+import type { SelectorBackend } from "../strategies/routing.js";
 import {
   routeDecision,
   type RoutedDecision,
-} from "../strategies/route_decision";
-import { reportPendingLease } from "../telemetry/prefix_state";
-import { scrubSecrets } from "../telemetry/scrub";
-import type { PreparedRoutedCompletion } from "./prepare_routed_completion";
+} from "../strategies/route_decision.js";
+import { reportPendingLease } from "../telemetry/prefix_state.js";
+import { scrubSecrets } from "../telemetry/scrub.js";
+import type { PreparedRoutedCompletion } from "./prepare_routed_completion.js";
 
 export type RoutingLeaseDecision = {
   decision: RoutingDecision;

package/src/runtime/runtime_reporter.ts

@@ -1,7 +1,7 @@
 import type { RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
-import type { InteractionOutput } from "../interaction/types";
-import type { SelectorRun } from "../strategies/routing";
-import type { ProviderKeySource } from "../types";
+import type { InteractionOutput } from "../interaction/types.js";
+import type { SelectorRun } from "../strategies/routing.js";
+import type { ProviderKeySource } from "../types.js";
 
 export type ReportedProviderExecution = {
   provider: string;

package/src/runtime/strict_provider_access.ts

@@ -0,0 +1,42 @@
+import { getBuiltinModels, getBuiltinProviders } from "@mupt-ai/pi-ai/providers/all";
+import { HttpError } from "../http/errors.js";
+import type { InteractionRequest } from "../interaction/types.js";
+import { explicitModelId } from "../protocol/input/router_model.js";
+import type { ResolvedRouter } from "../types.js";
+import { modelNotEnabled, strictModelRequired } from "./explicit_model.js";
+
+// Resolve only the requested catalog model, never turn a provider grant into
+// selector candidates. Unknown IDs fail closed; a grant-only router has no
+// candidates to route among, so it refuses them here with the strict errors.
+export function strictProviderAccess(
+  credentials: ResolvedRouter,
+  interaction: InteractionRequest,
+): { credentials: ResolvedRouter; interaction: InteractionRequest } {
+  const providers = credentials.strict_providers;
+  if (credentials.strict !== true || !providers?.length) return { credentials, interaction };
+  const requested = explicitModelId(interaction.model);
+  const grantOnly = credentials.enabled_models.length === 0;
+  if (requested === null) {
+    if (grantOnly) throw strictModelRequired();
+    return { credentials, interaction };
+  }
+  const matches = new Set<string>();
+  for (const provider of providers) {
+    if (!(getBuiltinProviders() as readonly string[]).includes(provider)) {
+      throw new HttpError(400, `Unknown strict provider '${provider}'.`, "unknown_provider");
+    }
+    for (const model of getBuiltinModels(provider as never)) {
+      const id = `${provider}/${model.id}`;
+      if (requested === id) matches.add(id);
+    }
+  }
+  const model = [...matches][0];
+  if (model === undefined) {
+    if (grantOnly) throw modelNotEnabled(requested);
+    return { credentials, interaction };
+  }
+  return {
+    credentials: { ...credentials, enabled_models: [...new Set([...credentials.enabled_models, model])] },
+    interaction: { ...interaction, model: `dari/model/${model}` },
+  };
+}

package/src/self_host/main.ts

@@ -3,18 +3,18 @@ import { chmodSync, existsSync } from "node:fs";
 import { Database } from "bun:sqlite";
 import { builtinModels } from "@mupt-ai/pi-ai/providers/all";
 
-import { bearerToken } from "../http/auth";
-import { errorResponse, HttpError } from "../http/errors";
-import { createRequestHandler } from "../http/handler";
-import { installShutdownHandlers, startServer } from "../http/serve";
-import { createAutoRoutingSelectorBackend } from "../strategies/auto_routing_selector";
-import { createPrioritySelectorBackend } from "../strategies/priority_selector";
-import type { SelectorBackend } from "../strategies/routing";
-import { loadGatewayConfig } from "./config";
-import { createSelfHostedPlatform } from "./platform";
-import { gatewayKeyIndex } from "./resolve";
-import { PrefixStore } from "./prefix_store";
-import { handleSubscriptionRequest, SubscriptionStore } from "./subscriptions";
+import { bearerToken } from "../http/auth.js";
+import { errorResponse, HttpError } from "../http/errors.js";
+import { createRequestHandler } from "../http/handler.js";
+import { installShutdownHandlers, startServer } from "../http/serve.js";
+import { createAutoRoutingSelectorBackend } from "../strategies/auto_routing_selector.js";
+import { createPrioritySelectorBackend } from "../strategies/priority_selector.js";
+import type { SelectorBackend } from "../strategies/routing.js";
+import { loadGatewayConfig } from "./config.js";
+import { createSelfHostedPlatform } from "./platform.js";
+import { gatewayKeyIndex } from "./resolve.js";
+import { PrefixStore } from "./prefix_store.js";
+import { handleSubscriptionRequest, SubscriptionStore } from "./subscriptions/index.js";
 
 const SUBSCRIPTION_ROUTES = "/v1/organizations/current/credentials";
 

package/src/self_host/platform.ts

@@ -1,8 +1,8 @@
-import { errorCode } from "../http/errors";
-import type { GatewayPlatform } from "../platform/platform";
-import type { PrefixStore } from "./prefix_store";
-import { resolveSelfHostedRouter, type SelfHostedResolverDeps } from "./resolve";
-import type { SubscriptionStore } from "./subscriptions";
+import { errorCode } from "../http/errors.js";
+import type { GatewayPlatform } from "../platform/platform.js";
+import type { PrefixStore } from "./prefix_store.js";
+import { resolveSelfHostedRouter, type SelfHostedResolverDeps } from "./resolve.js";
+import type { SubscriptionStore } from "./subscriptions/index.js";
 
 /**
  * The self-hosted platform: routers from the config file, subscriptions and

package/src/self_host/prefix_store.ts

@@ -14,8 +14,8 @@
 import type { Database } from "bun:sqlite";
 import type { ReasoningEffort, RouterPrefixHit } from "@mupt-ai/dari-router/policy-engine";
 
-import type { PendingLeaseWrite, PrefixStateWrite } from "../platform/platform";
-import { ROUTING_PREFIX_HASHES_MAX_COUNT } from "../platform/routing_contract";
+import type { PendingLeaseWrite, PrefixStateWrite } from "../platform/platform.js";
+import { ROUTING_PREFIX_HASHES_MAX_COUNT } from "../platform/routing_contract.js";
 
 // Resolve returns entries up to this age so a continuation after a pause still
 // recovers its conversation id and previous decision; the runtime itself

package/src/self_host/resolve.ts

@@ -4,33 +4,27 @@ import {
   nativeModelId,
   providerForModel,
   type ReasoningEffort,
-  type RouterModelPrice,
   type RouterPrefixHit,
 } from "@mupt-ai/dari-router/policy-engine";
-import { HttpError } from "../http/errors";
-import type { ResolveRouterRequest } from "../platform/platform";
-import { registeredModelPrice } from "../providers/pi";
-import type {
-  ProviderKeySource,
-  ResolvedRouter,
-  ResolvedRouterModelConfig,
-} from "../types";
-import type { GatewayConfig, RouterConfig } from "./config";
+import { HttpError } from "../http/errors.js";
+import type { ResolveRouterRequest } from "../platform/platform.js";
+import { codexModelConfig } from "../models/subscriptions.js";
+import { registeredModelPrice } from "../providers/pi.js";
+import type { ProviderKeySource, ResolvedRouter } from "../types.js";
+import type { GatewayConfig, RouterConfig } from "./config.js";
 import {
   freshAccessToken,
   type OAuthFetch,
   type SubscriptionCredential,
   type SubscriptionProvider,
   type SubscriptionStore,
-} from "./subscriptions";
+} from "./subscriptions/index.js";
 
 // A self-hosted gateway is one tenant; these stand in for the hosted
 // organization and the user a personal subscription belongs to.
 export const SELF_HOSTED_ORGANIZATION_ID = "self-hosted";
 export const SELF_HOSTED_USER_ID = "self-hosted";
 
-const CODEX_BACKEND_URL = "https://chatgpt.com/backend-api";
-
 export type SelfHostedResolverDeps = {
   config: GatewayConfig;
   gatewayKeys: readonly string[];
@@ -176,8 +170,8 @@ export function gatewayKeyIndex(keys: readonly string[], presented: string): num
   return null;
 }
 
-// Claude Code plans serve only Claude Code itself; ChatGPT plans serve any
-// client through the Codex backend.
+// Claude Code plans serve only Claude Code itself and Muse Code plans only
+// Muse Code; ChatGPT plans serve any client through the Codex backend.
 function subscriptionProviderFor(
   provider: string,
   clientHarness: ResolveRouterRequest["clientHarness"],
@@ -185,6 +179,7 @@ function subscriptionProviderFor(
   if (provider === "anthropic") {
     return clientHarness === "claude_code" ? "anthropic_claude_code" : null;
   }
+  if (provider === "meta") return clientHarness === "muse_code" ? "meta_muse" : null;
   if (provider === "openai") return "openai_codex";
   return null;
 }
@@ -197,34 +192,25 @@ function servingProviders(provider: string, credential: ProviderCredential): str
     : [provider];
 }
 
-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,
-  };
-}
-
 function thinkingLevels(router: RouterConfig): Record<string, ReasoningEffort[]> {
   return Object.fromEntries(
     router.models.flatMap((model) => model.thinking ? [[model.id, model.thinking]] : []),
   );
 }
 
+const SUBSCRIPTION_PLAN_NAMES: Record<SubscriptionProvider, string> = {
+  anthropic_claude_code: "Claude Code",
+  openai_codex: "ChatGPT",
+  meta_muse: "Muse Code",
+};
+
 function unavailableRouterError(
   routerId: string,
   exhausted: ReadonlySet<SubscriptionProvider>,
 ): HttpError {
   if (exhausted.size > 0) {
     const plans = [...exhausted]
-      .map((provider) => provider === "anthropic_claude_code" ? "Claude Code" : "ChatGPT")
+      .map((provider) => SUBSCRIPTION_PLAN_NAMES[provider])
       .join(" and ");
     return new HttpError(
       424,

package/src/self_host/subscriptions/access.ts

@@ -1,5 +1,5 @@
-import { refreshOAuth, type OAuthFetch } from "./oauth";
-import type { SubscriptionCredential, SubscriptionStore } from "./store";
+import { refreshOAuth, type OAuthFetch } from "./oauth.js";
+import type { SubscriptionCredential, SubscriptionStore } from "./store.js";
 
 const REFRESH_MARGIN_MS = 5 * 60_000;
 

package/src/self_host/subscriptions/http.ts

@@ -12,8 +12,8 @@ import {
   startOAuth,
   type OAuthFetch,
   type SubscriptionProvider,
-} from "./oauth";
-import { isHeld, type SubscriptionCredential, type SubscriptionStore } from "./store";
+} from "./oauth.js";
+import { isHeld, type SubscriptionCredential, type SubscriptionStore } from "./store.js";
 
 export type SubscriptionHttpDeps = {
   store: SubscriptionStore;

package/src/self_host/subscriptions/index.ts

@@ -18,8 +18,8 @@
  * `store.markUnavailable` holds that subscription until its reset and says
  * whether another one can serve the retry.
  */
-export { freshAccessToken } from "./access";
-export { handleSubscriptionRequest, type SubscriptionHttpDeps } from "./http";
+export { freshAccessToken } from "./access.js";
+export { handleSubscriptionRequest, type SubscriptionHttpDeps } from "./http.js";
 export {
   CODEX_APPROVAL_PENDING,
   SUBSCRIPTION_PROVIDERS,
@@ -34,10 +34,10 @@ export {
   type OAuthOptions,
   type OAuthTokens,
   type SubscriptionProvider,
-} from "./oauth";
+} from "./oauth.js";
 export {
   SubscriptionStore,
   isHeld,
   type PendingOAuthSession,
   type SubscriptionCredential,
-} from "./store";
+} from "./store.js";

package/src/self_host/subscriptions/oauth.ts

@@ -2,16 +2,18 @@ import { createHash, randomBytes } from "node:crypto";
 
 /**
  * OAuth protocols for personal subscriptions: Claude Code (PKCE, the user
- * pastes back the `code#state` Anthropic shows) and ChatGPT/Codex (device
- * code, the gateway polls for approval). Every network call goes through the
- * injected `fetch`.
+ * pastes back the `code#state` Anthropic shows), ChatGPT/Codex (device code,
+ * the gateway polls for approval), and Muse Code (Meta's device code, then the
+ * subscription's Model API key minted from the sign-in token). Every network
+ * call goes through the injected `fetch`.
  */
 
-export type SubscriptionProvider = "anthropic_claude_code" | "openai_codex";
+export type SubscriptionProvider = "anthropic_claude_code" | "openai_codex" | "meta_muse";
 
 export const SUBSCRIPTION_PROVIDERS: readonly SubscriptionProvider[] = [
   "anthropic_claude_code",
   "openai_codex",
+  "meta_muse",
 ];
 
 export type OAuthFetch = (url: string, init: RequestInit) => Promise<Response>;
@@ -20,7 +22,8 @@ export type OAuthOptions = { fetch: OAuthFetch; now?: Date };
 
 /** The provider refused or could not be reached (HTTP 502 at the edge). */
 export class SubscriptionOAuthProviderError extends Error {
-  constructor(message: string, readonly status?: number) {
+  // `errorCode` is the provider's OAuth `error` code, such as `authorization_pending`.
+  constructor(message: string, readonly status?: number, readonly errorCode?: string) {
     super(message);
     this.name = "SubscriptionOAuthProviderError";
   }
@@ -43,6 +46,8 @@ export type OAuthAuthorization = {
   flow: Record<string, string>;
 };
 
+// A Muse Code plan's access token is the Model API key minted for it, and its
+// refresh token the Meta sign-in token the key is minted from.
 export type OAuthTokens = {
   provider: SubscriptionProvider;
   accessToken: string;
@@ -76,6 +81,23 @@ 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: SubscriptionProvider,
   options: OAuthOptions,
@@ -103,6 +125,23 @@ export async function startOAuth(
       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`,
@@ -120,7 +159,7 @@ export async function startOAuth(
 
 /**
  * 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: SubscriptionProvider,
@@ -154,6 +193,35 @@ export async function completeOAuth(
     );
     return claudeTokens(token, now, null);
   }
+  if (provider === "meta_muse") {
+    let token: Record<string, unknown>;
+    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: Record<string, unknown>;
@@ -207,6 +275,28 @@ export async function refreshOAuth(
     );
     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: unknown) => {
+      throw error instanceof SubscriptionOAuthInputError ? new SubscriptionOAuthProviderError(error.message) : error;
+    });
+  }
   const token = await postJson(
     options.fetch,
     CODEX_TOKEN_URL,
@@ -258,6 +348,43 @@ function claudeTokens(
   };
 }
 
+function museRefreshToken(token: Record<string, unknown>): string | null {
+  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: string,
+  refreshToken: string | null,
+  fetch: OAuthFetch,
+  now: Date,
+): Promise<OAuthTokens> {
+  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: Record<string, unknown>,
   now: Date,
@@ -353,12 +480,13 @@ async function requestJson(
   body: string,
   contentType: string,
   operation: string,
+  headers: Record<string, string> = {},
 ): Promise<Record<string, unknown>> {
   let response: 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),
     });
@@ -366,10 +494,13 @@ async function requestJson(
     throw new SubscriptionOAuthProviderError(`${operation} could not reach the provider.`);
   }
   if (!response.ok) {
-    await response.body?.cancel();
+    // Only the RFC 6749 `error` code is kept; the rest may carry provider detail.
+    const failure: unknown = 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: unknown;

package/src/self_host/subscriptions/store.ts

@@ -13,7 +13,7 @@
 import type { Database } from "bun:sqlite";
 import { randomBytes, randomUUID } from "node:crypto";
 
-import type { OAuthTokens, SubscriptionProvider } from "./oauth";
+import type { OAuthTokens, SubscriptionProvider } from "./oauth.js";
 
 export type SubscriptionCredential = {
   id: string;
@@ -47,6 +47,7 @@ export type PendingOAuthSession = {
 const BASE_NAMES: Record<SubscriptionProvider, string> = {
   anthropic_claude_code: "ANTHROPIC_CLAUDE_CODE_OAUTH_TOKEN",
   openai_codex: "OPENAI_CODEX_OAUTH_TOKEN",
+  meta_muse: "META_MUSE_OAUTH_TOKEN",
 };
 
 type CredentialRow = {

package/src/strategies/auto_routing_selector.ts

@@ -1,6 +1,6 @@
 import { parseSelectorDecision } from "@mupt-ai/dari-router/policy-engine";
-import { HttpError } from "../http/errors";
-import type { SelectorBackend } from "./routing";
+import { HttpError } from "../http/errors.js";
+import type { SelectorBackend } from "./routing.js";
 
 export const DARI_AUTO_ROUTING_ENDPOINT = "https://routing.dari.dev/v1/auto-router";
 // Same selector identity and input budget as `createAutoRouter` in

package/src/strategies/eval_relevance.ts

@@ -8,9 +8,9 @@ import {
   type RouterEval,
 } from "@mupt-ai/dari-router/policy-engine";
 
-import { publicCatalogSelectorEvals } from "../context/eval_catalog";
-import { scrubSecrets } from "../telemetry/scrub";
-import type { ResolvedRouter } from "../types";
+import { publicCatalogSelectorEvals } from "../context/eval_catalog.js";
+import { scrubSecrets } from "../telemetry/scrub.js";
+import type { ResolvedRouter } from "../types.js";
 
 export type EvalRelevanceDetails =
   | {

package/src/strategies/priority_selector.ts

@@ -1,4 +1,4 @@
-import type { SelectorBackend } from "./routing";
+import type { SelectorBackend } from "./routing.js";
 
 const PRIORITY_SELECTOR_MODEL = "dari-gateway/priority";
 // Priority selection reads no messages, so the sized selector input only