@jsonstudio/rcc 0.89.3 → 0.89.164

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-conversation-store.js

@@ -1,4 +1,4 @@
-const TTL_MS = 1000 * 60 * 30; // 30 minutes safety window
+const TTL_MS = 1000 * 60 * 30; // 30min
 function cloneDeep(value) {
     try {
         if (typeof globalThis.structuredClone === 'function') {
@@ -49,19 +49,26 @@ function pickPersistedFields(payload) {
         'input_audio',
         'output_audio'
     ];
-    const result = {};
+    const next = {};
     for (const key of fields) {
         if (payload[key] !== undefined) {
-            result[key] = cloneDeep(payload[key]);
+            next[key] = cloneDeep(payload[key]);
         }
     }
-    return result;
+    return next;
 }
 function normalizeOutputItemToInput(item) {
+    if (!item || typeof item !== 'object') {
+        return null;
+    }
     const type = typeof item.type === 'string' ? item.type : '';
     if (type === 'message' || type === 'reasoning') {
         const role = typeof item.role === 'string' ? item.role : 'assistant';
-        const content = Array.isArray(item.content) ? cloneDeep(item.content) : (typeof item.text === 'string' ? [{ type: 'text', text: item.text }] : []);
+        const content = Array.isArray(item.content)
+            ? cloneDeep(item.content)
+            : typeof item.text === 'string'
+                ? [{ type: 'text', text: item.text }]
+                : [];
         return {
             type: 'message',
             role,
@@ -70,7 +77,11 @@ function normalizeOutputItemToInput(item) {
         };
     }
     if (type === 'function_call') {
-        const callId = typeof item.call_id === 'string' ? item.call_id : (typeof item.id === 'string' ? item.id : undefined);
+        const callId = typeof item.call_id === 'string'
+            ? item.call_id
+            : typeof item.id === 'string'
+                ? item.id
+                : undefined;
         return {
             type: 'function_call',
             role: 'assistant',
@@ -80,9 +91,9 @@ function normalizeOutputItemToInput(item) {
             arguments: item.arguments,
             function: isRecord(item.function)
                 ? cloneDeep(item.function)
-                : (typeof item.name === 'string'
+                : typeof item.name === 'string'
                     ? { name: item.name, arguments: item.arguments }
-                    : undefined)
+                    : undefined
         };
     }
     return null;
@@ -139,6 +150,18 @@ function normalizeSubmittedToolOutputs(toolOutputs) {
 class ResponsesConversationStore {
     requestMap = new Map();
     responseIndex = new Map();
+    rebindRequestId(oldId, newId) {
+        if (!oldId || !newId || oldId === newId) {
+            return;
+        }
+        const entry = this.requestMap.get(oldId);
+        if (!entry) {
+            return;
+        }
+        this.requestMap.delete(oldId);
+        entry.requestId = newId;
+        this.requestMap.set(newId, entry);
+    }
     captureRequestContext(args) {
         const { requestId, payload, context } = args;
         if (!requestId || !payload)
@@ -148,7 +171,8 @@ class ResponsesConversationStore {
             requestId,
             basePayload: pickPersistedFields(payload),
             input: coerceInputArray(context.input),
-            tools: coerceTools(context.toolsRaw || (Array.isArray(payload.tools) ? payload.tools : undefined)),
+            tools: coerceTools(context.toolsRaw) ||
+                coerceTools(Array.isArray(payload.tools) ? payload.tools : undefined),
             createdAt: Date.now(),
             updatedAt: Date.now()
         };
@@ -164,7 +188,7 @@ class ResponsesConversationStore {
         this.requestMap.set(requestId, entry);
     }
     recordResponse(args) {
-        const entry = this.requestMap.get(args.requestId);
+        const entry = args.requestId ? this.requestMap.get(args.requestId) : undefined;
         if (!entry)
             return;
         const response = args.response;
@@ -188,9 +212,7 @@ class ResponsesConversationStore {
         if (!entry) {
             throw new Error('Responses conversation expired or not found');
         }
-        const toolOutputs = Array.isArray(submitPayload.tool_outputs)
-            ? submitPayload.tool_outputs
-            : [];
+        const toolOutputs = Array.isArray(submitPayload.tool_outputs) ? submitPayload.tool_outputs : [];
         if (!toolOutputs.length) {
             throw new Error('tool_outputs array is required when submitting Responses tool results');
         }
@@ -208,7 +230,8 @@ class ResponsesConversationStore {
             payload.model = submitPayload.model.trim();
         }
         if (submitPayload.metadata && isRecord(submitPayload.metadata)) {
-            payload.metadata = { ...payload.metadata, ...cloneDeep(submitPayload.metadata) };
+            const baseMeta = isRecord(payload.metadata) ? payload.metadata : {};
+            payload.metadata = { ...baseMeta, ...cloneDeep(submitPayload.metadata) };
         }
         delete payload.tool_outputs;
         delete payload.response_id;
@@ -225,6 +248,8 @@ class ResponsesConversationStore {
         };
     }
     clearRequest(requestId) {
+        if (!requestId)
+            return;
         const entry = this.requestMap.get(requestId);
         if (!entry)
             return;
@@ -254,10 +279,14 @@ class ResponsesConversationStore {
         }
     }
 }
-export const responsesConversationStore = new ResponsesConversationStore();
+const store = new ResponsesConversationStore();
+const RESPONSES_DEBUG = (process.env.ROUTECODEX_RESPONSES_DEBUG || '').trim() === '1';
 export function captureResponsesRequestContext(args) {
     try {
-        responsesConversationStore.captureRequestContext(args);
+        if (RESPONSES_DEBUG) {
+            console.log('[responses-store] capture', args.requestId);
+        }
+        store.captureRequestContext(args);
     }
     catch {
         /* ignore capture failures */
@@ -265,15 +294,31 @@ export function captureResponsesRequestContext(args) {
 }
 export function recordResponsesResponse(args) {
     try {
-        responsesConversationStore.recordResponse(args);
+        if (RESPONSES_DEBUG) {
+            console.log('[responses-store] record', args.requestId, args.response?.id);
+        }
+        store.recordResponse(args);
     }
     catch {
         /* ignore */
     }
 }
 export function resumeResponsesConversation(responseId, submitPayload, options) {
-    return responsesConversationStore.resumeConversation(responseId, submitPayload, options);
+    if (RESPONSES_DEBUG) {
+        console.log('[responses-store] resume', responseId);
+    }
+    return store.resumeConversation(responseId, submitPayload, options);
 }
 export function clearResponsesConversationByRequestId(requestId) {
-    responsesConversationStore.clearRequest(requestId);
+    if (RESPONSES_DEBUG && requestId) {
+        console.log('[responses-store] clear', requestId);
+    }
+    store.clearRequest(requestId);
+}
+export function rebindResponsesConversationRequestId(oldId, newId) {
+    if (RESPONSES_DEBUG && oldId && newId) {
+        console.log('[responses-store] rebind', oldId, '->', newId);
+    }
+    store.rebindRequestId(oldId, newId);
 }
+export { store as responsesConversationStore };

package/node_modules/@jsonstudio/llms/dist/conversion/shared/tool-filter-pipeline.d.ts

@@ -0,0 +1,21 @@
+import { ToolFilterHints } from '../../filters/index.js';
+interface RequestFilterOptions {
+    entryEndpoint?: string;
+    requestId?: string;
+    model?: string;
+    profile?: string;
+    stream?: boolean;
+    toolFilterHints?: ToolFilterHints;
+    /**
+     * Optional raw payload snapshot for local tool governance (e.g. view_image exposure).
+     */
+    rawPayload?: Record<string, unknown>;
+}
+interface ResponseFilterOptions {
+    entryEndpoint?: string;
+    requestId?: string;
+    profile?: string;
+}
+export declare function runChatRequestToolFilters(chatRequest: any, options?: RequestFilterOptions): Promise<any>;
+export declare function runChatResponseToolFilters(chatJson: any, options?: ResponseFilterOptions): Promise<any>;
+export {};

package/node_modules/@jsonstudio/llms/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()}`,
@@ -21,24 +45,30 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
             return;
         snapshot(stage, payload);
     };
-    recordStage('req_process_tool_filters_input', chatRequest);
+    const preFiltered = applyLocalToolGovernance(chatRequest, options.rawPayload);
+    recordStage('req_process_tool_filters_input', preFiltered);
     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,15 +82,96 @@ 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 = preFiltered;
+    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;
 }
+function applyLocalToolGovernance(chatRequest, rawPayload) {
+    if (!chatRequest || typeof chatRequest !== 'object') {
+        return chatRequest;
+    }
+    const messages = Array.isArray(chatRequest.messages) ? chatRequest.messages : undefined;
+    const tools = Array.isArray(chatRequest.tools) ? chatRequest.tools : undefined;
+    if (!tools || !tools.length) {
+        return chatRequest;
+    }
+    const hasImageHint = detectImageHint(messages, rawPayload);
+    if (hasImageHint) {
+        return chatRequest;
+    }
+    const filteredTools = tools.filter((tool) => {
+        if (!tool || typeof tool !== 'object')
+            return false;
+        const fn = tool.function;
+        if (!fn || typeof fn !== 'object')
+            return true;
+        const name = fn.name;
+        if (typeof name !== 'string')
+            return true;
+        return name.trim() !== 'view_image';
+    });
+    if (filteredTools.length === tools.length) {
+        return chatRequest;
+    }
+    return {
+        ...chatRequest,
+        tools: filteredTools
+    };
+}
+function detectImageHint(messages, rawPayload) {
+    const candidates = [];
+    const collect = (value) => {
+        if (typeof value === 'string' && value) {
+            candidates.push(value);
+        }
+    };
+    if (Array.isArray(messages)) {
+        for (const msg of messages) {
+            if (msg && typeof msg === 'object') {
+                const text = msg.content;
+                if (typeof text === 'string') {
+                    collect(text);
+                }
+                else if (Array.isArray(text)) {
+                    for (const part of text) {
+                        if (part && typeof part === 'object') {
+                            collect(part.text);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (rawPayload && typeof rawPayload === 'object') {
+        collect(rawPayload.content);
+    }
+    if (!candidates.length) {
+        return false;
+    }
+    const patterns = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg'];
+    for (const text of candidates) {
+        const lower = text.toLowerCase();
+        for (const ext of patterns) {
+            if (lower.includes(ext)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 export async function runChatResponseToolFilters(chatJson, options = {}) {
     const resCtxBase = {
         requestId: options.requestId ?? `req_${Date.now()}`,
@@ -81,20 +192,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 +223,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/node_modules/@jsonstudio/llms/dist/conversion/shared/tool-governor.d.ts

@@ -0,0 +1,21 @@
+type Unknown = Record<string, unknown>;
+export interface ToolGovernanceOptions {
+    injectGuidance?: boolean;
+    snapshot?: {
+        enabled?: boolean;
+        endpoint?: string;
+        requestId?: string;
+        baseDir?: string;
+    };
+}
+export declare function processChatRequestTools(request: Unknown, opts?: ToolGovernanceOptions): Unknown;
+export declare function processChatResponseTools(resp: Unknown): Unknown;
+export interface GovernContext extends ToolGovernanceOptions {
+    phase: 'request' | 'response';
+    endpoint?: 'chat' | 'responses' | 'messages';
+    stream?: boolean;
+    produceRequiredAction?: boolean;
+    requestId?: string;
+}
+export declare function governTools(payload: Unknown, ctx: GovernContext): Unknown;
+export {};

package/node_modules/@jsonstudio/llms/dist/conversion/shared/tool-governor.js

@@ -40,6 +40,114 @@ function tryWriteSnapshot(options, stage, data) {
  * - Inject/Refine system tool guidance (idempotent)
  * - Canonicalize textual tool markup to tool_calls; set content=null when applicable
  */
+const IMAGE_EXT_RE = /\.(png|jpe?g|gif|webp|bmp|svg)(?:[?#].*)?$/i;
+function hasImageReference(messages) {
+    if (!Array.isArray(messages))
+        return false;
+    for (const entry of messages) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const content = entry.content;
+        if (!content)
+            continue;
+        if (Array.isArray(content)) {
+            if (content.some((part) => isImagePart(part)))
+                return true;
+        }
+        else if (isObject(content)) {
+            if (isImagePart(content))
+                return true;
+        }
+        else if (typeof content === 'string') {
+            if (stringHasImageLink(content))
+                return true;
+        }
+    }
+    return false;
+}
+function hasInputImage(entries) {
+    if (!Array.isArray(entries))
+        return false;
+    for (const entry of entries) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const type = String(entry.type || '').toLowerCase();
+        if (type.includes('image'))
+            return true;
+        const content = entry.content;
+        if (!content)
+            continue;
+        if (Array.isArray(content)) {
+            if (content.some((part) => isImagePart(part)))
+                return true;
+        }
+        else if (isObject(content)) {
+            if (isImagePart(content))
+                return true;
+        }
+    }
+    return false;
+}
+function attachmentsHaveImage(payload) {
+    const attachments = payload?.attachments;
+    if (!Array.isArray(attachments))
+        return false;
+    for (const attachment of attachments) {
+        if (!attachment || typeof attachment !== 'object')
+            continue;
+        const mime = typeof attachment.mime === 'string' ? attachment.mime.toLowerCase() : '';
+        if (mime.startsWith('image/'))
+            return true;
+        const name = typeof attachment.name === 'string' ? attachment.name : '';
+        if (IMAGE_EXT_RE.test(name))
+            return true;
+        const url = typeof attachment.url === 'string' ? attachment.url : '';
+        if (stringHasImageLink(url))
+            return true;
+    }
+    return false;
+}
+function stringHasImageLink(value) {
+    if (!value)
+        return false;
+    if (value.includes('cid:'))
+        return true;
+    if (IMAGE_EXT_RE.test(value))
+        return true;
+    const lowered = value.toLowerCase();
+    return lowered.includes('image://');
+}
+function isImagePart(part) {
+    if (!part || typeof part !== 'object')
+        return false;
+    const type = String(part.type || '').toLowerCase();
+    if (type.includes('image'))
+        return true;
+    const imageUrl = part.image_url || part.imageUrl;
+    if (typeof imageUrl === 'string')
+        return true;
+    if (isObject(imageUrl) && typeof imageUrl.url === 'string')
+        return true;
+    const url = part.url;
+    if (typeof url === 'string' && stringHasImageLink(url))
+        return true;
+    return false;
+}
+function shouldExposeViewImage(payload) {
+    if (hasImageReference(payload?.messages))
+        return true;
+    if (hasInputImage(payload?.input))
+        return true;
+    if (attachmentsHaveImage(payload))
+        return true;
+    return false;
+}
+function isViewImageTool(tool) {
+    if (!tool || typeof tool !== 'object')
+        return false;
+    const name = String(tool.name || tool?.function?.name || '').toLowerCase();
+    return name === 'view_image';
+}
 export function processChatRequestTools(request, opts) {
     const options = { ...(opts || {}) };
     if (!isObject(request))
@@ -48,8 +156,15 @@ export function processChatRequestTools(request, opts) {
     // tools 形状最小修复：为缺失 function.parameters 的工具补一个空对象，避免上游
     // Responses/OpenAI 校验 422（外部错误必须暴露，但这里属于规范化入口）。
     try {
-        const tools = Array.isArray(out?.tools) ? out.tools : [];
+        let tools = Array.isArray(out?.tools) ? out.tools : [];
         if (tools.length > 0) {
+            if (!shouldExposeViewImage(out)) {
+                const filtered = tools.filter((tool) => !isViewImageTool(tool));
+                if (filtered.length !== tools.length) {
+                    tools = filtered;
+                    out.tools = tools;
+                }
+            }
             for (const t of tools) {
                 if (!t || typeof t !== 'object')
                     continue;

package/node_modules/@jsonstudio/llms/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();
@@ -66,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;
@@ -105,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 = {

package/node_modules/@jsonstudio/llms/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"
+        }
+    ]
+}