@mupt-ai/dari-gateway 0.3.2 → 0.3.4

package/src/runtime/harness_identity/extract.ts

@@ -183,6 +183,16 @@ export function codexRequestContext(
   };
 }
 
+// Muse Code sends its thread on every Responses request. The main agent's
+// thread is its session, and each subagent has its own thread, so each keeps
+// its own conversation and lease.
+export function museCodeConversationIdentity(
+  headers: Headers,
+): HarnessConversationIdentity | undefined {
+  const threadId = boundedIdentity(headers.get("x-tbh-thread-id"), "x-tbh-thread-id");
+  return threadId === undefined ? undefined : { kind: "muse_code_thread", value: threadId };
+}
+
 export function claudeCodeConversationIdentity(
   headers: Headers,
   metadataSessionId?: string,

package/src/runtime/harness_identity/index.ts

@@ -11,6 +11,7 @@ export {
   codexConversationIdentity,
   codexRequestPurpose,
   codexRequestContext,
+  museCodeConversationIdentity,
   openCodeRequestContext,
   piRequestContext,
 } from "./extract.js";

package/src/runtime/prepare_routed_completion.ts

@@ -1,6 +1,8 @@
 import type { CandidatePruningAudit } from "@mupt-ai/dari-router/policy-engine";
 
 import { interactionConversationPrefix } from "../context/interaction_fingerprint.js";
+import { clampRequestedEffort } from "../context/routing_context.js";
+import { modelMetadataLookup } from "../providers/pi.js";
 import {
   buildRoutingContext,
   derivePrefixLookupHashes,
@@ -134,7 +136,14 @@ export async function prepareRoutedCompletion(args: {
   }
   const access = strictProviderAccess(credentials, args.interaction);
   credentials = access.credentials;
-  args = { ...args, interaction: access.interaction };
+  args = {
+    ...args,
+    interaction: clampRequestedEffort(
+      access.interaction,
+      credentials,
+      modelMetadataLookup(credentials.model_configs),
+    ),
+  };
   credentials = await withProviderCredentials(credentials, args.apiKey, args.clientHarness);
   const billable = true;
   const routing = await buildRoutingContext({
@@ -190,6 +199,8 @@ export async function prepareRoutedCompletion(args: {
     identityHit: routing.identityHit,
     hits: routing.hits,
     costEstimates: routing.reportingCostEstimates,
+    candidates: candidateResolution.candidates,
+    sessionPinKey: sessionPin?.key,
     pruning: reportedPruning(
       candidateResolution.pruning,
       routing.imageCapabilityPrunedModels,

package/src/self_host/config.ts

@@ -12,7 +12,7 @@ import {
  *   default:
  *     models:
  *       - anthropic/claude-sonnet-5-5
- *       - id: openai/gpt-5.5
+ *       - id: openai/gpt-6.1-sol
  *         thinking: [medium, high]
  *     subscriptions: true   # serve with connected Claude Code / ChatGPT plans
  *     sessionPinning: false # route each session and subagent once, then keep its model
@@ -65,7 +65,10 @@ const MODEL_ID_PATTERN = /^[a-z0-9][a-z0-9.-]*\/\S+$/;
 export async function loadGatewayConfig(path: string): Promise<GatewayConfig> {
   const file = Bun.file(path);
   if (!(await file.exists())) {
-    throw new Error(`Gateway config not found at ${path}.`);
+    throw new Error(
+      `Gateway config not found at ${path}. Write one from dari-gateway.example.yaml, `
+        + "or set DARI_GATEWAY_CONFIG (in the container image, mount it at /config/dari-gateway.yaml).",
+    );
   }
   const text = await file.text();
   const raw: unknown = path.endsWith(".json") ? JSON.parse(text) : Bun.YAML.parse(text);

package/src/self_host/main.ts

@@ -10,9 +10,11 @@ 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, providersWithoutCredentials } from "./resolve.js";
+import { providerForModel } from "@mupt-ai/dari-router/policy-engine";
+import { checkProviderKey } from "../providers/key_check.js";
+import { loadGatewayConfig, type GatewayConfig } from "./config.js";
+import { configuredProviderApiKey, gatewayKeyIndex, providersWithoutCredentials } from "./resolve.js";
 import { PrefixStore } from "./prefix_store.js";
 import { SessionPinStore } from "./session_pin_store.js";
 import { handleSubscriptionRequest, SubscriptionStore } from "./subscriptions/index.js";
@@ -76,6 +78,8 @@ export async function startSelfHostedGateway(env: Record<string, string> = proce
       );
     }
   }
+  await checkConfiguredProviderKeys(config, (provider) =>
+    configuredProviderApiKey({ config, providerApiKey, env }, provider));
   const autoRoutingKey = env.DARI_AUTO_ROUTING_API_KEY?.trim();
   const selectorBackend: SelectorBackend = autoRoutingKey
     ? createAutoRoutingSelectorBackend({
@@ -109,7 +113,8 @@ export async function startSelfHostedGateway(env: Record<string, string> = proce
     "dari-gateway listening",
     JSON.stringify({
       hostname,
-      port,
+      // The bound port, so PORT=0 reports the port the OS assigned.
+      port: server.port,
       routers: Object.keys(config.routers),
       auto_routing: autoRoutingKey ? "dari" : "priority",
     }),
@@ -117,7 +122,42 @@ export async function startSelfHostedGateway(env: Record<string, string> = proce
   return { server, close: () => db.close() };
 }
 
+/**
+ * Check each provider API key the routers use before serving: a key its
+ * provider rejects fails startup, and one no check could answer is reported.
+ */
+async function checkConfiguredProviderKeys(
+  config: GatewayConfig,
+  providerApiKey: (provider: string) => Promise<string | undefined>,
+): Promise<void> {
+  const providers = new Set(
+    Object.values(config.routers).flatMap((router) => router.models.map((model) => providerForModel(model.id))),
+  );
+  const checks = await Promise.all([...providers].map(async (provider) => {
+    const endpoint = config.providers[provider];
+    // Endpoints configured without a key variable take no key.
+    if (endpoint !== undefined && endpoint.apiKeyEnv === undefined) return null;
+    const key = await providerApiKey(provider);
+    if (key === undefined) return null;
+    return { provider, ...(await checkProviderKey({ provider, key, ...(endpoint ? { endpoint } : {}), fetch })) };
+  }));
+  const rejected = checks.flatMap((check) => check?.result === "rejected" ? [`${check.provider} (${check.status})`] : []);
+  if (rejected.length > 0) {
+    throw new Error(
+      `Provider API keys were rejected: ${rejected.join(", ")}. Fix or unset each key before starting the gateway.`,
+    );
+  }
+  const unchecked = checks.flatMap((check) => check?.result === "unchecked" ? [check.provider] : []);
+  if (unchecked.length > 0) {
+    console.warn("dari-gateway could not check these provider API keys", JSON.stringify({ providers: unchecked }));
+  }
+}
+
 if (import.meta.main) {
-  const { server, close } = await startSelfHostedGateway();
-  installShutdownHandlers(server, async () => close());
+  // Startup errors are configuration mistakes: print the message, not a stack.
+  const started = await startSelfHostedGateway().catch((error: unknown) => {
+    console.error(`dari-gateway: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  });
+  installShutdownHandlers(started.server, async () => started.close());
 }

package/src/self_host/resolve.ts

@@ -86,7 +86,7 @@ export async function resolveSelfHostedRouter(
     if (subscription !== null && deps.subscriptions.list(subscription).length > 0) {
       exhausted.add(subscription);
     }
-    const apiKey = await providerApiKey(deps, provider);
+    const apiKey = await configuredProviderApiKey(deps, provider);
     credentials.set(provider, apiKey ? { key: apiKey, source: "user" } : null);
   }
 
@@ -154,7 +154,7 @@ export async function resolveSelfHostedRouter(
 
 // Configured endpoints read their own key variable, or send a placeholder
 // when they take none; known providers use their standard variable.
-async function providerApiKey(
+export async function configuredProviderApiKey(
   deps: Pick<SelfHostedResolverDeps, "config" | "providerApiKey" | "env">,
   provider: string,
 ): Promise<string | undefined> {
@@ -226,7 +226,7 @@ export async function providersWithoutCredentials(
       : [];
     const connected = plans.some((plan) => plan !== null && deps.subscriptions.list(plan).length > 0);
     if (connected) continue;
-    const apiKey = await providerApiKey(deps, provider);
+    const apiKey = await configuredProviderApiKey(deps, provider);
     if (apiKey === undefined) missing.push(provider);
   }
   return missing;

package/src/strategies/selector_projection.ts

@@ -190,6 +190,8 @@ function selectorContentField(
       if (part.type === "tool_reference") {
         return { type: "text", text: `Referenced tool: ${part.toolName}` };
       }
+      // The selector model is text-only; it sees a marker, not the document bytes.
+      if (part.type === "document") return { type: "text", text: "(PDF document omitted from selector input)" };
       return imagePart(part.url, part.detail);
     }),
   };

package/src/telemetry/report.ts

@@ -11,6 +11,7 @@ import {
   type ChainHits,
   type PrefixHit,
   type PricingLookup,
+  type RoutingCandidate,
   type RoutingDecision,
   type RoutingStrategy,
 } from "@mupt-ai/dari-router/policy-engine";
@@ -25,7 +26,7 @@ import {
   type ProviderIdentity,
 } from "../interaction/types.js";
 import { captureOperationalError } from "../observability/errors.js";
-import { gatewayPlatform, type RequestTags } from "../platform/platform.js";
+import { gatewayPlatform, type RequestRecordRouter, type RequestTags } from "../platform/platform.js";
 import type {
   ProviderAttemptRecord,
   ProviderAttemptReport,
@@ -179,6 +180,10 @@ export class RequestReporter {
       identityHit?: PrefixHit;
       hits: ChainHits;
       costEstimates: CandidateCostEstimate[];
+      // The model and reasoning pairs this request could be routed to.
+      candidates: readonly RoutingCandidate[];
+      // The session pin this request routed under, when the router pins.
+      sessionPinKey?: string;
       // Cache-aware selector-candidate pruning outcome, plus any pre-strategy
       // capability exclusions. Null when custom routing configuration cannot
       // produce candidates.
@@ -603,6 +608,9 @@ export class RequestReporter {
       };
 
       gatewayPlatform().recordRequest({
+        router: requestRecordRouter(a.credentials),
+        candidates: a.candidates.map(({ model, reasoningEffort }) => ({ model, reasoningEffort })),
+        ...(a.sessionPinKey === undefined ? {} : { sessionPinKey: a.sessionPinKey }),
         row: ingestPayload,
         summary: {
           request_id: a.requestId,
@@ -786,3 +794,28 @@ function usageIngest(
     pricing_known: pricingKnown,
   };
 }
+
+function requestRecordRouter(router: ResolvedRouter): RequestRecordRouter {
+  return {
+    enabledModels: [...router.enabled_models],
+    thinkingLevels: Object.fromEntries(
+      router.enabled_models.map((model) => [
+        model,
+        [
+          ...(router.model_thinking_levels?.[model]
+            ?? router.model_configs?.[model]?.supported_thinking_levels
+            ?? []),
+        ],
+      ]),
+    ),
+    defaultThinkingLevels: Object.fromEntries(
+      router.enabled_models.flatMap((model) => {
+        const level = router.model_configs?.[model]?.default_thinking_level;
+        return level ? [[model, level]] : [];
+      }),
+    ),
+    strict: router.strict === true,
+    speculativeRouting: router.speculative_routing === true,
+    sessionPinning: router.session_pinning === true,
+  };
+}