@jsonstudio/llms 0.6.467 → 0.6.567

package/dist/conversion/responses/responses-openai-bridge.js

@@ -21,7 +21,6 @@ function isObject(v) {
 // --- Public bridge functions ---
 export function captureResponsesContext(payload, dto) {
     const preservedInput = cloneBridgeEntries(payload.input);
-    ensureResponsesApplyPatchArguments(preservedInput);
     ensureBridgeInstructions(payload);
     const context = {
         requestId: dto?.route?.requestId,
@@ -398,76 +397,6 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     ensureBridgeInstructions(out);
     return { request: out, originalSystemMessages };
 }
-export function ensureResponsesApplyPatchArguments(input) {
-    if (!Array.isArray(input) || !input.length) {
-        return;
-    }
-    for (const entry of input) {
-        if (!entry || typeof entry !== 'object')
-            continue;
-        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
-        if (type !== 'function_call')
-            continue;
-        const name = (typeof entry.name === 'string' && entry.name.trim()) ||
-            (entry.function && typeof entry.function === 'object' && typeof entry.function.name === 'string' && entry.function.name.trim()) ||
-            '';
-        if (name !== 'apply_patch')
-            continue;
-        let normalized;
-        try {
-            normalized = normalizeApplyPatchArguments(entry.arguments ?? entry.function?.arguments);
-        }
-        catch {
-            // best-effort: do not fail the whole request due to a malformed historical tool call
-            normalized = undefined;
-        }
-        if (normalized === undefined) {
-            continue;
-        }
-        entry.arguments = normalized;
-        if (entry.function && typeof entry.function === 'object') {
-            entry.function.arguments = normalized;
-        }
-    }
-}
-function normalizeApplyPatchArguments(source) {
-    let parsed;
-    if (typeof source === 'string' && source.trim()) {
-        try {
-            parsed = JSON.parse(source);
-        }
-        catch {
-            parsed = { patch: source };
-        }
-    }
-    else if (source && typeof source === 'object') {
-        parsed = { ...source };
-    }
-    else if (source === undefined) {
-        parsed = {};
-    }
-    else {
-        return typeof source === 'string' ? source : undefined;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return typeof source === 'string' ? source : undefined;
-    }
-    const patchText = typeof parsed.patch === 'string' && parsed.patch.trim().length
-        ? parsed.patch
-        : typeof parsed.input === 'string' && parsed.input.trim().length
-            ? parsed.input
-            : undefined;
-    if (patchText) {
-        parsed.patch = patchText;
-        parsed.input = patchText;
-    }
-    try {
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return typeof source === 'string' ? source : undefined;
-    }
-}
 function readToolCallIdStyleFromContext(ctx) {
     if (!ctx) {
         return undefined;

package/dist/conversion/shared/gemini-tool-utils.js

@@ -12,6 +12,14 @@ function cloneParameters(value) {
     if (isPlainRecord(value)) {
         const cloned = {};
         for (const [key, entry] of Object.entries(value)) {
+            // Gemini function_declarations.parameters only support a subset of JSON Schema.
+            // Drop meta/unsupported fields that cause INVALID_ARGUMENT, such as $schema/exclusiveMinimum.
+            if (typeof key === 'string') {
+                if (key.startsWith('$'))
+                    continue;
+                if (key === 'exclusiveMinimum' || key === 'exclusiveMaximum')
+                    continue;
+            }
             cloned[key] = cloneParameters(entry);
         }
         return cloned;

package/dist/conversion/shared/responses-output-builder.js

@@ -177,47 +177,6 @@ function normalizeUsage(usageRaw) {
     }
     return usageRaw;
 }
-function extractApplyPatchArguments(rawArgs) {
-    // Upstream Responses providers may wrap apply_patch arguments in a JSON object
-    // (e.g. { patch: '*** Begin Patch...', input: '...' }). For Codex, the tool
-    // expects a FREEFORM patch string obeying the unified diff grammar. Here we
-    // best-effort extract such a patch string when available.
-    const tryExtractFromObject = (obj) => {
-        if (!obj || typeof obj !== 'object' || Array.isArray(obj))
-            return null;
-        const record = obj;
-        const candidates = ['patch', 'input'];
-        for (const key of candidates) {
-            const value = record[key];
-            if (typeof value !== 'string')
-                continue;
-            const trimmed = value.trimStart();
-            if (trimmed.startsWith('*** Begin Patch')) {
-                return trimmed;
-            }
-        }
-        return null;
-    };
-    if (typeof rawArgs === 'string') {
-        const trimmed = rawArgs.trimStart();
-        if (trimmed.startsWith('*** Begin Patch')) {
-            return trimmed;
-        }
-        try {
-            const parsed = JSON.parse(rawArgs);
-            const fromObject = tryExtractFromObject(parsed);
-            if (fromObject) {
-                return fromObject;
-            }
-        }
-        catch {
-            // non-JSON string that is not a patch header; leave to caller
-        }
-        return null;
-    }
-    const fromObject = tryExtractFromObject(rawArgs);
-    return fromObject;
-}
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {
         const fn = call?.function || {};
@@ -228,37 +187,16 @@ function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, b
         if (!sanitized || sanitized.toLowerCase() === 'tool')
             return null;
         const rawArgs = fn?.arguments ?? call.arguments ?? {};
-        let argsStr;
-        if (sanitized === 'apply_patch') {
-            const patch = extractApplyPatchArguments(rawArgs);
-            if (patch != null) {
-                argsStr = patch;
-            }
-            else if (typeof rawArgs === 'string') {
-                argsStr = rawArgs;
-            }
-            else {
+        const argsStr = typeof rawArgs === 'string'
+            ? rawArgs
+            : (() => {
                 try {
-                    argsStr = JSON.stringify(rawArgs ?? {});
+                    return JSON.stringify(rawArgs ?? {});
                 }
                 catch {
-                    argsStr = '{}';
+                    return '{}';
                 }
-            }
-        }
-        else {
-            argsStr =
-                typeof rawArgs === 'string'
-                    ? rawArgs
-                    : (() => {
-                        try {
-                            return JSON.stringify(rawArgs ?? {});
-                        }
-                        catch {
-                            return '{}';
-                        }
-                    })();
-        }
+            })();
         const originalCallId = typeof call.id === 'string' && call.id.trim().length
             ? String(call.id)
             : (typeof call.call_id === 'string' && call.call_id.trim().length ? String(call.call_id) : undefined);

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

@@ -3,6 +3,7 @@
 // canonicalizer 按需加载（避免在请求侧仅注入时引入不必要的模块）
 // enforceChatBudget: 为避免在请求侧引入多余依赖，这里提供最小实现（保留形状，不裁剪）。
 import { augmentOpenAITools } from '../../guidance/index.js';
+import { validateToolCall } from '../../tools/tool-registry.js';
 function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
 // Note: tool schema strict augmentation removed per alignment
 function enforceChatBudget(chat, _modelId) { return chat; }
@@ -173,8 +174,7 @@ export function processChatRequestTools(request, opts) {
                     continue;
                 const typeStr = String(t.type || '').toLowerCase();
                 const nameStr = typeof fn.name === 'string' ? String(fn.name).toLowerCase() : '';
-                const shouldPatch = typeStr === 'function' ||
-                    nameStr === 'apply_patch';
+                const shouldPatch = typeStr === 'function' || nameStr === 'apply_patch';
                 if (!shouldPatch)
                     continue;
                 if (!Object.prototype.hasOwnProperty.call(fn, 'parameters')) {
@@ -208,7 +208,8 @@ export function processChatRequestTools(request, opts) {
         catch { /* ignore */ }
         // 4) Enforce payload budget (context bytes) with minimal loss policy
         const modelId = typeof canonical?.model === 'string' ? String(canonical.model) : 'unknown';
-        return enforceChatBudget(canonical, modelId);
+        const budgeted = enforceChatBudget(canonical, modelId);
+        return normalizeApplyPatchToolCallsOnRequest(budgeted);
     }
     catch {
         return out;
@@ -219,6 +220,75 @@ export function processChatRequestTools(request, opts) {
  * - Canonicalize textual tool markup to tool_calls; ensure finish_reason and content=null policy
  */
 import { repairArgumentsToString, parseLenient } from './jsonish.js';
+function normalizeApplyPatchToolCallsOnResponse(chat) {
+    try {
+        const out = JSON.parse(JSON.stringify(chat));
+        const choices = Array.isArray(out?.choices) ? out.choices : [];
+        for (const ch of choices) {
+            const msg = ch && ch.message ? ch.message : undefined;
+            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+            if (!tcs.length)
+                continue;
+            for (const tc of tcs) {
+                try {
+                    const fn = tc && tc.function ? tc.function : undefined;
+                    const name = typeof fn?.name === 'string' ? String(fn.name).trim().toLowerCase() : '';
+                    if (name !== 'apply_patch')
+                        continue;
+                    const rawArgs = fn?.arguments;
+                    const argsStr = repairArgumentsToString(rawArgs);
+                    const validation = validateToolCall('apply_patch', argsStr);
+                    if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
+                        fn.arguments = validation.normalizedArgs;
+                    }
+                }
+                catch {
+                    // best-effort per tool_call
+                }
+            }
+        }
+        return out;
+    }
+    catch {
+        return chat;
+    }
+}
+function normalizeApplyPatchToolCallsOnRequest(request) {
+    try {
+        const out = JSON.parse(JSON.stringify(request));
+        const messages = Array.isArray(out?.messages) ? out.messages : [];
+        for (const msg of messages) {
+            if (!msg || typeof msg !== 'object')
+                continue;
+            if (msg.role !== 'assistant')
+                continue;
+            const tcs = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+            if (!tcs.length)
+                continue;
+            for (const tc of tcs) {
+                try {
+                    const fn = tc && tc.function ? tc.function : undefined;
+                    const name = typeof fn?.name === 'string' ? String(fn.name).trim().toLowerCase() : '';
+                    if (name !== 'apply_patch')
+                        continue;
+                    const rawArgs = fn?.arguments;
+                    const argsStr = repairArgumentsToString(rawArgs);
+                    const validation = validateToolCall('apply_patch', argsStr);
+                    if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
+                        fn.arguments = validation.normalizedArgs;
+                    }
+                }
+                catch {
+                    // best-effort per tool_call
+                }
+            }
+        }
+        return out;
+    }
+    catch {
+        return request;
+    }
+}
 function enhanceResponseToolArguments(chat) {
     try {
         const enable = String(process?.env?.RCC_TOOL_ENHANCE ?? '1').trim() !== '0';
@@ -336,7 +406,8 @@ export function processChatResponseTools(resp) {
     try {
         const { canonicalizeChatResponseTools } = require('./tool-canonicalizer.js');
         const canon = canonicalizeChatResponseTools(resp);
-        return enhanceResponseToolArguments(canon);
+        const withPatch = normalizeApplyPatchToolCallsOnResponse(canon);
+        return enhanceResponseToolArguments(withPatch);
     }
     catch {
         return resp;

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

@@ -29,20 +29,26 @@ 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 = {
+    delete properties.input;
+    delete properties.patch;
+    properties.patch = {
         type: 'string',
-        description: 'Unified diff patch body between *** Begin Patch/*** End Patch.'
+        description: 'Unified diff patch text. The first line MUST be exactly "*** Begin Patch", followed by one or more file sections starting with ' +
+            '"*** Add File: {path}", "*** Update File: {path}", or "*** Delete File: {path}", using hunks with lines prefixed by " ", "+", or "-". ' +
+            'The last non-empty line MUST be exactly "*** End Patch". Git-style headers like "--- a/file" / "+++ b/file" and merge markers ' +
+            '"<<<<<<<", "=======", ">>>>>>>" are NOT allowed.'
     };
-    if (!properties.patch || typeof properties.patch !== 'object') {
-        properties.patch = {
-            type: 'string',
-            description: 'Alias of input for backwards compatibility.'
+    if (!isPlainObject(properties.paths)) {
+        properties.paths = {
+            type: 'array',
+            description: 'Optional explicit list of relative file paths that the patch touches. Each entry must be a relative workspace path (packages/foo/file.ts).',
+            items: { type: 'string' }
         };
     }
     schema.properties = properties;
     const requiredList = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === 'string') : [];
-    if (!requiredList.includes('input')) {
-        requiredList.push('input');
+    if (!requiredList.includes('patch')) {
+        requiredList.push('patch');
     }
     schema.required = requiredList;
     if (typeof schema.additionalProperties !== 'boolean') {

package/dist/filters/special/request-toolcalls-stringify.js

@@ -27,12 +27,14 @@ export class RequestToolCallsStringifyFilter {
                             const fnName = typeof fn.name === 'string' ? fn.name.trim() : '';
                             // Case 1: non-string arguments → stringify directly
                             if (currentArgs !== undefined && typeof currentArgs !== 'string') {
+                                let argsJson = '{}';
                                 try {
-                                    fn.arguments = JSON.stringify(currentArgs ?? {});
+                                    argsJson = JSON.stringify(currentArgs ?? {});
                                 }
                                 catch {
-                                    fn.arguments = '{}';
+                                    argsJson = '{}';
                                 }
+                                fn.arguments = argsJson;
                                 tc.function = fn;
                                 continue;
                             }
@@ -61,9 +63,6 @@ export class RequestToolCallsStringifyFilter {
                                         if (fnName === 'shell') {
                                             fn.arguments = JSON.stringify({ command: currentArgs });
                                         }
-                                        else if (fnName === 'apply_patch') {
-                                            fn.arguments = JSON.stringify({ patch: currentArgs });
-                                        }
                                         else {
                                             fn.arguments = JSON.stringify({ input: currentArgs });
                                         }
@@ -74,56 +73,7 @@ export class RequestToolCallsStringifyFilter {
                                     tc.function = fn;
                                     continue;
                                 }
-                                // 已经是合法 JSON 的场景下，仅对特定工具做形状修复。
-                                if (parsedOk && fnName === 'apply_patch') {
-                                    try {
-                                        let obj = parsedValue;
-                                        // 1) 若整体是字符串，则视为补丁文本
-                                        if (typeof obj === 'string') {
-                                            obj = { patch: obj };
-                                        }
-                                        if (obj && typeof obj === 'object') {
-                                            const container = obj;
-                                            const rawPatch = container.patch;
-                                            const rawInput = container.input;
-                                            // 2) 若 patch 是形如 JSON 的字符串，尝试解包 {"input": "..."} 或 {"patch": "..."}
-                                            if (typeof rawPatch === 'string') {
-                                                const ptrim = rawPatch.trim();
-                                                if (ptrim.startsWith('{') && ptrim.endsWith('}')) {
-                                                    try {
-                                                        const inner = JSON.parse(ptrim);
-                                                        if (typeof inner.patch === 'string') {
-                                                            container.patch = inner.patch;
-                                                        }
-                                                        else if (typeof inner.input === 'string') {
-                                                            container.patch = inner.input;
-                                                        }
-                                                        else {
-                                                            container.patch = ptrim;
-                                                        }
-                                                    }
-                                                    catch {
-                                                        container.patch = rawPatch;
-                                                    }
-                                                }
-                                            }
-                                            else if (rawPatch === undefined && typeof rawInput === 'string') {
-                                                // 3) 若只有 input 字段，则复制一份到 patch，避免双层包装
-                                                container.patch = rawInput;
-                                            }
-                                            fn.arguments = JSON.stringify(container);
-                                            tc.function = fn;
-                                            continue;
-                                        }
-                                    }
-                                    catch {
-                                        // 回退到原始字符串形状
-                                        fn.arguments = trimmed;
-                                        tc.function = fn;
-                                        continue;
-                                    }
-                                }
-                                // 其它合法 JSON 场景保持原样
+                                // 合法 JSON 场景保持原样
                                 fn.arguments = trimmed;
                                 tc.function = fn;
                             }

package/dist/filters/special/request-tools-normalize.js

@@ -101,25 +101,6 @@ 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/guidance/index.js

@@ -62,9 +62,11 @@ function augmentApplyPatch(fn) {
     const marker = '[Codex ApplyPatch Guidance]';
     const guidance = [
         marker,
-        'Edit files by applying a unified diff patch. Return ONLY the patch text with *** Begin Patch/*** End Patch blocks.',
-        'Paths resolve relative to the active workspace root. Use forward-slash paths (e.g., packages/foo/file.ts) and switch to absolute paths only if you truly need to edit outside the workspace.',
-        '路径一律相对于当前工作区根目录解析；请写 packages/foo/... 这样的相对路径，跨工作区时再使用绝对路径。',
+        'Edit files by applying a unified diff patch. Return ONLY the patch text with *** Begin Patch/*** End Patch blocks and file sections starting with "*** Add/Update/Delete File: {path}".',
+        'Populate the `paths` array with every relative file path touched by this patch (e.g., ["src/foo.ts"]); paths are preferred over any filenames embedded in the patch body.',
+        'Do NOT use git-style headers ("--- a/file", "+++ b/file") or merge markers ("<<<<<<<", "=======", ">>>>>>>"); hunks must use only " ", "+", "-" prefixes.',
+        'Paths resolve relative to the active workspace root. Use forward-slash paths (e.g., packages/foo/file.ts).',
+        '路径一律相对于当前工作区根目录解析；请写 packages/foo/... 这样的相对路径。',
         'Example:',
         '*** Begin Patch',
         '*** Update File: path/to/file.ts',
@@ -75,9 +77,16 @@ function augmentApplyPatch(fn) {
     ].join('\n');
     const params = ensureObjectSchema(fn.parameters);
     const props = params.properties;
-    if (!isObject(props.patch)) {
-        props.patch = { type: 'string', description: 'Unified diff patch text' };
+    if (isObject(props)) {
+        delete props.input;
     }
+    props.patch = { type: 'string', description: 'Unified diff patch text' };
+    props.paths = {
+        type: 'array',
+        description: 'Explicit list of relative file paths affected by this patch (e.g., ["src/foo.ts"]).',
+        items: { type: 'string' }
+    };
+    params.properties = props;
     if (!Array.isArray(params.required)) {
         params.required = [];
     }
@@ -171,9 +180,15 @@ export function augmentAnthropicTools(tools) {
             const n = name.trim();
             try {
                 if (n === 'apply_patch') {
-                    if (!isObject(schema.properties?.patch)) {
-                        schema.properties.patch = { type: 'string', description: 'Unified diff patch text' };
-                    }
+                    const props = ensureObjectSchema(schema.properties);
+                    delete props.input;
+                    props.patch = { type: 'string', description: 'Unified diff patch text' };
+                    props.paths = {
+                        type: 'array',
+                        description: 'Explicit list of relative file paths affected by this patch (e.g., ["src/foo.ts"]).',
+                        items: { type: 'string' }
+                    };
+                    schema.properties = props;
                     if (!Array.isArray(schema.required))
                         schema.required = [];
                     if (!schema.required.includes('patch'))
@@ -183,7 +198,8 @@ export function augmentAnthropicTools(tools) {
                     const marker = '[Codex ApplyPatch Guidance]';
                     const guidance = [
                         marker,
-                        'Use unified diff patch with *** Begin Patch/End Patch. Return only the patch text.',
+                        'Use unified diff patch with *** Begin Patch/End Patch. Return only the patch body.',
+                        'Populate the `paths` array with every relative workspace path touched by this patch.',
                         'All file paths must stay relative to the workspace root; never emit leading \'/\' or drive letters.',
                         '所有文件路径都必须相对当前工作区根目录，禁止输出以 / 或盘符开头的绝对路径。'
                     ].join('\n');

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

@@ -0,0 +1,11 @@
+import { ProviderHealthManager } from './health-manager.js';
+import { ProviderRegistry } from './provider-registry.js';
+import type { ProviderErrorEvent, ProviderFailureEvent, ProviderHealthConfig } from './types.js';
+type DebugLike = {
+    log?: (...args: unknown[]) => void;
+} | Console | undefined;
+export declare function handleProviderFailureImpl(event: ProviderFailureEvent, healthManager: ProviderHealthManager, healthConfig: Required<ProviderHealthConfig>, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void): void;
+export declare function mapProviderErrorImpl(event: ProviderErrorEvent, healthConfig: Required<ProviderHealthConfig>): ProviderFailureEvent | null;
+export declare function applySeriesCooldownImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;
+export declare function deriveReason(code: string, stage: string, statusCode?: number): string;
+export {};