@jsonstudio/llms 0.6.1354 → 0.6.1397

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_thought_signature_inject/index.js

@@ -0,0 +1,172 @@
+import { recordStage } from '../../../stages/utils.js';
+import { SKIP_THOUGHT_SIGNATURE, buildThoughtSignatureSessionKey, getCachedThoughtSignature, getLastThoughtSignature, shouldHandleThoughtSignature } from '../../../thought-signature/thought-signature-center.js';
+import { filterInvalidThinkingBlocks, removeTrailingUnsignedThinkingBlocks } from '../../../../../shared/thought-signature-validator.js';
+function isThinkingPart(part) {
+    if (part.thought === true)
+        return true;
+    const type = typeof part.type === 'string' ? String(part.type).toLowerCase() : '';
+    return type === 'thinking' || type === 'reasoning' || type === 'redacted_thinking';
+}
+function readThinkingText(part) {
+    const text = part.text ?? part.thinking;
+    if (typeof text === 'string' && text.trim())
+        return text.trim();
+    return undefined;
+}
+function hasSignedThinking(parts) {
+    return parts.some((part) => {
+        if (!isThinkingPart(part))
+            return false;
+        const sig = part.thoughtSignature ?? part.signature;
+        return typeof sig === 'string' && sig.trim().length >= 10;
+    });
+}
+function hasToolUse(parts) {
+    return parts.some((part) => {
+        if (part.functionCall || part.function_call)
+            return true;
+        if (part.type === 'tool_use' || part.type === 'tool_result')
+            return true;
+        return false;
+    });
+}
+function injectGeminiPayload(payload, sessionKey) {
+    const contents = Array.isArray(payload.contents) ? payload.contents : [];
+    for (const content of contents) {
+        const parts = Array.isArray(content.parts) ? content.parts : [];
+        if (!parts.length)
+            continue;
+        // Deep-filter invalid thinking parts before injection.
+        const cleanedParts = [];
+        for (const part of parts) {
+            if (!part || typeof part !== 'object') {
+                cleanedParts.push(part);
+                continue;
+            }
+            if (!isThinkingPart(part)) {
+                cleanedParts.push(part);
+                continue;
+            }
+            const text = readThinkingText(part);
+            const sig = part.thoughtSignature;
+            const sigValid = typeof sig === 'string' && sig.trim().length >= 10
+                ? true
+                : Boolean(sig && (!text || !String(text).trim().length));
+            if (sigValid) {
+                cleanedParts.push(part);
+            }
+            else if (text && text.trim()) {
+                cleanedParts.push({ text });
+            }
+        }
+        content.parts = cleanedParts;
+        const effectiveParts = cleanedParts;
+        const toolUsePresent = hasToolUse(effectiveParts);
+        let signedThinking = hasSignedThinking(effectiveParts);
+        for (const part of effectiveParts) {
+            if (!isThinkingPart(part))
+                continue;
+            const text = readThinkingText(part);
+            const sig = part.thoughtSignature;
+            if (typeof sig === 'string' && sig.trim()) {
+                continue;
+            }
+            const cached = text ? getCachedThoughtSignature(sessionKey, text) : undefined;
+            if (cached) {
+                part.thoughtSignature = cached;
+                signedThinking = true;
+            }
+            else if (text) {
+                part.thoughtSignature = SKIP_THOUGHT_SIGNATURE;
+            }
+        }
+        if (toolUsePresent && !signedThinking) {
+            const last = getLastThoughtSignature(sessionKey);
+            if (last) {
+                effectiveParts.unshift({ thought: true, text: last.text, thoughtSignature: last.signature });
+            }
+            else {
+                effectiveParts.unshift({ thought: true, text: '', thoughtSignature: SKIP_THOUGHT_SIGNATURE });
+            }
+        }
+    }
+}
+function injectAnthropicPayload(payload, sessionKey) {
+    const messages = Array.isArray(payload.messages) ? payload.messages : [];
+    for (const message of messages) {
+        if (message.role !== 'assistant')
+            continue;
+        const content = Array.isArray(message.content) ? message.content : [];
+        if (!content.length)
+            continue;
+        // Deep-filter invalid thinking blocks before injection.
+        const wrapper = { role: 'assistant', content: [...content] };
+        filterInvalidThinkingBlocks([wrapper]);
+        if (Array.isArray(wrapper.content)) {
+            removeTrailingUnsignedThinkingBlocks(wrapper.content);
+        }
+        message.content = wrapper.content;
+        const effectiveContent = Array.isArray(wrapper.content) ? wrapper.content : content;
+        const toolUsePresent = effectiveContent.some((block) => block && typeof block === 'object' && (block.type === 'tool_use' || block.type === 'tool_result'));
+        let signedThinking = effectiveContent.some((block) => {
+            if (!block || typeof block !== 'object')
+                return false;
+            const type = typeof block.type === 'string' ? String(block.type).toLowerCase() : '';
+            if (type !== 'thinking' && type !== 'redacted_thinking')
+                return false;
+            const sig = block.signature;
+            return typeof sig === 'string' && sig.trim().length >= 10;
+        });
+        for (const block of effectiveContent) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const type = typeof block.type === 'string' ? String(block.type).toLowerCase() : '';
+            if (type !== 'thinking' && type !== 'redacted_thinking')
+                continue;
+            const text = typeof block.thinking === 'string'
+                ? String(block.thinking).trim()
+                : typeof block.text === 'string'
+                    ? String(block.text).trim()
+                    : '';
+            const sig = block.signature;
+            if (typeof sig === 'string' && sig.trim())
+                continue;
+            const cached = text ? getCachedThoughtSignature(sessionKey, text) : undefined;
+            if (cached) {
+                block.signature = cached;
+                signedThinking = true;
+            }
+        }
+        if (toolUsePresent && !signedThinking) {
+            const last = getLastThoughtSignature(sessionKey);
+            if (last) {
+                effectiveContent.unshift({ type: 'thinking', thinking: last.text, signature: last.signature });
+            }
+            else {
+                effectiveContent.unshift({ type: 'thinking', thinking: '', signature: SKIP_THOUGHT_SIGNATURE });
+            }
+        }
+    }
+}
+export async function runReqOutboundStage2ThoughtSignatureInject(options) {
+    const { payload, adapterContext } = options;
+    if (!shouldHandleThoughtSignature(adapterContext)) {
+        return payload;
+    }
+    const sessionKey = buildThoughtSignatureSessionKey(adapterContext, payload);
+    if (!sessionKey) {
+        return payload;
+    }
+    const protocol = String(adapterContext.providerProtocol || '').toLowerCase();
+    if (protocol === 'gemini-chat') {
+        injectGeminiPayload(payload, sessionKey);
+    }
+    else if (protocol === 'anthropic-messages') {
+        injectAnthropicPayload(payload, sessionKey);
+    }
+    recordStage(options.stageRecorder, 'chat_process.req.stage7.thought_signature_inject', {
+        applied: true,
+        sessionKey
+    });
+    return payload;
+}

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage3_thought_signature_capture/index.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+type ProviderPayload = JsonObject;
+export declare function runRespInboundStage3ThoughtSignatureCapture(options: {
+    payload: ProviderPayload;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}): Promise<ProviderPayload>;
+export {};

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage3_thought_signature_capture/index.js

@@ -0,0 +1,71 @@
+import { recordStage } from '../../../stages/utils.js';
+import { buildThoughtSignatureSessionKey, cacheThoughtSignature, shouldHandleThoughtSignature } from '../../../thought-signature/thought-signature-center.js';
+function captureGeminiPayload(payload, sessionKey) {
+    const candidates = Array.isArray(payload.candidates) ? payload.candidates : [];
+    for (const candidate of candidates) {
+        const content = candidate?.content;
+        if (!content || typeof content !== 'object')
+            continue;
+        const parts = Array.isArray(content.parts) ? content.parts : [];
+        if (!parts.length)
+            continue;
+        let buffer = '';
+        for (const part of parts) {
+            if (!part || typeof part !== 'object')
+                continue;
+            if (part.thought === true || String(part.type || '').toLowerCase() === 'thinking') {
+                const text = part.text ?? part.thinking;
+                if (typeof text === 'string' && text.trim()) {
+                    buffer += text;
+                }
+            }
+            const sig = part.thoughtSignature;
+            if (typeof sig === 'string' && sig.trim() && buffer.trim()) {
+                cacheThoughtSignature(sessionKey, buffer, sig);
+            }
+        }
+    }
+}
+function captureAnthropicPayload(payload, sessionKey) {
+    const content = Array.isArray(payload.content) ? payload.content : [];
+    if (!content.length)
+        return;
+    let buffer = '';
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const type = typeof block.type === 'string' ? String(block.type).toLowerCase() : '';
+        if (type === 'thinking' || type === 'redacted_thinking') {
+            const text = block.thinking ?? block.text;
+            if (typeof text === 'string' && text.trim()) {
+                buffer += text;
+            }
+        }
+        const sig = block.signature;
+        if (typeof sig === 'string' && sig.trim() && buffer.trim()) {
+            cacheThoughtSignature(sessionKey, buffer, sig);
+        }
+    }
+}
+export async function runRespInboundStage3ThoughtSignatureCapture(options) {
+    const { payload, adapterContext } = options;
+    if (!shouldHandleThoughtSignature(adapterContext)) {
+        return payload;
+    }
+    const sessionKey = buildThoughtSignatureSessionKey(adapterContext, payload);
+    if (!sessionKey) {
+        return payload;
+    }
+    const protocol = String(adapterContext.providerProtocol || '').toLowerCase();
+    if (protocol === 'gemini-chat') {
+        captureGeminiPayload(payload, sessionKey);
+    }
+    else if (protocol === 'anthropic-messages') {
+        captureAnthropicPayload(payload, sessionKey);
+    }
+    recordStage(options.stageRecorder, 'chat_process.resp.stage3.thought_signature_capture', {
+        applied: true,
+        sessionKey
+    });
+    return payload;
+}

package/dist/conversion/hub/pipeline/thought-signature/thought-signature-center.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterContext } from '../../types/chat-envelope.js';
+import type { JsonObject } from '../../types/json.js';
+export declare const SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+type LastEntry = {
+    text: string;
+    signature: string;
+    timestamp: number;
+};
+export declare function buildThoughtSignatureSessionKey(ctx: AdapterContext, payload?: JsonObject): string | undefined;
+export declare function cacheThoughtSignature(sessionKey: string, text: unknown, signature: unknown): void;
+export declare function getCachedThoughtSignature(sessionKey: string, text: unknown): string | undefined;
+export declare function getLastThoughtSignature(sessionKey: string): LastEntry | undefined;
+export declare function shouldHandleThoughtSignature(ctx: AdapterContext): boolean;
+export {};

package/dist/conversion/hub/pipeline/thought-signature/thought-signature-center.js

@@ -0,0 +1,289 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+export const SKIP_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+const MEMORY_TTL_MS = 12 * 60 * 60 * 1000;
+const DISK_TTL_MS = 12 * 60 * 60 * 1000;
+const WRITE_INTERVAL_MS = 60 * 1000;
+const MAX_ENTRIES_PER_SESSION = 50;
+const MAX_SESSIONS = 200;
+const TEXT_HASH_HEX_LEN = 16;
+const sessionStores = new Map();
+const sessionLast = new Map();
+const diskEntries = new Map();
+let dirty = false;
+let writeTimer;
+let cleanupTimer;
+const stats = {
+    memoryHits: 0,
+    diskHits: 0,
+    misses: 0,
+    writes: 0,
+    lastWrite: 0
+};
+function resolveDefaultCachePath() {
+    const env = (process.env.ROUTECODEX_THOUGHT_SIGNATURE_CACHE_PATH ||
+        process.env.RCC_THOUGHT_SIGNATURE_CACHE_PATH ||
+        '').trim();
+    if (env)
+        return env;
+    const home = process.env.HOME || os.homedir() || '';
+    return path.join(home, '.routecodex', 'antigravity-signature-cache.json');
+}
+const persistencePath = resolveDefaultCachePath();
+function now() {
+    return Date.now();
+}
+function normalizeText(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function normalizeSignature(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function hashText(text) {
+    return createHash('sha256').update(text, 'utf8').digest('hex').slice(0, TEXT_HASH_HEX_LEN);
+}
+function makeDiskKey(sessionKey, textHash) {
+    return `${sessionKey}:${textHash}`;
+}
+function ensureSession(sessionKey) {
+    let store = sessionStores.get(sessionKey);
+    if (!store) {
+        pruneSessionsIfNeeded();
+        store = new Map();
+        sessionStores.set(sessionKey, store);
+    }
+    return store;
+}
+function pruneSession(store) {
+    const cutoff = now() - MEMORY_TTL_MS;
+    for (const [key, entry] of store) {
+        if (entry.timestamp < cutoff) {
+            store.delete(key);
+        }
+    }
+    if (store.size < MAX_ENTRIES_PER_SESSION)
+        return;
+    const entries = Array.from(store.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
+    const toRemove = entries.slice(0, Math.floor(MAX_ENTRIES_PER_SESSION / 4));
+    for (const [key] of toRemove) {
+        store.delete(key);
+    }
+}
+function ensureCacheDir(filePath) {
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+function loadPersistedCache() {
+    try {
+        if (!fs.existsSync(persistencePath))
+            return;
+        const raw = fs.readFileSync(persistencePath, 'utf-8');
+        if (!raw.trim())
+            return;
+        const parsed = JSON.parse(raw);
+        if (!parsed || parsed.version !== '1.0')
+            return;
+        const cutoff = now() - DISK_TTL_MS;
+        for (const [key, entry] of Object.entries(parsed.entries || {})) {
+            if (!entry || typeof entry.signature !== 'string')
+                continue;
+            const ts = typeof entry.timestamp === 'number' ? entry.timestamp : now();
+            if (ts < cutoff)
+                continue;
+            diskEntries.set(key, { signature: entry.signature, timestamp: ts });
+        }
+    }
+    catch {
+        // best-effort
+    }
+}
+function schedulePersist() {
+    if (writeTimer)
+        return;
+    writeTimer = setInterval(() => {
+        if (dirty) {
+            persistCache();
+        }
+    }, WRITE_INTERVAL_MS);
+    if (typeof writeTimer.unref === 'function') {
+        writeTimer.unref();
+    }
+}
+function scheduleCleanup() {
+    if (cleanupTimer)
+        return;
+    cleanupTimer = setInterval(() => {
+        const cutoff = now() - MEMORY_TTL_MS;
+        for (const store of sessionStores.values()) {
+            for (const [key, entry] of store.entries()) {
+                if (entry.timestamp < cutoff) {
+                    store.delete(key);
+                }
+            }
+        }
+    }, 30 * 60 * 1000);
+    if (typeof cleanupTimer.unref === 'function') {
+        cleanupTimer.unref();
+    }
+}
+function pruneSessionsIfNeeded() {
+    if (sessionStores.size < MAX_SESSIONS)
+        return;
+    const entries = [];
+    for (const key of sessionStores.keys()) {
+        const last = sessionLast.get(key);
+        entries.push({ key, ts: last?.timestamp ?? 0 });
+    }
+    entries.sort((a, b) => a.ts - b.ts);
+    const removeCount = Math.max(1, sessionStores.size - (MAX_SESSIONS - 1));
+    for (const entry of entries.slice(0, removeCount)) {
+        sessionStores.delete(entry.key);
+        sessionLast.delete(entry.key);
+        for (const diskKey of diskEntries.keys()) {
+            if (diskKey.startsWith(`${entry.key}:`)) {
+                diskEntries.delete(diskKey);
+            }
+        }
+    }
+}
+function persistCache() {
+    try {
+        ensureCacheDir(persistencePath);
+        const nowTs = now();
+        const validDisk = {};
+        for (const [key, entry] of diskEntries.entries()) {
+            if (nowTs - entry.timestamp <= DISK_TTL_MS) {
+                validDisk[key] = entry;
+            }
+        }
+        const merged = { ...validDisk };
+        for (const [sessionKey, store] of sessionStores.entries()) {
+            for (const [textHash, entry] of store.entries()) {
+                const diskKey = makeDiskKey(sessionKey, textHash);
+                merged[diskKey] = { signature: entry.signature, timestamp: entry.timestamp };
+            }
+        }
+        const data = {
+            version: '1.0',
+            memory_ttl_seconds: MEMORY_TTL_MS / 1000,
+            disk_ttl_seconds: DISK_TTL_MS / 1000,
+            entries: merged,
+            statistics: {
+                memory_hits: stats.memoryHits,
+                disk_hits: stats.diskHits,
+                misses: stats.misses,
+                writes: stats.writes + 1,
+                last_write: nowTs
+            }
+        };
+        const tmpPath = path.join(os.tmpdir(), `antigravity-cache-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf-8');
+        try {
+            fs.renameSync(tmpPath, persistencePath);
+        }
+        catch {
+            fs.writeFileSync(persistencePath, fs.readFileSync(tmpPath));
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+        stats.writes += 1;
+        stats.lastWrite = nowTs;
+        dirty = false;
+    }
+    catch {
+        // best-effort
+    }
+}
+loadPersistedCache();
+schedulePersist();
+scheduleCleanup();
+export function buildThoughtSignatureSessionKey(ctx, payload) {
+    const sessionId = typeof ctx.sessionId === 'string'
+        ? String(ctx.sessionId).trim()
+        : typeof ctx.conversationId === 'string'
+            ? String(ctx.conversationId).trim()
+            : typeof ctx.requestId === 'string'
+                ? String(ctx.requestId).trim()
+                : '';
+    if (!sessionId)
+        return undefined;
+    const model = (payload && typeof payload.model === 'string' && String(payload.model).trim()) ||
+        (typeof ctx.clientModelId === 'string' ? String(ctx.clientModelId).trim() : '') ||
+        (typeof ctx.originalModelId === 'string' ? String(ctx.originalModelId).trim() : '');
+    const protocol = typeof ctx.providerProtocol === 'string' && ctx.providerProtocol.trim()
+        ? ctx.providerProtocol.trim()
+        : 'unknown';
+    const modelKey = model || 'unknown';
+    return `${protocol}:${modelKey}:${sessionId}`;
+}
+export function cacheThoughtSignature(sessionKey, text, signature) {
+    const normalizedText = normalizeText(text);
+    const normalizedSignature = normalizeSignature(signature);
+    if (!sessionKey || !normalizedText || !normalizedSignature)
+        return;
+    const textHash = hashText(normalizedText);
+    const store = ensureSession(sessionKey);
+    if (store.size >= MAX_ENTRIES_PER_SESSION) {
+        pruneSession(store);
+    }
+    store.set(textHash, { signature: normalizedSignature, timestamp: now() });
+    sessionLast.set(sessionKey, { text: normalizedText, signature: normalizedSignature, timestamp: now() });
+    dirty = true;
+}
+export function getCachedThoughtSignature(sessionKey, text) {
+    if (!sessionKey)
+        return undefined;
+    const normalizedText = normalizeText(text);
+    if (!normalizedText)
+        return undefined;
+    const textHash = hashText(normalizedText);
+    const store = sessionStores.get(sessionKey);
+    if (store) {
+        const entry = store.get(textHash);
+        if (entry) {
+            if (now() - entry.timestamp <= MEMORY_TTL_MS) {
+                stats.memoryHits += 1;
+                return entry.signature;
+            }
+            store.delete(textHash);
+        }
+    }
+    const diskKey = makeDiskKey(sessionKey, textHash);
+    const diskEntry = diskEntries.get(diskKey);
+    if (diskEntry && now() - diskEntry.timestamp <= DISK_TTL_MS) {
+        stats.diskHits += 1;
+        const mem = ensureSession(sessionKey);
+        mem.set(textHash, { signature: diskEntry.signature, timestamp: now() });
+        return diskEntry.signature;
+    }
+    stats.misses += 1;
+    return undefined;
+}
+export function getLastThoughtSignature(sessionKey) {
+    if (!sessionKey)
+        return undefined;
+    return sessionLast.get(sessionKey);
+}
+export function shouldHandleThoughtSignature(ctx) {
+    const provider = typeof ctx.providerId === 'string' ? ctx.providerId.toLowerCase() : '';
+    if (provider === 'antigravity')
+        return true;
+    const profile = typeof ctx.profileId === 'string' ? ctx.profileId.toLowerCase() : '';
+    return profile.includes('antigravity');
+}

package/dist/conversion/hub/response/provider-response.js

@@ -8,6 +8,7 @@ import { OpenAIChatResponseMapper, ResponsesResponseMapper, AnthropicResponseMap
 import { runRespInboundStage1SseDecode } from '../pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js';
 import { runRespInboundStage2FormatParse } from '../pipeline/stages/resp_inbound/resp_inbound_stage2_format_parse/index.js';
 import { runRespInboundStage3SemanticMap } from '../pipeline/stages/resp_inbound/resp_inbound_stage3_semantic_map/index.js';
+import { runRespInboundStage3ThoughtSignatureCapture } from '../pipeline/stages/resp_inbound/resp_inbound_stage3_thought_signature_capture/index.js';
 import { runRespInboundStageCompatResponse } from '../pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js';
 import { runRespProcessStage1ToolGovernance } from '../pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js';
 import { runRespProcessStage2Finalize } from '../pipeline/stages/resp_process/resp_process_stage2_finalize/index.js';
@@ -299,6 +300,11 @@ export async function convertProviderResponse(options) {
         stageRecorder: options.stageRecorder
     });
     stripInternalPolicyDebugFields(formatEnvelope.payload);
+    formatEnvelope.payload = await runRespInboundStage3ThoughtSignatureCapture({
+        payload: formatEnvelope.payload,
+        adapterContext: options.context,
+        stageRecorder: options.stageRecorder
+    });
     // Phase 2 (shadow): response tool surface mismatch detection (provider inbound).
     // Only records diffs; does not rewrite payload.
     try {

package/dist/router/virtual-router/bootstrap.js

@@ -1241,6 +1241,12 @@ function coerceAliasSelectionStrategy(value) {
     if (normalized === 'sticky-queue' || normalized === 'sticky_queue' || normalized === 'stickyqueue') {
         return 'sticky-queue';
     }
+    if (normalized === 'best-quota' ||
+        normalized === 'best_quota' ||
+        normalized === 'quota-best' ||
+        normalized === 'quota_best') {
+        return 'best-quota';
+    }
     return undefined;
 }
 function coerceRatio(value) {

package/dist/router/virtual-router/engine-selection/alias-selection.d.ts

@@ -13,3 +13,18 @@ export declare function pinCandidatesByAliasQueue(opts: {
     modelIdOfKey: (providerKey: string) => string | null;
     availabilityCheck: (providerKey: string) => boolean;
 }): string[] | null;
+export declare function pinCandidatesByBestQuota(opts: {
+    providerId: string;
+    modelId: string;
+    candidates: string[];
+    orderedTargets: string[];
+    aliasOfKey: (providerKey: string) => string | null;
+    modelIdOfKey: (providerKey: string) => string | null;
+    quotaView: ((providerKey: string) => {
+        remainingFraction?: number | null;
+        inPool: boolean;
+        cooldownUntil?: number | null;
+        blacklistUntil?: number | null;
+    } | null) | undefined;
+    now: number;
+}): string[] | null;