llm-cli-gateway 2.16.0 → 2.17.0

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-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

@@ -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/request-helpers.d.ts

@@ -229,8 +229,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 +240,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/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;

package/dist/token-estimator.js

@@ -0,0 +1,59 @@
+const CJK_RE = /[\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uff00-\uffef\uac00-\ud7af]/g;
+const CODE_SYMBOL_RE = /[{}[\]()<>;=+\-*/\\|&%$#@`~]/g;
+const CODE_KEYWORD_RE = /\b(function|const|let|var|return|import|export|class|def|public|private|static|void|for|while|switch|case)\b/;
+const DIVISOR_BY_TYPE = new Map([
+    ["prose", 4],
+    ["code", 3],
+    ["cjk", 1.5],
+]);
+const FAMILY_MULTIPLIERS = new Map([
+    ["openai", 1.0],
+    ["o200k", 1.0],
+    ["cl100k", 1.02],
+    ["claude", 1.08],
+    ["gemini", 0.98],
+    ["sentencepiece", 0.98],
+    ["grok", 1.0],
+    ["mistral", 1.05],
+]);
+export function classifyContent(text) {
+    if (!text)
+        return "prose";
+    const nonSpace = text.replace(/\s+/g, "").length;
+    if (nonSpace === 0)
+        return "prose";
+    const cjkMatches = text.match(CJK_RE);
+    const cjkCount = cjkMatches ? cjkMatches.length : 0;
+    if (cjkCount / nonSpace >= 0.2)
+        return "cjk";
+    const trimmed = text.trim();
+    const looksJson = /^[[{]/.test(trimmed) && /[}\]]/.test(trimmed) && /[:,]/.test(trimmed);
+    const symbolMatches = trimmed.match(CODE_SYMBOL_RE);
+    const symbolCount = symbolMatches ? symbolMatches.length : 0;
+    const symbolRatio = symbolCount / nonSpace;
+    const hasKeyword = CODE_KEYWORD_RE.test(trimmed);
+    if (looksJson || symbolRatio >= 0.08 || (hasKeyword && symbolRatio >= 0.03)) {
+        return "code";
+    }
+    return "prose";
+}
+function familyMultiplier(family) {
+    if (!family)
+        return 1;
+    const f = family.toLowerCase();
+    for (const [key, multiplier] of FAMILY_MULTIPLIERS) {
+        if (f === key || f.includes(key))
+            return multiplier;
+    }
+    return 1;
+}
+export function estimateInputTokens(text, opts) {
+    if (!text)
+        return 0;
+    const type = classifyContent(text);
+    const divisor = DIVISOR_BY_TYPE.get(type) ?? 4;
+    const base = text.length / divisor;
+    const familyMult = familyMultiplier(opts?.family);
+    const k = opts?.calibrationK ?? 1;
+    return Math.ceil(base * familyMult * k);
+}

package/dist/upstream-contracts.js

@@ -1691,7 +1691,7 @@ export const UPSTREAM_CLI_CONTRACTS = {
         env: {
             VIBE_ACTIVE_MODEL: {
                 arity: "one",
-                pattern: /^[^\s\u0000-\u001f\u007f]+$/,
+                pattern: /^[^\s\p{Cc}]+$/u,
                 description: "Active model selector; Vibe uses env instead of a --model flag",
             },
         },

package/dist/validation-receipt.js

@@ -230,7 +230,7 @@ export function eagerMintFromJobId(deps, jobId) {
     const store = deps.validationRunStore;
     if (!store)
         return;
-    let validationId = null;
+    let validationId;
     try {
         validationId = store.getValidationRunIdByJobId(jobId);
     }

package/dist/validation-tools.d.ts

@@ -1,9 +1,15 @@
 import { z } from "zod/v3";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { AsyncJobManager } from "./async-job-manager.js";
+import { PerformanceMetrics } from "./metrics.js";
+import { type LeastCostConfig } from "./config.js";
+import type { FlightRecorderQuery } from "./flight-recorder.js";
 import { type ValidationOrchestratorDeps } from "./validation-orchestrator.js";
 export interface ValidationToolDeps extends ValidationOrchestratorDeps {
     asyncJobManager: AsyncJobManager;
+    leastCost?: LeastCostConfig;
+    performanceMetrics?: PerformanceMetrics;
+    flightRecorder?: FlightRecorderQuery;
 }
 export declare function buildValidationSchemas(deps: ValidationToolDeps): {
     providerSchema: z.ZodEnum<[string, ...string[]]>;