@mupt-ai/dari-gateway 0.2.0 → 0.2.1

package/dist/providers/stream_finalization.js

@@ -0,0 +1,165 @@
+import { captureOperationalError, } from "../observability/errors.js";
+import { reportedExecution, } from "../runtime/runtime_reporter.js";
+import { reportRoutingUsage, } from "../telemetry/usage.js";
+import { customerCanceledProviderMessage } from "../runtime/customer_disconnect.js";
+import { estimatedCancelUsage, partialInteractionOutput, } from "./cancel_estimate.js";
+/**
+ * A client cancel runs its finalization in the background, where a slow
+ * selector would only delay the record and, at shutdown, eat the drain budget.
+ * The record still gets the selector's run when it arrives within the cap;
+ * otherwise it is written without it. The response-owned path is not capped.
+ */
+export const CANCEL_REPORT_BARRIER_CAP_MS = 2_000;
+export function createStreamFinalizer(args) {
+    let frozen;
+    let responseOwnedCompleted = false;
+    async function finalize(outcome, path) {
+        frozen ??= freezeStreamTerminal(args, outcome, path);
+        // Normal close calls onFinal after the response-owned barrier has already
+        // succeeded. A cancellation racing that barrier reaches this branch first
+        // and settles the same immutable payload.
+        if (path === "detached" && responseOwnedCompleted)
+            return;
+        await frozen.reporting;
+        // The response terminator waits for the fast prefix-state write. A client
+        // cancellation has nothing left to hold, so its onFinal path skips this.
+        if (path === "response_owned") {
+            await args.reporter.waitForPrefixEntryWrite();
+            responseOwnedCompleted = true;
+        }
+    }
+    return {
+        beforeResponseClose: (outcome) => finalize(outcome, "response_owned"),
+        afterResponseDetached: (outcome) => finalize(outcome, "detached"),
+    };
+}
+function freezeStreamTerminal(args, outcome, path) {
+    const report = buildStreamTerminalReport(args, outcome);
+    args.reporter.recordProviderAttempt(report.attempt);
+    const terminal = args.reporter.freezeProviderTerminal(report.providerOutcome);
+    return {
+        terminal,
+        reporting: reportTerminalOnce(args, report, terminal, path),
+    };
+}
+async function reportTerminalOnce(args, report, terminal, path) {
+    const capture = (error, code) => captureOperationalError(error, {
+        code,
+        requestId: args.requestId,
+        routerId: args.execution.usageContext?.routerId,
+    });
+    try {
+        await (path === "response_owned"
+            ? args.reportBarrier
+            : Promise.race([
+                args.reportBarrier,
+                new Promise((resolve) => setTimeout(resolve, args.cancelBarrierCapMs ?? CANCEL_REPORT_BARRIER_CAP_MS)),
+            ]));
+    }
+    catch (error) {
+        capture(error, "routing_report_barrier_failed");
+    }
+    try {
+        terminal.report();
+        if (report.reportManagedUsage && args.execution.usageContext) {
+            await reportRoutingUsage(args.execution.usageContext, report.providerMessage);
+        }
+    }
+    catch (error) {
+        capture(error, "stream_report_finalization_failed");
+    }
+}
+function buildStreamTerminalReport(args, outcome) {
+    const execution = reportedExecution(args.execution);
+    const attemptBase = {
+        model: args.decision.selectedModel,
+        reasoning_effort: args.decision.reasoningEffort,
+        role: args.role,
+        attempt: args.attempt,
+        execution,
+    };
+    if (outcome.status === "completed") {
+        const responseBody = args.protocol.responseBody({
+            id: args.requestId,
+            model: args.execution.model,
+            output: outcome.output,
+            modelCost: args.reporter.modelCost({
+                ...attemptBase,
+                outcome: "completed",
+                message: outcome.message,
+                billingOutcome: "completed",
+            }),
+            request: args.interaction,
+            routing: args.decision,
+            conversationId: args.execution.conversationId,
+        });
+        return {
+            attempt: {
+                ...attemptBase,
+                outcome: "completed",
+                message: outcome.message,
+                billingOutcome: "completed",
+            },
+            providerOutcome: {
+                status: "completed",
+                output: outcome.output,
+                message: outcome.message,
+                responseBody,
+                providerLatencyMs: args.providerLatencyMs(),
+                execution,
+            },
+            providerMessage: outcome.message,
+            reportManagedUsage: true,
+        };
+    }
+    if (outcome.status === "provider_error") {
+        return {
+            attempt: {
+                ...attemptBase,
+                outcome: "terminal_error",
+                message: outcome.message,
+                billingOutcome: "provider_failed",
+            },
+            providerOutcome: {
+                status: "provider_error",
+                message: outcome.message,
+                providerLatencyMs: args.providerLatencyMs(),
+                execution,
+            },
+            providerMessage: outcome.message,
+            reportManagedUsage: false,
+        };
+    }
+    // The client left before the provider finished. The provider call was
+    // aborted at that moment, so bill the prompt plus what was delivered.
+    const delivered = args.delivered();
+    const usage = estimatedCancelUsage({
+        pricing: args.execution.pricing,
+        promptEstimate: args.execution.promptEstimate,
+        delivered,
+    });
+    const providerMessage = customerCanceledProviderMessage(usage);
+    return {
+        attempt: {
+            ...attemptBase,
+            outcome: "canceled",
+            message: providerMessage,
+            billingOutcome: "customer_canceled",
+        },
+        providerOutcome: {
+            status: "customer_canceled",
+            message: providerMessage,
+            responseBody: outcome.responseBody,
+            providerLatencyMs: args.providerLatencyMs(),
+            execution,
+            partialOutput: partialInteractionOutput({
+                delivered,
+                usage,
+                source: args.source,
+                createdAtMs: args.startedAtMs,
+            }),
+        },
+        providerMessage,
+        reportManagedUsage: true,
+    };
+}

package/dist/providers/subscription_limits.d.ts

@@ -0,0 +1,31 @@
+import type { ProviderKeySource } from "../types.js";
+import type { CapturedProviderResponse } from "./response_capture.js";
+export type SubscriptionOAuthProvider = "anthropic_claude_code" | "openai_codex";
+export type SubscriptionUsageLimit = {
+    oauthProvider: SubscriptionOAuthProvider;
+    resetsAt: Date;
+    reason: string;
+    switched?: boolean;
+};
+export declare const DEFAULT_USAGE_LIMIT_WINDOW_MS: number;
+export declare function subscriptionOAuthProviderFor(provider: string, keySource: ProviderKeySource): SubscriptionOAuthProvider | null;
+/**
+ * Recognize a personal subscription that has run out of quota. Claude Code
+ * answers 429 with the unified rate-limit headers; the ChatGPT backend answers
+ * 429 with a structured `error.code` and `resets_at`. The Codex WebSocket
+ * transport bypasses fetch, so its usage-limit error only survives as message
+ * text and is matched there without a reset time.
+ */
+export declare function detectSubscriptionUsageLimit(args: {
+    provider: string;
+    keySource: ProviderKeySource;
+    captured: CapturedProviderResponse | undefined;
+    failure: Record<string, unknown>;
+    now?: Date;
+}): SubscriptionUsageLimit | null;
+/** Tag a provider failure so telemetry and the terminal error know why. */
+export declare function failureWithSubscriptionUsageLimit(failure: Record<string, unknown>, limit: SubscriptionUsageLimit): Record<string, unknown>;
+export declare function subscriptionUsageLimitFromFailure(failure: Record<string, unknown>): SubscriptionUsageLimit | null;
+export declare function subscriptionUsageLimitMessage(limit: SubscriptionUsageLimit): string;
+export declare function subscriptionSwitchedMessage(limit: SubscriptionUsageLimit): string;
+export declare function retryAfterSeconds(limit: SubscriptionUsageLimit, now?: Date): number;

package/dist/providers/subscription_limits.js

@@ -0,0 +1,163 @@
+import { isRecord } from "@mupt-ai/dari-router/policy-engine";
+import { providerFailureMessage } from "../runtime/provider_stream_outcome.js";
+// Neither provider guarantees a reset time on every usage-limit response.
+// Without one, hold the subscription out for an hour rather than hammering an
+// exhausted plan on every request.
+export const DEFAULT_USAGE_LIMIT_WINDOW_MS = 60 * 60 * 1000;
+const FAILURE_MARKER = "subscription_usage_limit";
+const SUBSCRIPTION_LABEL = {
+    anthropic_claude_code: "Claude Code",
+    openai_codex: "ChatGPT",
+};
+export function subscriptionOAuthProviderFor(provider, keySource) {
+    if (keySource !== "subscription")
+        return null;
+    if (provider === "anthropic")
+        return "anthropic_claude_code";
+    if (provider === "openai" || provider === "openai-codex")
+        return "openai_codex";
+    return null;
+}
+/**
+ * Recognize a personal subscription that has run out of quota. Claude Code
+ * answers 429 with the unified rate-limit headers; the ChatGPT backend answers
+ * 429 with a structured `error.code` and `resets_at`. The Codex WebSocket
+ * transport bypasses fetch, so its usage-limit error only survives as message
+ * text and is matched there without a reset time.
+ */
+export function detectSubscriptionUsageLimit(args) {
+    const oauthProvider = subscriptionOAuthProviderFor(args.provider, args.keySource);
+    if (oauthProvider === null)
+        return null;
+    const now = args.now ?? new Date();
+    if (oauthProvider === "anthropic_claude_code") {
+        return anthropicUsageLimit(args.captured, now);
+    }
+    return codexUsageLimit(args.captured, providerFailureMessage(args.failure), now);
+}
+function anthropicUsageLimit(captured, now) {
+    if (captured === undefined || captured.status !== 429)
+        return null;
+    const status = captured.headers.get("anthropic-ratelimit-unified-status");
+    const overageStatus = captured.headers.get("anthropic-ratelimit-unified-overage-status");
+    // A plain per-minute rate limit is transient; only a rejected unified
+    // window means the plan itself is exhausted.
+    if (status !== "rejected" || (overageStatus !== null && overageStatus !== "rejected")) {
+        return null;
+    }
+    const claim = captured.headers.get("anthropic-ratelimit-unified-representative-claim");
+    return {
+        oauthProvider: "anthropic_claude_code",
+        resetsAt: resetFromUnixSeconds(captured.headers.get("anthropic-ratelimit-unified-reset"), now),
+        reason: claim ? `Claude Code ${claim.replaceAll("_", " ")} usage limit reached.` : "Claude Code usage limit reached.",
+    };
+}
+const CODEX_LIMIT_CODES = new Set(["usage_limit_reached", "usage_not_included"]);
+const CODEX_LIMIT_MESSAGE = /usage_limit_reached|usage_not_included|hit your ChatGPT usage limit|the usage limit has been reached/i;
+function codexUsageLimit(captured, failureMessage, now) {
+    if (captured !== undefined && captured.status === 429) {
+        const error = codexErrorBody(captured.bodyText);
+        const code = typeof error?.code === "string" ? error.code : "";
+        if (error !== null && (CODEX_LIMIT_CODES.has(code) || failureMessage.match(CODEX_LIMIT_MESSAGE))) {
+            const plan = typeof error.plan_type === "string" ? ` (${error.plan_type.toLowerCase()} plan)` : "";
+            return {
+                oauthProvider: "openai_codex",
+                resetsAt: laterReset(error.resets_at, captured.headers, now),
+                reason: `ChatGPT usage limit reached${plan}.`,
+            };
+        }
+        return null;
+    }
+    if (!CODEX_LIMIT_MESSAGE.test(failureMessage))
+        return null;
+    return {
+        oauthProvider: "openai_codex",
+        resetsAt: new Date(now.getTime() + DEFAULT_USAGE_LIMIT_WINDOW_MS),
+        reason: "ChatGPT usage limit reached.",
+    };
+}
+function codexErrorBody(bodyText) {
+    try {
+        const parsed = JSON.parse(bodyText);
+        return isRecord(parsed) && isRecord(parsed.error) ? parsed.error : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Codex may send both an absolute `resets_at` and Retry-After; the plan is
+// back only once both have passed.
+function laterReset(resetsAt, headers, now) {
+    const deadlines = [unixSecondsDeadline(resetsAt, now), retryAfterDeadline(headers, now)]
+        .filter((deadline) => deadline !== null);
+    if (deadlines.length === 0)
+        return new Date(now.getTime() + DEFAULT_USAGE_LIMIT_WINDOW_MS);
+    return new Date(Math.max(...deadlines.map((deadline) => deadline.getTime())));
+}
+function retryAfterDeadline(headers, now) {
+    const milliseconds = Number(headers.get("retry-after-ms") ?? NaN);
+    if (Number.isFinite(milliseconds) && milliseconds > 0) {
+        return new Date(now.getTime() + milliseconds);
+    }
+    const value = headers.get("retry-after")?.trim();
+    if (!value)
+        return null;
+    const seconds = Number(value);
+    const deadline = Number.isFinite(seconds)
+        ? new Date(now.getTime() + seconds * 1000)
+        : new Date(value);
+    return deadline.getTime() > now.getTime() ? deadline : null;
+}
+function unixSecondsDeadline(value, now) {
+    const seconds = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isFinite(seconds) && seconds * 1000 > now.getTime() ? new Date(seconds * 1000) : null;
+}
+function resetFromUnixSeconds(value, now) {
+    const seconds = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    if (Number.isFinite(seconds) && seconds * 1000 > now.getTime()) {
+        return new Date(seconds * 1000);
+    }
+    return new Date(now.getTime() + DEFAULT_USAGE_LIMIT_WINDOW_MS);
+}
+/** Tag a provider failure so telemetry and the terminal error know why. */
+export function failureWithSubscriptionUsageLimit(failure, limit) {
+    return {
+        ...failure,
+        [FAILURE_MARKER]: {
+            oauth_provider: limit.oauthProvider,
+            resets_at: limit.resetsAt.toISOString(),
+            reason: limit.reason,
+            ...(limit.switched === true ? { switched: true } : {}),
+        },
+    };
+}
+export function subscriptionUsageLimitFromFailure(failure) {
+    const marker = failure[FAILURE_MARKER];
+    if (!isRecord(marker))
+        return null;
+    const oauthProvider = marker.oauth_provider;
+    const resetsAt = typeof marker.resets_at === "string" ? new Date(marker.resets_at) : null;
+    if ((oauthProvider !== "anthropic_claude_code" && oauthProvider !== "openai_codex")
+        || resetsAt === null || Number.isNaN(resetsAt.getTime())) {
+        return null;
+    }
+    return {
+        oauthProvider,
+        resetsAt,
+        reason: typeof marker.reason === "string" ? marker.reason : "Subscription usage limit reached.",
+        ...(marker.switched === true ? { switched: true } : {}),
+    };
+}
+export function subscriptionUsageLimitMessage(limit) {
+    return `Your ${SUBSCRIPTION_LABEL[limit.oauthProvider]} subscription usage limit is reached. `
+        + `It resets at ${limit.resetsAt.toISOString()}. `
+        + "Mark it available early at https://app.dari.dev/credentials.";
+}
+export function subscriptionSwitchedMessage(limit) {
+    const label = SUBSCRIPTION_LABEL[limit.oauthProvider];
+    return `Your ${label} subscription usage limit is reached. `
+        + `Dari switched to your next connected ${label} subscription; retry the request.`;
+}
+export function retryAfterSeconds(limit, now = new Date()) {
+    return Math.max(0, Math.ceil((limit.resetsAt.getTime() - now.getTime()) / 1000));
+}

package/dist/providers/subscription_usage.d.ts

@@ -0,0 +1,10 @@
+import { type ModelPricing } from "@mupt-ai/dari-router/policy-engine";
+export type SubscriptionUsageContext = {
+    api: string;
+    model: string;
+    pricing: ModelPricing | null;
+};
+export declare function messageWithSubscriptionCacheWrites(message: Record<string, unknown>, context: SubscriptionUsageContext): Record<string, unknown>;
+export declare function eventsWithSubscriptionCacheWrites(events: AsyncIterable<Record<string, unknown>>, context: SubscriptionUsageContext): AsyncIterable<Record<string, unknown>>;
+export declare function subscriptionCacheWriteUsage(usage: unknown, context: SubscriptionUsageContext): unknown;
+export declare function modelPricingFromPiModel(model: Record<string, unknown>): ModelPricing | null;

package/dist/providers/subscription_usage.js

@@ -0,0 +1,79 @@
+import { isRecord, pricingForPrompt, providerMinCacheTokens } from "@mupt-ai/dari-router/policy-engine";
+// The ChatGPT subscription backend reports cached prompt tokens but never
+// cache_write_tokens, so every fresh token lands in the input bucket and is
+// priced at the input rate. The public API bills those tokens as cache writes
+// (the GPT-5.6 family accepts only 24h extended caching, and its responses
+// report a write within a few tokens of the fresh count), so subscription rows
+// otherwise read as $0.00 cache write while the identical API request records
+// the premium. Attribute them here, where the provider identity and the
+// pricing pi-ai used are both known, so telemetry, client usage, and the
+// estimator — which already prices fresh input at the cache-write rate — agree.
+const SUBSCRIPTION_RESPONSES_API = "openai-codex-responses";
+const MTOK = 1_000_000;
+export function messageWithSubscriptionCacheWrites(message, context) {
+    const usage = subscriptionCacheWriteUsage(message.usage, context);
+    return usage === message.usage ? message : { ...message, usage };
+}
+// Every stream consumer reads final usage off the terminal `done` message.
+export async function* eventsWithSubscriptionCacheWrites(events, context) {
+    for await (const event of events) {
+        if (event.type === "done" && isRecord(event.message)) {
+            yield { ...event, message: messageWithSubscriptionCacheWrites(event.message, context) };
+            continue;
+        }
+        yield event;
+    }
+}
+export function subscriptionCacheWriteUsage(usage, context) {
+    if (context.api !== SUBSCRIPTION_RESPONSES_API || !isRecord(usage))
+        return usage;
+    const pricing = context.pricing === null ? null : pricingForPrompt(context.pricing, (finiteNumber(usage.input) ?? 0) + (finiteNumber(usage.cacheRead) ?? 0) + (finiteNumber(usage.cacheWrite) ?? 0));
+    // Without a write premium the buckets price identically, so moving tokens
+    // between them would change the report without changing the cost.
+    if (!pricing || !(pricing.cacheWrite > pricing.input))
+        return usage;
+    const input = finiteNumber(usage.input) ?? 0;
+    const cacheRead = finiteNumber(usage.cacheRead) ?? 0;
+    const cacheWrite = finiteNumber(usage.cacheWrite) ?? 0;
+    // A reported write means this backend did account for the bucket; leave it.
+    if (cacheWrite > 0 || input <= 0)
+        return usage;
+    // Prompts under the provider minimum are never cached, so their fresh tokens
+    // are genuinely plain input. This path is gated to the OpenAI subscription
+    // API above, so the execution provider is openai by construction.
+    if (input + cacheRead < providerMinCacheTokens(context.model, "openai"))
+        return usage;
+    const cost = isRecord(usage.cost) ? usage.cost : {};
+    const outputCost = finiteNumber(cost.output) ?? 0;
+    const cacheReadCost = finiteNumber(cost.cacheRead) ?? 0;
+    const cacheWriteCost = (input * pricing.cacheWrite) / MTOK;
+    return {
+        ...usage,
+        input: 0,
+        cacheWrite: input,
+        cost: {
+            ...cost,
+            input: 0,
+            cacheRead: cacheReadCost,
+            cacheWrite: cacheWriteCost,
+            output: outputCost,
+            total: outputCost + cacheReadCost + cacheWriteCost,
+        },
+    };
+}
+export function modelPricingFromPiModel(model) {
+    const cost = model.cost;
+    if (!isRecord(cost))
+        return null;
+    const input = finiteNumber(cost.input);
+    const output = finiteNumber(cost.output);
+    const cacheRead = finiteNumber(cost.cacheRead);
+    const cacheWrite = finiteNumber(cost.cacheWrite);
+    if (input === null || output === null || cacheRead === null || cacheWrite === null)
+        return null;
+    const tiers = Array.isArray(cost.tiers) ? cost.tiers.filter((tier) => isRecord(tier) && [tier.inputTokensAbove, tier.input, tier.output, tier.cacheRead, tier.cacheWrite].every((rate) => finiteNumber(rate) !== null)) : [];
+    return { input, output, cacheRead, cacheWrite, ...(tiers.length ? { tiers } : {}) };
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/runtime/claude_code/auxiliary_routing.d.ts

@@ -0,0 +1,3 @@
+import type { RoutedDecision } from "../../strategies/route_decision.js";
+import type { PreparedRoutedCompletion } from "../prepare_routed_completion.js";
+export declare function auxiliaryDecision(prepared: PreparedRoutedCompletion): RoutedDecision | null;

package/dist/runtime/claude_code/auxiliary_routing.js

@@ -0,0 +1,60 @@
+import { routingCandidateKey, } from "@mupt-ai/dari-router/policy-engine";
+import { isBackgroundRequest } from "../../interaction/types.js";
+import { HttpError } from "../../http/errors.js";
+import { assertCreditAvailableBeforeRouting } from "../../telemetry/usage.js";
+import { leaseFallbackDecision } from "../routing_lease.js";
+// Explicit background classes bypass the selector and every lease path.
+// Keep the existing deterministic cheapest-input-cost serving policy.
+export function auxiliaryDecision(prepared) {
+    if (!isBackgroundRequest(prepared.interaction))
+        return null;
+    assertCreditAvailableBeforeRouting(prepared.billable, prepared.credentials);
+    const requestClass = prepared.interaction.agentContext.requestClass;
+    const cheapest = cheapestCandidate(prepared);
+    if (!cheapest) {
+        throw new HttpError(503, "Background requests require a routable model with known pricing.", "background_model_unavailable");
+    }
+    const decision = {
+        selectedModel: cheapest.model,
+        reasoningEffort: cheapest.reasoning_effort,
+        reason: `${requestClass} request served by the cheapest routable model without selection.`,
+    };
+    const fallbackDecision = leaseFallbackDecision({
+        candidates: prepared.routing.candidateResolution.candidates,
+        decision,
+        credentials: prepared.credentials,
+    });
+    if (fallbackDecision)
+        prepared.reporter.attachFallbackDecision(fallbackDecision);
+    return fallbackDecision ? { decision, fallbackDecision } : { decision };
+}
+/* Ranked on estimated input cost: these requests carry a whole transcript in
+   and a sentence out, so the prompt dominates. Estimates cover the configured
+   roster, so they are narrowed to the candidates pruning actually left
+   routable. Unpriced candidates are not comparable; fail explicitly if no
+   priced candidate is available, never fall through to selection. */
+function cheapestCandidate(prepared) {
+    const routable = new Set(prepared.routing.candidateResolution.candidates.map(routingCandidateKey));
+    let cheapest = null;
+    for (const estimate of prepared.routing.candidateResolution.costEstimates) {
+        if (!estimate.pricing_known || estimate.est_input_cost_usd === null)
+            continue;
+        if (!routable.has(routingCandidateKey({
+            model: estimate.model,
+            reasoningEffort: estimate.reasoning_effort,
+        }))) {
+            continue;
+        }
+        if (cheapest === null || cheaperThan(estimate, cheapest))
+            cheapest = estimate;
+    }
+    return cheapest;
+}
+function cheaperThan(candidate, incumbent) {
+    const candidateInput = candidate.est_input_cost_usd ?? Infinity;
+    const incumbentInput = incumbent.est_input_cost_usd ?? Infinity;
+    if (candidateInput !== incumbentInput)
+        return candidateInput < incumbentInput;
+    return (candidate.output_cost_per_mtok ?? Infinity)
+        < (incumbent.output_cost_per_mtok ?? Infinity);
+}

package/dist/runtime/customer_disconnect.d.ts

@@ -0,0 +1,20 @@
+import { HttpError } from "../http/errors.js";
+export declare class CustomerDisconnectedError extends HttpError {
+    readonly name = "CustomerDisconnectedError";
+    constructor();
+}
+export type ProviderAttemptAbort = {
+    readonly signal: AbortSignal;
+    readonly aborted: boolean;
+    abort(): void;
+    dispose(): void;
+};
+/**
+ * Give every provider attempt its own cancellation boundary tied to the
+ * client's disconnect. A cancelled request stops paying the provider at once;
+ * its usage is estimated from what was delivered instead of drained.
+ */
+export declare function createProviderAttemptAbort(args: {
+    clientSignal?: AbortSignal;
+}): ProviderAttemptAbort;
+export declare function customerCanceledProviderMessage(usage?: Record<string, unknown>, responseId?: string): Record<string, unknown>;

package/dist/runtime/customer_disconnect.js

@@ -0,0 +1,49 @@
+import { HttpError } from "../http/errors.js";
+const CUSTOMER_DISCONNECTED_MESSAGE = "Client disconnected.";
+export class CustomerDisconnectedError extends HttpError {
+    name = "CustomerDisconnectedError";
+    constructor() {
+        // 499 is the conventional server-side classification for a client that
+        // closed the request before a response could be delivered.
+        super(499, CUSTOMER_DISCONNECTED_MESSAGE, "client_disconnected");
+    }
+}
+/**
+ * Give every provider attempt its own cancellation boundary tied to the
+ * client's disconnect. A cancelled request stops paying the provider at once;
+ * its usage is estimated from what was delivered instead of drained.
+ */
+export function createProviderAttemptAbort(args) {
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted) {
+            controller.abort(new CustomerDisconnectedError());
+        }
+    };
+    const clientSignal = args.clientSignal;
+    if (clientSignal?.aborted) {
+        abort();
+    }
+    else {
+        clientSignal?.addEventListener("abort", abort, { once: true });
+    }
+    return {
+        signal: controller.signal,
+        get aborted() {
+            return controller.signal.aborted;
+        },
+        abort,
+        dispose() {
+            clientSignal?.removeEventListener("abort", abort);
+        },
+    };
+}
+export function customerCanceledProviderMessage(usage, responseId) {
+    return {
+        stopReason: "aborted",
+        errorMessage: CUSTOMER_DISCONNECTED_MESSAGE,
+        content: [],
+        ...(usage ? { usage, usage_estimated: usage.estimated === true } : {}),
+        ...(responseId ? { responseId } : {}),
+    };
+}

package/dist/runtime/explicit_model.d.ts

@@ -0,0 +1,4 @@
+import type { RoutedDecision } from "../strategies/route_decision.js";
+import type { PreparedRoutedCompletion } from "./prepare_routed_completion.js";
+export declare function explicitModelDecision(prepared: PreparedRoutedCompletion): RoutedDecision | null;
+export declare function strictModelDecision(prepared: PreparedRoutedCompletion): RoutedDecision;

package/dist/runtime/explicit_model.js

@@ -0,0 +1,53 @@
+import { HttpError } from "../http/errors.js";
+import { explicitModelId } from "../protocol/input/router_model.js";
+/* A request for `dari/model/<id>` is served by exactly that enabled model,
+   with no selector, lease, or fallback: the user chose it, like picking a
+   model in their agent's /model menu. The client's thinking level is kept
+   when the model supports it; otherwise the model's default level is used. */
+export function explicitModelDecision(prepared) {
+    const modelId = explicitModelId(prepared.interaction.model);
+    if (modelId === null)
+        return null;
+    if (!prepared.credentials.enabled_models.includes(modelId)) {
+        throw new HttpError(400, `Model '${modelId}' is not enabled on this router.`, "model_not_enabled", "model");
+    }
+    const candidates = prepared.routing.candidateResolution.candidates.filter((candidate) => candidate.model === modelId);
+    if (candidates.length === 0) {
+        throw new HttpError(400, `Model '${modelId}' cannot serve this request.`, "model_unavailable", "model");
+    }
+    const candidate = pickCandidate(prepared, modelId, candidates);
+    const decision = {
+        selectedModel: candidate.model,
+        reasoningEffort: candidate.reasoningEffort,
+        reason: `Requested model ${modelId} served without selection.`,
+    };
+    return { decision };
+}
+function pickCandidate(prepared, modelId, candidates) {
+    const preferred = [
+        prepared.interaction.reasoning?.effort,
+        prepared.credentials.model_configs?.[modelId]?.default_thinking_level,
+    ];
+    for (const effort of preferred) {
+        const match = candidates.find((candidate) => candidate.reasoningEffort === effort);
+        if (match)
+            return match;
+    }
+    return candidates[0];
+}
+/* A strict router serves only the pinned `dari/model/<id>` at exactly the
+   requested thinking level (the model's default when none is sent), and
+   refuses everything else instead of substituting. */
+export function strictModelDecision(prepared) {
+    const modelId = explicitModelId(prepared.interaction.model);
+    if (modelId === null) {
+        throw new HttpError(400, "This router is strict: request a pinned model as 'dari/model/<id>'.", "strict_model_required", "model");
+    }
+    const { decision } = explicitModelDecision(prepared);
+    const requested = prepared.interaction.reasoning?.effort
+        ?? prepared.credentials.model_configs?.[modelId]?.default_thinking_level;
+    if (requested !== undefined && requested !== null && decision.reasoningEffort !== requested) {
+        throw new HttpError(400, `Model '${modelId}' cannot serve thinking level '${requested}' on this router.`, "thinking_level_unavailable", "reasoning_effort");
+    }
+    return { decision };
+}