@jsonstudio/llms 0.6.34 → 0.6.74

package/dist/conversion/shared/text-markup-normalizer.js

@@ -95,10 +95,10 @@ export function extractApplyPatchCallsFromText(text) {
                     continue;
                 let argsStr = '{}';
                 try {
-                    argsStr = JSON.stringify({ input: patch });
+                    argsStr = JSON.stringify({ patch });
                 }
                 catch {
-                    argsStr = '{"input":""}';
+                    argsStr = '{"patch":""}';
                 }
                 out.push({ id: genId(), name: 'apply_patch', args: argsStr });
             }

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-filter-pipeline.js

@@ -1,6 +1,30 @@
 import { FilterEngine } from '../../filters/index.js';
 import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
 import { createSnapshotWriter } from './snapshot-utils.js';
+const REQUEST_FILTER_STAGES = [
+    'request_pre',
+    'request_map',
+    'request_post',
+    'request_finalize'
+];
+const RESPONSE_FILTER_STAGES = [
+    'response_pre',
+    'response_map',
+    'response_post',
+    'response_finalize'
+];
+function assertStageCoverage(label, registeredStages, skeletonStages) {
+    const allowed = new Set(skeletonStages);
+    const uncovered = [];
+    for (const stage of registeredStages) {
+        if (!allowed.has(stage)) {
+            uncovered.push(stage);
+        }
+    }
+    if (uncovered.length) {
+        throw new Error(`[tool-filter-pipeline] ${label}: registered filter stage(s) not covered by skeleton: ${uncovered.join(', ')}`);
+    }
+}
 export async function runChatRequestToolFilters(chatRequest, options = {}) {
     const reqCtxBase = {
         requestId: options.requestId ?? `req_${Date.now()}`,
@@ -23,22 +47,27 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
     };
     recordStage('req_process_tool_filters_input', chatRequest);
     const engine = new FilterEngine();
+    const registeredStages = new Set();
+    const register = (filter) => {
+        registeredStages.add(filter.stage);
+        engine.registerFilter(filter);
+    };
     const profile = (reqCtxBase.profile || '').toLowerCase();
     const endpoint = (reqCtxBase.endpoint || '').toLowerCase();
     const isAnthropic = profile === 'anthropic-messages' || endpoint.includes('/v1/messages');
     if (!isAnthropic) {
         try {
             const { RequestToolListFilter } = await import('../../filters/index.js');
-            engine.registerFilter(new RequestToolListFilter());
+            register(new RequestToolListFilter());
         }
         catch {
             /* optional */
         }
     }
     const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } = await import('../../filters/index.js');
-    engine.registerFilter(new RequestToolCallsStringifyFilter());
+    register(new RequestToolCallsStringifyFilter());
     if (!isAnthropic) {
-        engine.registerFilter(new RequestToolChoicePolicyFilter());
+        register(new RequestToolChoicePolicyFilter());
     }
     try {
         const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
@@ -52,12 +81,20 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
         } })());
     }
     catch { /* ignore */ }
-    let staged = await engine.run('request_pre', chatRequest, reqCtxBase);
-    recordStage('req_process_tool_filters_request_pre', staged);
-    staged = await engine.run('request_map', staged, reqCtxBase);
-    recordStage('req_process_tool_filters_request_map', staged);
-    staged = await engine.run('request_post', staged, reqCtxBase);
-    recordStage('req_process_tool_filters_request_post', staged);
+    try {
+        const { RequestOpenAIToolsNormalizeFilter, ToolPostConstraintsFilter } = await import('../../filters/index.js');
+        register(new RequestOpenAIToolsNormalizeFilter());
+        register(new ToolPostConstraintsFilter('request_finalize'));
+    }
+    catch {
+        // optional; keep prior behavior when filter not available
+    }
+    assertStageCoverage('request', registeredStages, REQUEST_FILTER_STAGES);
+    let staged = chatRequest;
+    for (const stage of REQUEST_FILTER_STAGES) {
+        staged = await engine.run(stage, staged, reqCtxBase);
+        recordStage(`req_process_tool_filters_${stage}`, staged);
+    }
     recordStage('req_process_tool_filters_output', staged);
     return staged;
 }
@@ -81,20 +118,25 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
     };
     recordStage('resp_process_tool_filters_input', chatJson);
     const engine = new FilterEngine();
+    const registeredStages = new Set();
+    const register = (filter) => {
+        registeredStages.add(filter.stage);
+        engine.registerFilter(filter);
+    };
     const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } = await import('../../filters/index.js');
-    engine.registerFilter(new ResponseToolTextCanonicalizeFilter());
+    register(new ResponseToolTextCanonicalizeFilter());
     try {
         const { ResponseToolArgumentsToonDecodeFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
-        engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter());
+        register(new ResponseToolArgumentsToonDecodeFilter());
         try {
-            engine.registerFilter(new ResponseToolArgumentsSchemaConvergeFilter());
+            register(new ResponseToolArgumentsSchemaConvergeFilter());
         }
         catch { /* optional */ }
-        engine.registerFilter(new ResponseToolArgumentsBlacklistFilter());
+        register(new ResponseToolArgumentsBlacklistFilter());
     }
     catch { /* optional */ }
-    engine.registerFilter(new ResponseToolArgumentsStringifyFilter());
-    engine.registerFilter(new ResponseFinishInvariantsFilter());
+    register(new ResponseToolArgumentsStringifyFilter());
+    register(new ResponseFinishInvariantsFilter());
     try {
         const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
         if (cfg)
@@ -107,12 +149,12 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
         } })());
     }
     catch { /* ignore */ }
-    let staged = await engine.run('response_pre', chatJson, resCtxBase);
-    recordStage('resp_process_tool_filters_response_pre', staged);
-    staged = await engine.run('response_map', staged, resCtxBase);
-    recordStage('resp_process_tool_filters_response_map', staged);
-    staged = await engine.run('response_post', staged, resCtxBase);
-    recordStage('resp_process_tool_filters_response_post', staged);
+    assertStageCoverage('response', registeredStages, RESPONSE_FILTER_STAGES);
+    let staged = chatJson;
+    for (const stage of RESPONSE_FILTER_STAGES) {
+        staged = await engine.run(stage, staged, resCtxBase);
+        recordStage(`resp_process_tool_filters_${stage}`, staged);
+    }
     recordStage('resp_process_tool_filters_output', staged);
     return staged;
 }

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

@@ -8,6 +8,56 @@ export function stringifyArgs(args) {
         return String(args);
     }
 }
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function clonePlainObject(value) {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return { ...value };
+    }
+}
+function asSchema(value) {
+    if (isPlainObject(value)) {
+        return clonePlainObject(value);
+    }
+    return undefined;
+}
+function ensureApplyPatchSchema(seed) {
+    const schema = seed ? { ...seed } : {};
+    schema.type = typeof schema.type === 'string' ? schema.type : 'object';
+    const properties = isPlainObject(schema.properties) ? { ...schema.properties } : {};
+    properties.input = {
+        type: 'string',
+        description: 'Unified diff patch body between *** Begin Patch/*** End Patch.'
+    };
+    if (!properties.patch || typeof properties.patch !== 'object') {
+        properties.patch = {
+            type: 'string',
+            description: 'Alias of input for backwards compatibility.'
+        };
+    }
+    schema.properties = properties;
+    const requiredList = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === 'string') : [];
+    if (!requiredList.includes('input')) {
+        requiredList.push('input');
+    }
+    schema.required = requiredList;
+    if (typeof schema.additionalProperties !== 'boolean') {
+        schema.additionalProperties = false;
+    }
+    return schema;
+}
+function enforceBuiltinToolSchema(name, candidate) {
+    const normalizedName = typeof name === 'string' ? name.trim().toLowerCase() : '';
+    if (normalizedName === 'apply_patch') {
+        const base = asSchema(candidate);
+        return ensureApplyPatchSchema(base);
+    }
+    return asSchema(candidate);
+}
 const DEFAULT_SANITIZER = (value) => {
     if (typeof value === 'string') {
         const trimmed = value.trim();
@@ -15,28 +65,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) {
@@ -88,7 +116,7 @@ export function bridgeToolToChatDefinition(rawTool, options) {
         return null;
     }
     const description = resolveToolDescription(fnNode?.description ?? tool.description);
-    const parameters = resolveToolParameters(fnNode, tool);
+    const parameters = enforceBuiltinToolSchema(name, resolveToolParameters(fnNode, tool));
     const strict = resolveToolStrict(fnNode, tool);
     const rawType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
     const normalizedType = rawType.toLowerCase() === 'custom' ? 'function' : rawType;
@@ -102,9 +130,6 @@ export function bridgeToolToChatDefinition(rawTool, options) {
     if (strict !== undefined) {
         fnOut.strict = strict;
     }
-    if (isApplyPatchTool(name)) {
-        applyPatchSchemaToFunction(fnOut);
-    }
     return {
         type: normalizedType,
         function: fnOut
@@ -130,7 +155,7 @@ export function chatToolToBridgeDefinition(rawTool, options) {
         return null;
     }
     const description = resolveToolDescription(fnNode?.description);
-    const parameters = resolveToolParameters(fnNode, undefined);
+    const parameters = enforceBuiltinToolSchema(name, resolveToolParameters(fnNode, undefined));
     const strict = resolveToolStrict(fnNode, undefined);
     const normalizedType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
     const responseShape = {
@@ -156,11 +181,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/filters/special/request-tools-normalize.js

@@ -73,7 +73,7 @@ export class RequestOpenAIToolsNormalizeFilter {
                             delete dst.function.strict;
                     }
                     catch { /* ignore */ }
-                    // Switch schema for 'shell' at unified shaping point
+                    // Switch schema for specific built-in tools at unified shaping point
                     try {
                         const name = String(dst.function.name || '').toLowerCase();
                         if (name === 'shell') {
@@ -101,6 +101,25 @@ export class RequestOpenAIToolsNormalizeFilter {
                                 };
                             }
                         }
+                        else if (name === 'apply_patch') {
+                            dst.function.parameters = {
+                                type: 'object',
+                                properties: {
+                                    input: {
+                                        type: 'string',
+                                        description: 'Unified diff patch body between *** Begin Patch/*** End Patch.'
+                                    },
+                                    patch: {
+                                        type: 'string',
+                                        description: 'Alias of input for backwards compatibility.'
+                                    }
+                                },
+                                required: ['input'],
+                                additionalProperties: false
+                            };
+                            dst.function.description =
+                                'Use apply_patch to edit files. Provide the diff via the input field (*** Begin Patch ... *** End Patch).';
+                        }
                     }
                     catch { /* ignore */ }
                     finalTools.push(dst);

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') {