@codebolt/agent 6.1.21 → 6.1.23

package/dist/unified/utils/agentToolLoader.d.ts

@@ -5,6 +5,19 @@ type ToolResponse = {
         tools?: unknown;
     } | unknown;
 };
+export type ToolSourceType = 'built-in' | 'mcp' | 'plugin' | 'project-local' | 'agent-local' | 'unknown';
+export interface RuntimeToolDescriptor {
+    name: string;
+    toolName: string;
+    namespace: string;
+    sourceType: ToolSourceType;
+    sourceId?: string;
+    displayName?: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
 export declare class LocalToolConfigurationError extends Error {
     constructor(message: string);
 }
@@ -15,10 +28,13 @@ export interface AgentLocalToolRegistry {
 export declare function normalizeToolForModel(tool: Tool): Tool;
 export declare function resolveToolExecutionName(modelToolName: string): string;
 export declare function normalizeToolResponse(response: ToolResponse | undefined): Tool[];
+export declare function normalizeRuntimeToolResponse(response: ToolResponse | undefined): RuntimeToolDescriptor[];
 export declare function mergeTools(...toolGroups: Tool[][]): Tool[];
+export declare function mergeRuntimeTools(...toolGroups: RuntimeToolDescriptor[][]): RuntimeToolDescriptor[];
 export declare function createAgentLocalToolRegistry(localTools?: AgentLocalTool[]): AgentLocalToolRegistry;
 export declare function assertNoLocalToolSchemaCollisions(localSchemas: Tool[], externalSchemas: Tool[]): void;
 export declare function listProjectLocalTools(): Promise<Tool[]>;
-export declare function listAgentAvailableTools(mentionedMCPs?: unknown[]): Promise<Tool[]>;
+export declare function listAgentAvailableTools(mentionedNamespaces?: unknown[]): Promise<Tool[]>;
+export declare function listAgentRuntimeTools(localTools?: AgentLocalTool[]): Promise<RuntimeToolDescriptor[]>;
 export declare function appendUniqueTools(targetTools: Tool[], toolsToAppend: Tool[]): void;
 export {};

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_-]+$/;
@@ -38,6 +41,80 @@ 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));
 }
@@ -58,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);
@@ -94,6 +171,31 @@ 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) {
     const mergedTools = new Map();
     for (const tools of toolGroups) {
@@ -106,6 +208,17 @@ function mergeTools(...toolGroups) {
     }
     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') {
         return false;
@@ -158,46 +271,79 @@ function assertNoLocalToolSchemaCollisions(localSchemas, externalSchemas) {
     }
 }
 async function listProjectLocalTools() {
-    const mcp = codeboltjs_1.default.mcp;
-    if (typeof mcp.getRegisteredTools === 'function') {
-        try {
-            return normalizeToolResponse(await mcp.getRegisteredTools());
-        }
-        catch (error) {
-            console.error('[AgentToolLoader] Failed to load registered MCP tools:', error);
-        }
-    }
-    if (typeof mcp.getLocalMCPServers === 'function') {
+    const tools = codeboltjs_1.default.tools;
+    if (typeof (tools === null || tools === void 0 ? void 0 : tools.listExternalTools) === 'function') {
         try {
-            return normalizeToolResponse(await mcp.getLocalMCPServers());
+            return normalizeRuntimeToolResponse(await tools.listExternalTools())
+                .map(runtimeDescriptorToTool);
         }
         catch (error) {
-            console.error('[AgentToolLoader] Failed to load project-local tools:', error);
+            console.error('[AgentToolLoader] Failed to load external tools:', error);
         }
     }
     return [];
 }
-async function listAgentAvailableTools(mentionedMCPs = []) {
+function getMentionedNamespace(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    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(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);
 }
+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);
+        }
+    }
+    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.21",
+  "version": "6.1.23",
   "description": "CodeBolt Agent utilities for building and managing AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",