@mupt-ai/dari-gateway 0.2.0 → 0.3.0

package/dist/runtime/routing_lease.js

@@ -0,0 +1,210 @@
+import { FIXED_TURN_COST_COMPARISON_TURNS, LEASE_DECISION_TURN_LAG, } from "@mupt-ai/dari-router/policy-engine";
+import { deriveFallbackDecision } from "../strategies/fallback_decision.js";
+import { executionProviderForModel } from "../models/execution_provider.js";
+import { routeDecision, } from "../strategies/route_decision.js";
+import { reportPendingLease } from "../telemetry/prefix_state.js";
+import { scrubSecrets } from "../telemetry/scrub.js";
+export function leasedRoutingDecision(args) {
+    if (!args.previousDecision)
+        return null;
+    const completedTurns = args.messages.filter((message) => message.role === "assistant").length;
+    const completedInLease = completedTurns % FIXED_TURN_COST_COMPARISON_TURNS;
+    if (completedInLease === 0)
+        return null;
+    return {
+        decision: {
+            selectedModel: args.previousDecision.model,
+            reasoningEffort: args.previousDecision.reasoningEffort,
+            reason: args.previousDecision.reason ||
+                `Continuing the current ${FIXED_TURN_COST_COMPARISON_TURNS}-turn routing lease.`,
+        },
+        completedTurns,
+        turnInLease: completedInLease + 1,
+    };
+}
+// The selector's ten-turn projection is only valid when its action owns ten
+// turns. Deriving lease position from the request keeps production behavior
+// stateless across gateway instances and process restarts.
+export function leasedDecision(prepared) {
+    const lease = leasedRoutingDecision({
+        messages: prepared.routing.selectorMessages,
+        previousDecision: prepared.routing.previousDecision,
+    });
+    if (!lease)
+        return null;
+    // Hold only a pair this request may still serve: a custom router whose
+    // rules no longer allow it (or no longer resolve) must reselect.
+    const held = prepared.routing.candidateResolution.candidates.some((candidate) => candidate.model === lease.decision.selectedModel &&
+        candidate.reasoningEffort === lease.decision.reasoningEffort);
+    if (!held)
+        return null;
+    // Billable traffic must reselect when credits are exhausted so a managed
+    // incumbent cannot hide an available user-owned key behind the lease.
+    if (prepared.billable && prepared.credentials.credit_exhausted)
+        return null;
+    const fallbackDecision = leaseFallbackDecision({
+        candidates: prepared.routing.candidateResolution.candidates,
+        decision: lease.decision,
+        credentials: prepared.credentials,
+    });
+    // Use attachServingDecision rather than attachDecision so next_model
+    // follows the model that actually serves. When fallback handles a primary
+    // failure, it inherits this countdown and subsequent held turns continue
+    // on the healthy serving pair instead of retrying the failed primary.
+    prepared.reporter.attachServingDecision(lease.decision);
+    prepared.reporter.attachFallbackDecision(fallbackDecision);
+    prepared.reporter.attachDecisionDetails({
+        decision_source: "lease_hold",
+        routing_lease: {
+            lease_turns: FIXED_TURN_COST_COMPARISON_TURNS,
+            completed_turns: lease.completedTurns,
+            turn_in_lease: lease.turnInLease,
+        },
+    });
+    return { decision: lease.decision, fallbackDecision };
+}
+// Wraps a lease-held (or adopted) decision with a runtime-derived fallback so
+// a mid-lease provider failure degrades like any other turn instead of
+// erroring the request. The fallback inherits the remaining commitment so the
+// completed prefix follows the healthy serving pair for the rest of the lease.
+export function committedLeaseDecision(prepared, decision) {
+    const fallbackDecision = leaseFallbackDecision({
+        candidates: prepared.routing.candidateResolution.candidates,
+        decision,
+        credentials: prepared.credentials,
+    });
+    if (fallbackDecision)
+        prepared.reporter.attachFallbackDecision(fallbackDecision);
+    return fallbackDecision ? { decision, fallbackDecision } : { decision };
+}
+export function leaseFallbackDecision(args) {
+    const fallback = deriveFallbackDecision({
+        candidates: args.candidates,
+        selected: {
+            model: args.decision.selectedModel,
+            reasoningEffort: args.decision.reasoningEffort,
+        },
+        enabled: args.credentials.model_fallback_enabled !== false,
+        requiresDifferentProvider: args.credentials.fallback_requires_different_provider !== false,
+        providerForModel: (model) => executionProviderForModel(args.credentials, model),
+    });
+    if (!fallback || args.decision.leaseTurnsRemaining === undefined) {
+        return fallback;
+    }
+    return {
+        ...fallback,
+        leaseTurnsRemaining: args.decision.leaseTurnsRemaining,
+    };
+}
+export async function selectorNegotiatesLeases(backend) {
+    if (backend.negotiatedLeaseTurns === undefined)
+        return false;
+    return (await backend.negotiatedLeaseTurns()).length > 0;
+}
+// Upper bound on how long the adoption turn waits for its consume-clear.
+const PENDING_LEASE_CLEAR_WAIT_MS = 1500;
+function withTimeout(task, capMs) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, capMs);
+        const settle = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        void task.then(settle, settle);
+    });
+}
+// Runs the routing decision for the next lease against this turn's state and
+// stamps the result onto the conversation's prefix rows. Failures only cost
+// the prefetch: expiry falls back to a synchronous decision.
+export async function prefetchNextLease(prepared, selectorBackend) {
+    try {
+        const routed = await routeDecision({
+            selectorMessages: prepared.routing.selectorMessages,
+            selectorImages: prepared.routing.selectorImages,
+            resolution: prepared.routing.candidateResolution,
+            credentials: prepared.credentials,
+            previousDecision: prepared.routing.previousDecision,
+            conversationId: prepared.routing.conversationId,
+            selectorBackend,
+            leaseHistory: prepared.routing.leaseHistory,
+        });
+        const remaining = routed.decision.leaseTurnsRemaining;
+        if (remaining === undefined) {
+            console.error("lease prefetch returned a per-turn decision; skipping");
+            return;
+        }
+        await reportPendingLease({
+            routerId: prepared.routerId,
+            conversationId: prepared.routing.conversationId,
+            decidedAtDepth: prepared.routing.leaseDepth,
+            lease: {
+                model: routed.decision.selectedModel,
+                reasoningEffort: routed.decision.reasoningEffort,
+                // The strategy assumes its granting turn serves the pair; a
+                // prefetched grant starts serving at adoption, so the full grant is
+                // stored and adoption stamps remaining = turns - 1.
+                turns: remaining + 1,
+                reason: routed.decision.reason,
+                outputText: routed.run?.outputText ?? null,
+            },
+        });
+    }
+    catch (error) {
+        console.error("lease prefetch failed", scrubSecrets(error instanceof Error ? error.message : String(error)));
+    }
+}
+export function leasePrefetchDue(prepared) {
+    return prepared.routing.activeLease?.turnsRemaining === LEASE_DECISION_TURN_LAG;
+}
+export async function clearPendingLease(prepared) {
+    await withTimeout(reportPendingLease({
+        routerId: prepared.routerId,
+        conversationId: prepared.routing.conversationId,
+        decidedAtDepth: prepared.routing.leaseDepth,
+        lease: null,
+    }), PENDING_LEASE_CLEAR_WAIT_MS);
+}
+function canServeCommittedPair(prepared, pair) {
+    if (prepared.billable && prepared.credentials.credit_exhausted)
+        return false;
+    return prepared.routing.candidateResolution.candidates.some((candidate) => candidate.model === pair.model &&
+        candidate.reasoningEffort === pair.reasoningEffort);
+}
+// Adopts the lease prefetched before the previous one expired. The pair was
+// re-validated against this request's candidates during preparation.
+export function pendingLeaseDecision(prepared) {
+    const pending = prepared.routing.pendingLease;
+    if (pending === undefined)
+        return null;
+    if (!canServeCommittedPair(prepared, pending))
+        return null;
+    return {
+        selectedModel: pending.model,
+        reasoningEffort: pending.reasoningEffort,
+        // Distinguishable from a synchronous grant in activity and responses:
+        // this decision was made turns ago and adopted here without a policy call.
+        reason: pending.reason === null
+            ? `Prefetched: policy leased ${pending.model}/${pending.reasoningEffort} ` +
+                `for ${pending.turns} turns.`
+            : `Prefetched: ${pending.reason}`,
+        leaseTurnsRemaining: pending.turns - 1,
+    };
+}
+// A leased conversation serves its committed pair without consulting the
+// selector: the policy already paid the decision cost when it granted the
+// lease, and holding is what keeps the provider cache warm. The lease
+// dissolves when its target stops being a candidate (core drops it during
+// preparation) or when the countdown reaches zero.
+export function leaseHoldDecision(prepared) {
+    const lease = prepared.routing.activeLease;
+    if (lease === undefined)
+        return null;
+    if (!canServeCommittedPair(prepared, lease))
+        return null;
+    return {
+        selectedModel: lease.model,
+        reasoningEffort: lease.reasoningEffort,
+        reason: `Lease hold: ${lease.turnsRemaining} committed turns remaining.`,
+        leaseTurnsRemaining: lease.turnsRemaining - 1,
+    };
+}

package/dist/runtime/runtime_reporter.d.ts

@@ -0,0 +1,71 @@
+import type { RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+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;
+    model: string;
+    providerKeySource: ProviderKeySource;
+};
+export declare function reportedExecution(execution: ReportedProviderExecution): ReportedProviderExecution;
+export type ReportableProviderOutcome = {
+    status: "completed";
+    output: InteractionOutput;
+    message: Record<string, unknown>;
+    responseBody: Record<string, unknown>;
+    providerLatencyMs: number;
+    execution: ReportedProviderExecution;
+} | {
+    status: "provider_error";
+    message: Record<string, unknown>;
+    providerLatencyMs: number;
+    execution: ReportedProviderExecution;
+} | {
+    status: "customer_canceled";
+    providerLatencyMs: number;
+    execution: ReportedProviderExecution;
+    message: Record<string, unknown> | null;
+    responseBody: Record<string, unknown> | null;
+    partialOutput?: InteractionOutput | null;
+};
+export type ProviderAttemptReport = {
+    model: string;
+    reasoning_effort: string;
+    role: "primary" | "fallback";
+    attempt: number;
+    outcome: "completed" | "error" | "terminal_error" | "canceled";
+};
+export type ProviderAttemptRecord = ProviderAttemptReport & {
+    execution: ReportedProviderExecution;
+    message: Record<string, unknown>;
+    billingOutcome: "completed" | "provider_failed" | "customer_canceled";
+};
+export type FrozenProviderTerminal = {
+    report(): void;
+};
+export type RoutedRuntimeReporter = {
+    attachSelectorRun(run: SelectorRun): void;
+    attachSpeculativeSelectorRun(run: SelectorRun, servingDecision: RoutingDecision): void;
+    attachDecision(decision: RoutingDecision): void;
+    attachFallbackDecision(decision: RoutingDecision | undefined): void;
+    attachServingDecision(decision: RoutingDecision): void;
+    recordProviderAttempt(attempt: ProviderAttemptRecord): void;
+    modelCost(attempt?: ProviderAttemptRecord): number | null;
+    attachDecisionDetails(details: Record<string, unknown>): void;
+    attachAdoptedSelectorOutput(adopted: {
+        outputText: string | null;
+        reason: string;
+        candidates: readonly {
+            model: string;
+            reasoningEffort: string;
+        }[];
+    }): void;
+    waitForPrefixEntryWrite(): Promise<void>;
+    freezeProviderTerminal(args: ReportableProviderOutcome): FrozenProviderTerminal;
+    freezeFailure(error: unknown): FrozenProviderTerminal;
+    reportSelectorFailure(error: unknown): void;
+};
+export type ExperimentRoutedRuntimeReporter = RoutedRuntimeReporter & {
+    decisionDetails: Record<string, unknown>;
+};
+export declare function createExperimentRoutedRuntimeReporter(): ExperimentRoutedRuntimeReporter;

package/dist/runtime/runtime_reporter.js

@@ -0,0 +1,35 @@
+export function reportedExecution(execution) {
+    return {
+        provider: execution.provider,
+        model: execution.model,
+        providerKeySource: execution.providerKeySource,
+    };
+}
+export function createExperimentRoutedRuntimeReporter() {
+    const terminal = {
+        report() { },
+    };
+    const reporter = {
+        decisionDetails: {},
+        attachSelectorRun() { },
+        attachSpeculativeSelectorRun() { },
+        attachDecision() { },
+        attachFallbackDecision() { },
+        attachServingDecision() { },
+        recordProviderAttempt() { },
+        modelCost() { return null; },
+        attachAdoptedSelectorOutput() { },
+        attachDecisionDetails(details) {
+            reporter.decisionDetails = { ...reporter.decisionDetails, ...details };
+        },
+        async waitForPrefixEntryWrite() { },
+        freezeProviderTerminal() {
+            return terminal;
+        },
+        freezeFailure() {
+            return terminal;
+        },
+        reportSelectorFailure() { },
+    };
+    return reporter;
+}

package/dist/runtime/strict_provider_access.d.ts

@@ -0,0 +1,6 @@
+import type { InteractionRequest } from "../interaction/types.js";
+import type { ResolvedRouter } from "../types.js";
+export declare function strictProviderAccess(credentials: ResolvedRouter, interaction: InteractionRequest): {
+    credentials: ResolvedRouter;
+    interaction: InteractionRequest;
+};

package/dist/runtime/strict_provider_access.js

@@ -0,0 +1,40 @@
+import { getBuiltinModels, getBuiltinProviders } from "@mupt-ai/pi-ai/providers/all";
+import { HttpError } from "../http/errors.js";
+import { explicitModelId } from "../protocol/input/router_model.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, interaction) {
+    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();
+    for (const provider of providers) {
+        if (!getBuiltinProviders().includes(provider)) {
+            throw new HttpError(400, `Unknown strict provider '${provider}'.`, "unknown_provider");
+        }
+        for (const model of getBuiltinModels(provider)) {
+            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/dist/self_host/config.d.ts

@@ -0,0 +1,46 @@
+import { type ReasoningEffort } from "@mupt-ai/dari-router/policy-engine";
+/**
+ * The self-hosted gateway's configuration file (YAML or JSON):
+ *
+ * ```yaml
+ * routers:
+ *   default:
+ *     models:
+ *       - anthropic/claude-sonnet-5-5
+ *       - id: openai/gpt-5.5
+ *         thinking: [medium, high]
+ *     fallback: true        # retry on the next model when a provider fails
+ *     subscriptions: true   # serve with connected Claude Code / ChatGPT plans
+ * providers:                # optional: OpenAI-compatible or self-run endpoints
+ *   local:
+ *     baseUrl: http://localhost:8000/v1
+ *     apiKeyEnv: LOCAL_API_KEY
+ * ```
+ *
+ * Secrets never live here: gateway keys come from `DARI_GATEWAY_KEYS`,
+ * provider API keys from each provider's standard environment variable, and
+ * personal subscriptions from the gateway database.
+ */
+export type GatewayConfig = {
+    routers: Record<string, RouterConfig>;
+    providers: Record<string, ProviderEndpointConfig>;
+};
+export type ProviderEndpointConfig = {
+    baseUrl: string;
+    api: string;
+    apiKeyEnv?: string;
+};
+export type RouterConfig = {
+    models: RouterModelConfig[];
+    fallback: boolean;
+    fallbackRequiresDifferentProvider: boolean;
+    retries: number;
+    subscriptions: boolean;
+    zdr: boolean;
+};
+export type RouterModelConfig = {
+    id: string;
+    thinking?: ReasoningEffort[];
+};
+export declare function loadGatewayConfig(path: string): Promise<GatewayConfig>;
+export declare function parseGatewayConfig(raw: unknown): GatewayConfig;

package/dist/self_host/config.js

@@ -0,0 +1,105 @@
+import { isReasoningEffort, isRecord, } from "@mupt-ai/dari-router/policy-engine";
+const ROUTER_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9.-]*$/;
+const MODEL_ID_PATTERN = /^[a-z0-9][a-z0-9.-]*\/\S+$/;
+export async function loadGatewayConfig(path) {
+    const file = Bun.file(path);
+    if (!(await file.exists())) {
+        throw new Error(`Gateway config not found at ${path}.`);
+    }
+    const text = await file.text();
+    const raw = path.endsWith(".json") ? JSON.parse(text) : Bun.YAML.parse(text);
+    return parseGatewayConfig(raw);
+}
+export function parseGatewayConfig(raw) {
+    if (!isRecord(raw) || !isRecord(raw.routers)) {
+        throw new Error("Gateway config needs a `routers` map.");
+    }
+    const routers = {};
+    for (const [id, router] of Object.entries(raw.routers)) {
+        if (!ROUTER_ID_PATTERN.test(id)) {
+            throw new Error(`Router id "${id}" may use only letters, digits, "-" and "_".`);
+        }
+        routers[id] = parseRouter(id, router);
+    }
+    if (Object.keys(routers).length === 0) {
+        throw new Error("Gateway config needs at least one router.");
+    }
+    const providers = {};
+    if (raw.providers !== undefined) {
+        if (!isRecord(raw.providers))
+            throw new Error("`providers` must be a map of provider ids.");
+        for (const [id, provider] of Object.entries(raw.providers)) {
+            if (!PROVIDER_ID_PATTERN.test(id)) {
+                throw new Error(`Provider id "${id}" may use only lowercase letters, digits, "." and "-".`);
+            }
+            providers[id] = parseProvider(id, provider);
+        }
+    }
+    return { routers, providers };
+}
+function parseProvider(id, raw) {
+    if (!isRecord(raw) || typeof raw.baseUrl !== "string" || !URL.canParse(raw.baseUrl)) {
+        throw new Error(`Provider "${id}" needs a \`baseUrl\` URL.`);
+    }
+    if (raw.api !== undefined && (typeof raw.api !== "string" || !raw.api.trim())) {
+        throw new Error(`providers.${id}.api must be a wire API name.`);
+    }
+    if (raw.apiKeyEnv !== undefined && (typeof raw.apiKeyEnv !== "string" || !raw.apiKeyEnv.trim())) {
+        throw new Error(`providers.${id}.apiKeyEnv must name an environment variable.`);
+    }
+    return {
+        baseUrl: raw.baseUrl.replace(/\/+$/, ""),
+        api: typeof raw.api === "string" ? raw.api.trim() : "openai-completions",
+        ...(typeof raw.apiKeyEnv === "string" ? { apiKeyEnv: raw.apiKeyEnv.trim() } : {}),
+    };
+}
+function parseRouter(id, raw) {
+    if (!isRecord(raw) || !Array.isArray(raw.models) || raw.models.length === 0) {
+        throw new Error(`Router "${id}" needs a non-empty \`models\` list.`);
+    }
+    const models = raw.models.map((model) => parseModel(id, model));
+    const seen = new Set();
+    for (const model of models) {
+        if (seen.has(model.id))
+            throw new Error(`Router "${id}" lists ${model.id} twice.`);
+        seen.add(model.id);
+    }
+    return {
+        models,
+        fallback: optionalBoolean(raw.fallback, `routers.${id}.fallback`) ?? true,
+        fallbackRequiresDifferentProvider: optionalBoolean(raw.fallbackRequiresDifferentProvider, `routers.${id}.fallbackRequiresDifferentProvider`) ?? false,
+        retries: optionalRetries(raw.retries, `routers.${id}.retries`) ?? 1,
+        subscriptions: optionalBoolean(raw.subscriptions, `routers.${id}.subscriptions`) ?? true,
+        zdr: optionalBoolean(raw.zdr, `routers.${id}.zdr`) ?? false,
+    };
+}
+function parseModel(routerId, raw) {
+    const entry = typeof raw === "string" ? { id: raw } : raw;
+    if (!isRecord(entry) || typeof entry.id !== "string" || !MODEL_ID_PATTERN.test(entry.id)) {
+        throw new Error(`Router "${routerId}" has an invalid model; use a canonical "provider/model" id.`);
+    }
+    if (entry.thinking === undefined)
+        return { id: entry.id };
+    if (!Array.isArray(entry.thinking) ||
+        entry.thinking.length === 0 ||
+        !entry.thinking.every(isReasoningEffort)) {
+        throw new Error(`Model ${entry.id} on router "${routerId}" has invalid thinking levels; use off, minimal, low, medium, high, xhigh, or max.`);
+    }
+    return { id: entry.id, thinking: [...new Set(entry.thinking)] };
+}
+function optionalBoolean(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw new Error(`${field} must be true or false.`);
+    return value;
+}
+function optionalRetries(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 5) {
+        throw new Error(`${field} must be an integer from 0 to 5.`);
+    }
+    return value;
+}

package/dist/self_host/main.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+/**
+ * Start a self-hosted Dari Gateway from environment variables:
+ *
+ * - `DARI_GATEWAY_KEYS` (required): comma-separated bearer keys clients use.
+ * - `DARI_GATEWAY_CONFIG`: router config file (default `dari-gateway.yaml`).
+ * - `DARI_GATEWAY_DB`: SQLite database for subscriptions and prefix-cache
+ *   state (default `dari-gateway.db`). It holds subscription tokens.
+ * - `DARI_AUTO_ROUTING_API_KEY`: choose among a router's models with Dari
+ *   Auto Routing; without it, `dari/routing` serves the first listed model.
+ * - `PORT` (default 8080), and each provider's standard API key variable.
+ */
+export declare function startSelfHostedGateway(env?: Record<string, string>): Promise<{
+    server: import("../http/http2_server.js").Http2RoutingServer | Bun.Server<undefined>;
+    close: () => void;
+}>;

package/dist/self_host/main.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env bun
+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.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 { 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";
+/**
+ * Start a self-hosted Dari Gateway from environment variables:
+ *
+ * - `DARI_GATEWAY_KEYS` (required): comma-separated bearer keys clients use.
+ * - `DARI_GATEWAY_CONFIG`: router config file (default `dari-gateway.yaml`).
+ * - `DARI_GATEWAY_DB`: SQLite database for subscriptions and prefix-cache
+ *   state (default `dari-gateway.db`). It holds subscription tokens.
+ * - `DARI_AUTO_ROUTING_API_KEY`: choose among a router's models with Dari
+ *   Auto Routing; without it, `dari/routing` serves the first listed model.
+ * - `PORT` (default 8080), and each provider's standard API key variable.
+ */
+export async function startSelfHostedGateway(env = process.env) {
+    const gatewayKeys = (env.DARI_GATEWAY_KEYS ?? "")
+        .split(",")
+        .map((key) => key.trim())
+        .filter(Boolean);
+    if (gatewayKeys.length === 0) {
+        throw new Error("Set DARI_GATEWAY_KEYS to the comma-separated keys clients authenticate with.");
+    }
+    const config = await loadGatewayConfig(env.DARI_GATEWAY_CONFIG ?? "dari-gateway.yaml");
+    const databasePath = env.DARI_GATEWAY_DB ?? "dari-gateway.db";
+    const created = databasePath !== ":memory:" && !existsSync(databasePath);
+    const db = new Database(databasePath, { create: true });
+    if (created)
+        chmodSync(databasePath, 0o600);
+    db.exec("PRAGMA journal_mode = WAL");
+    const subscriptions = new SubscriptionStore(db);
+    const prefixes = new PrefixStore(db);
+    // Pi's provider auth reads each provider's standard key variable, such as
+    // OPENAI_API_KEY, from this environment only.
+    const piModels = builtinModels({
+        authContext: { env: async (name) => env[name], fileExists: async () => false },
+    });
+    const platform = createSelfHostedPlatform({
+        config,
+        gatewayKeys,
+        subscriptions,
+        prefixes,
+        providerApiKey: async (provider) => (await piModels.getAuth(provider))?.auth.apiKey,
+        env,
+        fetch,
+    });
+    const autoRoutingKey = env.DARI_AUTO_ROUTING_API_KEY?.trim();
+    const selectorBackend = autoRoutingKey
+        ? createAutoRoutingSelectorBackend({
+            apiKey: autoRoutingKey,
+            ...(env.DARI_AUTO_ROUTING_URL ? { endpoint: env.DARI_AUTO_ROUTING_URL } : {}),
+        })
+        : createPrioritySelectorBackend();
+    const gateway = createRequestHandler({ platform, selectorBackend });
+    const handler = async (request) => {
+        const { pathname } = new URL(request.url);
+        if (pathname !== SUBSCRIPTION_ROUTES && !pathname.startsWith(`${SUBSCRIPTION_ROUTES}/`)) {
+            return await gateway(request);
+        }
+        try {
+            if (gatewayKeyIndex(gatewayKeys, bearerToken(request.headers)) === null) {
+                throw new HttpError(401, "Missing or invalid gateway key.", "authentication_error");
+            }
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+        return (await handleSubscriptionRequest(request, { store: subscriptions, fetch }))
+            ?? errorResponse(new HttpError(404, "Not found", "not_found"));
+    };
+    const port = Number(env.PORT ?? "8080");
+    const server = startServer(port, handler);
+    console.info("dari-gateway listening", JSON.stringify({
+        port,
+        routers: Object.keys(config.routers),
+        auto_routing: autoRoutingKey ? "dari" : "priority",
+    }));
+    return { server, close: () => db.close() };
+}
+if (import.meta.main) {
+    const { server, close } = await startSelfHostedGateway();
+    installShutdownHandlers(server, async () => close());
+}

package/dist/self_host/platform.d.ts

@@ -0,0 +1,13 @@
+import type { GatewayPlatform } from "../platform/platform.js";
+import type { PrefixStore } from "./prefix_store.js";
+import { type SelfHostedResolverDeps } from "./resolve.js";
+import type { SubscriptionStore } from "./subscriptions/index.js";
+/**
+ * The self-hosted platform: routers from the config file, subscriptions and
+ * prefix-cache state in the gateway's SQLite database, and one content-free
+ * log line per request.
+ */
+export declare function createSelfHostedPlatform(deps: Omit<SelfHostedResolverDeps, "prefixHits"> & {
+    prefixes: PrefixStore;
+    subscriptions: SubscriptionStore;
+}): GatewayPlatform;