@jsonstudio/llms 0.6.6 → 0.6.34

package/dist/conversion/codecs/gemini-openai-codec.js

@@ -262,6 +262,7 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     catch {
         // best-effort policy execution
     }
+    const normalizedFinishReason = toolCalls.length ? 'tool_calls' : finish_reason;
     const chatResp = {
         id: payload?.id || `chatcmpl_${Date.now()}`,
         object: 'chat.completion',
@@ -269,7 +270,7 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
         choices: [
             {
                 index: 0,
-                finish_reason,
+                finish_reason: normalizedFinishReason,
                 message: chatMsg
             }
         ]

package/dist/index.d.ts

@@ -7,4 +7,5 @@
 export * from './conversion/index.js';
 export * from './router/virtual-router/bootstrap.js';
 export * from './router/virtual-router/types.js';
+export { DEFAULT_THINKING_KEYWORDS } from './router/virtual-router/default-thinking-keywords.js';
 export declare const VERSION = "0.4.0";

package/dist/index.js

@@ -7,4 +7,5 @@
 export * from './conversion/index.js';
 export * from './router/virtual-router/bootstrap.js';
 export * from './router/virtual-router/types.js';
+export { DEFAULT_THINKING_KEYWORDS } from './router/virtual-router/default-thinking-keywords.js';
 export const VERSION = '0.4.0';

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

@@ -1,10 +1,13 @@
 import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+import { DEFAULT_THINKING_KEYWORDS } from './default-thinking-keywords.js';
+const KEYWORD_INJECTION_KEYS = ['thinking', 'background', 'vision', 'coding'];
 const DEFAULT_CLASSIFIER = {
-    longContextThresholdTokens: 60000,
-    thinkingKeywords: ['think step', 'analysis', 'reasoning', '仔细分析', '深度思考'],
+    longContextThresholdTokens: 180000,
+    thinkingKeywords: DEFAULT_THINKING_KEYWORDS,
     codingKeywords: ['apply_patch', 'write_file', 'create_file', 'shell', '修改文件', '写入文件'],
     backgroundKeywords: ['background', 'context dump', '上下文'],
-    visionKeywords: ['vision', 'image', 'picture', 'photo']
+    visionKeywords: ['vision', 'image', 'picture', 'photo'],
+    keywordInjections: {}
 };
 const DEFAULT_LOAD_BALANCING = { strategy: 'round-robin' };
 const DEFAULT_HEALTH = { failureThreshold: 3, cooldownMs: 30_000, fatalCooldownMs: 300_000 };
@@ -186,7 +189,8 @@ function normalizeClassifier(input) {
         thinkingKeywords: normalizeStringArray(normalized.thinkingKeywords, DEFAULT_CLASSIFIER.thinkingKeywords),
         codingKeywords: normalizeStringArray(normalized.codingKeywords, DEFAULT_CLASSIFIER.codingKeywords),
         backgroundKeywords: normalizeStringArray(normalized.backgroundKeywords, DEFAULT_CLASSIFIER.backgroundKeywords),
-        visionKeywords: normalizeStringArray(normalized.visionKeywords, DEFAULT_CLASSIFIER.visionKeywords)
+        visionKeywords: normalizeStringArray(normalized.visionKeywords, DEFAULT_CLASSIFIER.visionKeywords),
+        keywordInjections: normalizeKeywordInjectionMap(normalized.keywordInjections)
     };
     return result;
 }
@@ -197,6 +201,26 @@ function normalizeStringArray(value, fallback) {
     const normalized = value.map((item) => (typeof item === 'string' ? item.trim() : '')).filter(Boolean);
     return normalized.length ? normalized : [...fallback];
 }
+function normalizeKeywordInjectionMap(value) {
+    const map = {};
+    const record = asRecord(value);
+    if (!record) {
+        return map;
+    }
+    for (const key of KEYWORD_INJECTION_KEYS) {
+        const rawList = record[key];
+        if (!Array.isArray(rawList)) {
+            continue;
+        }
+        const normalized = rawList
+            .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+            .filter(Boolean);
+        if (normalized.length) {
+            map[key] = normalized;
+        }
+    }
+    return map;
+}
 function normalizeProvider(providerId, raw) {
     const provider = asRecord(raw);
     const providerType = detectProviderType(provider);
@@ -234,9 +258,9 @@ function normalizeResponsesConfig(provider) {
     return undefined;
 }
 function resolveCompatibilityProfile(provider) {
-    const compat = provider.compat;
-    if (typeof compat === 'string' && compat.trim().length > 0) {
-        return compat.trim();
+    const profile = readOptionalString(provider.compatibilityProfile);
+    if (profile) {
+        return profile;
     }
     return 'default';
 }

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

@@ -1,19 +1,42 @@
 import { DEFAULT_ROUTE, ROUTE_PRIORITY } from './types.js';
-const DEFAULT_LONG_CONTEXT_THRESHOLD = 60000;
+import { DEFAULT_THINKING_KEYWORDS } from './default-thinking-keywords.js';
+const DEFAULT_LONG_CONTEXT_THRESHOLD = 180000;
 export class RoutingClassifier {
     config;
     constructor(config) {
+        const keywordConfig = normalizeKeywordConfig(config);
         this.config = {
             longContextThresholdTokens: config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD,
-            thinkingKeywords: normalizeList(config.thinkingKeywords, ['think step', 'analysis', 'reasoning']),
-            backgroundKeywords: normalizeList(config.backgroundKeywords, ['background', 'context dump'])
+            thinkingKeywords: keywordConfig.thinking,
+            backgroundKeywords: keywordConfig.background,
+            visionKeywords: keywordConfig.vision,
+            codingKeywords: keywordConfig.coding
         };
     }
     classify(features) {
         const evaluations = [
+            {
+                route: 'longcontext',
+                triggered: features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD),
+                reason: 'longcontext:token-threshold'
+            },
+            {
+                route: 'thinking',
+                triggered: features.hasThinkingKeyword ||
+                    containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []) ||
+                    features.previousToolCategory === 'context_read' ||
+                    features.previousToolCategory === 'plan',
+                reason: 'thinking:keywords'
+            },
+            {
+                route: 'background',
+                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
+                reason: 'background:keywords'
+            },
             {
                 route: 'vision',
-                triggered: features.hasVisionTool && features.hasImageAttachment,
+                triggered: (features.hasVisionTool && features.hasImageAttachment) ||
+                    features.previousToolCategory === 'vision',
                 reason: 'vision:requires-tool+image'
             },
             {
@@ -23,29 +46,15 @@ export class RoutingClassifier {
             },
             {
                 route: 'coding',
-                triggered: features.hasCodingTool,
+                triggered: features.hasCodingTool ||
+                    containsKeywords(features.userTextSample, this.config.codingKeywords ?? []) ||
+                    features.previousToolCategory === 'coding',
                 reason: 'coding:coding-tools-detected'
             },
             {
                 route: 'tools',
                 triggered: features.hasTools || features.hasToolCallResponses,
                 reason: 'tools:tool-request-detected'
-            },
-            {
-                route: 'longcontext',
-                triggered: features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD),
-                reason: 'longcontext:token-threshold'
-            },
-            {
-                route: 'thinking',
-                triggered: features.hasThinkingKeyword ||
-                    containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []),
-                reason: 'thinking:keywords'
-            },
-            {
-                route: 'background',
-                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
-                reason: 'background:keywords'
             }
         ];
         const triggeredEvaluations = evaluations.filter((evaluation) => evaluation.triggered);
@@ -84,12 +93,6 @@ export class RoutingClassifier {
         return index >= 0 ? index : ROUTE_PRIORITY.length;
     }
 }
-function normalizeList(source, fallback) {
-    if (!source || source.length === 0) {
-        return fallback;
-    }
-    return source.map((item) => item.toLowerCase());
-}
 function containsKeywords(text, keywords) {
     if (!text || !keywords.length) {
         return false;
@@ -97,3 +100,29 @@ function containsKeywords(text, keywords) {
     const normalized = text.toLowerCase();
     return keywords.some((keyword) => normalized.includes(keyword));
 }
+function normalizeKeywordConfig(config) {
+    const injections = config.keywordInjections ?? {};
+    return {
+        thinking: mergeKeywordLists(DEFAULT_THINKING_KEYWORDS, config.thinkingKeywords, injections.thinking),
+        background: mergeKeywordLists(['background', 'context dump', '上下文'], config.backgroundKeywords, injections.background),
+        vision: mergeKeywordLists(['vision', 'image', 'picture', 'photo'], config.visionKeywords, injections.vision),
+        coding: mergeKeywordLists(config.codingKeywords, injections.coding)
+    };
+}
+function mergeKeywordLists(...lists) {
+    const set = new Set();
+    for (const list of lists) {
+        if (!Array.isArray(list)) {
+            continue;
+        }
+        for (const item of list) {
+            if (!item)
+                continue;
+            const normalized = String(item).toLowerCase();
+            if (normalized) {
+                set.add(normalized);
+            }
+        }
+    }
+    return Array.from(set);
+}

package/dist/router/virtual-router/default-thinking-keywords.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_THINKING_KEYWORDS: string[];

package/dist/router/virtual-router/default-thinking-keywords.js

@@ -0,0 +1,13 @@
+export const DEFAULT_THINKING_KEYWORDS = [
+    '思考',
+    '深度思考',
+    '分析',
+    '推理',
+    '思路',
+    '一步一步',
+    '慢慢',
+    'think',
+    'thinking',
+    'step by step',
+    'reason'
+];

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

@@ -1,3 +1,4 @@
+import { countRequestTokens } from './token-counter.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
 const WEB_TOOL_KEYWORDS = ['websearch', 'web_search', 'web-search', 'webfetch', 'web_fetch', 'web_request', 'search_web', 'internet_search'];
 export function buildRoutingFeatures(request, metadata) {
@@ -7,10 +8,11 @@ export function buildRoutingFeatures(request, metadata) {
     const normalizedUserText = latestUserText.toLowerCase();
     const hasTools = Array.isArray(request.tools) && request.tools.length > 0;
     const hasToolCallResponses = assistantMessages.some((msg) => Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0);
-    const estimatedTokens = estimateTokens(latestUserText, latestUserText ? 1 : 0);
+    const estimatedTokens = countRequestTokens(request);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
-    const hasVisionTool = detectVisionTool(request);
-    const hasImageAttachment = hasVisionTool && detectImageAttachment(latestUserMessage);
+    const previousToolCategory = detectPreviousToolCategory(request.messages);
+    const hasVisionTool = detectVisionTool(request) || previousToolCategory === 'vision';
+    const hasImageAttachment = previousToolCategory === 'vision' || (hasVisionTool && detectImageAttachment(latestUserMessage));
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
@@ -28,6 +30,7 @@ export function buildRoutingFeatures(request, metadata) {
         hasCodingTool,
         hasThinkingKeyword,
         estimatedTokens,
+        previousToolCategory,
         metadata: {
             ...metadata
         }
@@ -125,12 +128,111 @@ function detectExtendedThinkingKeyword(text) {
     const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
     return keywords.some((keyword) => text.includes(keyword));
 }
-function estimateTokens(text, messageCount) {
-    if (!text) {
-        return Math.max(32, messageCount * 16);
+function detectPreviousToolCategory(messages) {
+    if (!Array.isArray(messages) || !messages.length) {
+        return null;
+    }
+    let lastUserIndex = messages.length;
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        if (messages[idx]?.role === 'user') {
+            lastUserIndex = idx;
+            break;
+        }
+    }
+    for (let idx = lastUserIndex - 1; idx >= 0; idx -= 1) {
+        const candidate = messages[idx];
+        if (!candidate || candidate.role !== 'assistant') {
+            continue;
+        }
+        const messageRecord = candidate;
+        const rawCalls = Array.isArray(messageRecord.tool_calls)
+            ? messageRecord.tool_calls
+            : [];
+        if (!rawCalls.length) {
+            continue;
+        }
+        for (const call of rawCalls) {
+            const categorized = categorizeToolCall(call);
+            if (categorized) {
+                return categorized;
+            }
+        }
+    }
+    return null;
+}
+function categorizeToolCall(call) {
+    if (!call) {
+        return null;
+    }
+    const fn = (call.function ?? call);
+    const name = typeof (fn?.name ?? call.name) === 'string' ? String(fn?.name ?? call.name) : '';
+    if (!name) {
+        return null;
+    }
+    const args = parseFunctionArguments(typeof fn?.arguments === 'string' ? fn.arguments : undefined);
+    if (name === 'update_plan') {
+        return 'plan';
+    }
+    if (name === 'view_image') {
+        return hasImageLink(args) ? 'vision' : null;
+    }
+    if (name === 'apply_patch') {
+        return 'coding';
     }
-    const rough = Math.ceil(text.length / 4);
-    return Math.max(rough, messageCount * 32);
+    if (name === 'shell_command') {
+        const command = typeof args?.command === 'string' ? args.command : '';
+        return classifyShellCommand(command);
+    }
+    return null;
+}
+function parseFunctionArguments(raw) {
+    if (!raw) {
+        return null;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+const CONTEXT_READ_PATTERNS = [
+    /\brg\b/i,
+    /\bsed\b/i,
+    /\bcat\b/i,
+    /\btail\b/i,
+    /\bhead\b/i,
+    /\bls\b/i,
+    /\bwc\b/i,
+    /\bgrep\b/i,
+    /node\s+-\s*<<['"]/i,
+    /python\s+-\s*<<['"]/i
+];
+function classifyShellCommand(command) {
+    if (!command) {
+        return null;
+    }
+    const normalized = command.trim();
+    if (!normalized) {
+        return null;
+    }
+    if (CONTEXT_READ_PATTERNS.some((pattern) => pattern.test(normalized))) {
+        return 'context_read';
+    }
+    return null;
+}
+const IMAGE_LINK_KEYS = ['imagePath', 'path', 'filepath', 'file', 'url', 'image', 'src'];
+function hasImageLink(args) {
+    if (!args || typeof args !== 'object') {
+        return false;
+    }
+    for (const key of IMAGE_LINK_KEYS) {
+        const value = args[key];
+        if (typeof value === 'string' && value.trim()) {
+            return true;
+        }
+    }
+    return false;
 }
 function extractToolName(tool) {
     if (!tool || typeof tool !== 'object') {

package/dist/router/virtual-router/token-counter.d.ts

@@ -0,0 +1,2 @@
+import type { StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare function countRequestTokens(request: StandardizedRequest): number;

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

@@ -0,0 +1,105 @@
+import { encoding_for_model, get_encoding } from 'tiktoken';
+const DEFAULT_ENCODING = 'cl100k_base';
+const encoderCache = new Map();
+let defaultEncoder = null;
+function getEncoder(model) {
+    if (model) {
+        const normalized = model.trim();
+        if (encoderCache.has(normalized)) {
+            return encoderCache.get(normalized);
+        }
+        try {
+            const encoder = encoding_for_model(normalized);
+            encoderCache.set(normalized, encoder);
+            return encoder;
+        }
+        catch {
+            // fall back to default encoder
+        }
+    }
+    if (!defaultEncoder) {
+        defaultEncoder = get_encoding(DEFAULT_ENCODING);
+    }
+    return defaultEncoder;
+}
+export function countRequestTokens(request) {
+    const encoder = getEncoder(request.model);
+    let total = 0;
+    for (const message of request.messages || []) {
+        total += countMessageTokens(message, encoder);
+    }
+    if (Array.isArray(request.tools)) {
+        for (const tool of request.tools) {
+            total += encodeText(JSON.stringify(tool ?? {}), encoder);
+        }
+    }
+    if (request.parameters) {
+        total += encodeText(JSON.stringify(request.parameters), encoder);
+    }
+    if (request.metadata) {
+        total += encodeText(JSON.stringify(request.metadata), encoder);
+    }
+    return total;
+}
+function countMessageTokens(message, encoder) {
+    let total = 0;
+    total += encodeText(message.role, encoder);
+    total += encodeContent(message.content, encoder);
+    if (Array.isArray(message.tool_calls)) {
+        for (const call of message.tool_calls) {
+            total += encodeText(JSON.stringify(call ?? {}), encoder);
+        }
+    }
+    if (Array.isArray(message.metadata?.toolRuns)) {
+        total += encodeText(JSON.stringify(message.metadata?.toolRuns), encoder);
+    }
+    if (message.name) {
+        total += encodeText(message.name, encoder);
+    }
+    if (message.metadata) {
+        total += encodeText(JSON.stringify(message.metadata), encoder);
+    }
+    if (message.tool_call_id) {
+        total += encodeText(message.tool_call_id, encoder);
+    }
+    return total;
+}
+function encodeContent(content, encoder) {
+    if (content === null || content === undefined) {
+        return 0;
+    }
+    if (typeof content === 'string') {
+        return encodeText(content, encoder);
+    }
+    if (Array.isArray(content)) {
+        let total = 0;
+        for (const part of content) {
+            if (typeof part === 'string') {
+                total += encodeText(part, encoder);
+            }
+            else if (part && typeof part === 'object') {
+                if (typeof part.text === 'string') {
+                    total += encodeText(part.text, encoder);
+                }
+                else {
+                    total += encodeText(JSON.stringify(part), encoder);
+                }
+            }
+        }
+        return total;
+    }
+    if (typeof content === 'object') {
+        return encodeText(JSON.stringify(content), encoder);
+    }
+    return encodeText(String(content), encoder);
+}
+function encodeText(value, encoder) {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    const text = typeof value === 'string' ? value : String(value);
+    if (!text.trim()) {
+        return 0;
+    }
+    return encoder.encode(text).length;
+}

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

@@ -5,6 +5,7 @@ import type { StandardizedRequest } from '../../conversion/hub/types/standardize
 export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
 export type RoutingPools = Record<string, string[]>;
+export type PreviousToolCategory = 'context_read' | 'plan' | 'vision' | 'coding';
 export interface ProviderAuthConfig {
     type: 'apiKey' | 'oauth';
     secretRef?: string;
@@ -47,12 +48,14 @@ export interface ProviderRuntimeProfile {
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
 }
+export type RouteKeywordCategory = 'thinking' | 'background' | 'vision' | 'coding';
 export interface VirtualRouterClassifierConfig {
     longContextThresholdTokens?: number;
     thinkingKeywords?: string[];
     codingKeywords?: string[];
     backgroundKeywords?: string[];
     visionKeywords?: string[];
+    keywordInjections?: Partial<Record<RouteKeywordCategory, string[]>>;
 }
 export interface LoadBalancingPolicy {
     strategy: 'round-robin' | 'weighted' | 'sticky';
@@ -111,6 +114,7 @@ export interface RoutingFeatures {
     hasCodingTool: boolean;
     hasThinkingKeyword: boolean;
     estimatedTokens: number;
+    previousToolCategory?: PreviousToolCategory | null;
     metadata: RouterMetadataInput;
 }
 export interface ClassificationResult {

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

@@ -3,12 +3,12 @@
  */
 export const DEFAULT_ROUTE = 'default';
 export const ROUTE_PRIORITY = [
+    'longcontext',
+    'thinking',
     'vision',
     'websearch',
     'coding',
     'tools',
-    'longcontext',
-    'thinking',
     'background',
     DEFAULT_ROUTE
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.006",
+  "version": "0.6.034",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",