@jsonstudio/rcc 0.90.364 → 0.90.429

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

@@ -1,107 +0,0 @@
-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/@jsonstudio/llms/dist/router/virtual-router/health-weighted.d.ts

@@ -1,25 +0,0 @@
-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/@jsonstudio/llms/dist/router/virtual-router/health-weighted.js

@@ -1,63 +0,0 @@
-/**
- * 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/@jsonstudio/llms/dist/router/virtual-router/load-balancer.d.ts

@@ -1,28 +0,0 @@
-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/@jsonstudio/llms/dist/router/virtual-router/load-balancer.js

@@ -1,160 +0,0 @@
-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/@jsonstudio/llms/dist/router/virtual-router/message-utils.d.ts

@@ -1,15 +0,0 @@
-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/@jsonstudio/llms/dist/router/virtual-router/message-utils.js

@@ -1,235 +0,0 @@
-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/@jsonstudio/llms/dist/router/virtual-router/pre-command-file-resolver.d.ts

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