@jsonstudio/rcc 0.90.352 → 0.90.364

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine.d.ts

@@ -0,0 +1,43 @@
+import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+import type { ProviderErrorEvent, ProviderFailureEvent, ProviderQuotaView, ProviderSuccessEvent, RouterMetadataInput, RoutingDecision, RoutingDiagnostics, RoutingStatusSnapshot, StopMessageStateSnapshot, PreCommandStateSnapshot, TargetMetadata, VirtualRouterConfig, VirtualRouterHealthStore } from './types.js';
+export declare class VirtualRouterEngine {
+    private readonly nativeProxy;
+    private readonly registry;
+    private readonly routingInstructionStateStore;
+    constructor(deps?: {
+        healthStore?: VirtualRouterHealthStore;
+        routingStateStore?: {
+            loadSync: (key: string) => unknown;
+            saveAsync: (key: string, state: unknown) => void;
+            saveSync?: (key: string, state: unknown) => void;
+        };
+        quotaView?: ProviderQuotaView;
+    });
+    get antigravitySessionAliasStore(): Map<string, string>;
+    get routingInstructionState(): Map<string, unknown>;
+    get providerRegistry(): unknown;
+    initialize(config: VirtualRouterConfig): void;
+    updateDeps(deps: {
+        healthStore?: VirtualRouterHealthStore | null;
+        routingStateStore?: {
+            loadSync: (key: string) => unknown;
+            saveAsync: (key: string, state: unknown) => void;
+            saveSync?: (key: string, state: unknown) => void;
+        } | null;
+        quotaView?: ProviderQuotaView | null;
+    }): void;
+    updateVirtualRouterConfig(config: VirtualRouterConfig): void;
+    markProviderCooldown(providerKey: string, cooldownMs: number | undefined): void;
+    clearProviderCooldown(providerKey: string): void;
+    route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
+        target: TargetMetadata;
+        decision: RoutingDecision;
+        diagnostics: RoutingDiagnostics;
+    };
+    getStopMessageState(metadata: RouterMetadataInput): StopMessageStateSnapshot | null;
+    getPreCommandState(metadata: RouterMetadataInput): PreCommandStateSnapshot | null;
+    handleProviderFailure(event: ProviderFailureEvent): void;
+    handleProviderError(event: ProviderErrorEvent): void;
+    handleProviderSuccess(event: ProviderSuccessEvent): void;
+    getStatus(): RoutingStatusSnapshot;
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine.js

@@ -0,0 +1,360 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+import { createVirtualRouterEngineProxy } from './engine-selection/native-virtual-router-engine-proxy.js';
+import { cleanRoutingInstructionMarkersWithNative, parseRoutingInstructionKindsWithNative } from './engine-selection/native-virtual-router-routing-instructions-semantics.js';
+import { extractMessageText, getLatestUserMessage } from './message-utils.js';
+import { ProviderRegistry } from './provider-registry.js';
+import { resolveStopMessageScope } from './engine/routing-state/store.js';
+import { loadRoutingInstructionStateSync } from './sticky-session-store.js';
+import { mergeStopMessageFromPersisted } from './stop-message-state-sync.js';
+import { resolveRouteColor, resolveSessionColor } from './engine-logging.js';
+export class VirtualRouterEngine {
+    nativeProxy;
+    registry;
+    routingInstructionStateStore;
+    constructor(deps) {
+        this.nativeProxy = createVirtualRouterEngineProxy();
+        this.registry = new ProviderRegistry();
+        this.routingInstructionStateStore = new Map();
+        if (deps) {
+            this.nativeProxy.updateDeps(deps);
+        }
+    }
+    get antigravitySessionAliasStore() {
+        return this.nativeProxy.antigravitySessionAliasStore;
+    }
+    get routingInstructionState() {
+        return this.routingInstructionStateStore;
+    }
+    get providerRegistry() {
+        return this.registry;
+    }
+    initialize(config) {
+        this.nativeProxy.initialize(JSON.stringify(config));
+        this.registry.load(config.providers ?? {});
+        this.routingInstructionStateStore.clear();
+    }
+    updateDeps(deps) {
+        this.nativeProxy.updateDeps(deps);
+    }
+    updateVirtualRouterConfig(config) {
+        this.nativeProxy.updateVirtualRouterConfig(JSON.stringify(config));
+        this.registry.load(config.providers ?? {});
+    }
+    markProviderCooldown(providerKey, cooldownMs) {
+        this.nativeProxy.markProviderCooldown(providerKey, cooldownMs);
+    }
+    clearProviderCooldown(providerKey) {
+        this.nativeProxy.clearProviderCooldown(providerKey);
+    }
+    route(request, metadata) {
+        const parseLog = buildRoutingInstructionParseLog(request, metadata);
+        const nativeMetadata = injectRuntimeNowMs(metadata);
+        let raw;
+        try {
+            raw = this.nativeProxy.route(JSON.stringify(request), JSON.stringify(nativeMetadata));
+        }
+        catch (error) {
+            throw normalizeNativeVirtualRouterError(error);
+        }
+        if (typeof raw !== 'string') {
+            throw normalizeNativeVirtualRouterError(raw);
+        }
+        if (raw.startsWith('Error:') || raw.startsWith(VIRTUAL_ROUTER_ERROR_PREFIX)) {
+            throw normalizeNativeVirtualRouterError(raw);
+        }
+        const parsed = JSON.parse(raw);
+        emitRoutingInstructionParseLog(parseLog);
+        // Keep legacy observable behavior for callers/tests that inspect the request object
+        // after route(): instruction markers are stripped from forwarded payload structures.
+        cleanRoutingInstructionMarkersInPlace(request);
+        const stopScope = parseLog?.stopScope || resolveStopMessageScope(metadata);
+        const stopState = stopScope ? this.getStopMessageState(metadata) : null;
+        const forceStopStatusLabel = Boolean(parseLog?.stopMessageTypes.length ||
+            parseLog?.scopedTypes.some((type) => type === 'stopMessageSet' || type === 'stopMessageMode' || type === 'stopMessageClear'));
+        emitVirtualRouterHitLog(parsed, {
+            requestId: metadata.requestId,
+            sessionId: resolveVirtualRouterLogSessionId(metadata),
+            stopScope,
+            stopState,
+            forceStopStatusLabel
+        });
+        return parsed;
+    }
+    getStopMessageState(metadata) {
+        const raw = this.nativeProxy.getStopMessageState(JSON.stringify(metadata));
+        const snapshot = JSON.parse(raw);
+        const scope = resolveStopMessageScope(metadata);
+        return mergeStopMessageSnapshotWithPersisted(snapshot, scope);
+    }
+    getPreCommandState(metadata) {
+        const raw = this.nativeProxy.getPreCommandState(JSON.stringify(metadata));
+        return JSON.parse(raw);
+    }
+    handleProviderFailure(event) {
+        this.nativeProxy.handleProviderFailure(JSON.stringify(event));
+    }
+    handleProviderError(event) {
+        this.nativeProxy.handleProviderError(JSON.stringify(event));
+    }
+    handleProviderSuccess(event) {
+        this.nativeProxy.handleProviderSuccess(JSON.stringify(event));
+    }
+    getStatus() {
+        return JSON.parse(this.nativeProxy.getStatus());
+    }
+}
+const VIRTUAL_ROUTER_ERROR_PREFIX = 'VIRTUAL_ROUTER_ERROR:';
+function normalizeNativeVirtualRouterError(error) {
+    if (error instanceof VirtualRouterError) {
+        return error;
+    }
+    const message = extractNativeErrorMessage(error);
+    const parsed = parseVirtualRouterErrorMessage(message);
+    if (parsed) {
+        return new VirtualRouterError(parsed.message, parsed.code);
+    }
+    if (isVirtualRouterErrorLike(error)) {
+        return new VirtualRouterError(typeof error.message === 'string' && error.message.trim() ? error.message : 'Virtual router error', error.code);
+    }
+    return error instanceof Error ? error : new Error(message || 'Virtual router error');
+}
+function mergeStopMessageSnapshotWithPersisted(snapshot, scope) {
+    if (!scope) {
+        return snapshot;
+    }
+    let persisted = null;
+    try {
+        persisted = loadRoutingInstructionStateSync(scope);
+    }
+    catch {
+        return snapshot;
+    }
+    if (!persisted) {
+        return snapshot;
+    }
+    const persistedText = typeof persisted.stopMessageText === 'string' ? persisted.stopMessageText.trim() : '';
+    if (!snapshot && !persistedText) {
+        return snapshot;
+    }
+    const existing = {
+        stopMessageSource: snapshot?.stopMessageSource,
+        stopMessageText: snapshot?.stopMessageText,
+        stopMessageMaxRepeats: snapshot?.stopMessageMaxRepeats,
+        stopMessageUsed: snapshot?.stopMessageUsed,
+        stopMessageUpdatedAt: snapshot?.stopMessageUpdatedAt,
+        stopMessageLastUsedAt: snapshot?.stopMessageLastUsedAt,
+        stopMessageStageMode: snapshot?.stopMessageStageMode,
+        stopMessageAiMode: snapshot?.stopMessageAiMode,
+        stopMessageAiSeedPrompt: snapshot?.stopMessageAiSeedPrompt,
+        stopMessageAiHistory: snapshot?.stopMessageAiHistory
+    };
+    const merged = mergeStopMessageFromPersisted(existing, persisted);
+    const base = snapshot ?? {
+        stopMessageMaxRepeats: typeof merged.stopMessageMaxRepeats === 'number' && Number.isFinite(merged.stopMessageMaxRepeats)
+            ? merged.stopMessageMaxRepeats
+            : 0
+    };
+    const mergedMaxRepeats = typeof merged.stopMessageMaxRepeats === 'number' && Number.isFinite(merged.stopMessageMaxRepeats)
+        ? merged.stopMessageMaxRepeats
+        : base.stopMessageMaxRepeats;
+    return {
+        ...base,
+        stopMessageSource: merged.stopMessageSource,
+        stopMessageText: merged.stopMessageText,
+        stopMessageMaxRepeats: mergedMaxRepeats,
+        stopMessageUsed: merged.stopMessageUsed,
+        stopMessageUpdatedAt: merged.stopMessageUpdatedAt,
+        stopMessageLastUsedAt: merged.stopMessageLastUsedAt,
+        stopMessageStageMode: merged.stopMessageStageMode,
+        stopMessageAiMode: merged.stopMessageAiMode,
+        stopMessageAiSeedPrompt: merged.stopMessageAiSeedPrompt,
+        stopMessageAiHistory: merged.stopMessageAiHistory
+    };
+}
+function extractNativeErrorMessage(error) {
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (error && typeof error === 'object') {
+        const message = error.message;
+        if (typeof message === 'string') {
+            return message;
+        }
+    }
+    return '';
+}
+function parseVirtualRouterErrorMessage(message) {
+    if (!message) {
+        return null;
+    }
+    const normalized = message.startsWith('Error:') ? message.replace(/^Error:\s*/, '') : message;
+    if (!normalized.startsWith(VIRTUAL_ROUTER_ERROR_PREFIX)) {
+        return null;
+    }
+    const remainder = normalized.slice(VIRTUAL_ROUTER_ERROR_PREFIX.length);
+    const idx = remainder.indexOf(':');
+    if (idx <= 0) {
+        return null;
+    }
+    const code = remainder.slice(0, idx);
+    const detail = remainder.slice(idx + 1).trim();
+    if (!isVirtualRouterErrorCode(code)) {
+        return null;
+    }
+    return { code, message: detail || 'Virtual router error' };
+}
+function isVirtualRouterErrorCode(value) {
+    return Object.values(VirtualRouterErrorCode).includes(value);
+}
+function isVirtualRouterErrorLike(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const record = error;
+    return typeof record.code === 'string' && isVirtualRouterErrorCode(record.code);
+}
+function injectRuntimeNowMs(metadata) {
+    const nowMs = Date.now();
+    const rt = metadata.__rt;
+    if (rt && typeof rt === 'object' && !Array.isArray(rt)) {
+        return { ...metadata, __rt: { ...rt, nowMs } };
+    }
+    return { ...metadata, __rt: { nowMs } };
+}
+function buildRoutingInstructionParseLog(request, metadata) {
+    const messages = Array.isArray(request.messages)
+        ? (request.messages ?? [])
+        : [];
+    if (!messages.length) {
+        return null;
+    }
+    const latest = getLatestUserMessage(messages);
+    const latestText = latest ? extractMessageText(latest).trim() : '';
+    const latestHasMarker = /<\*\*[\s\S]*?\*\*>/.test(latestText);
+    const hasStopKeyword = /stopmessage/i.test(latestText);
+    if (!hasStopKeyword && !latestHasMarker) {
+        return null;
+    }
+    const parsedKinds = parseRoutingInstructionKindsWithNative(request);
+    const stopMessageTypes = parsedKinds.filter((type) => type === 'stopMessageSet' || type === 'stopMessageMode' || type === 'stopMessageClear');
+    const scopedTypes = parsedKinds.filter((type) => type === 'stopMessageSet' ||
+        type === 'stopMessageMode' ||
+        type === 'stopMessageClear' ||
+        type === 'preCommandSet' ||
+        type === 'preCommandClear');
+    if (!hasStopKeyword && stopMessageTypes.length === 0 && scopedTypes.length === 0) {
+        return null;
+    }
+    return {
+        requestId: metadata.requestId || 'n/a',
+        markerDetected: latestHasMarker,
+        preview: latestText.replace(/\s+/g, ' ').slice(0, 120),
+        stopMessageTypes,
+        scopedTypes,
+        stopScope: resolveStopMessageScope(metadata)
+    };
+}
+function emitRoutingInstructionParseLog(log) {
+    if (!log) {
+        return;
+    }
+    const reset = '\x1b[0m';
+    const tagColor = '\x1b[38;5;39m';
+    const scopeColor = '\x1b[38;5;220m';
+    console.log(`${tagColor}[virtual-router][stop_message_parse]${reset} requestId=${log.requestId} marker=${log.markerDetected ? 'detected' : 'missing'} parsed=${log.stopMessageTypes.join(',') || 'none'} preview=${log.preview}`);
+    if (log.scopedTypes.length > 0) {
+        if (log.stopScope) {
+            console.log(`${scopeColor}[virtual-router][stop_scope]${reset} requestId=${log.requestId} stage=apply scope=${log.stopScope} instructions=${log.scopedTypes.join(',')}`);
+        }
+        else {
+            console.log(`${scopeColor}[virtual-router][stop_scope]${reset} requestId=${log.requestId} stage=drop reason=missing_tmux_scope instructions=${log.scopedTypes.join(',')}`);
+        }
+    }
+}
+function emitVirtualRouterHitLog(result, options) {
+    const reset = '\x1b[0m';
+    const prefixColor = '\x1b[38;5;208m';
+    const timeColor = '\x1b[90m';
+    const stopColor = '\x1b[38;5;214m';
+    const now = new Date();
+    const timestamp = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+    const routeLabel = result.decision.poolId
+        ? `${result.decision.routeName}/${result.decision.poolId}`
+        : result.decision.routeName;
+    const routeColor = resolveSessionColor(options?.sessionId) || resolveRouteColor(result.decision.routeName);
+    const providerKey = result.decision.providerKey || result.target.providerKey;
+    const modelSuffix = result.target.modelId ? `.${result.target.modelId}` : '';
+    const reason = result.decision.reasoning ? ` reason=${result.decision.reasoning}` : '';
+    const stopStatusLabel = formatStopMessageStatusLabel(options?.stopState ?? null, options?.stopScope, Boolean(options?.forceStopStatusLabel));
+    const requestId = typeof options?.requestId === 'string' ? options.requestId : '';
+    const requestLabel = requestId && !requestId.includes('unknown') ? ` req=${requestId}` : '';
+    const sessionId = typeof options?.sessionId === 'string' ? options.sessionId.trim() : '';
+    const sessionLabel = sessionId ? ` sid=${sessionId}` : '';
+    console.log(`${prefixColor}[virtual-router-hit]${reset} ${timeColor}${timestamp}${reset}${requestLabel}${sessionLabel} ${routeColor}${routeLabel} -> ${providerKey}${modelSuffix}${reason}${reset}${stopStatusLabel ? ` ${stopColor}${stopStatusLabel}${reset}` : ''}`);
+}
+function resolveVirtualRouterLogSessionId(metadata) {
+    const candidates = [
+        metadata.sessionId,
+        metadata.clientTmuxSessionId,
+        metadata.client_tmux_session_id,
+        metadata.tmuxSessionId,
+        metadata.tmux_session_id,
+        metadata.conversationId
+    ];
+    for (const value of candidates) {
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function formatStopMessageStatusLabel(snapshot, scope, forceShow) {
+    const scopeLabel = scope && scope.trim() ? scope.trim() : 'none';
+    if (!snapshot) {
+        if (!forceShow) {
+            return '';
+        }
+        return `[stopMessage:scope=${scopeLabel} active=no state=cleared]`;
+    }
+    const text = typeof snapshot.stopMessageText === 'string' ? snapshot.stopMessageText.trim() : '';
+    const safeText = text ? (text.length > 24 ? `${text.slice(0, 21)}...` : text) : '(mode-only)';
+    const mode = (snapshot.stopMessageStageMode || 'unset').toString().toLowerCase();
+    const maxRepeats = typeof snapshot.stopMessageMaxRepeats === 'number' && Number.isFinite(snapshot.stopMessageMaxRepeats)
+        ? Math.max(0, Math.floor(snapshot.stopMessageMaxRepeats))
+        : 0;
+    const used = typeof snapshot.stopMessageUsed === 'number' && Number.isFinite(snapshot.stopMessageUsed)
+        ? Math.max(0, Math.floor(snapshot.stopMessageUsed))
+        : 0;
+    const remaining = maxRepeats > 0 ? Math.max(0, maxRepeats - used) : -1;
+    const active = mode !== 'off' && Boolean(text) && maxRepeats > 0;
+    const rounds = maxRepeats > 0 ? `${used}/${maxRepeats}` : `${used}/-`;
+    const left = remaining >= 0 ? String(remaining) : 'n/a';
+    return `[stopMessage:scope=${scopeLabel} text="${safeText}" mode=${mode} round=${rounds} left=${left} active=${active ? 'yes' : 'no'}]`;
+}
+function cleanRoutingInstructionMarkersInPlace(request) {
+    const cleaned = cleanRoutingInstructionMarkersWithNative(request);
+    if (Array.isArray(cleaned.messages)) {
+        request.messages = cleaned.messages;
+    }
+    const cleanedSemantics = cleaned.semantics;
+    if (cleanedSemantics && typeof cleanedSemantics === 'object' && !Array.isArray(cleanedSemantics)) {
+        const cleanedResponses = cleanedSemantics.responses;
+        if (cleanedResponses && typeof cleanedResponses === 'object' && !Array.isArray(cleanedResponses)) {
+            const cleanedContext = cleanedResponses.context;
+            if (cleanedContext !== undefined) {
+                const semantics = request.semantics && typeof request.semantics === 'object' && !Array.isArray(request.semantics)
+                    ? request.semantics
+                    : {};
+                const responses = semantics.responses && typeof semantics.responses === 'object' && !Array.isArray(semantics.responses)
+                    ? semantics.responses
+                    : {};
+                responses.context = cleanedContext;
+                semantics.responses = responses;
+                request.semantics = semantics;
+            }
+        }
+    }
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/error-center.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderErrorEvent } from './types.js';
+type ProviderErrorListener = (event: ProviderErrorEvent) => void;
+export declare class ProviderErrorCenter {
+    private readonly listeners;
+    subscribe(listener: ProviderErrorListener): () => void;
+    emit(event: ProviderErrorEvent): ProviderErrorEvent;
+    private normalize;
+}
+export declare const providerErrorCenter: ProviderErrorCenter;
+export {};

package/vendor/@jsonstudio/llms/dist/router/virtual-router/error-center.js

@@ -0,0 +1,39 @@
+export class ProviderErrorCenter {
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit(event) {
+        const enriched = this.normalize(event);
+        for (const listener of this.listeners) {
+            try {
+                listener(enriched);
+            }
+            catch {
+                // Listener failures should not break propagation
+            }
+        }
+        return enriched;
+    }
+    normalize(event) {
+        const timestamp = typeof event.timestamp === 'number' ? event.timestamp : Date.now();
+        const code = event.code?.toString() || 'ERR_UNKNOWN';
+        const message = event.message || code;
+        const stage = event.stage || 'unknown';
+        const runtime = event.runtime || {};
+        return {
+            code,
+            message,
+            stage,
+            status: event.status,
+            recoverable: event.recoverable,
+            runtime,
+            timestamp,
+            details: event.details
+        };
+    }
+}
+export const providerErrorCenter = new ProviderErrorCenter();

package/vendor/@jsonstudio/llms/dist/router/virtual-router/features.d.ts

@@ -0,0 +1,3 @@
+import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+import type { RouterMetadataInput, RoutingFeatures } from './types.js';
+export declare function buildRoutingFeatures(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): RoutingFeatures;

package/vendor/@jsonstudio/llms/dist/router/virtual-router/features.js

@@ -0,0 +1,124 @@
+import { analyzeMediaAttachments, detectExtendedThinkingKeyword, detectKeyword, extractMessageText, getLatestMessageRole, } from './message-utils.js';
+import { extractAntigravityGeminiSessionIdWithNative } from './engine-selection/native-router-hotpath.js';
+import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebSearchToolDeclared, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
+import { computeRequestTokens } from './token-estimator.js';
+const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function getLatestResponsesContextMessage(request) {
+    const contextInput = asRecord(request.semantics)?.responses;
+    const context = asRecord(contextInput)?.context;
+    const input = Array.isArray(asRecord(context)?.input) ? asRecord(context)?.input : [];
+    for (let idx = input.length - 1; idx >= 0; idx -= 1) {
+        const entry = asRecord(input[idx]);
+        if (!entry) {
+            continue;
+        }
+        const entryType = typeof entry.type === 'string' && entry.type.trim()
+            ? entry.type.trim().toLowerCase()
+            : 'message';
+        if (entryType !== 'message') {
+            continue;
+        }
+        const role = typeof entry.role === 'string' && entry.role.trim()
+            ? entry.role.trim().toLowerCase()
+            : 'user';
+        if (role !== 'user' && role !== 'assistant' && role !== 'tool') {
+            continue;
+        }
+        const content = entry.content;
+        if (typeof content !== 'string' && !Array.isArray(content)) {
+            continue;
+        }
+        return {
+            role,
+            message: {
+                role: role,
+                content: content
+            }
+        };
+    }
+    return null;
+}
+export function buildRoutingFeatures(request, metadata) {
+    const antigravitySessionId = (() => {
+        try {
+            const messages = Array.isArray(request.messages) ? request.messages : [];
+            const contents = messages.map((msg) => {
+                const role = msg?.role === 'user' ? 'user' : 'assistant';
+                const text = msg ? extractMessageText(msg) : '';
+                return { role, parts: [{ text }] };
+            });
+            return extractAntigravityGeminiSessionIdWithNative({ contents });
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const responsesLatestMessage = getLatestResponsesContextMessage(request);
+    const latestMessageRole = responsesLatestMessage?.role || getLatestMessageRole(request.messages);
+    const latestMessage = responsesLatestMessage?.message || (Array.isArray(request.messages) && request.messages.length
+        ? request.messages[request.messages.length - 1]
+        : undefined);
+    const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
+    const latestUserText = latestMessageRole === 'user' && latestMessage
+        ? extractMessageText(latestMessage)
+        : '';
+    const normalizedUserText = latestUserText.toLowerCase();
+    const meaningfulDeclaredTools = extractMeaningfulDeclaredToolNames(request.tools);
+    const hasTools = meaningfulDeclaredTools.length > 0;
+    const hasToolCallResponses = assistantMessages.some((msg) => Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0);
+    const estimatedTokens = computeRequestTokens(request, latestUserText);
+    const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
+    const hasVisionTool = detectVisionTool(request);
+    // Vision routing must only trigger for the current user turn (latest message),
+    // not for historical user messages carrying images during tool/assistant followups.
+    const mediaSignals = latestMessageRole === 'user' ? analyzeMediaAttachments(latestMessage) : analyzeMediaAttachments(undefined);
+    const hasImageAttachment = mediaSignals.hasAnyMedia;
+    const hasCodingTool = detectCodingTool(request);
+    const hasWebTool = detectWebTool(request);
+    const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
+    const lastAssistantTool = detectLastAssistantToolCategory(assistantMessages);
+    const lastAssistantToolLabel = (() => {
+        if (!lastAssistantTool) {
+            return undefined;
+        }
+        if (lastAssistantTool.commandSnippet && lastAssistantTool.commandSnippet.trim()) {
+            return lastAssistantTool.commandSnippet.trim();
+        }
+        if (lastAssistantTool.name && lastAssistantTool.name.trim()) {
+            return lastAssistantTool.name.trim();
+        }
+        return undefined;
+    })();
+    return {
+        requestId: metadata.requestId,
+        model: request.model,
+        totalMessages: request.messages?.length ?? 0,
+        userTextSample: latestUserText.slice(0, 2000),
+        toolCount: meaningfulDeclaredTools.length,
+        hasTools,
+        hasToolCallResponses,
+        hasVisionTool,
+        hasImageAttachment,
+        hasVideoAttachment: mediaSignals.hasVideo,
+        hasRemoteVideoAttachment: mediaSignals.hasRemoteVideo,
+        hasLocalVideoAttachment: mediaSignals.hasLocalVideo,
+        hasWebTool,
+        hasWebSearchToolDeclared: detectWebSearchToolDeclared(request),
+        hasCodingTool,
+        hasThinkingKeyword,
+        estimatedTokens,
+        lastAssistantToolCategory: lastAssistantTool?.category,
+        lastAssistantToolSnippet: lastAssistantTool?.commandSnippet,
+        lastAssistantToolLabel,
+        latestMessageFromUser: latestMessageRole === 'user',
+        metadata: {
+            ...metadata,
+            ...(antigravitySessionId ? { antigravitySessionId } : {})
+        }
+    };
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/health-manager.d.ts

@@ -0,0 +1,23 @@
+import type { ProviderHealthConfig, ProviderHealthState } from './types.js';
+interface ProviderInternalState extends ProviderHealthState {
+    lastFailureAt?: number;
+}
+export declare class ProviderHealthManager {
+    private readonly states;
+    private config;
+    configure(config?: ProviderHealthConfig): void;
+    registerProviders(providerKeys: string[]): void;
+    recordFailure(providerKey: string, reason?: string): ProviderInternalState;
+    /**
+     * 为可恢复错误（例如 429）提供短暂冷静期：在 cooldownMs 内将 providerKey
+     * 视为不可用，但不使用 fatalCooldownMs 的长熔断时间。
+     */
+    cooldownProvider(providerKey: string, reason?: string, overrideMs?: number): ProviderInternalState;
+    recordSuccess(providerKey: string): ProviderInternalState;
+    tripProvider(providerKey: string, reason?: string, cooldownOverrideMs?: number): ProviderInternalState;
+    isAvailable(providerKey: string): boolean;
+    getSnapshot(): ProviderHealthState[];
+    getConfig(): Required<ProviderHealthConfig>;
+    private getState;
+}
+export {};