@codebolt/agent 6.1.20 → 6.1.22

package/dist/unified/utils/agentToolLoader.js

@@ -7,11 +7,14 @@ exports.LocalToolConfigurationError = void 0;
 exports.normalizeToolForModel = normalizeToolForModel;
 exports.resolveToolExecutionName = resolveToolExecutionName;
 exports.normalizeToolResponse = normalizeToolResponse;
+exports.normalizeRuntimeToolResponse = normalizeRuntimeToolResponse;
 exports.mergeTools = mergeTools;
+exports.mergeRuntimeTools = mergeRuntimeTools;
 exports.createAgentLocalToolRegistry = createAgentLocalToolRegistry;
 exports.assertNoLocalToolSchemaCollisions = assertNoLocalToolSchemaCollisions;
 exports.listProjectLocalTools = listProjectLocalTools;
 exports.listAgentAvailableTools = listAgentAvailableTools;
+exports.listAgentRuntimeTools = listAgentRuntimeTools;
 exports.appendUniqueTools = appendUniqueTools;
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const MODEL_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
@@ -30,7 +33,90 @@ function isTool(value) {
         return false;
     }
     const candidate = value;
-    return candidate.type === 'function' && typeof ((_a = candidate.function) === null || _a === void 0 ? void 0 : _a.name) === 'string';
+    return candidate.type === 'function' &&
+        typeof ((_a = candidate.function) === null || _a === void 0 ? void 0 : _a.name) === 'string' &&
+        candidate.function.name.trim().length > 0;
+}
+function getToolName(tool) {
+    var _a, _b;
+    return ((_b = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.trim()) || '';
+}
+function splitQualifiedToolName(toolName) {
+    const separatorIndex = toolName.indexOf('--');
+    if (separatorIndex === -1) {
+        return { toolName };
+    }
+    return {
+        sourceId: toolName.slice(0, separatorIndex),
+        toolName: toolName.slice(separatorIndex + 2),
+    };
+}
+function inferSourceType(sourceId) {
+    if (sourceId === 'codebolt') {
+        return 'built-in';
+    }
+    if (sourceId === 'agent-local') {
+        return 'agent-local';
+    }
+    if (sourceId.startsWith('local/')) {
+        return 'project-local';
+    }
+    if (sourceId.startsWith('plugin:')) {
+        return 'plugin';
+    }
+    return 'mcp';
+}
+function deriveBuiltInNamespace(toolName) {
+    const dottedNamespace = toolName.split('.')[0];
+    if (dottedNamespace && dottedNamespace !== toolName) {
+        return dottedNamespace;
+    }
+    return toolName.split('_')[0] || 'codebolt';
+}
+function deriveNamespace(toolName, sourceType, sourceId) {
+    const parsed = splitQualifiedToolName(toolName);
+    if (parsed.sourceId && parsed.sourceId !== 'codebolt') {
+        return parsed.sourceId;
+    }
+    if (sourceType === 'built-in') {
+        return deriveBuiltInNamespace(parsed.toolName);
+    }
+    return parsed.sourceId || sourceId || parsed.toolName;
+}
+function toolToRuntimeDescriptor(tool, fallbackSourceType, fallbackSourceId) {
+    var _a, _b;
+    const parsed = splitQualifiedToolName(getToolName(tool));
+    const sourceId = parsed.sourceId || fallbackSourceId || 'codebolt';
+    const sourceType = fallbackSourceType || inferSourceType(sourceId);
+    return {
+        name: getToolName(tool),
+        toolName: parsed.toolName,
+        namespace: deriveNamespace(getToolName(tool), sourceType, sourceId),
+        sourceType,
+        sourceId,
+        displayName: parsed.toolName,
+        description: ((_a = tool.function) === null || _a === void 0 ? void 0 : _a.description) || '',
+        inputSchema: ((_b = tool.function) === null || _b === void 0 ? void 0 : _b.parameters) || { type: 'object', properties: {} },
+    };
+}
+function isRuntimeToolDescriptor(value) {
+    const candidate = value;
+    return !!candidate &&
+        typeof candidate.name === 'string' &&
+        typeof candidate.toolName === 'string';
+}
+function runtimeDescriptorToTool(tool) {
+    return normalizeToolForModel({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description || '',
+            parameters: tool.inputSchema || { type: 'object', properties: {} },
+        },
+    });
+}
+function compareToolsByName(leftTool, rightTool) {
+    return getToolName(leftTool).localeCompare(getToolName(rightTool));
 }
 function hashString(value) {
     let hash = 0;
@@ -49,9 +135,9 @@ function normalizeToolForModel(tool) {
     if (!MODEL_TOOL_NAME_PATTERN.test(originalName)) {
         const separatorIndex = originalName.indexOf('--');
         if (originalName.startsWith(LOCAL_TOOL_PREFIX) && separatorIndex > LOCAL_TOOL_PREFIX.length) {
-            const toolboxName = originalName.slice(LOCAL_TOOL_PREFIX.length, separatorIndex);
+            const namespaceName = originalName.slice(LOCAL_TOOL_PREFIX.length, separatorIndex);
             const actualToolName = originalName.slice(separatorIndex + 2);
-            modelName = `local_${sanitizeToolNamePart(toolboxName)}--${sanitizeToolNamePart(actualToolName)}`;
+            modelName = `local_${sanitizeToolNamePart(namespaceName)}--${sanitizeToolNamePart(actualToolName)}`;
         }
         else {
             modelName = sanitizeToolNamePart(originalName);
@@ -85,18 +171,53 @@ function normalizeToolResponse(response) {
             : [];
     return tools.filter(isTool).map(normalizeToolForModel);
 }
+function normalizeRuntimeToolResponse(response) {
+    const data = response === null || response === void 0 ? void 0 : response.data;
+    const tools = Array.isArray(data === null || data === void 0 ? void 0 : data.tools)
+        ? data.tools
+        : Array.isArray(data)
+            ? data
+            : [];
+    return tools
+        .map((tool) => {
+        if (isRuntimeToolDescriptor(tool)) {
+            const sourceType = tool.sourceType || (tool.sourceId ? inferSourceType(tool.sourceId) : 'unknown');
+            return {
+                ...tool,
+                namespace: tool.namespace || deriveNamespace(tool.name, sourceType, tool.sourceId),
+                sourceType,
+                inputSchema: tool.inputSchema || { type: 'object', properties: {} },
+            };
+        }
+        if (isTool(tool)) {
+            return toolToRuntimeDescriptor(normalizeToolForModel(tool));
+        }
+        return undefined;
+    })
+        .filter((tool) => !!tool);
+}
 function mergeTools(...toolGroups) {
-    var _a;
     const mergedTools = new Map();
     for (const tools of toolGroups) {
         for (const tool of tools) {
-            const toolName = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name;
+            const toolName = getToolName(tool);
             if (toolName && !mergedTools.has(toolName)) {
                 mergedTools.set(toolName, tool);
             }
         }
     }
-    return Array.from(mergedTools.values());
+    return Array.from(mergedTools.values()).sort(compareToolsByName);
+}
+function mergeRuntimeTools(...toolGroups) {
+    const mergedTools = new Map();
+    for (const tools of toolGroups) {
+        for (const tool of tools) {
+            if (tool.name && !mergedTools.has(tool.name)) {
+                mergedTools.set(tool.name, tool);
+            }
+        }
+    }
+    return Array.from(mergedTools.values()).sort((left, right) => left.name.localeCompare(right.name));
 }
 function isAgentLocalTool(value) {
     if (!value || typeof value !== 'object') {
@@ -150,50 +271,80 @@ function assertNoLocalToolSchemaCollisions(localSchemas, externalSchemas) {
     }
 }
 async function listProjectLocalTools() {
-    const mcp = codeboltjs_1.default.mcp;
-    if (typeof mcp.getLocalMCPServers !== 'function') {
-        return [];
+    const tools = codeboltjs_1.default.tools;
+    if (typeof (tools === null || tools === void 0 ? void 0 : tools.listExternalTools) === 'function') {
+        try {
+            return normalizeRuntimeToolResponse(await tools.listExternalTools())
+                .map(runtimeDescriptorToTool);
+        }
+        catch (error) {
+            console.error('[AgentToolLoader] Failed to load external tools:', error);
+        }
     }
-    try {
-        return normalizeToolResponse(await mcp.getLocalMCPServers());
+    return [];
+}
+function getMentionedNamespace(value) {
+    if (typeof value === 'string') {
+        return value;
     }
-    catch (error) {
-        console.error('[AgentToolLoader] Failed to load project-local tools:', error);
-        return [];
+    if (!value || typeof value !== 'object') {
+        return undefined;
     }
+    const candidate = value;
+    return typeof candidate.namespace === 'string'
+        ? candidate.namespace
+        : typeof candidate.sourceId === 'string'
+            ? candidate.sourceId
+            : undefined;
 }
-async function listAgentAvailableTools(mentionedMCPs = []) {
+async function listAgentAvailableTools(mentionedNamespaces = []) {
     let codeboltTools = [];
     let mentionedTools = [];
+    const toolGateway = codeboltjs_1.default.tools;
     try {
-        codeboltTools = normalizeToolResponse(await codeboltjs_1.default.mcp.listMcpFromServers(['codebolt']));
+        if (typeof (toolGateway === null || toolGateway === void 0 ? void 0 : toolGateway.listBuiltInTools) === 'function') {
+            codeboltTools = normalizeRuntimeToolResponse(await toolGateway.listBuiltInTools())
+                .map(runtimeDescriptorToTool);
+        }
     }
     catch (error) {
         console.error('[AgentToolLoader] Failed to load CodeBolt tools:', error);
     }
     const localTools = await listProjectLocalTools();
-    if (mentionedMCPs.length > 0) {
+    if (mentionedNamespaces.length > 0 && typeof (toolGateway === null || toolGateway === void 0 ? void 0 : toolGateway.listToolsByNamespace) === 'function') {
         try {
-            const response = await codeboltjs_1.default.mcp.getTools(mentionedMCPs);
-            mentionedTools = normalizeToolResponse(response);
+            const namespaceTools = await Promise.all(mentionedNamespaces
+                .map(getMentionedNamespace)
+                .filter((namespace) => typeof namespace === 'string' && namespace.length > 0)
+                .map(namespace => toolGateway.listToolsByNamespace(namespace)));
+            mentionedTools = namespaceTools
+                .flatMap(response => normalizeRuntimeToolResponse(response))
+                .map(runtimeDescriptorToTool);
         }
         catch (error) {
-            console.error('[AgentToolLoader] Failed to load mentioned MCP tools:', error);
+            console.error('[AgentToolLoader] Failed to load mentioned namespace tools:', error);
         }
     }
     return mergeTools(codeboltTools, localTools, mentionedTools);
 }
-function appendUniqueTools(targetTools, toolsToAppend) {
-    var _a;
-    const existingToolNames = new Set(targetTools
-        .map((tool) => { var _a; return (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name; })
-        .filter((toolName) => typeof toolName === 'string' && toolName.length > 0));
-    for (const tool of toolsToAppend) {
-        const toolName = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name;
-        if (!toolName || existingToolNames.has(toolName)) {
-            continue;
+async function listAgentRuntimeTools(localTools = []) {
+    const toolGateway = codeboltjs_1.default.tools;
+    const agentLocalSchemas = localTools.map(localTool => normalizeToolForModel(localTool.toOpenAITool()));
+    if (typeof (toolGateway === null || toolGateway === void 0 ? void 0 : toolGateway.listRuntimeTools) === 'function') {
+        try {
+            return normalizeRuntimeToolResponse(await toolGateway.listRuntimeTools({
+                agentLocalTools: agentLocalSchemas,
+            }));
+        }
+        catch (error) {
+            console.error('[AgentToolLoader] Failed to load runtime tool descriptors:', error);
         }
-        targetTools.push(tool);
-        existingToolNames.add(toolName);
     }
+    const runtimeTools = (await listAgentAvailableTools()).map(tool => toolToRuntimeDescriptor(tool));
+    const agentLocalRuntimeTools = agentLocalSchemas.map(tool => toolToRuntimeDescriptor(tool, 'agent-local', 'agent-local'));
+    return mergeRuntimeTools(runtimeTools, agentLocalRuntimeTools);
+}
+function appendUniqueTools(targetTools, toolsToAppend) {
+    const mergedTools = mergeTools(targetTools, toolsToAppend);
+    targetTools.splice(0, targetTools.length, ...mergedTools);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/agent",
-  "version": "6.1.20",
+  "version": "6.1.22",
   "description": "CodeBolt Agent utilities for building and managing AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -72,6 +72,10 @@
     "./unified": {
       "types": "./dist/unified/index.d.ts",
       "default": "./dist/unified/index.js"
+    },
+    "./unified/tools": {
+      "types": "./dist/unified/agent/tools.d.ts",
+      "default": "./dist/unified/agent/tools.js"
     }
   }
 }