@jsonstudio/llms 0.4.2

package/dist/conversion/schema-validator.d.ts

@@ -0,0 +1,7 @@
+export declare class SchemaValidator {
+    private readonly baseDir;
+    private readonly cache;
+    constructor(baseDir?: string);
+    validate(schemaPath: string | undefined, payload: unknown, context: string): Promise<void>;
+    private getValidator;
+}

package/dist/conversion/schema-validator.js

@@ -0,0 +1,67 @@
+import path from 'path';
+import fs from 'fs/promises';
+export class SchemaValidator {
+    baseDir;
+    cache = new Map();
+    constructor(baseDir) {
+        const rootDir = baseDir ?? process.cwd();
+        this.baseDir = rootDir;
+    }
+    async validate(schemaPath, payload, context) {
+        if (!schemaPath)
+            return;
+        const validator = await this.getValidator(schemaPath);
+        if (!validator(payload)) {
+            const errors = validator.errors?.map(err => `${err.instancePath} ${err.message}`).join('; ') ?? 'unknown';
+            const error = new Error(`Schema validation failed for ${context}: ${errors}`);
+            error.code = 'schema_validation_failed';
+            throw error;
+        }
+    }
+    async getValidator(schemaRelPath) {
+        // 明确路径策略：禁止多层 fallback。只支持两种确定路径：
+        // 1) 绝对路径；2) 以 host 包根目录为 baseDir 的相对路径（如 'config/schemas/...')。
+        if (this.cache.has(schemaRelPath)) {
+            return this.cache.get(schemaRelPath).validator;
+        }
+        let resolved = path.isAbsolute(schemaRelPath)
+            ? schemaRelPath
+            : path.resolve(this.baseDir, schemaRelPath);
+        // 若 baseDir 未指向 host 包根（例如运行于独立模块上下文），尝试一次性将
+        // schemaRelPath 解析到已安装的 routecodex 包根目录下（无其它兜底）。
+        if (!path.isAbsolute(schemaRelPath)) {
+            try {
+                const { createRequire } = await import('module');
+                const req = createRequire(import.meta.url);
+                const pkgJsonPath = req.resolve('routecodex/package.json');
+                const pkgRoot = path.dirname(pkgJsonPath);
+                const candidate = path.join(pkgRoot, schemaRelPath.replace(/^\/+/, ''));
+                // 仅当该文件确实存在时才采用；否则保留 baseDir 解析结果并抛错
+                await fs.access(candidate);
+                resolved = candidate;
+            }
+            catch {
+                // 不使用 cwd 等隐式回退。保持 resolved=baseDir 解析结果，读不到则抛错。
+            }
+        }
+        const schemaContent = await fs.readFile(resolved, 'utf-8');
+        const schemaJson = JSON.parse(schemaContent);
+        // Ajv 在某些 Node 环境下可能未构建 dist/ajv.js；
+        // 这里使用动态导入并在失败时回退为“永远通过”的占位校验器，
+        // 避免因依赖形态差异导致整个请求链路中断。
+        let validator;
+        try {
+            const mod = await import('ajv');
+            const AjvCtor = mod.default ?? mod;
+            const ajv = new AjvCtor({ allErrors: true, strict: false });
+            validator = ajv.compile(schemaJson);
+        }
+        catch {
+            const fn = ((_) => true);
+            fn.errors = [];
+            validator = fn;
+        }
+        this.cache.set(schemaRelPath, { validator, schemaPath: resolved });
+        return validator;
+    }
+}

package/dist/conversion/shared/args-mapping.d.ts

@@ -0,0 +1,18 @@
+export type Unknown = Record<string, unknown>;
+export interface NormalizeResult<T = Record<string, unknown>> {
+    ok: boolean;
+    value?: T;
+    errors?: string[];
+}
+type JsonSchema = {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema & {
+        ['x-aliases']?: string[];
+    }>;
+    required?: string[];
+    items?: JsonSchema;
+    additionalProperties?: boolean;
+};
+export declare function normalizeArgsBySchema(input: any, schema?: JsonSchema): NormalizeResult;
+export declare function normalizeTools(tools: any[]): Unknown[];
+export {};

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

@@ -0,0 +1,213 @@
+// Shared tool + argument mapping helpers (schema-driven)
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+const normKey = (k) => k.toLowerCase().replace(/[^a-z0-9]+/g, '');
+function getDefaultAliases(prop) {
+    const p = prop.toLowerCase();
+    switch (p) {
+        case 'file_path': return ['path', 'file', 'filepath', 'filePath'];
+        case 'pattern': return ['glob', 'include', 'includes', 'query', 'regex'];
+        case 'content': return ['text', 'data', 'body'];
+        case 'old_string': return ['old', 'from', 'before', 'oldString', 'previous'];
+        case 'new_string': return ['new', 'to', 'after', 'newString', 'next'];
+        case 'command': return ['cmd', 'command_list', 'commandList'];
+        case 'path': return ['dir', 'directory'];
+        case 'glob': return ['include', 'includes', 'patterns'];
+        case 'todos': return ['items', 'list', 'tasks'];
+        case 'replace_all': return ['replaceAll', 'all', 'allOccurrences'];
+        default: return [];
+    }
+}
+function buildPropertyMap(schema) {
+    const map = new Map();
+    const props = schema?.properties || {};
+    for (const [p, s] of Object.entries(props)) {
+        map.set(normKey(p), p);
+        const aliases = s['x-aliases'];
+        if (Array.isArray(aliases)) {
+            for (const a of aliases) {
+                if (typeof a === 'string') {
+                    map.set(normKey(a), p);
+                }
+            }
+        }
+        for (const a of getDefaultAliases(p)) {
+            map.set(normKey(a), p);
+        }
+    }
+    return map;
+}
+function coerceType(value, schema) {
+    const t = schema?.type;
+    const want = Array.isArray(t) ? t[0] : t;
+    if (!want) {
+        return value;
+    }
+    switch (want) {
+        case 'string':
+            if (typeof value === 'string')
+                return value;
+            if (Array.isArray(value))
+                return value.map(v => String(v)).join(' ');
+            if (value === null || value === undefined)
+                return value;
+            return String(value);
+        case 'number':
+            if (typeof value === 'number')
+                return value;
+            if (typeof value === 'string') {
+                const n = Number(value);
+                return Number.isFinite(n) ? n : value;
+            }
+            return value;
+        case 'integer':
+            if (typeof value === 'number')
+                return Math.trunc(value);
+            if (typeof value === 'string') {
+                const n = parseInt(value, 10);
+                return Number.isFinite(n) ? n : value;
+            }
+            return value;
+        case 'boolean':
+            if (typeof value === 'boolean')
+                return value;
+            if (typeof value === 'string') {
+                const s = value.toLowerCase();
+                if (s === 'true')
+                    return true;
+                if (s === 'false')
+                    return false;
+            }
+            return value;
+        case 'array':
+            if (Array.isArray(value))
+                return value;
+            if (typeof value === 'string') {
+                // conservative: split commas/newlines; caller controls format
+                const parts = value.split(/[\n,]+/).map(s => s.trim()).filter(Boolean);
+                return parts.length ? parts : value;
+            }
+            return value;
+        case 'object':
+            if (value && typeof value === 'object')
+                return value;
+            return value;
+        default:
+            return value;
+    }
+}
+export function normalizeArgsBySchema(input, schema) {
+    if (!schema || !schema.properties || !isObject(input)) {
+        const ok = !!(isObject(input) && Object.keys(input).length > 0);
+        return ok ? { ok: true, value: input } : { ok: false, errors: ['no_schema_or_invalid_input'] };
+    }
+    const propMap = buildPropertyMap(schema);
+    const out = {};
+    const errors = [];
+    const additional = schema.additionalProperties !== false;
+    const reqList = Array.isArray(schema.required) ? schema.required : [];
+    if (Object.keys(input).length === 1 && typeof input._raw === 'string' && reqList.length === 1) {
+        const only = reqList[0];
+        const child = (schema.properties || {})[only];
+        if (child) {
+            const coerced = coerceType(input._raw, child);
+            if (typeof coerced === 'string' && coerced.trim().length > 0)
+                out[only] = coerced;
+        }
+    }
+    for (const [k, v] of Object.entries(input)) {
+        const key = normKey(k);
+        const target = propMap.get(key);
+        if (target) {
+            const childSchema = schema.properties[target];
+            out[target] = coerceType(v, childSchema);
+        }
+        else if (additional) {
+            out[k] = v;
+        }
+    }
+    const req = schema.required || [];
+    for (const r of req) {
+        if (!(r in out)) {
+            errors.push(`missing_required:${r}`);
+            continue;
+        }
+        const v = out[r];
+        if (typeof v === 'string' && v.trim().length === 0) {
+            errors.push(`missing_required:${r}`);
+            continue;
+        }
+        if (Array.isArray(v) && v.length === 0) {
+            errors.push(`missing_required:${r}`);
+            continue;
+        }
+        if (v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 0) {
+            errors.push(`missing_required:${r}`);
+            continue;
+        }
+    }
+    const ok = errors.length === 0;
+    return ok ? { ok, value: out } : { ok, value: out, errors };
+}
+// Tools normalizer (OpenAI-like)
+export function normalizeTools(tools) {
+    if (!Array.isArray(tools))
+        return [];
+    const out = [];
+    for (const t of tools) {
+        if (!t || typeof t !== 'object')
+            continue;
+        const fn = t.function || {};
+        const topName = typeof t.name === 'string' ? t.name : undefined;
+        const topDesc = typeof t.description === 'string' ? t.description : undefined;
+        const topParams = t.parameters;
+        const name = typeof fn?.name === 'string' ? fn.name : topName;
+        const desc = typeof fn?.description === 'string' ? fn.description : topDesc;
+        let params = (fn?.parameters !== undefined ? fn.parameters : topParams);
+        if (typeof params === 'string') {
+            try {
+                params = JSON.parse(params);
+            }
+            catch {
+                params = {};
+            }
+        }
+        // Enforce schema for known tools with minimal, compatible constraints
+        let finalParams;
+        if (typeof name === 'string' && name.trim().toLowerCase() === 'shell') {
+            // Do NOT downgrade an existing schema; prefer string command, allow argv array as fallback
+            const base = isObject(params) ? params : {};
+            const props = isObject(base.properties) ? base.properties : {};
+            const existing = props.command;
+            const commandSchema = {
+                description: existing?.description ||
+                    'Shell command. Prefer a single string; an array of argv tokens is also accepted.',
+                oneOf: [
+                    { type: 'string' },
+                    { type: 'array', items: { type: 'string' } }
+                ]
+            };
+            props.command = commandSchema;
+            base.type = 'object';
+            base.properties = props;
+            const req = Array.isArray(base.required) ? base.required : [];
+            if (!req.includes('command'))
+                req.push('command');
+            base.required = req;
+            if (typeof base.additionalProperties !== 'boolean')
+                base.additionalProperties = false;
+            finalParams = base;
+        }
+        else if (isObject(params)) {
+            finalParams = params;
+        }
+        else {
+            finalParams = { type: 'object', properties: {}, additionalProperties: true };
+        }
+        const norm = { type: 'function', function: { name, ...(desc ? { description: desc } : {}), parameters: finalParams } };
+        if (norm.function?.name)
+            out.push(norm);
+    }
+    return out;
+}

package/dist/conversion/shared/chat-request-filters.d.ts

@@ -0,0 +1,9 @@
+import type { ConversionContext, ConversionProfile } from '../types.js';
+/**
+ * 统一的 Chat 请求侧过滤链路。
+ *
+ * 目标：
+ * - 所有进入 Provider 的 Chat 形状请求（无论入口为 /v1/chat、/v1/responses 还是 /v1/messages），
+ *   都在这里走同一套工具治理与参数标准化逻辑。
+ */
+export declare function runStandardChatRequestFilters(chatRequest: any, profile: ConversionProfile, context: ConversionContext): Promise<any>;

package/dist/conversion/shared/chat-request-filters.js

@@ -0,0 +1,74 @@
+import { FilterEngine, RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter, RequestStreamingToNonStreamingFilter } from '../../filters/index.js';
+import { normalizeChatRequest } from '../index.js';
+import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
+/**
+ * 统一的 Chat 请求侧过滤链路。
+ *
+ * 目标：
+ * - 所有进入 Provider 的 Chat 形状请求（无论入口为 /v1/chat、/v1/responses 还是 /v1/messages），
+ *   都在这里走同一套工具治理与参数标准化逻辑。
+ */
+export async function runStandardChatRequestFilters(chatRequest, profile, context) {
+    const requestId = context.requestId ?? `req_${Date.now()}`;
+    const modelId = (chatRequest && typeof chatRequest === 'object' && typeof chatRequest.model === 'string')
+        ? String(chatRequest.model)
+        : 'unknown';
+    const endpoint = context.entryEndpoint ||
+        context.endpoint ||
+        '/v1/chat/completions';
+    const reqCtxBase = {
+        requestId,
+        model: modelId,
+        endpoint,
+        profile: profile.outgoingProtocol,
+        debug: { emit: () => { } }
+    };
+    const engine = new FilterEngine();
+    // Request-side initial filters（与 openai-openai-codec 保持一致）
+    try {
+        const { RequestToolListFilter } = await import('../../filters/index.js');
+        engine.registerFilter(new RequestToolListFilter());
+    }
+    catch {
+        // 可选过滤器，失败时保持向后兼容
+    }
+    engine.registerFilter(new RequestToolCallsStringifyFilter());
+    engine.registerFilter(new RequestToolChoicePolicyFilter());
+    // 统一将 Provider 请求转为非流式 Chat；流式语义由上层 SSE 合成处理
+    engine.registerFilter(new RequestStreamingToNonStreamingFilter());
+    // FieldMap：保持与 Chat 入口一致，使用 openai-openai.fieldmap.json
+    try {
+        const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
+        if (cfg)
+            engine.setFieldMap(cfg);
+        engine.registerTransform('stringifyJson', (v) => (typeof v === 'string'
+            ? v
+            : (() => {
+                try {
+                    return JSON.stringify(v ?? {});
+                }
+                catch {
+                    return '{}';
+                }
+            })()));
+    }
+    catch {
+        // best-effort：缺少 fieldmap 时保持原样
+    }
+    let staged = await engine.run('request_pre', chatRequest, reqCtxBase);
+    staged = await engine.run('request_map', staged, reqCtxBase);
+    staged = await engine.run('request_post', staged, reqCtxBase);
+    // 归一化 Chat 请求后再做最终工具治理
+    let normalized = normalizeChatRequest(staged);
+    try {
+        const { RequestOpenAIToolsNormalizeFilter, ToolPostConstraintsFilter } = await import('../../filters/index.js');
+        engine.registerFilter(new RequestOpenAIToolsNormalizeFilter());
+        // 工具治理后的最后约束层：默认配置为空，由宿主/配置系统按 profile/provider/modelId 决定是否启用具体规则。
+        engine.registerFilter(new ToolPostConstraintsFilter('request_finalize'));
+        normalized = await engine.run('request_finalize', normalized, reqCtxBase);
+    }
+    catch {
+        // 可选工具归一过滤器，失败时保持已归一化结果
+    }
+    return normalized;
+}

package/dist/conversion/shared/jsonish.d.ts

@@ -0,0 +1,3 @@
+export declare function tryParseJson<T = unknown>(s: unknown): T | unknown;
+export declare function parseLenient(value: unknown): unknown;
+export declare function repairArgumentsToString(value: unknown): string;

package/dist/conversion/shared/jsonish.js

@@ -0,0 +1,177 @@
+// Shared JSON-ish parsing helpers
+export function tryParseJson(s) {
+    if (typeof s !== 'string')
+        return s;
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+// Lenient parsing for function.arguments often produced by models
+export function parseLenient(value) {
+    if (value === undefined || value === null)
+        return {};
+    if (typeof value === 'object')
+        return value;
+    if (typeof value !== 'string')
+        return { _raw: String(value) };
+    const s0 = value.trim();
+    if (!s0)
+        return {};
+    // 1) strict JSON
+    try {
+        return JSON.parse(s0);
+    }
+    catch { /* continue */ }
+    // 2) fenced ```json ... ``` or ``` ... ```
+    const fence = s0.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+    const candidate = fence ? fence[1] : s0;
+    // 3) object substring
+    const objMatch = candidate.match(/\{[\s\S]*\}/);
+    if (objMatch) {
+        try {
+            return JSON.parse(objMatch[0]);
+        }
+        catch { /* ignore */ }
+    }
+    // 4) array substring
+    const arrMatch = candidate.match(/\[[\s\S]*\]/);
+    if (arrMatch) {
+        try {
+            return JSON.parse(arrMatch[0]);
+        }
+        catch { /* ignore */ }
+    }
+    // 5) single quotes → double; unquoted keys → quoted
+    let t = candidate.replace(/'([^']*)'/g, '"$1"');
+    t = t.replace(/([{,\s])([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
+    try {
+        return JSON.parse(t);
+    }
+    catch { /* ignore */ }
+    // 6) key=value fallback across lines/commas
+    const obj = {};
+    const parts = candidate.split(/[\n,]+/).map(p => p.trim()).filter(Boolean);
+    for (const p of parts) {
+        const m = p.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*[:=]\s*(.+)$/);
+        if (!m)
+            continue;
+        const k = m[1];
+        let v = m[2].trim();
+        if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'")))
+            v = v.slice(1, -1);
+        try {
+            const pv = JSON.parse(v);
+            obj[k] = pv;
+            continue;
+        }
+        catch { /* fallthrough */ }
+        if (/^(true|false)$/i.test(v)) {
+            obj[k] = /^true$/i.test(v);
+            continue;
+        }
+        if (/^-?\d+(?:\.\d+)?$/.test(v)) {
+            obj[k] = Number(v);
+            continue;
+        }
+        obj[k] = v;
+    }
+    return obj;
+}
+// CCR-style repair: JSON -> JSON5-like cleanup -> safe fallback
+export function repairArgumentsToString(value) {
+    try {
+        if (value === undefined || value === null)
+            return '{}';
+        if (typeof value === 'object') {
+            try {
+                return JSON.stringify(value);
+            }
+            catch {
+                return '{}';
+            }
+        }
+        if (typeof value !== 'string') {
+            try {
+                return JSON.stringify({ _raw: String(value) });
+            }
+            catch {
+                return '{}';
+            }
+        }
+        let s = value.trim();
+        if (!s)
+            return '{}';
+        // 1) strict JSON
+        try {
+            JSON.parse(s);
+            return s;
+        }
+        catch { /* continue */ }
+        // 2) fenced ```json ... ``` or ``` ... ```
+        const fence = s.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+        if (fence && fence[1])
+            s = fence[1].trim();
+        // 3) strip comments (// and /* */)
+        try {
+            s = s.replace(/\/\/.*$/gm, '');
+            s = s.replace(/\/\*[\s\S]*?\*\//g, '');
+        }
+        catch { /* ignore */ }
+        // 4) remove trailing commas before } or ]
+        try {
+            s = s.replace(/,\s*(?=[}\]])/g, '');
+        }
+        catch { /* ignore */ }
+        // 5) single quotes to double
+        try {
+            s = s.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, '"$1"');
+        }
+        catch { /* ignore */ }
+        // 6) quote unquoted keys
+        try {
+            s = s.replace(/([\{,\s])([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
+        }
+        catch { /* ignore */ }
+        // 7) try parse after cleanup
+        try {
+            const obj = JSON.parse(s);
+            try {
+                if (obj && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, 'command')) {
+                    const cmd = obj.command;
+                    if (Array.isArray(cmd)) {
+                        obj.command = cmd.map((t) => String(t)).join(' ');
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            return JSON.stringify(obj);
+        }
+        catch { /* continue */ }
+        // 8) extract first {...} or [...] substring and try again
+        try {
+            const m = s.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+            if (m) {
+                const obj = JSON.parse(m[0]);
+                try {
+                    if (obj && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, 'command')) {
+                        const cmd = obj.command;
+                        if (Array.isArray(cmd)) {
+                            obj.command = cmd.map((t) => String(t)).join(' ');
+                        }
+                    }
+                }
+                catch { /* ignore */ }
+                return JSON.stringify(obj);
+            }
+        }
+        catch { /* ignore */ }
+        // 9) final fallback
+        return '{}';
+    }
+    catch {
+        return '{}';
+    }
+}

package/dist/conversion/shared/mcp-injection.d.ts

@@ -0,0 +1,2 @@
+export declare function injectMcpToolsForChat(tools: any[] | undefined, discoveredServers: string[]): any[];
+export declare function injectMcpToolsForResponses(tools: any[] | undefined, discoveredServers: string[]): any[];

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

@@ -0,0 +1,89 @@
+// Shared MCP tool exposure logic (two-step), aligned with claude-code-router
+const obj = (props, req) => ({
+    type: 'object',
+    properties: props,
+    required: req,
+    additionalProperties: false,
+});
+function uniq(arr) { return Array.from(new Set(arr)); }
+export function injectMcpToolsForChat(tools, discoveredServers) {
+    const out = [];
+    const keep = new Set();
+    const listServers = discoveredServers && discoveredServers.length ? { type: 'string', enum: uniq(discoveredServers) } : { type: 'string' };
+    const ensure = (name, def) => { if (!keep.has(name)) {
+        out.push(def);
+        keep.add(name);
+    } };
+    const current = Array.isArray(tools) ? tools : [];
+    for (const t of current) {
+        const name = t && t.function && typeof t.function.name === 'string' ? String(t.function.name) : '';
+        const lower = name.toLowerCase();
+        if (!name) {
+            out.push(t);
+            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.', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }, []) } });
+            continue;
+        }
+        if (lower === 'read_mcp_resource' || lower === 'list_mcp_resource_templates') {
+            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;
+            }
+        }
+        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 ensure = (name, def) => { if (!keep.has(name)) {
+        out.push(def);
+        keep.add(name);
+    } };
+    const current = Array.isArray(tools) ? tools : [];
+    for (const t of current) {
+        const name = t && t.function && typeof t.function.name === 'string' ? String(t.function.name) : '';
+        const lower = name.toLowerCase();
+        if (!name) {
+            out.push(t);
+            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.', parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }, []) } });
+            continue;
+        }
+        if (lower === 'read_mcp_resource' || lower === 'list_mcp_resource_templates') {
+            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 via MCP server.', parameters: obj({ server: srv, uri: { type: 'string' } }, ['server', 'uri']) } });
+                }
+                else {
+                    ensure('list_mcp_resource_templates', { type: 'function', function: { name: 'list_mcp_resource_templates', description: 'List resource templates via MCP server.', parameters: obj({ server: srv }, ['server']) } });
+                }
+                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' } }, []) } });
+    }
+    return out;
+}

package/dist/conversion/shared/media.d.ts

@@ -0,0 +1 @@
+export declare function isImagePath(p: unknown): boolean;