@jsonstudio/llms 0.6.1172 → 0.6.1354

package/dist/conversion/shared/jsonish.js

@@ -132,7 +132,7 @@ export function repairArgumentsToString(value) {
         catch { /* ignore */ }
         // 6) quote unquoted keys
         try {
-            s = s.replace(/([\{,\s])([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
+            s = s.replace(/([{,\s])([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
         }
         catch { /* ignore */ }
         // 7) try parse after cleanup

package/dist/conversion/shared/mcp-injection.js

@@ -11,10 +11,48 @@ const obj = (props, req = []) => {
     return schema;
 };
 function uniq(arr) { return Array.from(new Set(arr)); }
+function buildKnownServersLine(discoveredServers) {
+    if (!Array.isArray(discoveredServers) || discoveredServers.length === 0)
+        return '';
+    const list = uniq(discoveredServers).slice(0, 8);
+    const suffix = discoveredServers.length > list.length ? ` (+${discoveredServers.length - list.length} more)` : '';
+    return `Known MCP servers: ${list.join(', ')}${suffix}.`;
+}
+function buildMcpServerReminder() {
+    return 'Note: arguments.server is an MCP server label (NOT a tool name like shell/exec_command/apply_patch).';
+}
+function buildListResourcesDescription(discoveredServers) {
+    return [
+        'List resources exposed by MCP servers.',
+        'Only use this for MCP resources (not MCP tools). Many MCP servers expose tools only; if the result is empty, do not retry.',
+        'If you do not know the MCP server name yet, call this tool with {} once; then reuse the returned server names for subsequent calls.',
+        buildMcpServerReminder(),
+        buildKnownServersLine(discoveredServers)
+    ].filter(Boolean).join('\n');
+}
+function buildListTemplatesDescription(discoveredServers) {
+    return [
+        'List resource templates exposed by MCP servers.',
+        'Only use this for MCP resources (not MCP tools). If list_mcp_resources returns empty, do not retry.',
+        'If you do not know the MCP server name yet, call list_mcp_resources({}) once first.',
+        buildMcpServerReminder(),
+        buildKnownServersLine(discoveredServers)
+    ].filter(Boolean).join('\n');
+}
+function buildReadResourceDescription(discoveredServers) {
+    return [
+        'Read a specific MCP resource by { server, uri }.',
+        'Only use this for MCP resources (not MCP tools). If list_mcp_resources returns empty, do not retry.',
+        'If you do not know the MCP server name yet, call list_mcp_resources({}) once first.',
+        buildMcpServerReminder(),
+        buildKnownServersLine(discoveredServers)
+    ].filter(Boolean).join('\n');
+}
 export function injectMcpToolsForChat(tools, discoveredServers) {
     const out = [];
     const keep = new Set();
-    const listServers = discoveredServers && discoveredServers.length ? { type: 'string', enum: uniq(discoveredServers) } : { type: 'string' };
+    const listServers = discoveredServers && discoveredServers.length ? { type: 'string', enum: uniq(discoveredServers), minLength: 1 } : { type: 'string', minLength: 1 };
+    const templateServer = discoveredServers && discoveredServers.length ? { type: 'string', enum: uniq(discoveredServers), minLength: 1 } : { type: 'string', minLength: 1 };
     const ensure = (name, def) => { if (!keep.has(name)) {
         out.push(def);
         keep.add(name);
@@ -28,35 +66,45 @@ export function injectMcpToolsForChat(tools, discoveredServers) {
             continue;
         }
         if (lower === 'list_mcp_resources') {
-            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: t.function?.description || 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: (t.function?.description && String(t.function.description).trim()) ? t.function.description : buildListResourcesDescription(discoveredServers), parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+            continue;
+        }
+        if (lower === 'list_mcp_resource_templates') {
+            ensure('list_mcp_resource_templates', {
+                type: 'function',
+                function: {
+                    name: 'list_mcp_resource_templates',
+                    description: (t.function?.description && String(t.function.description).trim()) ? t.function.description : buildListTemplatesDescription(discoveredServers),
+                    parameters: obj({ server: templateServer, cursor: { type: 'string' } })
+                }
+            });
             continue;
         }
-        if (lower === 'read_mcp_resource' || lower === 'list_mcp_resource_templates') {
+        if (lower === 'read_mcp_resource') {
+            // Phase gating: do not expose read until we have known server labels.
             if (discoveredServers.length > 0) {
                 const srv = { type: 'string', enum: uniq(discoveredServers) };
-                if (lower === 'read_mcp_resource') {
-                    ensure('read_mcp_resource', { type: 'function', function: { name: 'read_mcp_resource', description: t.function?.description || 'Read a resource from a given MCP server.', parameters: obj({ server: srv, uri: { type: 'string' }, cursor: { type: 'string' } }, ['server', 'uri']) } });
-                }
-                else {
-                    ensure('list_mcp_resource_templates', { type: 'function', function: { name: 'list_mcp_resource_templates', description: t.function?.description || 'List resource templates from a given MCP server.', parameters: obj({ server: srv, cursor: { type: 'string' } }, ['server']) } });
-                }
-                continue;
+                ensure('read_mcp_resource', {
+                    type: 'function',
+                    function: {
+                        name: 'read_mcp_resource',
+                        description: (t.function?.description && String(t.function.description).trim()) ? t.function.description : buildReadResourceDescription(discoveredServers),
+                        parameters: obj({ server: srv, uri: { type: 'string' } }, ['server', 'uri'])
+                    }
+                });
             }
+            continue;
         }
         out.push(t);
         keep.add(lower);
     }
-    // Ensure list exists when user did not provide it
-    if (!keep.has('list_mcp_resources')) {
-        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
-    }
     return out;
 }
 export function injectMcpToolsForResponses(tools, discoveredServers) {
     const out = [];
     const keep = new Set();
-    const listServers = { type: 'string' };
-    const templateServer = discoveredServers && discoveredServers.length ? { type: 'string', enum: uniq(discoveredServers) } : { type: 'string' };
+    const listServers = { type: 'string', minLength: 1 };
+    const templateServer = discoveredServers && discoveredServers.length ? { type: 'string', enum: uniq(discoveredServers), minLength: 1 } : { type: 'string', minLength: 1 };
     const ensure = (name, def) => { if (!keep.has(name)) {
         out.push(def);
         keep.add(name);
@@ -70,7 +118,7 @@ export function injectMcpToolsForResponses(tools, discoveredServers) {
             continue;
         }
         if (lower === 'list_mcp_resources') {
-            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: t.function?.description || 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+            ensure('list_mcp_resources', { type: 'function', function: { name: 'list_mcp_resources', description: (t.function?.description && String(t.function.description).trim()) ? t.function.description : buildListResourcesDescription(discoveredServers), parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
             continue;
         }
         if (lower === 'list_mcp_resource_templates') {
@@ -78,7 +126,7 @@ export function injectMcpToolsForResponses(tools, discoveredServers) {
                 type: 'function',
                 function: {
                     name: 'list_mcp_resource_templates',
-                    description: t.function?.description || 'List resource templates from MCP servers.',
+                    description: (t.function?.description && String(t.function.description).trim()) ? t.function.description : buildListTemplatesDescription(discoveredServers),
                     parameters: obj({ server: templateServer, cursor: { type: 'string' } })
                 }
             });
@@ -86,25 +134,11 @@ export function injectMcpToolsForResponses(tools, discoveredServers) {
         }
         if (lower === 'read_mcp_resource' && discoveredServers.length > 0) {
             const srv = { type: 'string', enum: uniq(discoveredServers) };
-            ensure('read_mcp_resource', { type: 'function', function: { name: 'read_mcp_resource', description: t.function?.description || 'Read a resource via MCP server.', parameters: obj({ server: srv, uri: { type: 'string' } }, ['server', 'uri']) } });
+            ensure('read_mcp_resource', { type: 'function', function: { name: 'read_mcp_resource', description: (t.function?.description && String(t.function.description).trim()) ? t.function.description : buildReadResourceDescription(discoveredServers), parameters: obj({ server: srv, uri: { type: 'string' } }, ['server', 'uri']) } });
             continue;
         }
         out.push(t);
         keep.add(lower);
     }
-    if (!keep.has('list_mcp_resources')) {
-        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: 'List resources from a given MCP server (arguments.server = server label).', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
-        keep.add('list_mcp_resources');
-    }
-    if (!keep.has('list_mcp_resource_templates')) {
-        out.push({
-            type: 'function',
-            function: {
-                name: 'list_mcp_resource_templates',
-                description: 'List resource templates from MCP servers.',
-                parameters: obj({ server: templateServer, cursor: { type: 'string' } })
-            }
-        });
-    }
     return out;
 }

package/dist/conversion/shared/openai-finalizer.js

@@ -59,8 +59,9 @@ export async function finalizeOpenAIChatResponse(chatLike, opts) {
                         }
                         catch { /* ignore */ }
                     }
-                    if (first.finish_reason == null)
+                    if (String(first.finish_reason || '').toLowerCase() !== 'tool_calls') {
                         first.finish_reason = 'tool_calls';
+                    }
                 }
             }
             // nothing more to do for Chat completion response

package/dist/conversion/shared/openai-message-normalize.js

@@ -3,6 +3,14 @@ import { injectMcpToolsForChat } from './mcp-injection.js';
 // with the deprecated "openai-normalizer" module entry). This file contains the
 // previously-implemented logic from openai-normalize.ts.
 // Legacy tooling stage removed for Chat; tool canonicalization lives in codecs
+function isMcpToolName(name) {
+    if (typeof name !== 'string')
+        return false;
+    const lowered = name.trim().toLowerCase();
+    return (lowered === 'list_mcp_resources' ||
+        lowered === 'list_mcp_resource_templates' ||
+        lowered === 'read_mcp_resource');
+}
 export function normalizeChatRequest(request) {
     if (!request || typeof request !== 'object')
         return request;
@@ -54,38 +62,85 @@ export function normalizeChatRequest(request) {
             const enableMcp = String(process?.env?.ROUTECODEX_MCP_ENABLE ?? '1') !== '0';
             if (enableMcp) {
                 const known = new Set();
+                const fromEnv = String(process?.env?.RCC_MCP_SERVERS || '').trim();
+                if (fromEnv) {
+                    for (const s of fromEnv.split(',').map((x) => x.trim()).filter(Boolean))
+                        known.add(s);
+                }
+                const addServer = (v) => {
+                    if (typeof v === 'string') {
+                        const s = v.trim();
+                        if (s)
+                            known.add(s);
+                    }
+                };
+                const extractFromOutput = (output) => {
+                    try {
+                        if (Array.isArray(output)) {
+                            for (const item of output) {
+                                if (typeof item === 'string')
+                                    addServer(item);
+                                else if (item && typeof item === 'object' && !Array.isArray(item))
+                                    addServer(item.server);
+                            }
+                            return;
+                        }
+                        if (!output || typeof output !== 'object' || Array.isArray(output))
+                            return;
+                        const o = output;
+                        if (Array.isArray(o.servers))
+                            for (const s of o.servers)
+                                addServer(s);
+                        if (Array.isArray(o.resources))
+                            for (const r of o.resources)
+                                addServer(r?.server ?? r?.source?.server);
+                        if (Array.isArray(o.resourceTemplates))
+                            for (const t of o.resourceTemplates)
+                                addServer(t?.server ?? t?.source?.server);
+                    }
+                    catch {
+                        // best-effort
+                    }
+                };
+                // IMPORTANT: do NOT treat assistant tool_calls as authoritative for MCP server labels
+                // (the model may guess "shell"/"exec_command"/etc). Only trust tool results.
                 try {
                     const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
                     for (const m of msgs) {
                         if (!m || typeof m !== 'object')
                             continue;
-                        if (m.role === 'tool' && typeof m.content === 'string') {
-                            try {
-                                const obj = JSON.parse(m.content);
-                                const sv = obj?.arguments?.server;
-                                if (typeof sv === 'string' && sv.trim())
-                                    known.add(sv.trim());
-                            }
-                            catch { /* ignore */ }
-                        }
-                        if (m.role === 'assistant' && Array.isArray(m.tool_calls)) {
-                            for (const tc of m.tool_calls) {
-                                try {
-                                    const argStr = String(tc?.function?.arguments ?? '');
-                                    const parsed = JSON.parse(argStr);
-                                    const sv = parsed?.server;
-                                    if (typeof sv === 'string' && sv.trim())
-                                        known.add(sv.trim());
+                        if (String(m.role || '').toLowerCase() !== 'tool')
+                            continue;
+                        const content = m.content;
+                        if (typeof content !== 'string' || content.trim().length === 0)
+                            continue;
+                        try {
+                            const parsed = JSON.parse(content);
+                            if (parsed && typeof parsed === 'object' && parsed.version === 'rcc.tool.v1' && parsed.tool?.name) {
+                                const toolName = String(parsed.tool.name).toLowerCase();
+                                if (toolName === 'list_mcp_resources') {
+                                    extractFromOutput(parsed.result?.output);
                                 }
-                                catch { /* ignore */ }
+                            }
+                            else {
+                                extractFromOutput(parsed?.output ?? parsed);
                             }
                         }
+                        catch {
+                            // ignore
+                        }
                     }
                 }
                 catch { /* ignore */ }
-                const discovered = Array.from(known);
-                const currentTools = Array.isArray(normalized.tools) ? normalized.tools : [];
-                normalized.tools = injectMcpToolsForChat(currentTools, discovered);
+                const currentTools = Array.isArray(normalized.tools)
+                    ? normalized.tools
+                    : undefined;
+                // IMPORTANT: Do not force-inject MCP tools. If the inbound request doesn't include MCP tools,
+                // keep tools untouched (and do not create a tools=[] placeholder).
+                if (currentTools && currentTools.some((t) => isMcpToolName(t?.function?.name))) {
+                    const discovered = Array.from(known);
+                    normalized.tools = injectMcpToolsForChat(currentTools, discovered);
+                }
             }
         }
         catch { /* ignore MCP injection */ }

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

@@ -243,8 +243,14 @@ function buildRequiredActionFromNormalized(calls) {
     if (!calls.length)
         return undefined;
     const submitCalls = calls.map((entry) => ({
+        // Internal + client compat:
+        // - keep OpenAI-style `id` + `function`
+        // - also expose `tool_call_id` + top-level `name` for legacy/bridge clients
         id: entry.id,
+        tool_call_id: entry.id,
         type: 'function',
+        name: entry.name,
+        arguments: entry.args,
         function: {
             name: entry.name,
             arguments: entry.args

package/dist/conversion/shared/runtime-metadata.d.ts

@@ -0,0 +1,7 @@
+import { type JsonObject } from '../hub/types/json.js';
+export type RuntimeMetadataCarrier = Record<string, unknown> & {
+    __rt?: JsonObject;
+};
+export declare function readRuntimeMetadata(carrier?: Record<string, unknown> | null): JsonObject | undefined;
+export declare function ensureRuntimeMetadata(carrier: Record<string, unknown>): JsonObject;
+export declare function cloneRuntimeMetadata(carrier?: Record<string, unknown> | null): JsonObject | undefined;

package/dist/conversion/shared/runtime-metadata.js

@@ -0,0 +1,23 @@
+import { isJsonObject, jsonClone } from '../hub/types/json.js';
+export function readRuntimeMetadata(carrier) {
+    if (!carrier || typeof carrier !== 'object') {
+        return undefined;
+    }
+    const candidate = carrier.__rt;
+    return candidate && isJsonObject(candidate) ? candidate : undefined;
+}
+export function ensureRuntimeMetadata(carrier) {
+    if (!carrier || typeof carrier !== 'object') {
+        throw new Error('ensureRuntimeMetadata requires object carrier');
+    }
+    const existing = readRuntimeMetadata(carrier);
+    if (existing) {
+        return existing;
+    }
+    carrier.__rt = {};
+    return carrier.__rt;
+}
+export function cloneRuntimeMetadata(carrier) {
+    const rt = readRuntimeMetadata(carrier);
+    return rt ? jsonClone(rt) : undefined;
+}

package/dist/conversion/shared/text-markup-normalizer.d.ts

@@ -3,7 +3,9 @@ export type ToolCallLite = {
     name: string;
     args: string;
 };
+export declare function extractToolNamespaceXmlBlocksFromText(text: string): ToolCallLite[] | null;
 export declare function extractParameterXmlToolsFromText(text: string): ToolCallLite[] | null;
+export declare function extractInvokeToolsFromText(text: string): ToolCallLite[] | null;
 export declare function extractBareExecCommandFromText(text: string): ToolCallLite[] | null;
 export declare function extractApplyPatchCallsFromText(text: string): ToolCallLite[] | null;
 export declare function extractExecuteBlocksFromText(text: string): ToolCallLite[] | null;