llm-cli-gateway 2.16.0 → 2.17.1

package/dist/pricing.js

@@ -116,3 +116,170 @@ export function estimateCacheSavingsUsd(cli, model, cacheReadTokens) {
     const savedPerToken = (p.inputUsd * (1 - p.cacheReadMultiplier)) / 1_000_000;
     return cacheReadTokens * savedPerToken;
 }
+export function modelIdToFamily(model) {
+    const lower = model.toLowerCase();
+    if (lower.includes("sonnet"))
+        return "claude-sonnet";
+    if (lower.includes("opus"))
+        return "claude-opus";
+    if (lower.includes("haiku"))
+        return "claude-haiku";
+    if (lower.includes("gpt-5") || lower.includes("o3"))
+        return "openai-gpt5";
+    const geminiSpecialty = lower.includes("lite") ||
+        lower.includes("image") ||
+        lower.includes("audio") ||
+        lower.includes("tts");
+    if (!geminiSpecialty) {
+        if (lower.includes("2.5-flash"))
+            return "gemini-2.5-flash";
+        if (lower.includes("2.5-pro"))
+            return "gemini-2.5-pro";
+        if (lower.includes("gemini-3") && lower.includes("pro"))
+            return "gemini-3-pro";
+    }
+    if (lower.includes("grok-build") || lower.includes("grok-code"))
+        return "grok-build";
+    if (lower.includes("grok-4") || lower.includes("grok-3") || lower.includes("grok-latest")) {
+        return "grok-4";
+    }
+    if (lower.includes("devstral-small"))
+        return "mistral-devstral";
+    if (lower.includes("mistral-medium-3.5"))
+        return "mistral-medium";
+    return "unknown";
+}
+const FAMILY_PRICING = new Map([
+    ["claude-sonnet", ANTHROPIC_SONNET],
+    ["claude-opus", ANTHROPIC_OPUS],
+    ["claude-haiku", ANTHROPIC_HAIKU],
+    ["openai-gpt5", OPENAI_GPT5],
+    ["gemini-2.5-pro", GEMINI_25_PRO],
+    ["gemini-2.5-flash", GEMINI_FLASH],
+    ["gemini-3-pro", GEMINI_3_PRO],
+    ["grok-4", GROK_4],
+    ["grok-build", GROK_BUILD],
+    ["mistral-medium", MISTRAL_MEDIUM],
+    ["mistral-devstral", MISTRAL_DEVSTRAL],
+]);
+export const API_CATALOG_AS_OF = "2026-07-11";
+export const API_CATALOG = new Map([
+    [
+        "openai/gpt-5.5",
+        {
+            inputUsdPerMTok: 1.25,
+            outputUsdPerMTok: 10,
+            cacheReadMultiplier: 0.5,
+            family: "openai-gpt5",
+        },
+    ],
+    [
+        "anthropic/claude-sonnet-4.5",
+        {
+            inputUsdPerMTok: 3,
+            outputUsdPerMTok: 15,
+            cacheReadMultiplier: 0.1,
+            accountingMode: "disjoint",
+            family: "claude-sonnet",
+        },
+    ],
+    [
+        "google/gemini-2.5-flash",
+        {
+            inputUsdPerMTok: 0.3,
+            outputUsdPerMTok: 2.5,
+            cacheReadMultiplier: 0.1,
+            family: "gemini-2.5-flash",
+        },
+    ],
+    [
+        "grok-build-0.1",
+        { inputUsdPerMTok: 1, outputUsdPerMTok: 2, cacheReadMultiplier: 0.2, family: "grok-build" },
+    ],
+    [
+        "grok-4",
+        { inputUsdPerMTok: 1.25, outputUsdPerMTok: 2.5, cacheReadMultiplier: 0.16, family: "grok-4" },
+    ],
+]);
+function tableModelCost(family, rate) {
+    const accountingMode = family.startsWith("claude-") ? "disjoint" : "inclusive";
+    return {
+        inputUsdPerMTok: rate.inputUsd,
+        outputUsdPerMTok: rate.outputUsd,
+        cacheReadMultiplier: rate.cacheReadMultiplier,
+        cacheWriteUsdPerMTok: rate.inputUsd,
+        accountingMode,
+        family,
+        source: "table",
+        asOf: PRICING_AS_OF,
+    };
+}
+function catalogModelCost(model, entry) {
+    const family = entry.family ?? modelIdToFamily(model);
+    return {
+        inputUsdPerMTok: entry.inputUsdPerMTok,
+        outputUsdPerMTok: entry.outputUsdPerMTok,
+        cacheReadMultiplier: entry.cacheReadMultiplier,
+        cacheWriteUsdPerMTok: entry.inputUsdPerMTok,
+        accountingMode: entry.accountingMode ?? "inclusive",
+        family: family === "unknown" ? model.toLowerCase() : family,
+        source: "api-catalog",
+        asOf: API_CATALOG_AS_OF,
+    };
+}
+const UNKNOWN_MODEL_COST = {
+    inputUsdPerMTok: 0,
+    outputUsdPerMTok: 0,
+    cacheReadMultiplier: 0,
+    cacheWriteUsdPerMTok: 0,
+    accountingMode: "inclusive",
+    family: "unknown",
+    source: "unknown",
+    asOf: PRICING_AS_OF,
+};
+export function getModelCost(provider, model, opts) {
+    const catalog = opts?.catalog ?? API_CATALOG;
+    const preferCatalog = opts?.preferCatalog ?? true;
+    const catalogEntry = catalog.get(model.toLowerCase());
+    const family = modelIdToFamily(model);
+    const familyRate = FAMILY_PRICING.get(family);
+    if (catalogEntry !== undefined && (preferCatalog || familyRate === undefined)) {
+        return catalogModelCost(model, catalogEntry);
+    }
+    if (familyRate !== undefined) {
+        return tableModelCost(family, familyRate);
+    }
+    return { ...UNKNOWN_MODEL_COST };
+}
+function composeTotalUsd(inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, reasoningTokens, modelCost, inputIsWholePrompt) {
+    const M = 1_000_000;
+    const { inputUsdPerMTok, outputUsdPerMTok, cacheWriteUsdPerMTok, cacheReadMultiplier } = modelCost;
+    const outputCost = ((outputTokens + reasoningTokens) * outputUsdPerMTok) / M;
+    const cacheWriteCost = (cacheWriteTokens * cacheWriteUsdPerMTok) / M;
+    if (modelCost.accountingMode === "disjoint") {
+        const freshTokens = inputIsWholePrompt
+            ? inputTokens - cacheReadTokens - cacheWriteTokens
+            : inputTokens;
+        const freshCost = (freshTokens * inputUsdPerMTok) / M;
+        const cacheReadCost = (cacheReadTokens * inputUsdPerMTok * cacheReadMultiplier) / M;
+        return freshCost + cacheWriteCost + cacheReadCost + outputCost;
+    }
+    const baseCost = (inputTokens * inputUsdPerMTok) / M;
+    const cacheReadDiscount = (cacheReadTokens * inputUsdPerMTok * (1 - cacheReadMultiplier)) / M;
+    return baseCost + cacheWriteCost + outputCost - cacheReadDiscount;
+}
+export function composeCost(counts, estimate, modelCost) {
+    if (counts?.reportedCostUsd != null) {
+        return {
+            costUsd: counts.reportedCostUsd,
+            cost_basis: "provider-reported",
+            confidence: "high",
+        };
+    }
+    if (counts != null && modelCost.source !== "unknown") {
+        const costUsd = composeTotalUsd(counts.inputTokens, counts.outputTokens, counts.cacheReadTokens ?? 0, counts.cacheCreationTokens ?? 0, counts.reasoningTokens ?? 0, modelCost, false);
+        return { costUsd, cost_basis: "derived-from-tokens", confidence: "high" };
+    }
+    const costUsd = composeTotalUsd(estimate.estInputTokens, estimate.estOutputTokens, estimate.estCacheReadTokens ?? 0, estimate.estCacheWriteTokens ?? 0, 0, modelCost, true);
+    return { costUsd, cost_basis: "pre-flight-estimate", confidence: "low" };
+}

package/dist/provider-admin-tools.js

@@ -122,6 +122,13 @@ export function familyBaseRisk(provider, fam) {
         return contract.risk;
     return fam.safety === "read-only" ? "read_only" : "writes_local_config";
 }
+function contractAdminProjectionCeiling(provider, commandPath) {
+    const exactContract = getCliSubcommandContract(provider, commandPath);
+    return exactContract?.adminProjection === "not_exposed" ? "not_exposed" : null;
+}
+function projectedAdminExposure(provider, commandPath, risk) {
+    return contractAdminProjectionCeiling(provider, commandPath) ?? adminRiskToExposure(risk);
+}
 function rootAdvertises(discovered, family) {
     const wanted = family.toLowerCase();
     return discovered.rootHelp.subcommands.some(s => s.name.toLowerCase() === wanted);
@@ -142,6 +149,7 @@ export function projectProviderAdminOperations(def, discovered) {
         if (adminSurfaceKind(fam) !== "cli-subcommand")
             continue;
         const baseRisk = familyBaseRisk(def.id, fam);
+        const familyExposure = projectedAdminExposure(def.id, [fam.family], baseRisk);
         if (!discovered) {
             ops.push({
                 provider: def.id,
@@ -149,8 +157,8 @@ export function projectProviderAdminOperations(def, discovered) {
                 operationId: fam.family,
                 argv: [fam.family],
                 risk: baseRisk,
-                exposure: adminRiskToExposure(baseRisk),
-                mutating: adminRiskToExposure(baseRisk) === "mcp_requires_approval",
+                exposure: familyExposure,
+                mutating: familyExposure === "mcp_requires_approval",
                 available: false,
                 discoverySource: "no-discovery",
                 summary: fam.evidence,
@@ -165,7 +173,7 @@ export function projectProviderAdminOperations(def, discovered) {
                 if (!isSafeAdminToken(sub.name))
                     continue;
                 const risk = classifyOperationRisk(sub.name, baseRisk, { isSubcommand: true });
-                const exposure = adminRiskToExposure(risk);
+                const exposure = projectedAdminExposure(def.id, [fam.family, sub.name], risk);
                 ops.push({
                     provider: def.id,
                     family: fam.family,
@@ -183,7 +191,7 @@ export function projectProviderAdminOperations(def, discovered) {
         }
         const baseExposure = adminRiskToExposure(baseRisk);
         const risk = baseExposure === "not_exposed" ? baseRisk : classifyOperationRisk(fam.family, baseRisk);
-        const exposure = adminRiskToExposure(risk);
+        const exposure = projectedAdminExposure(def.id, [fam.family], risk);
         ops.push({
             provider: def.id,
             family: fam.family,

package/dist/provider-definitions.d.ts

@@ -97,6 +97,10 @@ export interface ProviderRequestSurface {
     readonly acpCapable: boolean;
     readonly syncToolName: string;
     readonly asyncToolName: string;
+    readonly acceptsImages: boolean;
+    readonly acceptsAttachments: boolean;
+    readonly toolCalling: boolean;
+    readonly jsonSchema: boolean;
 }
 export interface ProviderDefinition {
     readonly id: ProviderId;

package/dist/provider-definitions.js

@@ -5,13 +5,13 @@ export function adminSurfaceKind(family) {
 }
 export const DEVIN_ACP_AGENT_TYPES = ["summarizer", "review"];
 export const PROVIDER_TARGET_VERSIONS = {
-    claude: "claude 2.1.206",
-    codex: "codex-cli 0.144.1",
-    gemini: "agy 1.1.0",
-    grok: "grok 0.2.93 (f00f96316d)",
+    claude: "claude 2.1.207",
+    codex: "codex-cli 0.144.3",
+    gemini: "agy 1.1.1",
+    grok: "grok 0.2.99 (b1b49ccb71)",
     mistral: "vibe 2.19.1",
     devin: "devin 3000.1.27 (0d4bf12e)",
-    cursor: "cursor-agent 2026.07.09-c59fd9a",
+    cursor: "cursor-agent 2026.07.09-a3815c0",
 };
 const PROVIDER_DEFINITIONS = {
     claude: {
@@ -28,6 +28,10 @@ const PROVIDER_DEFINITIONS = {
             acpCapable: false,
             syncToolName: "claude_request",
             asyncToolName: "claude_request_async",
+            acceptsImages: false,
+            acceptsAttachments: false,
+            toolCalling: true,
+            jsonSchema: true,
         },
         docs: { primary: ["https://code.claude.com/docs/en/cli-reference"] },
         discovery: {
@@ -127,6 +131,10 @@ const PROVIDER_DEFINITIONS = {
             acpCapable: false,
             syncToolName: "codex_request",
             asyncToolName: "codex_request_async",
+            acceptsImages: true,
+            acceptsAttachments: true,
+            toolCalling: true,
+            jsonSchema: true,
         },
         docs: {
             primary: [
@@ -264,6 +272,10 @@ const PROVIDER_DEFINITIONS = {
             acpCapable: false,
             syncToolName: "gemini_request",
             asyncToolName: "gemini_request_async",
+            acceptsImages: false,
+            acceptsAttachments: false,
+            toolCalling: true,
+            jsonSchema: false,
         },
         docs: {
             primary: [
@@ -363,6 +375,10 @@ const PROVIDER_DEFINITIONS = {
             acpCapable: true,
             syncToolName: "grok_request",
             asyncToolName: "grok_request_async",
+            acceptsImages: false,
+            acceptsAttachments: false,
+            toolCalling: true,
+            jsonSchema: true,
         },
         docs: {
             primary: [
@@ -470,6 +486,10 @@ const PROVIDER_DEFINITIONS = {
             acpCapable: true,
             syncToolName: "mistral_request",
             asyncToolName: "mistral_request_async",
+            acceptsImages: false,
+            acceptsAttachments: false,
+            toolCalling: true,
+            jsonSchema: false,
         },
         docs: { primary: ["https://github.com/mistralai/mistral-vibe"] },
         discovery: {
@@ -586,6 +606,10 @@ const PROVIDER_DEFINITIONS = {
             acpCapable: true,
             syncToolName: "devin_request",
             asyncToolName: "devin_request_async",
+            acceptsImages: false,
+            acceptsAttachments: false,
+            toolCalling: true,
+            jsonSchema: false,
         },
         docs: { primary: ["https://docs.devin.ai/cli/reference/commands"] },
         discovery: {
@@ -697,6 +721,10 @@ const PROVIDER_DEFINITIONS = {
             acpCapable: true,
             syncToolName: "cursor_request",
             asyncToolName: "cursor_request_async",
+            acceptsImages: false,
+            acceptsAttachments: false,
+            toolCalling: true,
+            jsonSchema: false,
         },
         docs: { primary: ["https://docs.cursor.com/en/cli/overview"] },
         discovery: {

package/dist/provider-tool-capabilities.js

@@ -615,7 +615,7 @@ const TOOL_CONTROLS = {
     mistral: {
         providerKind: "cli",
         gatewayRequestTools: ["mistral_request", "mistral_request_async"],
-        summary: "Mistral Vibe owns its runtime tool catalog; the gateway can pass Vibe enabled-tool controls and reports local skills if present.",
+        summary: "Mistral Vibe owns its runtime tool catalog; the gateway can pass Vibe enabled- and disabled-tool controls and reports local skills if present.",
         controls: {
             allowlist: {
                 supported: true,
@@ -624,9 +624,10 @@ const TOOL_CONTROLS = {
                 behavior: "Each entry is emitted as a separate Vibe enabled-tool flag.",
             },
             denylist: {
-                supported: false,
+                supported: true,
                 requestField: "disallowedTools",
-                behavior: "Accepted for caller parity but ignored because Vibe has no deny-list flag.",
+                cliFlag: "--disabled-tools",
+                behavior: "Each entry is emitted as a separate Vibe disabled-tool flag.",
             },
             mcpServers: {
                 supported: false,
@@ -675,15 +676,11 @@ const TOOL_CONTROLS = {
             approvalAndSandboxControls: true,
             costAndLoopControls: true,
             workspaceAndWorktreeControls: true,
+            toolAllowDenyControls: true,
             enabledToolAllowlist: true,
             trustControl: true,
         }),
         unsupportedInputs: [
-            {
-                input: "disallowedTools",
-                behavior: "ignored",
-                details: "Accepted for caller parity but ignored because Vibe has no deny-list flag.",
-            },
             {
                 input: "mcpServers",
                 behavior: "approval_tracking_only",
@@ -798,7 +795,7 @@ const TOOL_CONTROLS = {
                 supported: true,
                 requestField: "permissionMode",
                 cliFlag: "--permission-mode",
-                behavior: "Maps to Devin CLI --permission-mode: auto auto-approves read-only tools; smart additionally auto-runs actions a fast model judges safe; dangerous auto-approves all.",
+                behavior: "Maps to Devin CLI --permission-mode: auto auto-approves read-only tools; accept-edits also auto-approves workspace edits; smart additionally auto-runs actions a fast model judges safe; dangerous auto-approves all.",
             },
             promptControl: {
                 supported: true,

package/dist/request-helpers.d.ts

@@ -52,10 +52,9 @@ export interface PrepareMistralRequestInput {
 export interface PrepareMistralRequestResult {
     args: string[];
     env: Record<string, string>;
-    ignoredDisallowedTools: boolean;
 }
 export declare function prepareMistralRequest(input: PrepareMistralRequestInput): PrepareMistralRequestResult;
-export declare const CLAUDE_PERMISSION_MODES: readonly ["default", "acceptEdits", "plan", "auto", "dontAsk", "bypassPermissions"];
+export declare const CLAUDE_PERMISSION_MODES: readonly ["default", "acceptEdits", "auto", "bypassPermissions", "manual", "dontAsk", "plan"];
 export type ClaudePermissionMode = (typeof CLAUDE_PERMISSION_MODES)[number];
 export interface ClaudePermissionFlagsInput {
     permissionMode?: ClaudePermissionMode;
@@ -229,8 +228,8 @@ export declare const CODEX_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodObject<{
     disable: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     search?: boolean | undefined;
-    outputSchema?: string | Record<string, unknown> | undefined;
     profile?: string | undefined;
+    outputSchema?: string | Record<string, unknown> | undefined;
     configOverrides?: Record<string, string> | undefined;
     ephemeral?: boolean | undefined;
     images?: string[] | undefined;
@@ -240,8 +239,8 @@ export declare const CODEX_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodObject<{
     disable?: string[] | undefined;
 }, {
     search?: boolean | undefined;
-    outputSchema?: string | Record<string, unknown> | undefined;
     profile?: string | undefined;
+    outputSchema?: string | Record<string, unknown> | undefined;
     configOverrides?: Record<string, string> | undefined;
     ephemeral?: boolean | undefined;
     images?: string[] | undefined;

package/dist/request-helpers.js

@@ -3,6 +3,7 @@ import { tmpdir } from "os";
 import { join, isAbsolute } from "path";
 import { randomUUID } from "crypto";
 import { z } from "zod/v3";
+import { CLAUDE_WIRE_PERMISSION_MODES } from "./upstream-contracts.js";
 export const GATEWAY_SESSION_PREFIX = "gw-";
 export function validateSessionId(sessionId) {
     if (sessionId.startsWith(GATEWAY_SESSION_PREFIX)) {
@@ -117,6 +118,12 @@ export function prepareMistralRequest(input) {
             args.push("--enabled-tools", tool);
         }
     }
+    if (input.disallowedTools && input.disallowedTools.length > 0) {
+        sanitizeCliArgValues(input.disallowedTools, "disallowedTools");
+        for (const tool of input.disallowedTools) {
+            args.push("--disabled-tools", tool);
+        }
+    }
     if (input.trust) {
         args.push("--trust");
     }
@@ -137,8 +144,7 @@ export function prepareMistralRequest(input) {
             args.push("--add-dir", dir);
         }
     }
-    const ignoredDisallowedTools = Boolean(input.disallowedTools && input.disallowedTools.length > 0);
-    return { args, env, ignoredDisallowedTools };
+    return { args, env };
 }
 function normalizeMistralOutputFormat(format) {
     if (format === "plain")
@@ -147,14 +153,7 @@ function normalizeMistralOutputFormat(format) {
         return "streaming";
     return format;
 }
-export const CLAUDE_PERMISSION_MODES = [
-    "default",
-    "acceptEdits",
-    "plan",
-    "auto",
-    "dontAsk",
-    "bypassPermissions",
-];
+export const CLAUDE_PERMISSION_MODES = ["default", ...CLAUDE_WIRE_PERMISSION_MODES];
 export function resolveClaudePermissionFlags(input) {
     const { permissionMode, dangerouslySkipPermissions } = input;
     let warning;

package/dist/resources.d.ts

@@ -3,7 +3,7 @@ import { type CliType } from "./session-manager.js";
 import { PerformanceMetrics } from "./metrics.js";
 import { FlightRecorderQuery } from "./flight-recorder.js";
 import { type GlobalCacheStats, type PrefixCacheStats, type SessionCacheStats } from "./cache-stats.js";
-import { type CacheAwarenessConfig, type ProvidersConfig } from "./config.js";
+import { type CacheAwarenessConfig, type LeastCostConfig, type ProvidersConfig } from "./config.js";
 import type { AcpConfig } from "./config.js";
 import { type ResolvedProviderCapability } from "./provider-capability-resolver.js";
 export interface ResourceDefinition {
@@ -31,7 +31,9 @@ export declare class ResourceProvider {
     private providers;
     private capabilityPeek;
     private acpConfig;
-    constructor(sessionManager: ISessionManager, performanceMetrics: PerformanceMetrics, flightRecorder?: FlightRecorderQuery, cacheAwareness?: CacheAwarenessConfig | null, providers?: ProvidersConfig | null, capabilityPeek?: (id: CliType) => ResolvedProviderCapability | null, acpConfig?: AcpConfig | null);
+    private leastCost;
+    constructor(sessionManager: ISessionManager, performanceMetrics: PerformanceMetrics, flightRecorder?: FlightRecorderQuery, cacheAwareness?: CacheAwarenessConfig | null, providers?: ProvidersConfig | null, capabilityPeek?: (id: CliType) => ResolvedProviderCapability | null, acpConfig?: AcpConfig | null, leastCost?: LeastCostConfig | undefined);
+    private routingResourcesEnabled;
     getFlightRecorderQuery(): FlightRecorderQuery;
     private apiRuntimes;
     private continuityTrackedApiRuntimes;
@@ -42,7 +44,40 @@ export declare class ResourceProvider {
     readCacheStateSession(sessionId: string): SessionCacheStats;
     readCacheStateForPrefix(stablePrefixHash: string): PrefixCacheStats;
     listResources(): ResourceDefinition[];
+    private readRoutingDecisions;
+    private readRoutingPriors;
     private ownedSessions;
     private ownedActiveId;
     readResource(uri: string): Promise<ResourceContents | null>;
 }
+export interface RoutingDecision {
+    provider: string;
+    model: string;
+    tier: string;
+    estCostUsd: number | null;
+    costBasis: string | null;
+    confidence: string | null;
+    reason: string | null;
+    considered: number | null;
+    reroutes: number | null;
+    at: string;
+}
+export interface RoutingPriorsPayload {
+    priorsScope: string;
+    priceAsOf: {
+        table: string;
+        apiCatalog: string;
+    };
+    outputPriors: Array<{
+        candidate: string;
+        median: number;
+        p90: number;
+        samples: number;
+    }>;
+    calibration: Array<{
+        bucket: string;
+        k: number;
+        samples: number;
+        confidence: string;
+    }>;
+}

package/dist/resources.js

@@ -4,6 +4,9 @@ import { getRequestContext, principalCanAccess, resolveOwnerPrincipal } from "./
 import { getAvailableCliInfo } from "./model-registry.js";
 import { computeGlobalCacheStats, computePrefixCacheStats, computeSessionCacheStats, computeTtlRemaining, } from "./cache-stats.js";
 import { enabledApiProviders, } from "./config.js";
+import { computeLcrPriorsFromDb } from "./lcr-priors.js";
+import { telemetryTierFor } from "./lcr-telemetry.js";
+import { PRICING_AS_OF, API_CATALOG_AS_OF } from "./pricing.js";
 import { apiContinuityForKind } from "./api-provider.js";
 import { apiProviderCatalogEntry } from "./api-request.js";
 import { buildProviderSubcommandsCompactCatalog, getCliSubcommandContract, serializeCliSubcommandContract, } from "./upstream-contracts.js";
@@ -20,7 +23,8 @@ export class ResourceProvider {
     providers;
     capabilityPeek;
     acpConfig;
-    constructor(sessionManager, performanceMetrics, flightRecorder = { queryRequests: () => [] }, cacheAwareness = null, providers = null, capabilityPeek = peekProviderCapabilitySet, acpConfig = null) {
+    leastCost;
+    constructor(sessionManager, performanceMetrics, flightRecorder = { queryRequests: () => [] }, cacheAwareness = null, providers = null, capabilityPeek = peekProviderCapabilitySet, acpConfig = null, leastCost = undefined) {
         this.sessionManager = sessionManager;
         this.performanceMetrics = performanceMetrics;
         this.flightRecorder = flightRecorder;
@@ -28,6 +32,10 @@ export class ResourceProvider {
         this.providers = providers;
         this.capabilityPeek = capabilityPeek;
         this.acpConfig = acpConfig;
+        this.leastCost = leastCost;
+    }
+    routingResourcesEnabled() {
+        return this.leastCost?.enabled === true;
     }
     getFlightRecorderQuery() {
         return this.flightRecorder;
@@ -172,8 +180,79 @@ export class ResourceProvider {
                     priority: 0.7,
                 },
             })),
+            ...(this.routingResourcesEnabled()
+                ? [
+                    {
+                        uri: "routing://decisions",
+                        name: "Routing Decisions",
+                        title: "Least-Cost Routing Decisions",
+                        description: "Recent redacted least-cost routing decisions (provider/model/tier/est cost/confidence)",
+                        mimeType: "application/json",
+                        annotations: {
+                            audience: ["user", "assistant"],
+                            priority: 0.7,
+                        },
+                    },
+                    {
+                        uri: "routing://priors",
+                        name: "Routing Priors",
+                        title: "Least-Cost Routing Priors",
+                        description: "Learned output-token priors + input-token calibration (k, samples, quality) + price asOf",
+                        mimeType: "application/json",
+                        annotations: {
+                            audience: ["user", "assistant"],
+                            priority: 0.7,
+                        },
+                    },
+                ]
+                : []),
         ];
     }
+    readRoutingDecisions() {
+        const rows = this.flightRecorder.queryRequests(`SELECT r.cli, r.model, r.datetime_utc, r.cost_basis,
+              m.route_est_cost_usd, m.route_est_confidence, m.route_reason,
+              m.route_considered, m.route_reroutes
+       FROM requests r
+       LEFT JOIN gateway_metadata m ON m.request_id = r.id
+       WHERE m.routed = 1
+       ORDER BY r.datetime_utc DESC
+       LIMIT 50`);
+        return rows.map(row => ({
+            provider: row.cli,
+            model: row.model,
+            tier: telemetryTierFor(row.cli),
+            estCostUsd: row.route_est_cost_usd ?? null,
+            costBasis: row.cost_basis ?? null,
+            confidence: row.route_est_confidence ?? null,
+            reason: row.route_reason ?? null,
+            considered: row.route_considered ?? null,
+            reroutes: row.route_reroutes ?? null,
+            at: row.datetime_utc,
+        }));
+    }
+    readRoutingPriors() {
+        const scope = this.leastCost?.priorsScope ?? "off";
+        const priors = computeLcrPriorsFromDb(this.flightRecorder, {
+            priorsScope: scope,
+            ownerPrincipal: resolveOwnerPrincipal(getRequestContext()),
+        });
+        return {
+            priorsScope: scope,
+            priceAsOf: { table: PRICING_AS_OF, apiCatalog: API_CATALOG_AS_OF },
+            outputPriors: Array.from(priors.outputPriors, ([key, prior]) => ({
+                candidate: key,
+                median: prior.median,
+                p90: prior.p90,
+                samples: prior.samples,
+            })),
+            calibration: Array.from(priors.calibration, ([key, bucket]) => ({
+                bucket: key,
+                k: bucket.k,
+                samples: bucket.samples,
+                confidence: bucket.confidence,
+            })),
+        };
+    }
     ownedSessions(sessions) {
         const caller = resolveOwnerPrincipal(getRequestContext());
         const owned = sessions.filter(s => principalCanAccess(s.ownerPrincipal, caller));
@@ -256,6 +335,22 @@ export class ResourceProvider {
                 };
             }
         }
+        if (this.routingResourcesEnabled()) {
+            if (uri === "routing://decisions") {
+                return {
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify({ decisions: this.readRoutingDecisions() }, null, 2),
+                };
+            }
+            if (uri === "routing://priors") {
+                return {
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify(this.readRoutingPriors(), null, 2),
+                };
+            }
+        }
         if (uri === "metrics://performance") {
             return {
                 uri,

package/dist/retry.d.ts

@@ -19,6 +19,7 @@ export interface RetryOptions {
     isTransient: (error: any) => boolean;
     onRetry: (error: any, attempt: number, delay: number) => void;
 }
+export declare const isDefaultTransient: (error: any) => boolean;
 export declare function createCircuitBreaker(options?: {
     resetTimeout?: number;
     failureThreshold?: number;

package/dist/retry.js

@@ -4,7 +4,7 @@ export var CircuitBreakerState;
     CircuitBreakerState["OPEN"] = "OPEN";
     CircuitBreakerState["HALF_OPEN"] = "HALF_OPEN";
 })(CircuitBreakerState || (CircuitBreakerState = {}));
-const isDefaultTransient = (error) => {
+export const isDefaultTransient = (error) => {
     if (!error) {
         return false;
     }

package/dist/token-estimator.d.ts

@@ -0,0 +1,6 @@
+export type ContentType = "prose" | "code" | "cjk";
+export declare function classifyContent(text: string): ContentType;
+export declare function estimateInputTokens(text: string, opts?: {
+    family?: string;
+    calibrationK?: number;
+}): number;