@jsonstudio/rcc 0.89.611 → 0.89.683

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

@@ -1,321 +0,0 @@
-// Unified tool harvesting (对齐, single entry)
-// - First-time harvesting only (no late-stage repair)
-// - Handles textual markers (<function=execute>, unified diff)
-// - Handles structural shapes (function_call legacy, tool_calls)
-// - Normalizes arguments (single JSON string), sets finish_reason when applicable
-function isObject(v) {
-    return !!v && typeof v === 'object' && !Array.isArray(v);
-}
-// Adjacent dedupe state (per request)
-const dedupeState = new Map();
-function hashString(s) {
-    try {
-        return require('crypto').createHash('sha1').update(s).digest('hex');
-    }
-    catch {
-        return String(s.length);
-    }
-}
-function toJsonString(v) {
-    if (typeof v === 'string')
-        return v;
-    try {
-        return JSON.stringify(v ?? {});
-    }
-    catch {
-        return '{}';
-    }
-}
-function genId(ctx, i = 0) {
-    const p = ctx?.idPrefix || 'call';
-    return `${p}_${Date.now()}_${(Math.random().toString(36).slice(2, 8))}_${i}`;
-}
-function chunkString(input, size) {
-    try {
-        const s = String(input ?? '');
-        if (!s)
-            return [];
-        const out = [];
-        for (let i = 0; i < s.length; i += size)
-            out.push(s.slice(i, i + size));
-        return out;
-    }
-    catch {
-        return [String(input ?? '')];
-    }
-}
-function extractFromTextual(content, ctx) {
-    const events = [];
-    if (typeof content !== 'string' || !content)
-        return events;
-    // 1) unified diff
-    const beginIdx = content.indexOf('*** Begin Patch');
-    const endIdx = content.indexOf('*** End Patch');
-    if (beginIdx >= 0 && endIdx > beginIdx) {
-        const patchText = content.slice(beginIdx, endIdx + '*** End Patch'.length);
-        const id = genId(ctx, 0);
-        const argStr = toJsonString({ patch: patchText });
-        events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name: 'apply_patch' } }] });
-        const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
-        for (const d of parts) {
-            events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
-        }
-        return events;
-    }
-    // 2) <function=execute>
-    const execRe = /<function=execute>[\s\S]*?<parameter=command>([\s\S]*?)<\/parameter>[\s\S]*?<\/function=execute>/i;
-    const mExec = execRe.exec(content);
-    if (mExec && mExec[1]) {
-        const cmdRaw = mExec[1].trim();
-        const argv = splitCommand(cmdRaw);
-        const id = genId(ctx, 0);
-        const argStr = toJsonString({ command: argv });
-        events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name: 'shell' } }] });
-        const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
-        for (const d of parts) {
-            events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
-        }
-        return events;
-    }
-    // 3) rcc.tool.v1 JSON envelope (removed)
-    // 4) Generic <tool_call> textual block with <arg_key>/<arg_value>
-    try {
-        // Explicit wrapper form
-        const blockRe = /<tool_call[^>]*>[\s\S]*?<\/tool_call>/gi;
-        const blocks = content.match(blockRe) || [];
-        let matched = false;
-        for (const b of blocks) {
-            const nameTag = /<tool_name>([\s\S]*?)<\/tool_name>/i.exec(b);
-            let nm = nameTag && nameTag[1] ? String(nameTag[1]).trim() : '';
-            if (!nm) {
-                if (/<arg_key>\s*command\s*<\/arg_key>/i.test(b))
-                    nm = 'shell';
-                else if (/\bapply_patch\b/i.test(b))
-                    nm = 'apply_patch';
-                else if (/\bupdate_plan\b/i.test(b))
-                    nm = 'update_plan';
-                else if (/\bview_image\b/i.test(b))
-                    nm = 'view_image';
-            }
-            const pairRe = /<arg_key>([\s\S]*?)<\/arg_key>\s*<arg_value>([\s\S]*?)<\/arg_value>/gi;
-            const argsObj = {};
-            let m;
-            while ((m = pairRe.exec(b)) !== null) {
-                const k = String((m[1] || '').trim());
-                const vRaw = (m[2] || '').trim();
-                let v = vRaw;
-                try {
-                    v = JSON.parse(vRaw);
-                }
-                catch { /* keep as string */ }
-                if (nm === 'shell' && k === 'command') {
-                    if (!Array.isArray(v))
-                        v = splitCommand(String(vRaw));
-                }
-                argsObj[k] = v;
-            }
-            if (nm) {
-                const id = genId(ctx, 0);
-                events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name: nm } }] });
-                const argStr = toJsonString(argsObj);
-                const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
-                for (const d of parts) {
-                    events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
-                }
-                matched = true;
-            }
-        }
-        if (matched)
-            return events;
-        // Inline fallback: e.g., 'shell\n<arg_key>command</arg_key>...'
-        const inlineRe = /(shell|apply_patch|update_plan|view_image)[\s\S]*?<arg_key>([\s\S]*?)<\/arg_key>\s*<arg_value>([\s\S]*?)<\/arg_value>/i;
-        const mi = inlineRe.exec(content);
-        if (mi) {
-            const nm = String(mi[1]).trim();
-            const k = String(mi[2]).trim();
-            const vRaw = String(mi[3]).trim();
-            let v = vRaw;
-            try {
-                v = JSON.parse(vRaw);
-            }
-            catch { /* keep as string */ }
-            const args = {};
-            if (nm === 'shell' && k === 'command') {
-                if (!Array.isArray(v))
-                    v = splitCommand(String(vRaw));
-            }
-            args[k] = v;
-            const id = genId(ctx, 0);
-            events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name: nm } }] });
-            const argStr = toJsonString(args);
-            for (const d of chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)))) {
-                events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
-            }
-            return events;
-        }
-    }
-    catch { /* ignore textual tool_call parse errors */ }
-    return events;
-}
-function splitCommand(s) {
-    try {
-        const out = [];
-        let cur = '';
-        let quote = null;
-        for (let i = 0; i < s.length; i++) {
-            const ch = s[i];
-            if (quote) {
-                if (ch === quote) {
-                    quote = null;
-                }
-                else {
-                    cur += ch;
-                }
-            }
-            else {
-                if (ch === '"' || ch === '\'') {
-                    quote = ch;
-                }
-                else if (/\s/.test(ch)) {
-                    if (cur) {
-                        out.push(cur);
-                        cur = '';
-                    }
-                }
-                else {
-                    cur += ch;
-                }
-            }
-        }
-        if (cur)
-            out.push(cur);
-        return out;
-    }
-    catch {
-        return [s];
-    }
-}
-export function harvestTools(signal, ctx) {
-    const result = { deltaEvents: [] };
-    const chunkSize = Math.max(32, Math.min(1024, ctx?.chunkSize || 256));
-    try {
-        if (signal.type === 'delta') {
-            // OpenAI streaming chunk delta
-            const delta = signal.payload;
-            const events = [];
-            const content = delta?.choices?.[0]?.delta?.content;
-            if (typeof content === 'string' && content.trim()) {
-                events.push(...extractFromTextual(content, ctx));
-            }
-            // legacy function_call → tool_calls
-            const fc = delta?.choices?.[0]?.delta?.function_call;
-            if (isObject(fc)) {
-                const name = typeof fc.name === 'string' ? fc.name : undefined;
-                const argStr = toJsonString(fc.arguments);
-                const id = genId(ctx, 0);
-                if (name) {
-                    events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name } }] });
-                    for (const d of chunkString(argStr, chunkSize)) {
-                        events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
-                    }
-                }
-            }
-            // direct delta.tool_calls
-            const tcd = delta?.choices?.[0]?.delta?.tool_calls;
-            if (Array.isArray(tcd)) {
-                let idx = 0;
-                for (const tc of tcd) {
-                    const id = typeof tc?.id === 'string' ? tc.id : genId(ctx, idx);
-                    const name = typeof tc?.function?.name === 'string' ? tc.function.name : undefined;
-                    const args = (tc?.function?.arguments !== undefined) ? toJsonString(tc.function.arguments) : undefined;
-                    // Adjacent dedupe per requestId
-                    const key = ctx?.requestId || 'default';
-                    const state = dedupeState.get(key) || {};
-                    const argsHash = typeof args === 'string' ? hashString(args) : undefined;
-                    const isDup = (state.name === name && state.argsHash && argsHash && state.argsHash === argsHash);
-                    if (!isDup) {
-                        if (name) {
-                            events.push({ tool_calls: [{ index: idx, id, type: 'function', function: { name } }] });
-                        }
-                        if (typeof args === 'string') {
-                            for (const d of chunkString(args, chunkSize)) {
-                                events.push({ tool_calls: [{ index: idx, id, type: 'function', function: { arguments: d } }] });
-                            }
-                        }
-                        dedupeState.set(key, { name, argsHash });
-                    }
-                    idx += 1;
-                }
-            }
-            result.deltaEvents = events;
-            return result;
-        }
-        // final/compat: normalize choices[0].message.tool_calls (no synthesis)
-        const src = signal.payload;
-        const choice = Array.isArray(src?.choices) ? src.choices[0] : null;
-        const msg = choice?.message || {};
-        const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
-        if (toolCalls.length > 0) {
-            // Ensure arguments are stringified
-            for (const tc of toolCalls) {
-                const fn = tc.function || {};
-                if (fn && fn.arguments && typeof fn.arguments !== 'string') {
-                    fn.arguments = toJsonString(fn.arguments);
-                }
-            }
-            // finish_reason
-            if (choice && choice.finish_reason !== 'tool_calls') {
-                choice.finish_reason = 'tool_calls';
-            }
-            // content policy: set to empty string or null unchanged
-            result.normalized = src;
-            return result;
-        }
-        // If no structured tool_calls, attempt textual harvesting from message.content
-        try {
-            const content = msg?.content;
-            if (typeof content === 'string' && content.trim()) {
-                const evs = extractFromTextual(content, ctx);
-                if (Array.isArray(evs) && evs.length > 0) {
-                    // Aggregate deltaEvents into final tool_calls (group by id)
-                    const map = {};
-                    for (const e of evs) {
-                        const tcs = Array.isArray(e.tool_calls) ? e.tool_calls : [];
-                        for (const t of tcs) {
-                            const id = String(t.id || genId(ctx, 0));
-                            if (!map[id])
-                                map[id] = { name: undefined, args: [], type: 'function' };
-                            const nm = t.function?.name;
-                            const arg = t.function?.arguments;
-                            if (typeof nm === 'string' && !map[id].name)
-                                map[id].name = nm;
-                            if (typeof arg === 'string')
-                                map[id].args.push(arg);
-                        }
-                    }
-                    const merged = [];
-                    for (const [id, item] of Object.entries(map)) {
-                        const argStr = item.args.join('');
-                        merged.push({ id, type: 'function', function: { name: item.name, arguments: argStr } });
-                    }
-                    if (merged.length > 0) {
-                        msg.tool_calls = merged;
-                        // Clear textual content to avoid duplicate display
-                        msg.content = '';
-                        if (choice && choice.finish_reason !== 'tool_calls') {
-                            choice.finish_reason = 'tool_calls';
-                        }
-                        result.normalized = src;
-                        return result;
-                    }
-                }
-            }
-        }
-        catch { /* ignore textual harvest on final */ }
-        result.normalized = src;
-        return result;
-    }
-    catch {
-        return result;
-    }
-}

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

@@ -1,19 +0,0 @@
-import type { ChatToolDefinition } from '../hub/types/chat-envelope.js';
-import type { BridgeToolDefinition } from './bridge-message-types.js';
-export interface ToolCallFunction {
-    name: string;
-    arguments: string;
-}
-export interface ToolCallItem {
-    id?: string;
-    type: 'function';
-    function: ToolCallFunction;
-}
-export declare function stringifyArgs(args: unknown): string;
-export interface BridgeToolMapOptions {
-    sanitizeName?: (raw: unknown) => string | undefined;
-}
-export declare function bridgeToolToChatDefinition(rawTool: BridgeToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): ChatToolDefinition | null;
-export declare function mapBridgeToolsToChat(rawTools: unknown, options?: BridgeToolMapOptions): ChatToolDefinition[] | undefined;
-export declare function chatToolToBridgeDefinition(rawTool: ChatToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): BridgeToolDefinition | null;
-export declare function mapChatToolsToBridge(rawTools: unknown, options?: BridgeToolMapOptions): BridgeToolDefinition[] | undefined;

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

@@ -1,218 +0,0 @@
-export function stringifyArgs(args) {
-    if (typeof args === 'string')
-        return args;
-    try {
-        return JSON.stringify(args ?? {});
-    }
-    catch {
-        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);
-    }
-    if (normalizedName === 'web_search') {
-        // For web_search we currently accept any incoming schema and fall back to a
-        // minimal object definition. Server-side web_search execution only relies
-        // on the function name + JSON arguments, so tool schema is best-effort.
-        const base = asSchema(candidate) ?? {};
-        if (!base.type) {
-            base.type = 'object';
-        }
-        if (!Object.prototype.hasOwnProperty.call(base, 'properties')) {
-            base.properties = {};
-        }
-        return base;
-    }
-    return asSchema(candidate);
-}
-const DEFAULT_SANITIZER = (value) => {
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        return trimmed.length ? trimmed : undefined;
-    }
-    return undefined;
-};
-function resolveToolName(candidate, options) {
-    const sanitized = options?.sanitizeName?.(candidate);
-    if (typeof sanitized === 'string' && sanitized.trim().length) {
-        return sanitized.trim();
-    }
-    return DEFAULT_SANITIZER(candidate);
-}
-function pickToolName(candidates, options) {
-    for (const candidate of candidates) {
-        const name = resolveToolName(candidate, options);
-        if (name) {
-            return name;
-        }
-    }
-    return undefined;
-}
-function resolveToolDescription(candidate) {
-    if (typeof candidate === 'string') {
-        return candidate;
-    }
-    return undefined;
-}
-function resolveToolParameters(container, fallback) {
-    if (container && Object.prototype.hasOwnProperty.call(container, 'parameters')) {
-        return container.parameters;
-    }
-    if (fallback && Object.prototype.hasOwnProperty.call(fallback, 'parameters')) {
-        return fallback.parameters;
-    }
-    return undefined;
-}
-function resolveToolStrict(container, fallback) {
-    if (container && typeof container.strict === 'boolean') {
-        return container.strict;
-    }
-    if (fallback && typeof fallback.strict === 'boolean') {
-        return fallback.strict;
-    }
-    return undefined;
-}
-export function bridgeToolToChatDefinition(rawTool, options) {
-    if (!rawTool || typeof rawTool !== 'object') {
-        return null;
-    }
-    const tool = rawTool;
-    const fnNode = tool.function && typeof tool.function === 'object' ? tool.function : undefined;
-    let name = pickToolName([fnNode?.name, tool.name], options);
-    // Special case for Responses builtin web_search tools:
-    // Codex / Claude‑code may send tools shaped as `{ type: "web_search", ... }`
-    // without a nested `function` node. Treat these as a canonical `web_search`
-    // function tool so downstream Chat / Standardized layers can reason over a
-    // single function-style web_search surface.
-    if (!name) {
-        const rawType = typeof tool.type === 'string' ? tool.type.trim().toLowerCase() : '';
-        if (rawType === 'web_search' || rawType.startsWith('web_search')) {
-            name = 'web_search';
-        }
-    }
-    if (!name)
-        return null;
-    const description = resolveToolDescription(fnNode?.description ?? tool.description);
-    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;
-    const fnOut = { name };
-    if (description !== undefined) {
-        fnOut.description = description;
-    }
-    if (parameters !== undefined) {
-        fnOut.parameters = parameters;
-    }
-    if (strict !== undefined) {
-        fnOut.strict = strict;
-    }
-    return {
-        type: normalizedType,
-        function: fnOut
-    };
-}
-export function mapBridgeToolsToChat(rawTools, options) {
-    if (!Array.isArray(rawTools) || rawTools.length === 0) {
-        return undefined;
-    }
-    const mapped = rawTools
-        .map((entry) => bridgeToolToChatDefinition(entry, options))
-        .filter((entry) => !!entry);
-    return mapped.length ? mapped : undefined;
-}
-export function chatToolToBridgeDefinition(rawTool, options) {
-    if (!rawTool || typeof rawTool !== 'object') {
-        return null;
-    }
-    const tool = rawTool;
-    const fnNode = tool.function && typeof tool.function === 'object' ? tool.function : undefined;
-    const name = pickToolName([fnNode?.name, tool.name], options);
-    if (!name) {
-        return null;
-    }
-    const description = resolveToolDescription(fnNode?.description);
-    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 = {
-        type: normalizedType,
-        name
-    };
-    if (description !== undefined) {
-        responseShape.description = description;
-    }
-    if (parameters !== undefined) {
-        responseShape.parameters = parameters;
-    }
-    if (strict !== undefined) {
-        responseShape.strict = strict;
-    }
-    const fnOut = { name };
-    if (description !== undefined) {
-        fnOut.description = description;
-    }
-    if (parameters !== undefined) {
-        fnOut.parameters = parameters;
-    }
-    if (strict !== undefined) {
-        fnOut.strict = strict;
-    }
-    responseShape.function = fnOut;
-    return responseShape;
-}
-export function mapChatToolsToBridge(rawTools, options) {
-    if (!Array.isArray(rawTools) || rawTools.length === 0) {
-        return undefined;
-    }
-    const mapped = rawTools
-        .map((entry) => chatToolToBridgeDefinition(entry, options))
-        .filter((entry) => !!entry);
-    return mapped.length ? mapped : undefined;
-}

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

@@ -1,4 +0,0 @@
-import type { ChatToolDefinition, MissingField } from '../hub/types/chat-envelope.js';
-import type { JsonValue } from '../hub/types/json.js';
-export declare function normalizeAnthropicTools(rawTools: JsonValue | undefined, missing?: MissingField[]): ChatToolDefinition[] | undefined;
-export declare function normalizeGeminiTools(rawTools: JsonValue | undefined, missing?: MissingField[]): ChatToolDefinition[] | undefined;

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

@@ -1,84 +0,0 @@
-import { isJsonObject, jsonClone } from '../hub/types/json.js';
-export function normalizeAnthropicTools(rawTools, missing) {
-    if (!Array.isArray(rawTools) || rawTools.length === 0)
-        return undefined;
-    const tools = [];
-    rawTools.forEach((entry, index) => {
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
-            missing?.push({
-                path: `tools[${index}]`,
-                reason: 'invalid_entry',
-                originalValue: jsonClone(entry)
-            });
-            return;
-        }
-        const nameValue = entry.name;
-        if (typeof nameValue !== 'string' || !nameValue.trim())
-            return;
-        const desc = entry.description;
-        const schema = entry.input_schema;
-        const parameters = schema && typeof schema === 'object' && !Array.isArray(schema)
-            ? schema
-            : { type: 'object', properties: {} };
-        tools.push({
-            type: 'function',
-            function: {
-                name: nameValue,
-                description: typeof desc === 'string' ? desc : undefined,
-                parameters
-            }
-        });
-    });
-    return tools.length ? tools : undefined;
-}
-export function normalizeGeminiTools(rawTools, missing) {
-    if (!rawTools)
-        return undefined;
-    const arr = Array.isArray(rawTools) ? rawTools : [rawTools];
-    const tools = [];
-    arr.forEach((entry, index) => {
-        if (!entry || typeof entry !== 'object') {
-            missing?.push({
-                path: `tools[${index}]`,
-                reason: 'invalid_entry',
-                originalValue: jsonClone(entry)
-            });
-            return;
-        }
-        const obj = entry;
-        const declarations = Array.isArray(obj.functionDeclarations) ? obj.functionDeclarations : undefined;
-        if (declarations && declarations.length) {
-            declarations.forEach((decl, declIndex) => {
-                if (!decl || typeof decl !== 'object') {
-                    missing?.push({ path: `tools[${index}].functionDeclarations[${declIndex}]`, reason: 'invalid_entry' });
-                    return;
-                }
-                const def = decl;
-                const name = typeof def.name === 'string' ? def.name : undefined;
-                if (!name)
-                    return;
-                tools.push({
-                    type: 'function',
-                    function: {
-                        name,
-                        description: typeof def.description === 'string' ? def.description : undefined,
-                        parameters: isJsonObject(def.parameters) ? jsonClone(def.parameters) : { type: 'object', properties: {} }
-                    }
-                });
-            });
-            return;
-        }
-        const name = typeof obj.name === 'string' ? obj.name : undefined;
-        if (!name)
-            return;
-        tools.push({
-            type: 'function',
-            function: {
-                name,
-                description: typeof obj.description === 'string' ? obj.description : undefined,
-                parameters: isJsonObject(obj.parameters) ? jsonClone(obj.parameters) : { type: 'object', properties: {} }
-            }
-        });
-    });
-    return tools.length ? tools : undefined;
-}