@jsonstudio/llms 0.6.230 → 0.6.375

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

@@ -27,7 +27,7 @@ export function bootstrapVirtualRouterConfig(input) {
     if (!Object.keys(routingSource).length) {
         throw new VirtualRouterError('Virtual Router routing table cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
     }
-    const webSearch = normalizeWebSearch(section.webSearch);
+    const webSearch = normalizeWebSearch(section.webSearch, routingSource);
     validateWebSearchRouting(webSearch, routingSource);
     const { runtimeEntries, aliasIndex } = buildProviderRuntimeEntries(providersSource);
     const { routing, targetKeys } = expandRoutingTable(routingSource, aliasIndex);
@@ -121,7 +121,8 @@ function buildProviderRuntimeEntries(providers) {
                 streaming: normalizedProvider.streaming,
                 modelStreaming: normalizedProvider.modelStreaming,
                 modelContextTokens: normalizedProvider.modelContextTokens,
-                defaultContextTokens: normalizedProvider.defaultContextTokens
+                defaultContextTokens: normalizedProvider.defaultContextTokens,
+                ...(normalizedProvider.serverToolsDisabled ? { serverToolsDisabled: true } : {})
             };
         }
     }
@@ -158,7 +159,8 @@ function expandRoutingTable(routingSource, aliasIndex) {
                     id: pool.id,
                     priority: pool.priority,
                     backup: pool.backup,
-                    targets: expandedTargets
+                    targets: expandedTargets,
+                    ...(pool.force ? { force: true } : {})
                 });
             }
         }
@@ -194,7 +196,8 @@ function buildProviderProfiles(targetKeys, runtimeEntries) {
             processMode: runtime.processMode || 'chat',
             responsesConfig: runtime.responsesConfig,
             streaming: streamingPref,
-            maxContextTokens: contextTokens
+            maxContextTokens: contextTokens,
+            ...(runtime.serverToolsDisabled ? { serverToolsDisabled: true } : {})
         };
         targetRuntime[targetKey] = {
             ...runtime,
@@ -274,12 +277,15 @@ function normalizeRoutePoolEntry(routeName, entry, index, total) {
         (typeof record.type === 'string' && record.type.toLowerCase() === 'backup');
     const priority = normalizePriorityValue(record.priority, total - index);
     const targets = normalizeRouteTargets(record);
+    const force = record.force === true ||
+        (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true');
     return targets.length
         ? {
             id,
             priority,
             backup,
-            targets
+            targets,
+            ...(force ? { force: true } : {})
         }
         : null;
 }
@@ -386,6 +392,12 @@ function normalizeProvider(providerId, raw) {
     const streaming = resolveProviderStreamingPreference(provider, responsesNode);
     const modelStreaming = normalizeModelStreaming(provider);
     const { modelContextTokens, defaultContextTokens } = normalizeModelContextTokens(provider);
+    const serverToolsDisabled = provider.serverToolsDisabled === true ||
+        (typeof provider.serverToolsDisabled === 'string' &&
+            provider.serverToolsDisabled.trim().toLowerCase() === 'true') ||
+        (provider.serverTools &&
+            typeof provider.serverTools === 'object' &&
+            provider.serverTools.enabled === false);
     return {
         providerId,
         providerType,
@@ -398,7 +410,8 @@ function normalizeProvider(providerId, raw) {
         streaming,
         modelStreaming,
         modelContextTokens,
-        defaultContextTokens
+        defaultContextTokens,
+        ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
     };
 }
 function normalizeModelStreaming(provider) {
@@ -539,9 +552,9 @@ function validateWebSearchRouting(webSearch, routingSource) {
     if (!webSearch) {
         return;
     }
-    const routePools = routingSource['web_search'];
+    const routePools = routingSource['web_search'] ?? routingSource['search'];
     if (!Array.isArray(routePools) || !routePools.length) {
-        throw new VirtualRouterError('Virtual Router webSearch.engines configured but routing.web_search route is missing or empty', VirtualRouterErrorCode.CONFIG_ERROR);
+        throw new VirtualRouterError('Virtual Router webSearch.engines configured but routing.web_search (or search) route is missing or empty', VirtualRouterErrorCode.CONFIG_ERROR);
     }
     const targets = new Set();
     for (const pool of routePools) {
@@ -556,11 +569,11 @@ function validateWebSearchRouting(webSearch, routingSource) {
     }
     for (const engine of webSearch.engines) {
         if (!targets.has(engine.providerKey)) {
-            throw new VirtualRouterError(`Virtual Router webSearch engine "${engine.id}" references providerKey "${engine.providerKey}" which is not present in routing.web_search`, VirtualRouterErrorCode.CONFIG_ERROR);
+            throw new VirtualRouterError(`Virtual Router webSearch engine "${engine.id}" references providerKey "${engine.providerKey}" which is not present in routing.web_search/search`, VirtualRouterErrorCode.CONFIG_ERROR);
         }
     }
 }
-function normalizeWebSearch(input) {
+function normalizeWebSearch(input, routingSource) {
     if (!input || typeof input !== 'object') {
         return undefined;
     }
@@ -588,6 +601,12 @@ function normalizeWebSearch(input) {
             : undefined;
         const isDefault = node.default === true ||
             (typeof node.default === 'string' && node.default.trim().toLowerCase() === 'true');
+        const serverToolsDisabled = node.serverToolsDisabled === true ||
+            (typeof node.serverToolsDisabled === 'string' &&
+                node.serverToolsDisabled.trim().toLowerCase() === 'true') ||
+            (node.serverTools &&
+                typeof node.serverTools === 'object' &&
+                node.serverTools.enabled === false);
         // Deduplicate by id; first wins, subsequent are ignored.
         if (engines.some((engine) => engine.id === id)) {
             continue;
@@ -596,13 +615,15 @@ function normalizeWebSearch(input) {
             id,
             providerKey,
             description,
-            default: isDefault
+            default: isDefault,
+            ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
         });
     }
     if (!engines.length) {
         return undefined;
     }
     let injectPolicy;
+    let force;
     const rawPolicy = record.injectPolicy ?? record?.inject_policy;
     if (typeof rawPolicy === 'string') {
         const normalized = rawPolicy.trim().toLowerCase();
@@ -610,9 +631,20 @@ function normalizeWebSearch(input) {
             injectPolicy = normalized;
         }
     }
+    if (record.force === true ||
+        (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true')) {
+        force = true;
+    }
+    else {
+        const webSearchPools = routingSource['web_search'] ?? routingSource['search'] ?? [];
+        if (Array.isArray(webSearchPools) && webSearchPools.some((pool) => pool.force)) {
+            force = true;
+        }
+    }
     return {
         engines,
-        injectPolicy: injectPolicy ?? 'selective'
+        injectPolicy: injectPolicy ?? 'selective',
+        ...(force ? { force } : {})
     };
 }
 function extractProviderAuthEntries(providerId, raw) {

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

@@ -17,34 +17,28 @@ export class RoutingClassifier {
         const thinkingContinuation = lastToolCategory === 'read';
         const searchContinuation = lastToolCategory === 'search';
         const toolsContinuation = lastToolCategory === 'other';
-        if (latestMessageFromUser) {
-            const reasoning = 'thinking:user-input';
-            const evaluations = {
-                thinking: { triggered: true, reason: reasoning }
-            };
-            const candidates = this.ensureDefaultCandidate(['thinking']);
-            return this.buildResult('thinking', reasoning, evaluations, candidates);
-        }
+        // 用户输入优先级最高(仅次于 vision),确保每次新的用户输入都走 thinking 路由进行工具检查
+        // thinking_continuation 用于区分"工具轮次中的 read 类调用"与"用户新输入"
         const evaluationMap = {
             vision: {
-                triggered: features.hasVisionTool && features.hasImageAttachment,
-                reason: 'vision:requires-tool+image'
+                triggered: features.hasImageAttachment,
+                reason: 'vision:image-detected'
+            },
+            thinking: {
+                triggered: latestMessageFromUser,
+                reason: 'thinking:user-input'
             },
             longcontext: {
                 triggered: reachedLongContext,
                 reason: 'longcontext:token-threshold'
             },
-            websearch: {
-                triggered: features.hasWebTool || searchContinuation,
-                reason: searchContinuation ? 'websearch:last-tool-search' : 'websearch:web-tools-detected'
-            },
             coding: {
                 triggered: codingContinuation,
                 reason: 'coding:last-tool-write'
             },
-            thinking: {
-                triggered: thinkingContinuation || latestMessageFromUser,
-                reason: thinkingContinuation ? 'thinking:last-tool-read' : 'thinking:user-input'
+            thinking_continuation: {
+                triggered: thinkingContinuation,
+                reason: 'thinking:last-tool-read'
             },
             tools: {
                 triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,

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

@@ -12,6 +12,7 @@ export declare class VirtualRouterEngine {
     private readonly debug;
     private healthConfig;
     private readonly statsCenter;
+    private webSearchForce;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -28,6 +29,11 @@ export declare class VirtualRouterEngine {
         }>;
         health: import("./types.js").ProviderHealthState[];
     };
+    /**
+     * 将分类器产生的逻辑路由名直接归一化为配置中的路由键。
+     * 不再维护 "websearch" 之类的别名，调用方应显式使用 "web_search" 或 "search" 等实际路由名。
+     */
+    private normalizeRouteAlias;
     private validateConfig;
     private selectProvider;
     private trySelectFromTier;
@@ -40,8 +46,11 @@ export declare class VirtualRouterEngine {
     private mapProviderError;
     private deriveReason;
     private buildRouteCandidates;
+    private reorderForInlineVision;
+    private routeSupportsInlineVision;
     private sortByPriority;
     private routeWeight;
+    private routeHasForceFlag;
     private routeHasTargets;
     private hasPrimaryPool;
     private sortRoutePools;

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

@@ -18,6 +18,8 @@ export class VirtualRouterEngine {
     debug = console; // thin hook; host may monkey-patch for colored logging
     healthConfig = null;
     statsCenter = getStatsCenter();
+    // Derived flags from VirtualRouterConfig/routing used by process / response layers.
+    webSearchForce = false;
     initialize(config) {
         this.validateConfig(config);
         this.routing = config.routing;
@@ -29,6 +31,7 @@ export class VirtualRouterEngine {
         this.classifier = new RoutingClassifier(config.classifier);
         this.contextRouting = config.contextRouting ?? { warnRatio: 0.9, hardLimit: false };
         this.contextAdvisor.configure(this.contextRouting);
+        this.webSearchForce = config.webSearch?.force === true;
         this.routeStats = new Map();
         for (const routeName of Object.keys(this.routing)) {
             this.routeStats.set(routeName, { hits: 0 });
@@ -36,10 +39,24 @@ export class VirtualRouterEngine {
     }
     route(request, metadata) {
         const features = buildRoutingFeatures(request, metadata);
-        const classification = this.classifier.classify(features);
-        const routeName = classification.routeName || DEFAULT_ROUTE;
-        const selection = this.selectProvider(routeName, metadata, classification, features);
-        const target = this.providerRegistry.buildTarget(selection.providerKey);
+        const classification = metadata.routeHint && metadata.routeHint.trim()
+            ? {
+                routeName: metadata.routeHint.trim(),
+                confidence: 1,
+                reasoning: `route_hint:${metadata.routeHint.trim()}`,
+                fallback: false,
+                candidates: [metadata.routeHint.trim()]
+            }
+            : this.classifier.classify(features);
+        const requestedRoute = this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
+        const selection = this.selectProvider(requestedRoute, metadata, classification, features);
+        const baseTarget = this.providerRegistry.buildTarget(selection.providerKey);
+        const forceVision = this.routeHasForceFlag('vision');
+        const target = {
+            ...baseTarget,
+            ...(this.webSearchForce ? { forceWebSearch: true } : {}),
+            ...(forceVision ? { forceVision: true } : {})
+        };
         this.healthManager.recordSuccess(selection.providerKey);
         this.incrementRouteStat(selection.routeUsed, selection.providerKey);
         try {
@@ -64,7 +81,7 @@ export class VirtualRouterEngine {
         else {
             this.debug?.log?.('[virtual-router-hit]', selection.routeUsed, selection.providerKey, target.modelId || '', hitReason ? `reason=${hitReason}` : '');
         }
-        const didFallback = selection.routeUsed !== routeName;
+        const didFallback = selection.routeUsed !== requestedRoute;
         return {
             target,
             decision: {
@@ -123,6 +140,14 @@ export class VirtualRouterEngine {
             health: this.healthManager.getSnapshot()
         };
     }
+    /**
+     * 将分类器产生的逻辑路由名直接归一化为配置中的路由键。
+     * 不再维护 "websearch" 之类的别名，调用方应显式使用 "web_search" 或 "search" 等实际路由名。
+     */
+    normalizeRouteAlias(routeName) {
+        const base = routeName && routeName.trim() ? routeName.trim() : DEFAULT_ROUTE;
+        return base;
+    }
     validateConfig(config) {
         if (!config.routing || typeof config.routing !== 'object') {
             throw new VirtualRouterError('routing configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
@@ -158,7 +183,7 @@ export class VirtualRouterEngine {
         }
     }
     selectProvider(requestedRoute, metadata, classification, features) {
-        const candidates = this.buildRouteCandidates(requestedRoute, classification.candidates);
+        const candidates = this.buildRouteCandidates(requestedRoute, classification.candidates, features);
         const stickyKey = this.resolveStickyKey(metadata);
         const attempted = [];
         const visitedRoutes = new Set();
@@ -180,7 +205,7 @@ export class VirtualRouterEngine {
             visitedRoutes.add(routeName);
             const orderedPools = this.sortRoutePools(routePools);
             for (const poolTier of orderedPools) {
-                const { providerKey, poolTargets, tierId, failureHint } = this.trySelectFromTier(routeName, poolTier, stickyKey, estimatedTokens);
+                const { providerKey, poolTargets, tierId, failureHint } = this.trySelectFromTier(routeName, poolTier, stickyKey, estimatedTokens, features);
                 if (providerKey) {
                     return { providerKey, routeUsed: routeName, pool: poolTargets, poolId: tierId };
                 }
@@ -191,8 +216,50 @@ export class VirtualRouterEngine {
         }
         throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
     }
-    trySelectFromTier(routeName, tier, stickyKey, estimatedTokens) {
-        const targets = Array.isArray(tier.targets) ? tier.targets : [];
+    trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features) {
+        let targets = Array.isArray(tier.targets) ? tier.targets : [];
+        const serverToolRequired = features.metadata?.serverToolRequired === true;
+        if (serverToolRequired) {
+            const filtered = [];
+            for (const key of targets) {
+                try {
+                    const profile = this.providerRegistry.get(key);
+                    if (!profile.serverToolsDisabled) {
+                        filtered.push(key);
+                    }
+                }
+                catch {
+                    // ignore unknown providers when filtering for servertools
+                }
+            }
+            targets = filtered;
+        }
+        // 当当前请求包含图片且路由为 default/thinking 时，优先在该路由池内选择
+        // Responses/Gemini 类型的 Provider，以便一次完成多模态推理；如果不存在则回退到原始列表。
+        if (features.hasImageAttachment && (routeName === DEFAULT_ROUTE || routeName === 'thinking')) {
+            const prioritized = [];
+            const fallthrough = [];
+            for (const key of targets) {
+                try {
+                    const profile = this.providerRegistry.get(key);
+                    if (profile.providerType === 'responses') {
+                        prioritized.push(key);
+                    }
+                    else if (profile.providerType === 'gemini') {
+                        prioritized.push(key);
+                    }
+                    else {
+                        fallthrough.push(key);
+                    }
+                }
+                catch {
+                    fallthrough.push(key);
+                }
+            }
+            if (prioritized.length) {
+                targets = prioritized;
+            }
+        }
         if (!targets.length) {
             return { providerKey: null, poolTargets: [], tierId: tier.id, failureHint: `${routeName}:${tier.id}:empty` };
         }
@@ -346,12 +413,32 @@ export class VirtualRouterEngine {
             return 'client_error';
         return 'unknown';
     }
-    buildRouteCandidates(requestedRoute, classificationCandidates) {
-        const normalized = requestedRoute || DEFAULT_ROUTE;
-        const baseList = classificationCandidates && classificationCandidates.length
-            ? classificationCandidates
-            : [normalized];
-        const ordered = this.sortByPriority(baseList);
+    buildRouteCandidates(requestedRoute, classificationCandidates, features) {
+        const forceVision = this.routeHasForceFlag('vision');
+        const normalized = this.normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
+        const baseList = [];
+        if (classificationCandidates && classificationCandidates.length) {
+            for (const candidate of classificationCandidates) {
+                baseList.push(this.normalizeRouteAlias(candidate));
+            }
+        }
+        else if (normalized) {
+            baseList.push(normalized);
+        }
+        // 当检测到当前请求包含图片时，确保 default/thinking 也参与候选集，
+        // 以便优先尝试内建多模态模型（Responses/Gemini），再回落到 vision 路由池。
+        if (features.hasImageAttachment && !forceVision) {
+            const visionAwareRoutes = [DEFAULT_ROUTE, 'thinking'];
+            for (const routeName of visionAwareRoutes) {
+                if (this.routeHasTargets(this.routing[routeName]) && !baseList.includes(routeName)) {
+                    baseList.push(routeName);
+                }
+            }
+        }
+        let ordered = this.sortByPriority(baseList);
+        if (features.hasImageAttachment && !forceVision) {
+            ordered = this.reorderForInlineVision(ordered);
+        }
         const deduped = [];
         for (const routeName of ordered) {
             if (routeName && !deduped.includes(routeName)) {
@@ -367,6 +454,53 @@ export class VirtualRouterEngine {
         }
         return filtered.length ? filtered : [DEFAULT_ROUTE];
     }
+    reorderForInlineVision(routeNames) {
+        const unique = Array.from(new Set(routeNames.filter(Boolean)));
+        if (!unique.length) {
+            return unique;
+        }
+        // 仅当 default/thinking 中存在 Responses/Gemini 提供方时，才将其提前作为「一次完成」优先级。
+        const inlinePreferred = [];
+        const inlineRoutes = [DEFAULT_ROUTE, 'thinking'];
+        for (const routeName of inlineRoutes) {
+            if (this.routeSupportsInlineVision(routeName) && !inlinePreferred.includes(routeName)) {
+                inlinePreferred.push(routeName);
+            }
+        }
+        if (!inlinePreferred.length) {
+            return unique;
+        }
+        const remaining = [];
+        for (const routeName of unique) {
+            if (!inlinePreferred.includes(routeName)) {
+                remaining.push(routeName);
+            }
+        }
+        return [...inlinePreferred, ...remaining];
+    }
+    routeSupportsInlineVision(routeName) {
+        const pools = this.routing[routeName];
+        if (!Array.isArray(pools)) {
+            return false;
+        }
+        for (const pool of pools) {
+            if (!Array.isArray(pool.targets)) {
+                continue;
+            }
+            for (const providerKey of pool.targets) {
+                try {
+                    const profile = this.providerRegistry.get(providerKey);
+                    if (profile.providerType === 'responses' || profile.providerType === 'gemini') {
+                        return true;
+                    }
+                }
+                catch {
+                    // ignore unknown provider keys during capability probing
+                }
+            }
+        }
+        return false;
+    }
     sortByPriority(routeNames) {
         return [...routeNames].sort((a, b) => this.routeWeight(a) - this.routeWeight(b));
     }
@@ -374,6 +508,13 @@ export class VirtualRouterEngine {
         const idx = ROUTE_PRIORITY.indexOf(routeName);
         return idx >= 0 ? idx : ROUTE_PRIORITY.length;
     }
+    routeHasForceFlag(routeName) {
+        const pools = this.routing[routeName];
+        if (!Array.isArray(pools)) {
+            return false;
+        }
+        return pools.some((pool) => pool.force);
+    }
     routeHasTargets(pools) {
         if (!Array.isArray(pools)) {
             return false;
@@ -434,8 +575,8 @@ export class VirtualRouterEngine {
             if (routeUsed === 'coding') {
                 return this.decorateWithDetail(primary || 'coding', primary, commandDetail);
             }
-            if (routeUsed === 'websearch') {
-                return this.decorateWithDetail(primary || 'websearch', primary, commandDetail);
+            if (routeUsed === 'web_search' || routeUsed === 'search') {
+                return this.decorateWithDetail(primary || routeUsed, primary, commandDetail);
             }
             if (routeUsed === DEFAULT_ROUTE && classification.fallback) {
                 return primary || 'fallback:default';
@@ -495,7 +636,8 @@ export class VirtualRouterEngine {
             thinking: '\x1b[34m',
             coding: '\x1b[35m',
             longcontext: '\x1b[38;5;141m',
-            websearch: '\x1b[32m',
+            web_search: '\x1b[32m',
+            search: '\x1b[38;5;34m',
             vision: '\x1b[38;5;207m',
             background: '\x1b[90m'
         };

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

@@ -14,7 +14,7 @@ export function buildRoutingFeatures(request, metadata) {
     const estimatedTokens = computeRequestTokens(request, latestUserText);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
     const hasVisionTool = detectVisionTool(request);
-    const hasImageAttachment = hasVisionTool && detectImageAttachment(latestUserMessage);
+    const hasImageAttachment = detectImageAttachment(latestUserMessage);
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);

package/dist/router/virtual-router/message-utils.js

@@ -37,30 +37,42 @@ export function detectExtendedThinkingKeyword(text) {
 export function detectImageAttachment(message) {
     if (!message)
         return false;
-    if (!message.metadata || typeof message.metadata !== 'object') {
-        return false;
-    }
-    const meta = message.metadata;
-    const attachments = (meta.attachments ?? null);
-    if (Array.isArray(attachments)) {
-        return attachments.some((attachment) => {
-            const candidate = attachment;
-            const typeValue = typeof candidate.type === 'string' ? candidate.type.toLowerCase() : '';
-            const urlValue = typeof candidate.url === 'string'
-                ? candidate.url
-                : typeof candidate.src === 'string'
-                    ? candidate.src
-                    : typeof candidate.image_url === 'string'
-                        ? candidate.image_url
-                        : typeof candidate.image_url?.url === 'string'
-                            ? candidate.image_url.url
-                            : '';
-            return typeValue.includes('image') && urlValue.trim().length > 0;
-        });
-    }
-    if (typeof meta.attachmentType === 'string' && meta.attachmentType.toLowerCase().includes('image')) {
-        const urlCandidate = typeof meta.attachmentUrl === 'string' ? meta.attachmentUrl : '';
-        return urlCandidate.trim().length > 0;
+    // 仅基于标准 Chat 语义判断是否携带图片：
+    // - content 为数组时查找 { type: 'image' | 'image_url' | 'input_image', ... } 块；
+    // - 不再依赖 metadata.attachments，也不再用纯文本关键字或剪贴板标记作为信号。
+    if (Array.isArray(message.content)) {
+        for (const part of message.content) {
+            if (!part || typeof part !== 'object') {
+                continue;
+            }
+            const record = part;
+            const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
+            // For chat/standardized content, images may appear as:
+            // - { type: "image_url", image_url: { url } }
+            // - { type: "image", uri: "...", data: "...", url: "..." }
+            // - { type: "input_image", image_url: "data:..." }
+            // Treat any non-empty URL/URI/data on an image-* block as a signal.
+            let imageCandidate = '';
+            if (typeof record.image_url === 'string') {
+                imageCandidate = record.image_url ?? '';
+            }
+            else if (record.image_url &&
+                typeof record.image_url?.url === 'string') {
+                imageCandidate = record.image_url?.url ?? '';
+            }
+            else if (typeof record.url === 'string') {
+                imageCandidate = record.url ?? '';
+            }
+            else if (typeof record.uri === 'string') {
+                imageCandidate = record.uri ?? '';
+            }
+            else if (typeof record.data === 'string') {
+                imageCandidate = record.data ?? '';
+            }
+            if (typeValue.includes('image') && imageCandidate.trim().length > 0) {
+                return true;
+            }
+        }
     }
     return false;
 }

package/dist/router/virtual-router/provider-registry.js

@@ -62,7 +62,8 @@ export class ProviderRegistry {
             processMode: profile.processMode || 'chat',
             responsesConfig: profile.responsesConfig,
             streaming: profile.streaming,
-            maxContextTokens: profile.maxContextTokens
+            maxContextTokens: profile.maxContextTokens,
+            ...(profile.serverToolsDisabled ? { serverToolsDisabled: true } : {})
         };
     }
 }

package/dist/router/virtual-router/token-counter.js

@@ -78,11 +78,22 @@ function encodeContent(content, encoder) {
                 total += encodeText(part, encoder);
             }
             else if (part && typeof part === 'object') {
-                if (typeof part.text === 'string') {
-                    total += encodeText(part.text, encoder);
+                const record = part;
+                const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
+                // Large binary/image payloads (data URIs, base64, etc.) should not
+                // dominate context estimation. For image-like blocks, only count a
+                // small textual placeholder instead of the full JSON/body.
+                if (typeValue.startsWith('image')) {
+                    const caption = typeof record.caption === 'string' && record.caption.trim().length
+                        ? record.caption
+                        : '[image]';
+                    total += encodeText(caption, encoder);
+                }
+                else if (typeof record.text === 'string') {
+                    total += encodeText(record.text, encoder);
                 }
                 else {
-                    total += encodeText(JSON.stringify(part), encoder);
+                    total += encodeText(JSON.stringify(record), encoder);
                 }
             }
         }