@jsonstudio/llms 0.6.34 → 0.6.54

package/dist/conversion/shared/tool-canonicalizer.js

@@ -12,133 +12,31 @@ function repairArgumentsToString(args) {
         return String(args);
     }
 }
-function extractStringContent(value) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        const parts = [];
-        for (const entry of value) {
-            if (typeof entry === 'string') {
-                parts.push(entry);
-            }
-            else if (entry && typeof entry === 'object') {
-                const text = entry.text;
-                if (typeof text === 'string') {
-                    parts.push(text);
-                }
-            }
-        }
-        if (parts.length) {
-            return parts.join('\n');
-        }
-    }
-    return null;
-}
-function readApplyPatchArgument(args) {
-    if (!args || typeof args !== 'object')
-        return undefined;
-    const input = args.input;
-    if (typeof input === 'string' && input.trim().length > 0) {
-        return input;
-    }
-    const legacy = args.patch;
-    if (typeof legacy === 'string' && legacy.trim().length > 0) {
-        return legacy;
-    }
-    return undefined;
-}
-function hasApplyPatchInput(argText) {
-    if (!argText) {
-        return false;
-    }
-    try {
-        const parsed = JSON.parse(argText);
-        const content = readApplyPatchArgument(parsed);
-        return typeof content === 'string' && content.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-function extractUnifiedDiff(content) {
-    if (!content)
-        return undefined;
-    const begin = content.indexOf('*** Begin Patch');
-    const end = content.indexOf('*** End Patch');
-    if (begin >= 0 && end > begin) {
-        return content.slice(begin, end + '*** End Patch'.length).trim();
-    }
-    return undefined;
-}
-function createToolCallId() {
-    return `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-}
 export function canonicalizeChatResponseTools(payload) {
     try {
         const out = isObject(payload) ? JSON.parse(JSON.stringify(payload)) : payload;
         const choices = Array.isArray(out?.choices) ? out.choices : [];
         for (const ch of choices) {
             const msg = ch && ch.message ? ch.message : undefined;
-            const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : undefined;
-            const hasToolCalls = Array.isArray(toolCalls) && toolCalls.length > 0;
-            const originalContentText = extractStringContent(msg?.content);
-            const harvestedPatch = typeof originalContentText === 'string' ? extractUnifiedDiff(originalContentText) : undefined;
-            if (hasToolCalls) {
-                // ensure arguments is string and content is null when tool_calls present
-                try {
-                    if (!ch.finish_reason)
-                        ch.finish_reason = 'tool_calls';
-                }
-                catch { /* ignore */ }
-                try {
-                    if (msg && typeof msg === 'object')
-                        msg.content = null;
-                }
-                catch { /* ignore */ }
-                for (const tc of toolCalls) {
-                    try {
-                        const fn = tc && tc.function ? tc.function : undefined;
-                        if (fn) {
-                            const repaired = repairArgumentsToString(fn.arguments);
-                            let nextArgs = repaired;
-                            try {
-                                const parsed = JSON.parse(repaired);
-                                const diffText = readApplyPatchArgument(parsed);
-                                if (typeof diffText === 'string' && diffText.trim().length > 0) {
-                                    nextArgs = JSON.stringify({ input: diffText });
-                                }
-                            }
-                            catch {
-                                // fallback to repaired string
-                            }
-                            fn.arguments = nextArgs;
-                            if (typeof fn.name === 'string' &&
-                                fn.name === 'apply_patch' &&
-                                !hasApplyPatchInput(fn.arguments) &&
-                                harvestedPatch) {
-                                fn.arguments = JSON.stringify({ input: harvestedPatch });
-                            }
-                        }
-                    }
-                    catch { /* ignore */ }
-                }
+            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+            if (!tcs || !tcs.length)
                 continue;
+            // ensure arguments is string and content is null when tool_calls present
+            try {
+                if (!ch.finish_reason)
+                    ch.finish_reason = 'tool_calls';
             }
-            if (harvestedPatch) {
-                const id = createToolCallId();
-                const toolCall = {
-                    id,
-                    type: 'function',
-                    function: {
-                        name: 'apply_patch',
-                        arguments: JSON.stringify({ input: harvestedPatch })
-                    }
-                };
-                try {
-                    msg.tool_calls = [toolCall];
+            catch { /* ignore */ }
+            try {
+                if (msg && typeof msg === 'object')
                     msg.content = null;
-                    ch.finish_reason = 'tool_calls';
+            }
+            catch { /* ignore */ }
+            for (const tc of tcs) {
+                try {
+                    const fn = tc && tc.function ? tc.function : undefined;
+                    if (fn)
+                        fn.arguments = repairArgumentsToString(fn.arguments);
                 }
                 catch { /* ignore */ }
             }

package/dist/conversion/shared/tool-mapping.js

@@ -15,28 +15,6 @@ const DEFAULT_SANITIZER = (value) => {
     }
     return undefined;
 };
-const APPLY_PATCH_TOOL_NAME = 'apply_patch';
-const APPLY_PATCH_ARG_KEY = 'input';
-function isApplyPatchTool(name) {
-    return typeof name === 'string' && name.trim() === APPLY_PATCH_TOOL_NAME;
-}
-function buildApplyPatchParameters() {
-    return {
-        type: 'object',
-        properties: {
-            [APPLY_PATCH_ARG_KEY]: {
-                type: 'string',
-                description: 'Unified diff patch content (*** Begin Patch ... *** End Patch)'
-            }
-        },
-        required: [APPLY_PATCH_ARG_KEY],
-        additionalProperties: false
-    };
-}
-function applyPatchSchemaToFunction(fnNode) {
-    fnNode.parameters = buildApplyPatchParameters();
-    fnNode.strict = true;
-}
 function resolveToolName(candidate, options) {
     const sanitized = options?.sanitizeName?.(candidate);
     if (typeof sanitized === 'string' && sanitized.trim().length) {
@@ -102,9 +80,6 @@ export function bridgeToolToChatDefinition(rawTool, options) {
     if (strict !== undefined) {
         fnOut.strict = strict;
     }
-    if (isApplyPatchTool(name)) {
-        applyPatchSchemaToFunction(fnOut);
-    }
     return {
         type: normalizedType,
         function: fnOut
@@ -156,11 +131,6 @@ export function chatToolToBridgeDefinition(rawTool, options) {
     if (strict !== undefined) {
         fnOut.strict = strict;
     }
-    if (isApplyPatchTool(name)) {
-        applyPatchSchemaToFunction(fnOut);
-        responseShape.parameters = buildApplyPatchParameters();
-        responseShape.strict = true;
-    }
     responseShape.function = fnOut;
     return responseShape;
 }

package/dist/filters/config/openai-openai.fieldmap.json

@@ -0,0 +1,18 @@
+{
+    "request": [
+        {
+            "sourcePath": "messages[*].tool_calls[*].function.arguments",
+            "targetPath": "messages[*].tool_calls[*].function.arguments",
+            "type": "string",
+            "transform": "stringifyJson"
+        }
+    ],
+    "response": [
+        {
+            "sourcePath": "choices[*].message.tool_calls[*].function.arguments",
+            "targetPath": "choices[*].message.tool_calls[*].function.arguments",
+            "type": "string",
+            "transform": "stringifyJson"
+        }
+    ]
+}

package/dist/index.d.ts

@@ -7,5 +7,4 @@
 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,5 +7,4 @@
 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,13 +1,10 @@
 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: 180000,
-    thinkingKeywords: DEFAULT_THINKING_KEYWORDS,
+    thinkingKeywords: ['think step', 'analysis', 'reasoning', '仔细分析', '深度思考'],
     codingKeywords: ['apply_patch', 'write_file', 'create_file', 'shell', '修改文件', '写入文件'],
     backgroundKeywords: ['background', 'context dump', '上下文'],
-    visionKeywords: ['vision', 'image', 'picture', 'photo'],
-    keywordInjections: {}
+    visionKeywords: ['vision', 'image', 'picture', 'photo']
 };
 const DEFAULT_LOAD_BALANCING = { strategy: 'round-robin' };
 const DEFAULT_HEALTH = { failureThreshold: 3, cooldownMs: 30_000, fatalCooldownMs: 300_000 };
@@ -189,8 +186,7 @@ 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),
-        keywordInjections: normalizeKeywordInjectionMap(normalized.keywordInjections)
+        visionKeywords: normalizeStringArray(normalized.visionKeywords, DEFAULT_CLASSIFIER.visionKeywords)
     };
     return result;
 }
@@ -201,26 +197,6 @@ 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);
@@ -232,7 +208,7 @@ function normalizeProvider(providerId, raw) {
                 ? provider.baseUrl.trim()
                 : '';
     const headers = normalizeHeaders(provider.headers);
-    const compatibilityProfile = resolveCompatibilityProfile(provider);
+    const compatibilityProfile = resolveCompatibilityProfile(providerId, provider);
     const responsesConfig = normalizeResponsesConfig(provider);
     const processMode = normalizeProcessMode(provider.process);
     return {
@@ -257,12 +233,21 @@ function normalizeResponsesConfig(provider) {
     }
     return undefined;
 }
-function resolveCompatibilityProfile(provider) {
-    const profile = readOptionalString(provider.compatibilityProfile);
-    if (profile) {
-        return profile;
+function resolveCompatibilityProfile(providerId, provider) {
+    if (typeof provider.compatibilityProfile === 'string' && provider.compatibilityProfile.trim()) {
+        return provider.compatibilityProfile.trim();
+    }
+    const legacyFields = [];
+    if (typeof provider.compat === 'string') {
+        legacyFields.push('compat');
+    }
+    if (typeof provider.compatibility_profile === 'string') {
+        legacyFields.push('compatibility_profile');
+    }
+    if (legacyFields.length > 0) {
+        throw new VirtualRouterError(`Provider "${providerId}" uses legacy compatibility field(s): ${legacyFields.join(', ')}. Rename to "compatibilityProfile".`, VirtualRouterErrorCode.CONFIG_ERROR);
     }
-    return 'default';
+    return 'compat:passthrough';
 }
 function normalizeProcessMode(value) {
     if (typeof value !== 'string') {

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

@@ -1,73 +1,67 @@
 import { DEFAULT_ROUTE, ROUTE_PRIORITY } from './types.js';
-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: keywordConfig.thinking,
-            backgroundKeywords: keywordConfig.background,
-            visionKeywords: keywordConfig.vision,
-            codingKeywords: keywordConfig.coding
+            thinkingKeywords: normalizeList(config.thinkingKeywords, ['think step', 'analysis', 'reasoning']),
+            backgroundKeywords: normalizeList(config.backgroundKeywords, ['background', 'context dump'])
         };
     }
     classify(features) {
-        const evaluations = [
-            {
-                route: 'longcontext',
-                triggered: features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD),
-                reason: 'longcontext:token-threshold'
+        const lastToolCategory = features.lastAssistantToolCategory;
+        const reachedLongContext = features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD);
+        const thinkingKeywordHit = features.hasThinkingKeyword ||
+            containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []);
+        const codingContinuation = lastToolCategory === 'write';
+        const thinkingContinuation = lastToolCategory === 'read';
+        const searchContinuation = lastToolCategory === 'search';
+        const toolsContinuation = lastToolCategory === 'other';
+        const evaluationMap = {
+            vision: {
+                triggered: features.hasVisionTool && features.hasImageAttachment,
+                reason: 'vision:requires-tool+image'
             },
-            {
-                route: 'thinking',
-                triggered: features.hasThinkingKeyword ||
-                    containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []) ||
-                    features.previousToolCategory === 'context_read' ||
-                    features.previousToolCategory === 'plan',
-                reason: 'thinking:keywords'
+            longcontext: {
+                triggered: reachedLongContext,
+                reason: 'longcontext:token-threshold'
             },
-            {
-                route: 'background',
-                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
-                reason: 'background:keywords'
+            websearch: {
+                triggered: features.hasWebTool || searchContinuation,
+                reason: searchContinuation ? 'websearch:last-tool-search' : 'websearch:web-tools-detected'
             },
-            {
-                route: 'vision',
-                triggered: (features.hasVisionTool && features.hasImageAttachment) ||
-                    features.previousToolCategory === 'vision',
-                reason: 'vision:requires-tool+image'
+            coding: {
+                triggered: codingContinuation,
+                reason: 'coding:last-tool-write'
             },
-            {
-                route: 'websearch',
-                triggered: features.hasWebTool,
-                reason: 'websearch:web-tools-detected'
+            thinking: {
+                triggered: thinkingContinuation || thinkingKeywordHit,
+                reason: thinkingContinuation ? 'thinking:last-tool-read' : 'thinking:keywords'
             },
-            {
-                route: 'coding',
-                triggered: features.hasCodingTool ||
-                    containsKeywords(features.userTextSample, this.config.codingKeywords ?? []) ||
-                    features.previousToolCategory === 'coding',
-                reason: 'coding:coding-tools-detected'
+            tools: {
+                triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,
+                reason: toolsContinuation ? 'tools:last-tool-other' : 'tools:tool-request-detected'
             },
-            {
-                route: 'tools',
-                triggered: features.hasTools || features.hasToolCallResponses,
-                reason: 'tools:tool-request-detected'
+            background: {
+                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
+                reason: 'background:keywords'
+            }
+        };
+        for (const routeName of ROUTE_PRIORITY) {
+            const evaluation = evaluationMap[routeName];
+            if (evaluation && evaluation.triggered) {
+                const candidates = this.ensureDefaultCandidate([routeName]);
+                return this.buildResult(routeName, evaluation.reason, evaluationMap, candidates);
             }
-        ];
-        const triggeredEvaluations = evaluations.filter((evaluation) => evaluation.triggered);
-        const orderedRoutes = this.orderRoutes(triggeredEvaluations.map((entry) => entry.route));
-        const chosenRoute = orderedRoutes.length ? orderedRoutes[0] : DEFAULT_ROUTE;
-        const chosenReason = triggeredEvaluations.find((entry) => entry.route === chosenRoute)?.reason || 'fallback:default';
-        const candidates = this.ensureDefaultCandidate(orderedRoutes);
-        return this.buildResult(chosenRoute, chosenReason, evaluations, candidates);
+        }
+        const candidates = this.ensureDefaultCandidate([DEFAULT_ROUTE]);
+        return this.buildResult(DEFAULT_ROUTE, 'fallback:default', evaluationMap, candidates);
     }
     buildResult(routeName, chosenReason, evaluations, candidates) {
-        const diagnostics = evaluations
-            .filter((evaluation) => evaluation.triggered)
-            .map((evaluation) => evaluation.reason);
+        const diagnostics = Object.entries(evaluations)
+            .filter(([_, evaluation]) => evaluation.triggered)
+            .map(([_, evaluation]) => evaluation.reason);
         const reasoningParts = [chosenReason, ...diagnostics.filter((reason) => reason !== chosenReason)];
         return {
             routeName,
@@ -93,6 +87,12 @@ 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;
@@ -100,29 +100,3 @@ 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);
-}