llm-cli-gateway 2.16.0 → 2.17.0

package/dist/flight-recorder.js

@@ -83,6 +83,35 @@ function ensureCompressionColumns(db) {
         db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_tokens_saved_est INTEGER");
     }
 }
+function ensureRequestsCostBasisColumn(db) {
+    const rows = db.prepare("PRAGMA table_info(requests)").all();
+    const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
+    if (!names.has("cost_basis")) {
+        db.exec("ALTER TABLE requests ADD COLUMN cost_basis TEXT");
+    }
+}
+function ensureMetadataRoutingColumns(db) {
+    const rows = db.prepare("PRAGMA table_info(gateway_metadata)").all();
+    const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
+    if (!names.has("routed")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN routed INTEGER");
+    }
+    if (!names.has("route_est_cost_usd")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_est_cost_usd REAL");
+    }
+    if (!names.has("route_est_confidence")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_est_confidence TEXT");
+    }
+    if (!names.has("route_reason")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_reason TEXT");
+    }
+    if (!names.has("route_considered")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_considered INTEGER");
+    }
+    if (!names.has("route_reroutes")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_reroutes INTEGER");
+    }
+}
 export function resolveFlightRecorderDbPath() {
     const configured = process.env.LLM_GATEWAY_LOGS_DB;
     if (configured !== undefined) {
@@ -161,7 +190,8 @@ export class FlightRecorder {
         output_tokens INTEGER,
         cache_read_tokens INTEGER,
         cache_creation_tokens INTEGER,
-        owner_principal TEXT
+        owner_principal TEXT,
+        cost_basis TEXT
       );
 
       CREATE TABLE IF NOT EXISTS gateway_metadata (
@@ -178,6 +208,12 @@ export class FlightRecorder {
         async_job_id TEXT,
         provider_session_id TEXT,
         stop_reason TEXT,
+        routed INTEGER,
+        route_est_cost_usd REAL,
+        route_est_confidence TEXT,
+        route_reason TEXT,
+        route_considered INTEGER,
+        route_reroutes INTEGER,
         status TEXT NOT NULL DEFAULT 'started'
       );
 
@@ -219,6 +255,14 @@ export class FlightRecorder {
         this.db
             .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(8, ?)")
             .run(new Date().toISOString());
+        ensureRequestsCostBasisColumn(this.db);
+        this.db
+            .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(9, ?)")
+            .run(new Date().toISOString());
+        ensureMetadataRoutingColumns(this.db);
+        this.db
+            .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(10, ?)")
+            .run(new Date().toISOString());
         if (process.platform !== "win32") {
             try {
                 chmodSync(dbPath, 0o600);
@@ -265,7 +309,8 @@ export class FlightRecorder {
           input_tokens = @input_tokens,
           output_tokens = @output_tokens,
           cache_read_tokens = @cache_read_tokens,
-          cache_creation_tokens = @cache_creation_tokens
+          cache_creation_tokens = @cache_creation_tokens,
+          cost_basis = @cost_basis
       WHERE id = @id
     `);
         const updateMetadata = this.db.prepare(`
@@ -296,6 +341,7 @@ export class FlightRecorder {
                 output_tokens: result.outputTokens ?? null,
                 cache_read_tokens: result.cacheReadTokens ?? null,
                 cache_creation_tokens: result.cacheCreationTokens ?? null,
+                cost_basis: result.costBasis ?? null,
             });
             updateMetadata.run({
                 id: correlationId,
@@ -338,6 +384,25 @@ export class FlightRecorder {
             tokens_saved_est: telemetry.estimatedTokensSaved,
         });
     }
+    recordRouting(correlationId, routing) {
+        this.db
+            .prepare(`UPDATE gateway_metadata
+         SET routed = 1,
+             route_est_cost_usd = @est_cost_usd,
+             route_est_confidence = @est_confidence,
+             route_reason = @reason,
+             route_considered = @considered,
+             route_reroutes = @reroutes
+         WHERE request_id = @id`)
+            .run({
+            id: correlationId,
+            est_cost_usd: routing.estCostUsd ?? null,
+            est_confidence: routing.estConfidence ?? null,
+            reason: routing.reason ?? null,
+            considered: routing.considered ?? null,
+            reroutes: routing.reroutes ?? null,
+        });
+    }
     redactStart(entry) {
         return {
             ...entry,
@@ -372,6 +437,7 @@ export class NoopFlightRecorder {
     logStart(_entry) { }
     logComplete(_correlationId, _result) { }
     recordCompressionTelemetry(_correlationId, _telemetry) { }
+    recordRouting(_correlationId, _routing) { }
     queryRequests(_sql, ..._params) {
         return [];
     }

package/dist/http-transport.js

@@ -19,12 +19,7 @@ async function readBody(req) {
     const raw = await readCappedRawBody(req, maxHttpBodyBytes());
     if (!raw)
         return undefined;
-    try {
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        throw error;
-    }
+    return JSON.parse(raw);
 }
 function methodNotAllowed(res) {
     res.writeHead(405, { allow: "GET, POST, DELETE", "content-type": "application/json" });
@@ -34,10 +29,6 @@ function jsonError(res, status, message) {
     res.writeHead(status, { "content-type": "application/json" });
     res.end(JSON.stringify({ error: message }));
 }
-function jsonResponse(res, status, body) {
-    res.writeHead(status, { "content-type": "application/json" });
-    res.end(JSON.stringify(body));
-}
 function parseNoAuthPaths(raw, protectedPath) {
     const paths = new Set();
     for (const value of (raw ?? "").split(/[,;\s]+/)) {
@@ -133,21 +124,21 @@ export async function startHttpGateway(options) {
     }
     async function createSession(releaseInitializeReservation) {
         const gatewayServer = options.createGatewayServer(options.deps);
-        let entry;
+        const onSessionInitialized = (sessionId) => {
+            const initializedAt = Date.now();
+            releaseInitializeReservation();
+            entry.sessionId = sessionId;
+            entry.createdAt = initializedAt;
+            entry.lastActivityAt = initializedAt;
+            entry.inFlight++;
+            sessions.set(sessionId, entry);
+        };
         const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => randomUUID(),
-            onsessioninitialized: sessionId => {
-                const now = Date.now();
-                releaseInitializeReservation();
-                entry.sessionId = sessionId;
-                entry.createdAt = now;
-                entry.lastActivityAt = now;
-                entry.inFlight++;
-                sessions.set(sessionId, entry);
-            },
+            onsessioninitialized: onSessionInitialized,
         });
         const now = Date.now();
-        entry = {
+        const entry = {
             server: gatewayServer,
             transport,
             createdAt: now,
@@ -209,6 +200,9 @@ export async function startHttpGateway(options) {
         if (manager) {
             const limiter = manager.getLimiterSnapshot();
             const limits = manager.getConfiguredLimits();
+            const durableAdmission = manager.getDurableAdmissionHealth();
+            const persistence = options.deps?.persistence;
+            const durablePersistenceConfigured = persistence !== undefined && persistence.backend !== "none" && persistence.asyncJobsEnabled;
             payload.jobs = {
                 running: limiter.running,
                 queued: limiter.queued,
@@ -222,7 +216,11 @@ export async function startHttpGateway(options) {
                 saturated: limiter.saturated,
                 completedJobMemoryTtlMs: limits.completedJobMemoryTtlMs,
                 maxJobOutputBytes: limits.maxJobOutputBytes,
+                durableAdmission,
             };
+            payload.ready = durableAdmission.storeAttached
+                ? durableAdmission.admitting
+                : !durablePersistenceConfigured;
         }
         return payload;
     }

package/dist/index.d.ts

@@ -5,7 +5,8 @@ import { ISessionManager, type CliType, type ProviderType } from "./session-mana
 import { ResourceProvider } from "./resources.js";
 import { PerformanceMetrics } from "./metrics.js";
 import { type CompressResult } from "./compressor/index.js";
-import { type PersistenceConfig, type CacheAwarenessConfig, type CompressionConfig, type ProvidersConfig, type ApiProviderRuntime, type AcpConfig, type AdminConfig } from "./config.js";
+import { type PersistenceConfig, type CacheAwarenessConfig, type CompressionConfig, type ProvidersConfig, type ApiProviderRuntime, type AcpConfig, type AdminConfig, type LeastCostConfig } from "./config.js";
+import type { CostBasis } from "./least-cost-types.js";
 import { DatabaseConnection } from "./db.js";
 import { type DevinAcpAgentType } from "./provider-definitions.js";
 import { AsyncJobManager } from "./async-job-manager.js";
@@ -39,6 +40,7 @@ type ExtendedToolResponse = {
     };
     reviewIntegrity?: ReviewIntegrityResult;
     warnings?: WarningEntry[];
+    routing?: RouteResponseBlock;
     compression?: CompressResult;
 };
 export declare const logger: {
@@ -83,6 +85,7 @@ export interface GatewayServerDeps {
     acpConfig?: AcpConfig;
     adminConfig?: AdminConfig;
     workspaces?: WorkspaceRegistry;
+    leastCost?: LeastCostConfig;
 }
 export interface GatewayServerRuntime {
     sessionManager: ISessionManager;
@@ -100,6 +103,7 @@ export interface GatewayServerRuntime {
     acpConfig: AcpConfig;
     adminConfig: AdminConfig;
     workspaces: WorkspaceRegistry;
+    leastCost: LeastCostConfig;
 }
 export declare function resolveGatewayServerRuntime(deps?: GatewayServerDeps, options?: {
     isolateState?: boolean;
@@ -696,5 +700,41 @@ export declare function handleCodexRequestAsync(deps: AsyncHandlerDeps, params:
         ref?: string;
     };
 }): Promise<ExtendedToolResponse>;
+export interface RouteResponseBlock {
+    chosen: {
+        provider: string;
+        model: string;
+    } | null;
+    tier?: string;
+    estCostUsd?: number;
+    costBasis?: string;
+    confidence?: string;
+    nearTie?: boolean;
+    estInputTokens?: number;
+    estOutputTokens?: number;
+    priceAsOf?: string;
+    priceSource?: string;
+    consideredCount: number;
+    rejected: {
+        candidate: {
+            provider: string;
+            model: string;
+        };
+        reason: string;
+    }[];
+    reroutes: number;
+    error?: string;
+}
+export declare function isTransientRouteFailure(provider: string, response: ExtendedToolResponse): boolean;
+export declare function deriveCostBasis(provider: string, resolvedModel: string, usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    costUsd?: number;
+}): {
+    costUsd?: number;
+    costBasis?: CostBasis;
+};
 export declare function createGatewayServer(deps?: GatewayServerDeps): McpServer;
 export {};