@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/router/virtual-router/health-manager.js

@@ -0,0 +1,107 @@
+const DEFAULT_CONFIG = {
+    failureThreshold: 3,
+    cooldownMs: 30_000,
+    fatalCooldownMs: 120_000
+};
+export class ProviderHealthManager {
+    states = new Map();
+    config = DEFAULT_CONFIG;
+    configure(config) {
+        if (config) {
+            const normalizedCooldown = Math.max(5_000, config.cooldownMs ?? DEFAULT_CONFIG.cooldownMs);
+            const fatalCooldownCandidate = config.fatalCooldownMs ?? DEFAULT_CONFIG.fatalCooldownMs ?? normalizedCooldown;
+            this.config = {
+                failureThreshold: Math.max(1, config.failureThreshold ?? DEFAULT_CONFIG.failureThreshold),
+                cooldownMs: normalizedCooldown,
+                fatalCooldownMs: Math.max(fatalCooldownCandidate, normalizedCooldown)
+            };
+        }
+    }
+    registerProviders(providerKeys) {
+        for (const key of providerKeys) {
+            if (!this.states.has(key)) {
+                this.states.set(key, {
+                    providerKey: key,
+                    state: 'healthy',
+                    failureCount: 0
+                });
+            }
+        }
+    }
+    recordFailure(providerKey, reason) {
+        const state = this.getState(providerKey);
+        state.failureCount += 1;
+        state.lastFailureAt = Date.now();
+        if (reason) {
+            state.reason = reason;
+        }
+        // 在新版策略中，普通失败仅用于监控；不再根据 failureThreshold 自动熔断。
+        // 只有显式 fatal 或 tripProvider 调用时才会进入 tripped 状态。
+        return state;
+    }
+    /**
+     * 为可恢复错误（例如 429）提供短暂冷静期：在 cooldownMs 内将 providerKey
+     * 视为不可用，但不使用 fatalCooldownMs 的长熔断时间。
+     */
+    cooldownProvider(providerKey, reason, overrideMs) {
+        const state = this.getState(providerKey);
+        state.failureCount += 1;
+        state.state = 'tripped';
+        state.reason = reason;
+        const ttl = overrideMs ?? this.config.cooldownMs;
+        state.cooldownExpiresAt = Date.now() + ttl;
+        state.lastFailureAt = Date.now();
+        return state;
+    }
+    recordSuccess(providerKey) {
+        const state = this.getState(providerKey);
+        state.failureCount = 0;
+        state.state = 'healthy';
+        state.cooldownExpiresAt = undefined;
+        state.lastFailureAt = undefined;
+        state.reason = undefined;
+        return state;
+    }
+    tripProvider(providerKey, reason, cooldownOverrideMs) {
+        const state = this.getState(providerKey);
+        state.failureCount = Math.max(state.failureCount, this.config.failureThreshold);
+        state.state = 'tripped';
+        state.reason = reason;
+        const ttl = cooldownOverrideMs ?? this.config.fatalCooldownMs ?? this.config.cooldownMs;
+        state.cooldownExpiresAt = Date.now() + ttl;
+        state.lastFailureAt = Date.now();
+        return state;
+    }
+    isAvailable(providerKey) {
+        const state = this.getState(providerKey);
+        if (state.state === 'healthy') {
+            return true;
+        }
+        if (state.cooldownExpiresAt && Date.now() >= state.cooldownExpiresAt) {
+            this.recordSuccess(providerKey);
+            return true;
+        }
+        return false;
+    }
+    getSnapshot() {
+        return Array.from(this.states.values()).map((state) => ({
+            providerKey: state.providerKey,
+            state: state.state,
+            failureCount: state.failureCount,
+            cooldownExpiresAt: state.cooldownExpiresAt
+        }));
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    getState(providerKey) {
+        if (!this.states.has(providerKey)) {
+            this.states.set(providerKey, {
+                providerKey,
+                state: 'healthy',
+                failureCount: 0
+            });
+        }
+        return this.states.get(providerKey);
+    }
+}

package/vendor/llmswitch-core/dist/router/virtual-router/health-weighted.d.ts

@@ -0,0 +1,25 @@
+import type { HealthWeightedLoadBalancingConfig, ProviderQuotaViewEntry } from './types.js';
+export type ResolvedHealthWeightedConfig = Required<{
+    enabled: boolean;
+    baseWeight: number;
+    minMultiplier: number;
+    beta: number;
+    halfLifeMs: number;
+    recoverToBestOnRetry: boolean;
+}>;
+/**
+ * AWRR constant table (defaults).
+ *
+ * Notes:
+ * - `minMultiplier=0.5` is the "50% of baseline share" floor: penalties will not reduce a key below ~half of
+ *   its initial (equal) share within the same pool bucket.
+ * - `halfLifeMs=10min` means: if no new errors occur, the effect of the last error decays by 50% every 10 minutes.
+ * - `beta` controls how quickly errors reduce share; tune carefully.
+ */
+export declare const DEFAULT_HEALTH_WEIGHTED_CONFIG: ResolvedHealthWeightedConfig;
+export declare function resolveHealthWeightedConfig(raw?: HealthWeightedLoadBalancingConfig | null): ResolvedHealthWeightedConfig;
+export declare function computeHealthMultiplier(entry: ProviderQuotaViewEntry | null, nowMs: number, cfg: ResolvedHealthWeightedConfig): number;
+export declare function computeHealthWeight(entry: ProviderQuotaViewEntry | null, nowMs: number, cfg: ResolvedHealthWeightedConfig): {
+    weight: number;
+    multiplier: number;
+};

package/vendor/llmswitch-core/dist/router/virtual-router/health-weighted.js

@@ -0,0 +1,63 @@
+/**
+ * AWRR constant table (defaults).
+ *
+ * Notes:
+ * - `minMultiplier=0.5` is the "50% of baseline share" floor: penalties will not reduce a key below ~half of
+ *   its initial (equal) share within the same pool bucket.
+ * - `halfLifeMs=10min` means: if no new errors occur, the effect of the last error decays by 50% every 10 minutes.
+ * - `beta` controls how quickly errors reduce share; tune carefully.
+ */
+export const DEFAULT_HEALTH_WEIGHTED_CONFIG = {
+    enabled: false,
+    baseWeight: 100,
+    minMultiplier: 0.5,
+    beta: 0.1,
+    halfLifeMs: 10 * 60 * 1000,
+    recoverToBestOnRetry: true
+};
+export function resolveHealthWeightedConfig(raw) {
+    const enabled = raw?.enabled ?? DEFAULT_HEALTH_WEIGHTED_CONFIG.enabled;
+    const baseWeight = typeof raw?.baseWeight === 'number' && Number.isFinite(raw.baseWeight) && raw.baseWeight > 0
+        ? Math.floor(raw.baseWeight)
+        : DEFAULT_HEALTH_WEIGHTED_CONFIG.baseWeight;
+    const minMultiplier = typeof raw?.minMultiplier === 'number' && Number.isFinite(raw.minMultiplier) && raw.minMultiplier > 0
+        ? Math.min(1, raw.minMultiplier)
+        : DEFAULT_HEALTH_WEIGHTED_CONFIG.minMultiplier;
+    const beta = typeof raw?.beta === 'number' && Number.isFinite(raw.beta) && raw.beta >= 0
+        ? raw.beta
+        : DEFAULT_HEALTH_WEIGHTED_CONFIG.beta;
+    const halfLifeMs = typeof raw?.halfLifeMs === 'number' && Number.isFinite(raw.halfLifeMs) && raw.halfLifeMs > 0
+        ? Math.floor(raw.halfLifeMs)
+        : DEFAULT_HEALTH_WEIGHTED_CONFIG.halfLifeMs;
+    const recoverToBestOnRetry = raw?.recoverToBestOnRetry ?? DEFAULT_HEALTH_WEIGHTED_CONFIG.recoverToBestOnRetry;
+    return {
+        enabled,
+        baseWeight,
+        minMultiplier,
+        beta,
+        halfLifeMs,
+        recoverToBestOnRetry
+    };
+}
+export function computeHealthMultiplier(entry, nowMs, cfg) {
+    if (!entry) {
+        return 1;
+    }
+    const lastErrorAtMs = typeof entry.lastErrorAtMs === 'number' && Number.isFinite(entry.lastErrorAtMs) ? entry.lastErrorAtMs : null;
+    const consecutiveErrorCount = typeof entry.consecutiveErrorCount === 'number' && Number.isFinite(entry.consecutiveErrorCount) && entry.consecutiveErrorCount > 0
+        ? Math.floor(entry.consecutiveErrorCount)
+        : 0;
+    if (!lastErrorAtMs || consecutiveErrorCount <= 0) {
+        return 1;
+    }
+    const elapsedMs = Math.max(0, nowMs - lastErrorAtMs);
+    const decay = Math.exp((-Math.log(2) * elapsedMs) / cfg.halfLifeMs);
+    const effectiveErrors = consecutiveErrorCount * decay;
+    const raw = 1 - cfg.beta * effectiveErrors;
+    return Math.max(cfg.minMultiplier, Math.min(1, raw));
+}
+export function computeHealthWeight(entry, nowMs, cfg) {
+    const multiplier = computeHealthMultiplier(entry, nowMs, cfg);
+    const weight = Math.max(1, Math.round(cfg.baseWeight * multiplier));
+    return { weight, multiplier };
+}

package/vendor/llmswitch-core/dist/router/virtual-router/load-balancer.d.ts

@@ -0,0 +1,28 @@
+import type { LoadBalancingPolicy } from './types.js';
+export interface LoadBalancingOptions {
+    routeName: string;
+    candidates: string[];
+    stickyKey?: string;
+    weights?: Record<string, number>;
+    availabilityCheck: (providerKey: string) => boolean;
+}
+export interface GroupedLoadBalancingOptions {
+    routeName: string;
+    groups: Map<string, string[]>;
+    stickyKey?: string;
+    weights?: Record<string, number>;
+    availabilityCheck: (providerKey: string) => boolean;
+}
+export declare class RouteLoadBalancer {
+    private policy;
+    private readonly states;
+    constructor(policy?: LoadBalancingPolicy);
+    updatePolicy(policy?: LoadBalancingPolicy): void;
+    getPolicy(): LoadBalancingPolicy;
+    select(options: LoadBalancingOptions, strategyOverride?: LoadBalancingPolicy['strategy']): string | null;
+    selectGrouped(options: GroupedLoadBalancingOptions, strategyOverride?: LoadBalancingPolicy['strategy']): string | null;
+    private selectRoundRobin;
+    private selectWeighted;
+    private selectSticky;
+    private getState;
+}

package/vendor/llmswitch-core/dist/router/virtual-router/load-balancer.js

@@ -0,0 +1,160 @@
+export class RouteLoadBalancer {
+    policy;
+    states = new Map();
+    constructor(policy) {
+        this.policy = policy ?? { strategy: 'round-robin' };
+    }
+    updatePolicy(policy) {
+        if (policy) {
+            this.policy = policy;
+        }
+    }
+    getPolicy() {
+        return this.policy;
+    }
+    select(options, strategyOverride) {
+        const available = options.candidates.filter((candidate) => options.availabilityCheck(candidate));
+        if (available.length === 0) {
+            return null;
+        }
+        const strategy = strategyOverride ?? this.policy.strategy;
+        switch (strategy) {
+            case 'sticky':
+                return this.selectSticky(options.routeName, available, options.stickyKey, options.weights ?? this.policy.weights);
+            case 'weighted':
+                return this.selectWeighted(options.routeName, available, options.weights ?? this.policy.weights);
+            default:
+                if (options.weights) {
+                    const distinct = new Set(available.map((candidate) => normalizeWeight(options.weights?.[candidate])));
+                    if (distinct.size > 1) {
+                        return this.selectWeighted(options.routeName, available, options.weights);
+                    }
+                }
+                return this.selectRoundRobin(options.routeName, available);
+        }
+    }
+    selectGrouped(options, strategyOverride) {
+        const groupIds = Array.from(options.groups.keys()).filter((groupId) => {
+            const members = options.groups.get(groupId) ?? [];
+            return members.some((candidate) => options.availabilityCheck(candidate));
+        });
+        if (groupIds.length === 0) {
+            return null;
+        }
+        const normalizedWeights = normalizeGroupWeights(groupIds, options.weights);
+        const strategy = strategyOverride ?? this.policy.strategy;
+        const groupRoute = `${options.routeName}:group`;
+        let selectedGroup = null;
+        switch (strategy) {
+            case 'sticky':
+                selectedGroup = this.selectSticky(groupRoute, groupIds, options.stickyKey, normalizedWeights);
+                break;
+            case 'weighted':
+                selectedGroup = this.selectWeighted(groupRoute, groupIds, normalizedWeights);
+                break;
+            default:
+                selectedGroup = this.selectRoundRobin(groupRoute, groupIds);
+                break;
+        }
+        if (!selectedGroup) {
+            return null;
+        }
+        const groupCandidates = (options.groups.get(selectedGroup) ?? []).filter((candidate) => options.availabilityCheck(candidate));
+        if (groupCandidates.length === 0) {
+            return null;
+        }
+        return this.selectRoundRobin(`${groupRoute}:${selectedGroup}`, groupCandidates);
+    }
+    selectRoundRobin(routeName, candidates) {
+        const state = this.getState(routeName);
+        const choice = candidates[state.pointer % candidates.length];
+        state.pointer = (state.pointer + 1) % candidates.length;
+        return choice;
+    }
+    selectWeighted(routeName, candidates, weights) {
+        // Deterministic smooth weighted round-robin (no randomness) so routing behavior is testable and stable.
+        // Each candidate with a positive weight is guaranteed to be selected eventually.
+        const state = this.getState(routeName);
+        const current = state.weighted.currentWeights;
+        const candidateSet = new Set(candidates);
+        for (const existing of Array.from(current.keys())) {
+            if (!candidateSet.has(existing)) {
+                current.delete(existing);
+            }
+        }
+        for (const key of candidates) {
+            if (!current.has(key)) {
+                current.set(key, 0);
+            }
+        }
+        const candidateWeights = candidates.map((candidate) => normalizeWeight(weights?.[candidate]));
+        const totalWeight = candidateWeights.reduce((sum, w) => sum + w, 0);
+        if (!Number.isFinite(totalWeight) || totalWeight <= 0) {
+            return this.selectRoundRobin(routeName, candidates);
+        }
+        let bestIndex = 0;
+        let bestScore = Number.NEGATIVE_INFINITY;
+        for (let i = 0; i < candidates.length; i += 1) {
+            const key = candidates[i];
+            const w = candidateWeights[i];
+            const next = (current.get(key) ?? 0) + w;
+            current.set(key, next);
+            if (next > bestScore) {
+                bestScore = next;
+                bestIndex = i;
+            }
+        }
+        const selectedKey = candidates[bestIndex];
+        current.set(selectedKey, (current.get(selectedKey) ?? 0) - totalWeight);
+        return selectedKey;
+    }
+    selectSticky(routeName, candidates, stickyKey, weights) {
+        if (!stickyKey) {
+            return this.selectRoundRobin(routeName, candidates);
+        }
+        const state = this.getState(routeName);
+        const pinned = state.stickyMap.get(stickyKey);
+        if (pinned && candidates.includes(pinned)) {
+            return pinned;
+        }
+        const choice = weights && Object.keys(weights).length > 0
+            ? this.selectWeighted(`${routeName}:sticky`, candidates, weights)
+            : this.selectRoundRobin(routeName, candidates);
+        state.stickyMap.set(stickyKey, choice);
+        return choice;
+    }
+    getState(routeName) {
+        if (!this.states.has(routeName)) {
+            this.states.set(routeName, { pointer: 0, stickyMap: new Map(), weighted: { currentWeights: new Map() } });
+        }
+        return this.states.get(routeName);
+    }
+}
+function normalizeWeight(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        return value;
+    }
+    return 1;
+}
+function normalizeGroupWeights(groupIds, weights) {
+    if (!weights || groupIds.length === 0) {
+        return undefined;
+    }
+    const normalized = {};
+    let total = 0;
+    for (const id of groupIds) {
+        const raw = weights[id];
+        const value = typeof raw === 'number' && Number.isFinite(raw) && raw > 0 ? raw : 0;
+        if (value > 0) {
+            normalized[id] = value;
+            total += value;
+        }
+    }
+    if (!Number.isFinite(total) || total <= 0) {
+        return undefined;
+    }
+    for (const id of Object.keys(normalized)) {
+        normalized[id] = normalized[id] / total;
+    }
+    return normalized;
+}

package/vendor/llmswitch-core/dist/router/virtual-router/message-utils.d.ts

@@ -0,0 +1,15 @@
+import type { StandardizedMessage } from '../../conversion/hub/types/standardized.js';
+export declare function getLatestUserMessage(messages: StandardizedMessage[]): StandardizedMessage | undefined;
+export declare function getLatestMessageRole(messages: StandardizedMessage[]): string | undefined;
+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;

package/vendor/llmswitch-core/dist/router/virtual-router/message-utils.js

@@ -0,0 +1,235 @@
+import { isIP } from 'node:net';
+export function getLatestUserMessage(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        if (messages[idx]?.role === 'user') {
+            return messages[idx];
+        }
+    }
+    return undefined;
+}
+export function getLatestMessageRole(messages) {
+    if (!Array.isArray(messages) || !messages.length) {
+        return undefined;
+    }
+    const last = messages[messages.length - 1];
+    if (last && typeof last.role === 'string' && last.role.trim()) {
+        return last.role.trim();
+    }
+    return undefined;
+}
+export function extractMessageText(message) {
+    if (typeof message.content === 'string' && message.content.trim()) {
+        return message.content;
+    }
+    const content = message.content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const entry of content) {
+            if (typeof entry === 'string' && entry.trim()) {
+                parts.push(entry);
+            }
+            else if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+                const record = entry;
+                if (typeof record.text === 'string' && record.text.trim()) {
+                    parts.push(record.text);
+                }
+                else if (typeof record.content === 'string' && record.content.trim()) {
+                    parts.push(record.content);
+                }
+            }
+        }
+        const joined = parts.join('\n').trim();
+        if (joined) {
+            return joined;
+        }
+    }
+    return '';
+}
+export function detectKeyword(text, keywords) {
+    if (!text)
+        return false;
+    return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+}
+export function detectExtendedThinkingKeyword(text) {
+    if (!text) {
+        return false;
+    }
+    const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
+    return keywords.some((keyword) => text.includes(keyword));
+}
+const LOCAL_URL_SCHEMES = ['data:', 'file:', 'blob:'];
+function extractMediaUrlCandidate(record) {
+    if (typeof record.image_url === 'string') {
+        return record.image_url ?? '';
+    }
+    if (typeof record.video_url === 'string') {
+        return record.video_url ?? '';
+    }
+    if (record.image_url &&
+        typeof record.image_url?.url === 'string') {
+        return record.image_url?.url ?? '';
+    }
+    if (record.video_url &&
+        typeof record.video_url?.url === 'string') {
+        return record.video_url?.url ?? '';
+    }
+    if (typeof record.url === 'string') {
+        return record.url ?? '';
+    }
+    if (typeof record.uri === 'string') {
+        return record.uri ?? '';
+    }
+    if (typeof record.data === 'string') {
+        return record.data ?? '';
+    }
+    return '';
+}
+function resolveMediaKind(typeValue, record) {
+    if (typeValue.includes('video')) {
+        return 'video';
+    }
+    if (typeValue.includes('image')) {
+        return 'image';
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'video_url')) {
+        return 'video';
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'image_url')) {
+        return 'image';
+    }
+    return null;
+}
+function isPrivateHost(host) {
+    const normalized = host.trim().toLowerCase();
+    if (!normalized) {
+        return true;
+    }
+    if (normalized === 'localhost' || normalized.endsWith('.local')) {
+        return true;
+    }
+    const ipType = isIP(normalized);
+    if (ipType === 4) {
+        const octets = normalized.split('.').map((part) => Number.parseInt(part, 10));
+        if (octets.length !== 4 || octets.some((value) => !Number.isFinite(value))) {
+            return true;
+        }
+        if (octets[0] === 10)
+            return true;
+        if (octets[0] === 127)
+            return true;
+        if (octets[0] === 0)
+            return true;
+        if (octets[0] === 169 && octets[1] === 254)
+            return true;
+        if (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31)
+            return true;
+        if (octets[0] === 192 && octets[1] === 168)
+            return true;
+        return false;
+    }
+    if (ipType === 6) {
+        if (normalized === '::1')
+            return true;
+        if (normalized.startsWith('fc') || normalized.startsWith('fd'))
+            return true;
+        if (normalized.startsWith('fe80:'))
+            return true;
+        return false;
+    }
+    return false;
+}
+function isRemotePublicHttpUrl(raw) {
+    const value = raw.trim();
+    if (!value) {
+        return false;
+    }
+    const lowered = value.toLowerCase();
+    if (LOCAL_URL_SCHEMES.some((prefix) => lowered.startsWith(prefix))) {
+        return false;
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return false;
+    }
+    return !isPrivateHost(parsed.hostname);
+}
+export function analyzeMediaAttachments(message) {
+    const result = {
+        hasAnyMedia: false,
+        hasImage: false,
+        hasVideo: false,
+        hasRemoteVideo: false,
+        hasLocalVideo: false
+    };
+    if (!message) {
+        return result;
+    }
+    if (typeof message.content === 'string' && message.content.trim()) {
+        const raw = message.content;
+        const hasImageBlock = /"type"\s*:\s*"(?:input_)?image(?:_url)?"/iu.test(raw);
+        const hasVideoBlock = /"type"\s*:\s*"(?:input_)?video(?:_url)?"/iu.test(raw);
+        const hasDataVideo = /data:video\//iu.test(raw);
+        const hasRemoteVideo = /https?:\/\/[^\s"'\\]+/iu.test(raw);
+        if (hasImageBlock || hasVideoBlock) {
+            result.hasAnyMedia = true;
+        }
+        if (hasImageBlock) {
+            result.hasImage = true;
+        }
+        if (hasVideoBlock) {
+            result.hasVideo = true;
+            if (hasDataVideo) {
+                result.hasLocalVideo = true;
+            }
+            if (hasRemoteVideo) {
+                result.hasRemoteVideo = true;
+            }
+            if (!hasDataVideo && !hasRemoteVideo) {
+                result.hasLocalVideo = true;
+            }
+        }
+        if (result.hasAnyMedia) {
+            return result;
+        }
+    }
+    if (!Array.isArray(message.content)) {
+        return result;
+    }
+    for (const part of message.content) {
+        if (!part || typeof part !== 'object') {
+            continue;
+        }
+        const record = part;
+        const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
+        const mediaKind = resolveMediaKind(typeValue, record);
+        if (!mediaKind) {
+            continue;
+        }
+        const mediaUrl = extractMediaUrlCandidate(record).trim();
+        if (!mediaUrl) {
+            continue;
+        }
+        result.hasAnyMedia = true;
+        if (mediaKind === 'image') {
+            result.hasImage = true;
+            continue;
+        }
+        result.hasVideo = true;
+        if (isRemotePublicHttpUrl(mediaUrl)) {
+            result.hasRemoteVideo = true;
+        }
+        else {
+            result.hasLocalVideo = true;
+        }
+    }
+    return result;
+}
+export function detectImageAttachment(message) {
+    return analyzeMediaAttachments(message).hasAnyMedia;
+}

package/vendor/llmswitch-core/dist/router/virtual-router/pre-command-file-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function resolvePreCommandScriptPath(raw: string): string;
+export declare function isPreCommandScriptPathAllowed(rawPath: string): boolean;