@mupt-ai/dari-gateway 0.2.0 → 0.3.0

package/dist/models/execution_provider.js

@@ -0,0 +1,17 @@
+import { providerForModel } from "@mupt-ai/dari-router/policy-engine";
+/** Actual serving provider for a canonical model on a resolved managed router. */
+export function executionProviderForModel(credentials, model) {
+    const configured = credentials.model_configs?.[model]?.provider?.trim();
+    return configured || providerForModel(model);
+}
+/**
+ * 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/gateways.d.ts

@@ -0,0 +1,11 @@
+export type Gateway = {
+    label: string;
+    baseUrl: string;
+    compat: Record<string, unknown>;
+    requestFields(options: {
+        zdr: boolean;
+    }): Record<string, unknown>;
+};
+export declare function gatewayFor(provider: unknown): Gateway | undefined;
+/** Deep-merges gateway routing fields into a provider request body. */
+export declare function payloadWithGatewayFields(payload: Record<string, unknown>, fields: Record<string, unknown>): Record<string, unknown>;

package/dist/models/gateways.js

@@ -0,0 +1,45 @@
+import { isRecord } from "@mupt-ai/dari-router/policy-engine";
+function gateway(spec) {
+    return { ...spec, compat: { thinkingFormat: "openrouter", ...spec.compat } };
+}
+const GATEWAYS = {
+    openrouter: gateway({
+        label: "OpenRouter",
+        baseUrl: "https://openrouter.ai/api/v1",
+        requestFields: ({ zdr }) => zdr ? { provider: { data_collection: "deny", zdr: true } } : {},
+    }),
+    // https://vercel.com/docs/ai-gateway/models-and-providers/provider-options
+    "vercel-ai-gateway": gateway({
+        label: "Vercel AI Gateway",
+        baseUrl: "https://ai-gateway.vercel.sh/v1",
+        // Pi detects OpenRouter's role, caching, and session conventions from its
+        // URL but not Vercel's: the system role reaches every upstream, and
+        // x-session-affinity keeps prompt-cache locality.
+        compat: {
+            supportsDeveloperRole: false,
+            sendSessionAffinityHeaders: true,
+            sessionAffinityFormat: "openai",
+        },
+        // Vercel passes requests through untouched unless asked to place the
+        // cache breakpoints Anthropic models need.
+        requestFields: ({ zdr }) => ({
+            providerOptions: {
+                gateway: { caching: "auto", ...(zdr ? { zeroDataRetention: true } : {}) },
+            },
+        }),
+    }),
+};
+export function gatewayFor(provider) {
+    return typeof provider === "string" ? GATEWAYS[provider.toLowerCase()] : undefined;
+}
+/** Deep-merges gateway routing fields into a provider request body. */
+export function payloadWithGatewayFields(payload, fields) {
+    const merged = { ...payload };
+    for (const [key, value] of Object.entries(fields)) {
+        const current = merged[key];
+        merged[key] = isRecord(current) && isRecord(value)
+            ? payloadWithGatewayFields(current, value)
+            : value;
+    }
+    return merged;
+}

package/dist/models/ids.d.ts

@@ -0,0 +1 @@
+export declare function requireCandidateModels(value: unknown): string[];

package/dist/models/ids.js

@@ -0,0 +1,15 @@
+import { providerForModel } from "@mupt-ai/dari-router/policy-engine";
+import { HttpError } from "../http/errors.js";
+export function requireCandidateModels(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new HttpError(400, "routing.candidate_models must include at least one model.", "invalid_routing_request", "routing.candidate_models");
+    }
+    const candidates = value.map((item, index) => {
+        if (typeof item !== "string" || item.trim() === "") {
+            throw new HttpError(400, "routing.candidate_models must contain non-empty strings.", "invalid_routing_request", `routing.candidate_models[${index}]`);
+        }
+        providerForModel(item);
+        return item;
+    });
+    return [...new Set(candidates)];
+}

package/dist/models/provider_defaults.d.ts

@@ -0,0 +1,4 @@
+/** Display label for a provider slug; custom slugs title-case per segment. */
+export declare function providerLabel(provider: string): string;
+/** Endpoint fallback when neither the resolved config nor the registry has one. */
+export declare function defaultBaseUrl(provider: string): string | null;

package/dist/models/provider_defaults.js

@@ -0,0 +1,44 @@
+import { gatewayFor } from "./gateways.js";
+// Built-in model provider presentation and endpoint defaults; gateways carry
+// their own. Mirrors the hosted Dari model catalog's provider defaults; keep
+// the two in sync when adding a provider.
+const PROVIDER_LABELS = {
+    openai: "OpenAI",
+    anthropic: "Anthropic",
+    fireworks: "Fireworks",
+    meta: "Meta",
+    xai: "xAI",
+    dari: "Dari",
+    "amazon-bedrock": "Amazon Bedrock",
+    azure: "Microsoft Azure",
+};
+/** Display label for a provider slug; custom slugs title-case per segment. */
+export function providerLabel(provider) {
+    const known = PROVIDER_LABELS[provider.toLowerCase()] ?? gatewayFor(provider)?.label;
+    if (known)
+        return known;
+    return (provider
+        .split(/[._-]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ") || provider);
+}
+const PROVIDER_BASE_URLS = {
+    openai: "https://api.openai.com/v1",
+    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.
+    "amazon-bedrock": "https://bedrock-runtime.us-east-1.amazonaws.com",
+    // Microsoft Azure has no default: the platform derives each model's base
+    // URL from the credential's resource endpoint at resolve time.
+};
+/** Endpoint fallback when neither the resolved config nor the registry has one. */
+export function defaultBaseUrl(provider) {
+    return PROVIDER_BASE_URLS[provider.toLowerCase()] ?? gatewayFor(provider)?.baseUrl ?? null;
+}

package/dist/models/runtime_overrides.d.ts

@@ -0,0 +1,7 @@
+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;
+export declare function runtimeCompat(provider: string, registered: Record<string, unknown> | undefined, modelId?: string): unknown;

package/dist/models/runtime_overrides.js

@@ -0,0 +1,226 @@
+import { canonicalModelId, isRecord } from "@mupt-ai/dari-router/policy-engine";
+import { gatewayFor } from "./gateways.js";
+const MODEL_CONTEXT_OVERRIDES = {
+    // Selector and title models are not router candidate configs, so their
+    // context windows cannot depend on the Pi registry carrying them.
+    "openai/gpt-5.6-luna": 1_050_000,
+    "openai/gpt-6-luna": 1_050_000,
+};
+// Models whose true non-reasoning mode is the provider-literal effort "none"
+// rather than omitting the field. Live-validated: Fireworks DeepSeek thinks
+// by default when the request carries no reasoning_effort (and pi-ai's
+// completions path drops Dari's "off" before serializing), so a client's
+// explicit off must be injected into the provider payload as
+// reasoning_effort "none" (verified quiet: ~2 output tokens vs ~40 thinking).
+// OpenAI gpt-5.x models need no entry: the pi-ai registry already maps their
+// "off" to wire "none".
+// Models whose catalog metadata is not yet bundled in the installed Pi registry
+// but need explicit compat overrides to produce correct provider payloads.
+const MODEL_COMPAT_OVERRIDES = {
+    // The Pi registry does not carry Fable 5.1, Opus 5.5, Sonnet 5.5, and Opus 5's
+    // adaptive-thinking compatibility for every serving provider (OpenRouter,
+    // Bedrock), so it is declared here. Sonnet 5 is in the Pi
+    // registry (with forceAdaptiveThinking), but it's missing supportsTemperature
+    // (the Anthropic docs confirm non-default temperature returns 400).
+    "anthropic/claude-fable-5-1": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+    },
+    "anthropic/claude-opus-5-5": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+        supportsMidConvoEffort: true,
+    },
+    "anthropic/claude-opus-5": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+    },
+    "anthropic/claude-sonnet-5-5": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+        supportsMidConvoEffort: true,
+    },
+    "anthropic/claude-sonnet-5": {
+        supportsTemperature: false,
+    },
+    "anthropic/claude-haiku-5-5": {
+        forceAdaptiveThinking: true,
+        supportsTemperature: false,
+    },
+    // GPT-6 Astra always reasons and OpenAI rejects temperature on it (400
+    // "Unsupported parameter: 'temperature'"), on api.openai.com and on Azure
+    // alike. The OpenAI transports do not read this flag themselves, so
+    // buildOptions drops the parameter. Live-validated 2026-09-15.
+    "openai/gpt-6-astra": {
+        supportsTemperature: false,
+    },
+    // GPT-6 Sol and Luna are newer than the installed Pi registry. They retain
+    // the GPT-5.6 Responses feature set, including explicit prompt caching and
+    // deferred tool loading. Keep this local until Pi ships their metadata.
+    "openai/gpt-6.1-sol": {
+        supportsStrictMode: true,
+        supportsOpenAIGrammarTools: true,
+        supportsAdditionalTools: true,
+        supportsToolSearch: true,
+        supportsExplicitPromptCacheMode: true,
+        supportsReasoningConfigurationUpdate: true,
+    },
+    "openai/gpt-6-sol": {
+        supportsStrictMode: true,
+        supportsOpenAIGrammarTools: true,
+        supportsAdditionalTools: true,
+        supportsToolSearch: true,
+        supportsExplicitPromptCacheMode: true,
+        supportsReasoningConfigurationUpdate: true,
+    },
+    "openai/gpt-6-luna": {
+        supportsStrictMode: true,
+        supportsOpenAIGrammarTools: true,
+        supportsAdditionalTools: true,
+        supportsToolSearch: true,
+        supportsExplicitPromptCacheMode: true,
+        supportsReasoningConfigurationUpdate: true,
+    },
+    // Kimi K3 is not in the installed Pi registry under the Fireworks provider.
+    // Fireworks returns preserved thinking in reasoning_content and accepts the
+    // model's documented low/high/max reasoning_effort values.
+    "moonshotai/Kimi-K3": {
+        thinkingFormat: "deepseek",
+        supportsReasoningEffort: true,
+        requiresReasoningContentOnAssistantMessages: true,
+    },
+    // DeepSeek V4 Flash 0731 is not in the installed Pi registry (new model),
+    // so it needs the same compat overrides as Kimi K3 for correct deepseek-
+    // format response parsing and multi-turn reasoning continuity.
+    "deepseek-ai/DeepSeek-V4-Flash-0731": {
+        thinkingFormat: "deepseek",
+        supportsReasoningEffort: true,
+        requiresReasoningContentOnAssistantMessages: true,
+    },
+    "deepseek-ai/DeepSeek-V4.1-Flash-1017": {
+        thinkingFormat: "deepseek",
+        supportsReasoningEffort: true,
+        requiresReasoningContentOnAssistantMessages: true,
+    },
+};
+// Serving-provider specific compat that replaces the model-level override
+// above. Microsoft Foundry serves DeepSeek through its own OpenAI-compatible
+// endpoint: the `thinking` parameter the deepseek thinking format sends is
+// rejected (400 unrecognized_request_argument), plain reasoning_effort
+// (none/low/high/max) is accepted, and reasoning comes back in
+// reasoning_content. Grok on Foundry takes reasoning_effort the same way.
+// Live-validated against a Foundry resource on 2026-09-15.
+const PROVIDER_MODEL_COMPAT_OVERRIDES = {
+    azure: {
+        "deepseek-ai/DeepSeek-V4-Flash-0731": {
+            supportsReasoningEffort: true,
+            requiresReasoningContentOnAssistantMessages: true,
+        },
+        "xai/grok-4.6": {
+            supportsReasoningEffort: true,
+        },
+        "xai/grok-4.7": {
+            supportsReasoningEffort: true,
+        },
+    },
+};
+// Compat keys that describe a model's native reasoning wire format, which a
+// gateway replaces with its own.
+const NATIVE_REASONING_COMPAT_KEYS = new Set([
+    "thinkingFormat",
+    "supportsReasoningEffort",
+    "requiresReasoningContentOnAssistantMessages",
+]);
+// Models whose input modalities are not detectable from the Pi registry.
+// GPT-5.6 is registered for Bedrock only under the unprefixed
+// "openai.gpt-5.6-*" ids; Dari executes the "us." inference profiles, which
+// miss the registry and would otherwise be pruned as text-only.
+const MODEL_INPUT_OVERRIDES = {
+    "anthropic/claude-haiku-5-5": ["text", "image"],
+    "anthropic/claude-sonnet-5-5": ["text", "image"],
+    "openai/gpt-6.1-sol": ["text", "image"],
+    "openai/gpt-6-sol": ["text", "image"],
+    "openai/gpt-6-luna": ["text", "image"],
+    "openai/gpt-5.6-luna": ["text", "image"],
+    "openai/gpt-5.6-sol": ["text", "image"],
+    "openai/gpt-5.6-terra": ["text", "image"],
+    "openai/gpt-6-astra": ["text", "image"],
+    "moonshotai/Kimi-K3": ["text", "image"],
+    "deepseek-ai/DeepSeek-V4.1-Flash-1017": ["text", "image"],
+    "zai-org/GLM-5.3-Flash": ["text", "image"],
+    // Grok 4.6 and 4.7 are registered for xAI's Responses API only; Foundry
+    // serves them through chat completions with the same text and image input.
+    "xai/grok-4.6": ["text", "image"],
+    "xai/grok-4.7": ["text", "image"],
+};
+const MODEL_OFF_WIRE_NONE = new Set([
+    // No longer bundled under Fireworks in Pi 1.1; preserve explicit off.
+    "zai-org/GLM-5.2",
+    "deepseek-ai/DeepSeek-V4-Pro-0813",
+    "fireworks/deepseek-ai/DeepSeek-V4-Flash",
+    "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));
+}
+export function contextWindowOverride(modelId) {
+    return MODEL_CONTEXT_OVERRIDES[canonicalModelId(modelId)];
+}
+export function inputModalitiesOverride(modelId) {
+    return MODEL_INPUT_OVERRIDES[canonicalModelId(modelId)];
+}
+export function runtimeCompat(provider, registered, modelId) {
+    const canonical = modelId ? canonicalModelId(modelId) : undefined;
+    const compatOverride = canonical
+        ? PROVIDER_MODEL_COMPAT_OVERRIDES[provider]?.[canonical] ?? MODEL_COMPAT_OVERRIDES[canonical]
+        : undefined;
+    const gateway = gatewayFor(provider);
+    if (gateway) {
+        // A gateway's own dialect decides how reasoning goes over the wire, so
+        // the model overrides' native reasoning settings do not apply.
+        const modelOverride = Object.fromEntries(Object.entries(compatOverride ?? {}).filter(([key]) => !NATIVE_REASONING_COMPAT_KEYS.has(key)));
+        return {
+            ...(isRecord(registered?.compat) ? registered.compat : {}),
+            ...modelOverride,
+            ...gateway.compat,
+        };
+    }
+    if (provider !== "fireworks") {
+        if (compatOverride === undefined)
+            return registered?.compat;
+        return {
+            ...(isRecord(registered?.compat) ? registered.compat : {}),
+            ...compatOverride,
+        };
+    }
+    // Fireworks needs two compat defaults pi-ai does not detect for it:
+    // serverless cache hits ride on session-affinity headers pi-ai only sends
+    // when compat asks for them, and several Fireworks chat templates (e.g.
+    // DeepSeek) silently drop developer-role messages, so system prompts must
+    // go out under the system role. Registry-declared compat keys still win,
+    // and per-model overrides win over both for models the registry omits.
+    return {
+        sendSessionAffinityHeaders: true,
+        supportsDeveloperRole: false,
+        ...(isRecord(registered?.compat) ? registered.compat : {}),
+        ...compatOverride,
+    };
+}

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,
+    };
+}

package/dist/observability/errors.d.ts

@@ -0,0 +1,8 @@
+import { type OperationalErrorContext, type RequestErrorContext } from "../platform/platform.js";
+export type { OperationalErrorCode } from "../platform/platform.js";
+export declare function captureRequestError(error: unknown, context: RequestErrorContext): void;
+/**
+ * Report failures deliberately caught outside the ingress exception path,
+ * including work after a response has started and process shutdown.
+ */
+export declare function captureOperationalError(error: unknown, context: OperationalErrorContext): void;

package/dist/observability/errors.js

@@ -0,0 +1,11 @@
+import { gatewayPlatform, } from "../platform/platform.js";
+export function captureRequestError(error, context) {
+    gatewayPlatform().captureRequestError(error, context);
+}
+/**
+ * Report failures deliberately caught outside the ingress exception path,
+ * including work after a response has started and process shutdown.
+ */
+export function captureOperationalError(error, context) {
+    gatewayPlatform().captureOperationalError(error, context);
+}

package/dist/platform/platform.d.ts

@@ -0,0 +1,156 @@
+import type { Provider, ReasoningEffort, RoutingStrategy } from "@mupt-ai/dari-router/policy-engine";
+import type { HarnessConversationIdentity } from "../runtime/harness_identity/index.js";
+import type { InteractionRequest, SourceProtocol } from "../interaction/types.js";
+import type { SubscriptionUsageLimit } from "../providers/subscription_limits.js";
+import type { ClientHarness, ProviderCredential, ProviderKeySource, ResolvedRouter } from "../types.js";
+/**
+ * Everything the gateway runtime needs from the deployment around it: router
+ * configuration and credentials, durable routing state, accounting sinks, and
+ * error reporting. The self-hosted gateway implements it with a local config
+ * file and SQLite (`self_host/`); other deployments supply their own.
+ *
+ * Methods may throw. Call sites that must not fail a served request catch,
+ * log, and continue.
+ */
+export type GatewayPlatform = {
+    /**
+     * Authenticate the request's key and return the router it may use, with
+     * decrypted provider credentials and the prefix-cache evidence matching
+     * `prefixHashes`. Throws HttpError(401) for an unknown key.
+     */
+    resolveRouter(request: ResolveRouterRequest): Promise<ResolvedRouter>;
+    /**
+     * Optional. Supply the credential for one enabled model of this request,
+     * consulted after `resolveRouter` and before its provider keys (for the
+     * self-hosted gateway, its environment keys), so an embedder can serve
+     * per-tenant keys from its own store. Undefined keeps the resolved key. A
+     * credential with `subscription` serves the model on that plan, even on a
+     * strict router; a plan that cannot serve the model for this client (see
+     * SubscriptionKind) is ignored.
+     */
+    resolveProviderCredential?(request: ProviderCredentialRequest): Promise<ProviderCredential | undefined>;
+    /** Persist one completed turn's prefix entry and/or refresh a read entry. */
+    writePrefixState(write: PrefixStateWrite): Promise<void>;
+    /** Set or clear a conversation's prefetched routing lease. */
+    writePendingLease(write: PendingLeaseWrite): Promise<void>;
+    /**
+     * Hold an exhausted personal subscription until it resets. Resolves whether
+     * another connected subscription for the same provider can serve a retry.
+     */
+    markSubscriptionUnavailable(hold: SubscriptionHold): Promise<boolean>;
+    /**
+     * Account one call served on a platform-managed provider key. Only reached
+     * when `resolveRouter` reports a "managed" key source.
+     */
+    recordUsage(usage: Record<string, unknown>): Promise<void>;
+    /** Receive the finished request's log row. Must not throw. */
+    recordRequest(record: RequestRecord): void;
+    captureRequestError(error: unknown, context: RequestErrorContext): void;
+    captureOperationalError(error: unknown, context: OperationalErrorContext): void;
+};
+export type ResolveRouterRequest = {
+    routerId: string;
+    apiKey: string;
+    prefixHashes?: string[];
+    conversationId?: string;
+    includePublicEvalCatalog?: boolean;
+    clientHarness?: ClientHarness;
+};
+export type ProviderCredentialRequest = {
+    provider: Provider;
+    model: string;
+    routerId: string;
+    organizationId: string;
+    apiKey: string;
+    clientHarness?: ClientHarness;
+};
+export type PrefixStateWrite = {
+    organization_id: string;
+    router_id: string;
+    received_at: string;
+    zdr: boolean;
+    prefix_entry: Record<string, unknown> | null;
+    touched_prefix_hash: string | null;
+};
+export type PendingLeaseWrite = {
+    router_id: string;
+    conversation_id: string;
+    decided_at_depth: number;
+    pending_lease: {
+        model: string;
+        reasoning_effort: string;
+        turns: number;
+        reason: string;
+        output_text: string | null;
+    } | null;
+};
+export type SubscriptionHold = {
+    userId: string;
+    credentialId: string | undefined;
+    limit: SubscriptionUsageLimit;
+};
+export type RequestRecord = {
+    row: Record<string, unknown>;
+    summary: RequestSummary;
+    distinctId: string;
+    interaction: InteractionRequest;
+    isNewConversation: boolean;
+    zdr: boolean;
+    harnessConversationIdentity?: HarnessConversationIdentity;
+    tags: RequestTags;
+};
+export type RequestTags = Record<string, string>;
+export type RequestSummary = {
+    request_id: string;
+    organization_id: string;
+    router_id: string;
+    api_key_id: string | null;
+    source_protocol: SourceProtocol;
+    request_kind: "user_message" | "tool_continuation" | "other";
+    status: "completed" | "provider_error" | "selector_error" | "aborted";
+    error_code: string | null;
+    stream: boolean;
+    zdr: boolean;
+    strategy: RoutingStrategy;
+    selected_model: string | null;
+    selected_provider: Provider | null;
+    selected_reasoning_effort: ReasoningEffort | null;
+    next_model: string | null;
+    next_reasoning_effort: ReasoningEffort | null;
+    fallback_model: string | null;
+    fallback_reasoning_effort: ReasoningEffort | null;
+    provider_key_source: ProviderKeySource | null;
+    message_count: number;
+    tool_count: number;
+    candidate_count: number;
+    provider_attempt_count: number;
+    prefix_match_depth: number | null;
+    prefix_warm_tokens: number | null;
+    selector_latency_ms: number | null;
+    provider_latency_ms: number | null;
+    total_latency_ms: number;
+    input_tokens: number | null;
+    cache_read_tokens: number | null;
+    cache_write_tokens: number | null;
+    output_tokens: number | null;
+    total_tokens: number | null;
+    total_cost_usd: number | null;
+    cost_source: "provider" | "pricing" | null;
+    pricing_known: boolean | null;
+};
+export type RequestErrorContext = {
+    request: Request;
+    routerId: string;
+    requestId?: string;
+    sourceProtocol: SourceProtocol | "openai_models" | "anthropic_models";
+    status: number;
+};
+export type OperationalErrorCode = "background_drain_timeout" | "billing_usage_report_failed" | "routing_report_assembly_failed" | "routing_report_barrier_failed" | "server_force_stop_failed" | "stream_report_finalization_failed" | "subscription_unavailable_ingest_failed";
+export type OperationalErrorContext = {
+    code: OperationalErrorCode;
+    requestId?: string;
+    routerId?: string;
+};
+/** Bind the platform every request uses. The latest binding wins. */
+export declare function bindGatewayPlatform(platform: GatewayPlatform): void;
+export declare function gatewayPlatform(): GatewayPlatform;

package/dist/platform/platform.js

@@ -0,0 +1,11 @@
+let bound = null;
+/** Bind the platform every request uses. The latest binding wins. */
+export function bindGatewayPlatform(platform) {
+    bound = platform;
+}
+export function gatewayPlatform() {
+    if (bound === null) {
+        throw new Error("No gateway platform is bound; create the request handler first.");
+    }
+    return bound;
+}

package/dist/platform/routing_contract.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ROUTER_ALIAS = "default";
+export declare const ROUTING_PREFIX_HASHES_MAX_COUNT = 200;

package/dist/platform/routing_contract.js

@@ -0,0 +1,5 @@
+// Stable public identity for the standard /v1 router. Platforms resolve it
+// to the caller's default router.
+export const DEFAULT_ROUTER_ALIAS = "default";
+// The most prefix hashes one router resolution looks up.
+export const ROUTING_PREFIX_HASHES_MAX_COUNT = 200;

package/dist/protocol/input/anthropic_messages.d.ts

@@ -0,0 +1,2 @@
+import type { InteractionRequest } from "../../interaction/types.js";
+export declare function anthropicMessagesToInteraction(payload: Record<string, unknown>): InteractionRequest;