@jsonstudio/llms 0.6.6 → 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/router/virtual-router/bootstrap.js

@@ -1,6 +1,6 @@
 import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
 const DEFAULT_CLASSIFIER = {
-    longContextThresholdTokens: 60000,
+    longContextThresholdTokens: 180000,
     thinkingKeywords: ['think step', 'analysis', 'reasoning', '仔细分析', '深度思考'],
     codingKeywords: ['apply_patch', 'write_file', 'create_file', 'shell', '修改文件', '写入文件'],
     backgroundKeywords: ['background', 'context dump', '上下文'],
@@ -208,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 {
@@ -233,12 +233,21 @@ function normalizeResponsesConfig(provider) {
     }
     return undefined;
 }
-function resolveCompatibilityProfile(provider) {
-    const compat = provider.compat;
-    if (typeof compat === 'string' && compat.trim().length > 0) {
-        return compat.trim();
+function resolveCompatibilityProfile(providerId, provider) {
+    if (typeof provider.compatibilityProfile === 'string' && provider.compatibilityProfile.trim()) {
+        return provider.compatibilityProfile.trim();
     }
-    return 'default';
+    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 'compat:passthrough';
 }
 function normalizeProcessMode(value) {
     if (typeof value !== 'string') {

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

@@ -1,5 +1,5 @@
 import { DEFAULT_ROUTE, ROUTE_PRIORITY } from './types.js';
-const DEFAULT_LONG_CONTEXT_THRESHOLD = 60000;
+const DEFAULT_LONG_CONTEXT_THRESHOLD = 180000;
 export class RoutingClassifier {
     config;
     constructor(config) {
@@ -10,55 +10,58 @@ export class RoutingClassifier {
         };
     }
     classify(features) {
-        const evaluations = [
-            {
-                route: 'vision',
+        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: 'websearch',
-                triggered: features.hasWebTool,
-                reason: 'websearch:web-tools-detected'
+            longcontext: {
+                triggered: reachedLongContext,
+                reason: 'longcontext:token-threshold'
             },
-            {
-                route: 'coding',
-                triggered: features.hasCodingTool,
-                reason: 'coding:coding-tools-detected'
+            websearch: {
+                triggered: features.hasWebTool || searchContinuation,
+                reason: searchContinuation ? 'websearch:last-tool-search' : 'websearch:web-tools-detected'
             },
-            {
-                route: 'tools',
-                triggered: features.hasTools || features.hasToolCallResponses,
-                reason: 'tools:tool-request-detected'
+            coding: {
+                triggered: codingContinuation,
+                reason: 'coding:last-tool-write'
             },
-            {
-                route: 'longcontext',
-                triggered: features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD),
-                reason: 'longcontext:token-threshold'
+            thinking: {
+                triggered: thinkingContinuation || thinkingKeywordHit,
+                reason: thinkingContinuation ? 'thinking:last-tool-read' : 'thinking:keywords'
             },
-            {
-                route: 'thinking',
-                triggered: features.hasThinkingKeyword ||
-                    containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []),
-                reason: 'thinking:keywords'
+            tools: {
+                triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,
+                reason: toolsContinuation ? 'tools:last-tool-other' : 'tools:tool-request-detected'
             },
-            {
-                route: 'background',
+            background: {
                 triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
                 reason: 'background:keywords'
             }
-        ];
-        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);
+        };
+        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 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,

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'
+];