@jsonstudio/llms 0.6.2125 → 0.6.2172

package/dist/router/virtual-router/engine/routing-pools/index.js

@@ -1,5 +1,6 @@
 import { DEFAULT_ROUTE, VirtualRouterError, VirtualRouterErrorCode } from '../../types.js';
-import { extractExcludedProviderKeySet, extractProviderId } from '../../engine-selection/key-parsing.js';
+import { extractExcludedProviderKeySet, extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from '../../engine-selection/key-parsing.js';
+import { providerSupportsMultimodalRequest } from '../../engine-selection/multimodal-capability.js';
 import { trySelectFromTier } from '../../engine-selection/tier-selection.js';
 import { resolveInstructionTarget } from '../../engine-selection/instruction-target.js';
 import { filterCandidatesByRoutingState } from '../../engine-selection/routing-state-filter.js';
@@ -49,7 +50,7 @@ export function selectProviderImpl(requestedRoute, metadata, classification, fea
         stickyResolution = resolveInstructionTarget(state.stickyTarget, deps.providerRegistry);
         if (stickyResolution && stickyResolution.mode === 'exact') {
             const stickyKey = stickyResolution.keys[0];
-            if (stickyProviderMatchesRequestCapabilities(stickyKey, requestedRoute, classification, features, deps.routing) &&
+            if (stickyProviderMatchesRequestCapabilities(stickyKey, requestedRoute, classification, features, deps.routing, deps.providerRegistry) &&
                 (deps.quotaView ? true : deps.healthManager.isAvailable(stickyKey)) &&
                 !excludedProviderKeys.has(stickyKey) &&
                 !deps.isProviderCoolingDown(stickyKey) &&
@@ -63,7 +64,7 @@ export function selectProviderImpl(requestedRoute, metadata, classification, fea
             }
         }
         if (stickyResolution && stickyResolution.mode === 'filter' && stickyResolution.keys.length > 0) {
-            const liveKeys = stickyResolution.keys.filter((key) => stickyProviderMatchesRequestCapabilities(key, requestedRoute, classification, features, deps.routing) &&
+            const liveKeys = stickyResolution.keys.filter((key) => stickyProviderMatchesRequestCapabilities(key, requestedRoute, classification, features, deps.routing, deps.providerRegistry) &&
                 (deps.quotaView ? true : deps.healthManager.isAvailable(key)) &&
                 !excludedProviderKeys.has(key) &&
                 !deps.isProviderCoolingDown(key) &&
@@ -177,7 +178,7 @@ export function selectProviderImpl(requestedRoute, metadata, classification, fea
         allowAliasRotation
     });
 }
-function stickyProviderMatchesRequestCapabilities(providerKey, requestedRoute, classification, features, routing) {
+function stickyProviderMatchesRequestCapabilities(providerKey, requestedRoute, classification, features, routing, providerRegistry) {
     if (!providerKey) {
         return false;
     }
@@ -187,6 +188,9 @@ function stickyProviderMatchesRequestCapabilities(providerKey, requestedRoute, c
         if (!supportsImageRoute) {
             return false;
         }
+        if (!providerSupportsMultimodalRequest(providerKey, features, providerRegistry)) {
+            return false;
+        }
     }
     if (requestRequiresSearchRoute(requestedRoute, classification, features)) {
         const supportsSearchRoute = routeTargetsIncludeProvider(routing, 'web_search', providerKey) ||
@@ -230,9 +234,13 @@ function routeTargetsIncludeProvider(routing, routeName, providerKey) {
     }
     return false;
 }
+function isFinitePositiveNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
 function selectFromCandidates(routes, metadata, classification, features, state, deps, options) {
     const allowedProviders = new Set(state.allowedProviders);
     const disabledProviders = new Set(state.disabledProviders);
+    const excludedProviderKeys = extractExcludedProviderKeySet(features.metadata);
     const disabledKeysMap = new Map(Array.from(state.disabledKeys.entries()).map(([provider, keys]) => [
         provider,
         new Set(Array.from(keys).map((k) => (typeof k === 'string' ? k : k + 1)))
@@ -242,6 +250,89 @@ function selectFromCandidates(routes, metadata, classification, features, state,
     const attempted = [];
     const visitedRoutes = new Set();
     const routeQueue = initializeRouteQueue(routes);
+    const healthSnapshotByProviderKey = new Map(deps.healthManager.getSnapshot().map((entry) => [entry.providerKey, entry]));
+    let minRecoverableCooldownMs;
+    const recoverableCooldownHints = [];
+    const recordRecoverableCooldown = (providerKey, waitMsRaw, source) => {
+        const waitMs = Math.max(1, Math.floor(waitMsRaw));
+        if (!isFinitePositiveNumber(waitMs)) {
+            return;
+        }
+        if (!Number.isFinite(minRecoverableCooldownMs) || waitMs < minRecoverableCooldownMs) {
+            minRecoverableCooldownMs = waitMs;
+        }
+        const existing = recoverableCooldownHints.find((item) => item.providerKey === providerKey && item.source === source);
+        if (!existing) {
+            recoverableCooldownHints.push({ providerKey, waitMs, source });
+            return;
+        }
+        if (waitMs < existing.waitMs) {
+            existing.waitMs = waitMs;
+        }
+    };
+    const collectRecoverableCooldownForKey = (providerKey) => {
+        const nowMs = Date.now();
+        if (deps.quotaView) {
+            const entry = deps.quotaView(providerKey);
+            if (!entry) {
+                return;
+            }
+            if (isFinitePositiveNumber(entry.blacklistUntil) && entry.blacklistUntil > nowMs) {
+                return;
+            }
+            if (isFinitePositiveNumber(entry.cooldownUntil) && entry.cooldownUntil > nowMs) {
+                recordRecoverableCooldown(providerKey, entry.cooldownUntil - nowMs, 'quota.cooldown');
+            }
+            return;
+        }
+        if (typeof deps.getProviderCooldownRemainingMs === 'function') {
+            const localCooldownMs = deps.getProviderCooldownRemainingMs(providerKey);
+            if (isFinitePositiveNumber(localCooldownMs)) {
+                recordRecoverableCooldown(providerKey, localCooldownMs, 'router.cooldown');
+            }
+        }
+        const healthState = healthSnapshotByProviderKey.get(providerKey);
+        if (healthState && isFinitePositiveNumber(healthState.cooldownExpiresAt) && healthState.cooldownExpiresAt > nowMs) {
+            recordRecoverableCooldown(providerKey, healthState.cooldownExpiresAt - nowMs, 'health.cooldown');
+        }
+    };
+    const isEligibleTargetForCurrentAttempt = (providerKey) => {
+        if (!providerKey || excludedProviderKeys.has(providerKey)) {
+            return false;
+        }
+        if (options.requiredProviderKeys && options.requiredProviderKeys.size > 0 && !options.requiredProviderKeys.has(providerKey)) {
+            return false;
+        }
+        const providerId = extractProviderId(providerKey);
+        if (!providerId) {
+            return false;
+        }
+        if (allowedProviders.size > 0 && !allowedProviders.has(providerId)) {
+            return false;
+        }
+        if (disabledProviders.has(providerId)) {
+            return false;
+        }
+        const disabledKeys = disabledKeysMap.get(providerId);
+        if (disabledKeys && disabledKeys.size > 0) {
+            const keyAlias = extractKeyAlias(providerKey);
+            const keyIndex = extractKeyIndex(providerKey);
+            if (keyAlias && disabledKeys.has(keyAlias)) {
+                return false;
+            }
+            if (keyIndex !== undefined && disabledKeys.has(keyIndex + 1)) {
+                return false;
+            }
+        }
+        const disabledModelSet = disabledModels.get(providerId);
+        if (disabledModelSet && disabledModelSet.size > 0) {
+            const modelId = getProviderModelId(providerKey, deps.providerRegistry);
+            if (modelId && disabledModelSet.has(modelId)) {
+                return false;
+            }
+        }
+        return true;
+    };
     const estimatedTokens = typeof features.estimatedTokens === 'number' && Number.isFinite(features.estimatedTokens)
         ? Math.max(0, features.estimatedTokens)
         : 0;
@@ -273,8 +364,23 @@ function selectFromCandidates(routes, metadata, classification, features, state,
             if (failureHint) {
                 attempted.push(failureHint);
             }
+            if (Array.isArray(poolTier.targets) && poolTier.targets.length > 0) {
+                for (const providerKey of poolTier.targets) {
+                    if (!isEligibleTargetForCurrentAttempt(providerKey)) {
+                        continue;
+                    }
+                    collectRecoverableCooldownForKey(providerKey);
+                }
+            }
         }
     }
     const requestedRoute = normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
-    throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
+    const details = { routeName: requestedRoute, attempted };
+    if (isFinitePositiveNumber(minRecoverableCooldownMs)) {
+        details.minRecoverableCooldownMs = Math.floor(minRecoverableCooldownMs);
+        details.recoverableCooldownHints = recoverableCooldownHints
+            .sort((a, b) => a.waitMs - b.waitMs)
+            .slice(0, 8);
+    }
+    throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, details);
 }

package/dist/router/virtual-router/engine-selection/multimodal-capability.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderRegistry } from '../provider-registry.js';
+import type { RoutingFeatures } from '../types.js';
+export declare function providerSupportsMultimodalRequest(providerKey: string, features: RoutingFeatures, providerRegistry: ProviderRegistry): boolean;

package/dist/router/virtual-router/engine-selection/multimodal-capability.js

@@ -0,0 +1,26 @@
+import { extractProviderId, getProviderModelId } from './key-parsing.js';
+function isQwen35PlusProvider(providerKey, providerRegistry) {
+    const providerId = (extractProviderId(providerKey) ?? '').trim().toLowerCase();
+    if (providerId !== 'qwen') {
+        return false;
+    }
+    const modelId = (getProviderModelId(providerKey, providerRegistry) ?? '').trim().toLowerCase();
+    if (!modelId) {
+        return false;
+    }
+    return modelId === 'qwen3.5-plus' || modelId === 'qwen3-5-plus' || modelId === 'qwen3_5-plus';
+}
+export function providerSupportsMultimodalRequest(providerKey, features, providerRegistry) {
+    if (!features.hasImageAttachment) {
+        return true;
+    }
+    if (!isQwen35PlusProvider(providerKey, providerRegistry)) {
+        return true;
+    }
+    if (features.hasVideoAttachment !== true) {
+        return true;
+    }
+    const hasRemoteVideo = features.hasRemoteVideoAttachment === true;
+    const hasLocalVideo = features.hasLocalVideoAttachment === true;
+    return hasRemoteVideo && !hasLocalVideo;
+}

package/dist/router/virtual-router/engine-selection/route-utils.js

@@ -43,6 +43,10 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
     const forceVision = routeHasForceFlag('vision', routing);
     const hasMultimodalTargets = routeHasTargets(routing.multimodal);
     const hasVisionTargets = routeHasTargets(routing.vision);
+    const hasLocalVideoAttachment = features.hasVideoAttachment === true && features.hasLocalVideoAttachment === true;
+    if (features.hasImageAttachment && hasLocalVideoAttachment && hasVisionTargets) {
+        return ['vision'];
+    }
     const normalized = normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
     const baseList = [];
     if (classificationCandidates && classificationCandidates.length) {
@@ -59,9 +63,9 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
                 baseList.unshift('multimodal');
             }
         }
-        else if (hasVisionTargets) {
+        if (hasVisionTargets) {
             if (!baseList.includes('vision')) {
-                baseList.unshift('vision');
+                baseList.push('vision');
             }
         }
         if (!forceVision && hasMultimodalTargets) {

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

@@ -10,6 +10,7 @@ export type SelectionDeps = {
     contextAdvisor: ContextAdvisor;
     loadBalancer: RouteLoadBalancer;
     isProviderCoolingDown: (providerKey: string) => boolean;
+    getProviderCooldownRemainingMs?: (providerKey: string) => number;
     resolveStickyKey: (metadata: RouterMetadataInput) => string | undefined;
     quotaView?: ProviderQuotaView;
     aliasQueueStore?: Map<string, string[]>;

package/dist/router/virtual-router/engine-selection/tier-selection.js

@@ -3,6 +3,7 @@ import { resolveContextWeightedConfig } from '../context-weighted.js';
 import { resolveHealthWeightedConfig } from '../health-weighted.js';
 import { pinCandidatesByAliasQueue, resolveAliasSelectionStrategy } from './alias-selection.js';
 import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './key-parsing.js';
+import { providerSupportsMultimodalRequest } from './multimodal-capability.js';
 import { selectProviderKeyFromCandidatePool } from './tier-selection-select.js';
 import { lookupAntigravityPinnedAliasForSessionId, unpinAntigravitySessionAliasForSessionId } from '../../../conversion/compat/antigravity-session-signature.js';
 const DEFAULT_ANTIGRAVITY_ALIAS_SESSION_COOLDOWN_MS = 5 * 60_000;
@@ -388,6 +389,7 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
         targets = filtered;
     }
     if (features.hasImageAttachment && routeName === 'multimodal') {
+        targets = targets.filter((key) => providerSupportsMultimodalRequest(key, features, deps.providerRegistry));
         const kimiTargets = targets.filter((key) => {
             const modelId = getProviderModelId(key, deps.providerRegistry) ?? '';
             return modelId.trim().toLowerCase() === 'kimi-k2.5';

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

@@ -44,6 +44,7 @@ export declare class VirtualRouterEngine {
         quotaView?: ProviderQuotaView | null;
     }): void;
     private parseDirectProviderModel;
+    private shouldFallbackDirectModelForMedia;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -117,6 +118,7 @@ export declare class VirtualRouterEngine {
     private markProviderCooldown;
     private clearProviderCooldown;
     private isProviderCoolingDown;
+    private getProviderCooldownRemainingMs;
     private restoreHealthFromStore;
     private buildHealthSnapshot;
     private persistHealthSnapshot;

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

@@ -207,6 +207,24 @@ export class VirtualRouterEngine {
         }
         return { providerId, modelId };
     }
+    shouldFallbackDirectModelForMedia(direct, features) {
+        if (!features.hasImageAttachment) {
+            return false;
+        }
+        const providerId = direct.providerId.trim().toLowerCase();
+        const modelId = direct.modelId.trim().toLowerCase();
+        if (providerId !== 'qwen') {
+            return false;
+        }
+        const isQwen35Plus = modelId === 'qwen3.5-plus' || modelId === 'qwen3-5-plus' || modelId === 'qwen3_5-plus';
+        if (!isQwen35Plus) {
+            return false;
+        }
+        if (!(features.hasVideoAttachment === true && features.hasLocalVideoAttachment === true)) {
+            return false;
+        }
+        return this.routeHasTargets(this.routing.vision);
+    }
     initialize(config) {
         this.validateConfig(config);
         this.routing = config.routing;
@@ -638,6 +656,7 @@ export class VirtualRouterEngine {
             quotaView: this.quotaView
         };
         if (directProviderModel) {
+            const forceMediaFallback = this.shouldFallbackDirectModelForMedia(directProviderModel, features);
             const providerKeys = this.providerRegistry.listProviderKeys(directProviderModel.providerId);
             let hasModel = false;
             for (const key of providerKeys) {
@@ -655,19 +674,26 @@ export class VirtualRouterEngine {
             if (!hasModel) {
                 throw new VirtualRouterError(`Unknown model ${directProviderModel.modelId} for provider ${directProviderModel.providerId}`, VirtualRouterErrorCode.CONFIG_ERROR, { providerId: directProviderModel.providerId, modelId: directProviderModel.modelId });
             }
-            classification = {
-                routeName: 'direct',
-                confidence: 1,
-                reasoning: `direct_model:${directProviderModel.providerId}.${directProviderModel.modelId}`,
-                fallback: false,
-                candidates: ['direct']
-            };
-            requestedRoute = 'direct';
-            const directSelection = selectDirectProviderModel(directProviderModel.providerId, directProviderModel.modelId, metadata, features, routingState, selectionDeps);
-            if (!directSelection) {
-                throw new VirtualRouterError(`All providers unavailable for model ${directProviderModel.providerId}.${directProviderModel.modelId}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { providerId: directProviderModel.providerId, modelId: directProviderModel.modelId });
+            if (!forceMediaFallback) {
+                const directSelection = selectDirectProviderModel(directProviderModel.providerId, directProviderModel.modelId, metadata, features, routingState, selectionDeps);
+                if (!directSelection) {
+                    throw new VirtualRouterError(`All providers unavailable for model ${directProviderModel.providerId}.${directProviderModel.modelId}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { providerId: directProviderModel.providerId, modelId: directProviderModel.modelId });
+                }
+                classification = {
+                    routeName: 'direct',
+                    confidence: 1,
+                    reasoning: `direct_model:${directProviderModel.providerId}.${directProviderModel.modelId}`,
+                    fallback: false,
+                    candidates: ['direct']
+                };
+                requestedRoute = 'direct';
+                selection = directSelection;
+            }
+            else {
+                classification = this.classifier.classify(features);
+                requestedRoute = this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
+                selection = this.selectProvider(requestedRoute, metadata, classification, features, routingState);
             }
-            selection = directSelection;
         }
         else {
             // Prefer target (from "<**!provider.model**>") is evaluated before routing classification.
@@ -1128,6 +1154,7 @@ export class VirtualRouterEngine {
             contextAdvisor: this.contextAdvisor,
             loadBalancer: this.loadBalancer,
             isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
+            getProviderCooldownRemainingMs: (key) => this.getProviderCooldownRemainingMs(key),
             resolveStickyKey: (m) => this.resolveStickyKey(m),
             quotaView: this.quotaView,
             aliasQueueStore: this.stickySessionManager.getAllStores().aliasQueueStore,
@@ -1287,6 +1314,7 @@ export class VirtualRouterEngine {
             contextAdvisor: this.contextAdvisor,
             loadBalancer: this.loadBalancer,
             isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
+            getProviderCooldownRemainingMs: (key) => this.getProviderCooldownRemainingMs(key),
             resolveStickyKey: (m) => this.resolveStickyKey(m),
             quotaView: this.quotaView,
             aliasQueueStore: this.stickySessionManager.getAllStores().aliasQueueStore
@@ -1421,6 +1449,10 @@ export class VirtualRouterEngine {
         const forceVision = this.routeHasForceFlag('vision');
         const hasMultimodalTargets = this.routeHasTargets(this.routing.multimodal);
         const hasVisionTargets = this.routeHasTargets(this.routing.vision);
+        const hasLocalVideoAttachment = features.hasVideoAttachment === true && features.hasLocalVideoAttachment === true;
+        if (features.hasImageAttachment && hasLocalVideoAttachment && hasVisionTargets) {
+            return ['vision'];
+        }
         const normalized = this.normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
         const baseList = [];
         if (classificationCandidates && classificationCandidates.length) {
@@ -1437,9 +1469,9 @@ export class VirtualRouterEngine {
                     baseList.unshift('multimodal');
                 }
             }
-            else if (hasVisionTargets) {
+            if (hasVisionTargets) {
                 if (!baseList.includes('vision')) {
-                    baseList.unshift('vision');
+                    baseList.push('vision');
                 }
             }
             if (!forceVision && hasMultimodalTargets) {
@@ -1629,6 +1661,17 @@ export class VirtualRouterEngine {
     isProviderCoolingDown(providerKey) {
         return this.cooldownManager.isProviderCoolingDown(providerKey);
     }
+    getProviderCooldownRemainingMs(providerKey) {
+        if (!providerKey) {
+            return 0;
+        }
+        const expiry = this.providerCooldowns.get(providerKey);
+        if (!expiry || !Number.isFinite(expiry)) {
+            return 0;
+        }
+        const remaining = Math.floor(expiry - Date.now());
+        return remaining > 0 ? remaining : 0;
+    }
     restoreHealthFromStore() {
         this.cooldownManager.restoreHealthFromStore();
     }

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

@@ -1,4 +1,4 @@
-import { detectExtendedThinkingKeyword, detectImageAttachment, detectKeyword, extractMessageText, getLatestMessageRole, getLatestUserMessage } from './message-utils.js';
+import { analyzeMediaAttachments, detectExtendedThinkingKeyword, detectKeyword, extractMessageText, getLatestMessageRole, } from './message-utils.js';
 import { extractAntigravityGeminiSessionId } from '../../conversion/compat/antigravity-session-signature.js';
 import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebSearchToolDeclared, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
 import { computeRequestTokens } from './token-estimator.js';
@@ -18,10 +18,14 @@ export function buildRoutingFeatures(request, metadata) {
             return undefined;
         }
     })();
-    const latestUserMessage = getLatestUserMessage(request.messages);
     const latestMessageRole = getLatestMessageRole(request.messages);
+    const latestMessage = 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 = latestUserMessage ? extractMessageText(latestUserMessage) : '';
+    const latestUserText = latestMessageRole === 'user' && latestMessage
+        ? extractMessageText(latestMessage)
+        : '';
     const normalizedUserText = latestUserText.toLowerCase();
     const meaningfulDeclaredTools = extractMeaningfulDeclaredToolNames(request.tools);
     const hasTools = meaningfulDeclaredTools.length > 0;
@@ -31,7 +35,8 @@ export function buildRoutingFeatures(request, metadata) {
     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 hasImageAttachment = latestMessageRole === 'user' && detectImageAttachment(latestUserMessage);
+    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);
@@ -58,6 +63,9 @@ export function buildRoutingFeatures(request, metadata) {
         hasToolCallResponses,
         hasVisionTool,
         hasImageAttachment,
+        hasVideoAttachment: mediaSignals.hasVideo,
+        hasRemoteVideoAttachment: mediaSignals.hasRemoteVideo,
+        hasLocalVideoAttachment: mediaSignals.hasLocalVideo,
         hasWebTool,
         hasWebSearchToolDeclared: detectWebSearchToolDeclared(request),
         hasCodingTool,

package/dist/router/virtual-router/message-utils.d.ts

@@ -4,4 +4,12 @@ export declare function getLatestMessageRole(messages: StandardizedMessage[]): s
 export declare function extractMessageText(message: StandardizedMessage): string;
 export declare function detectKeyword(text: string, keywords: string[]): boolean;
 export declare function detectExtendedThinkingKeyword(text: string): boolean;
+export interface MediaAttachmentSignals {
+    hasAnyMedia: boolean;
+    hasImage: boolean;
+    hasVideo: boolean;
+    hasRemoteVideo: boolean;
+    hasLocalVideo: boolean;
+}
+export declare function analyzeMediaAttachments(message: StandardizedMessage | undefined): MediaAttachmentSignals;
 export declare function detectImageAttachment(message: StandardizedMessage | undefined): boolean;