@codebolt/codeboltjs 5.0.8 → 5.1.10

package/dist/tools/orchestration/agent-find.d.ts

@@ -1,18 +0,0 @@
-/**
- * Agent Find Tool - Finds agents for a task
- * Wraps the SDK's codeboltAgent.findAgent() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface AgentFindParams {
-    /** Task description to find agents for */
-    task: string;
-    /** Maximum number of results */
-    max_results?: number;
-}
-export declare class AgentFindTool extends BaseDeclarativeTool<AgentFindParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: AgentFindParams): string | null;
-    protected createInvocation(params: AgentFindParams): ToolInvocation<AgentFindParams, ToolResult>;
-}

package/dist/tools/orchestration/agent-find.js

@@ -1,125 +0,0 @@
-"use strict";
-/**
- * Agent Find Tool - Finds agents for a task
- * Wraps the SDK's codeboltAgent.findAgent() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentFindTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const agent_1 = __importDefault(require("../../modules/agent"));
-const enum_1 = require("@codebolt/types/enum");
-class AgentFindInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const response = await agent_1.default.findAgent(this.params.task, this.params.max_results || 3, [], enum_1.AgentLocation.ALL, enum_1.FilterUsing.USE_VECTOR_DB);
-            if (response && response.success === false) {
-                const errorMsg = typeof response.error === 'string'
-                    ? response.error
-                    : (response.error && typeof response.error === 'object' && 'message' in response.error)
-                        ? String(response.error.message)
-                        : 'Agent find failed';
-                return {
-                    llmContent: `Agent find failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.AGENT_NOT_FOUND,
-                    },
-                };
-            }
-            let output = `Found agents for task: ${this.params.task}`;
-            if (response.agents && Array.isArray(response.agents)) {
-                output += `\n\nMatching Agents (${response.agents.length}):\n`;
-                for (const agent of response.agents) {
-                    const agentId = this.getAgentId(agent);
-                    const agentDesc = this.getAgentDescription(agent);
-                    output += `- ${agentId}: ${agentDesc}\n`;
-                    if (agent && typeof agent === 'object' && 'score' in agent && typeof agent.score === 'number') {
-                        output += `  Score: ${(agent.score).toFixed(2)}\n`;
-                    }
-                }
-            }
-            return {
-                llmContent: output,
-                returnDisplay: `Found agents for task: ${this.params.task}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error finding agents: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-    getAgentId(agent) {
-        if (this.isAgentToolFunctionDescriptor(agent)) {
-            return agent.function.name;
-        }
-        if (agent && typeof agent === 'object' && ('id' in agent || 'name' in agent)) {
-            return String(agent.id || agent.name);
-        }
-        return 'Unknown';
-    }
-    getAgentDescription(agent) {
-        if (this.isAgentToolFunctionDescriptor(agent)) {
-            return agent.function.description || 'No description';
-        }
-        if (agent && typeof agent === 'object' && 'description' in agent) {
-            return String(agent.description || 'No description');
-        }
-        return 'No description';
-    }
-    isAgentToolFunctionDescriptor(x) {
-        if (!x || typeof x !== 'object')
-            return false;
-        const maybe = x;
-        if (maybe.type !== 'function')
-            return false;
-        const fn = maybe.function;
-        if (!fn || typeof fn !== 'object')
-            return false;
-        const fnRec = fn;
-        return typeof fnRec.name === 'string';
-    }
-}
-class AgentFindTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(AgentFindTool.Name, 'AgentFind', 'Finds agents suitable for a given task.', types_1.Kind.Read, {
-            properties: {
-                task: {
-                    description: 'The task description to find agents for.',
-                    type: 'string',
-                },
-                max_results: {
-                    description: 'Maximum number of results (default: 3).',
-                    type: 'number',
-                },
-            },
-            required: ['task'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        if (!params.task || params.task.trim() === '') {
-            return "'task' is required for agent find";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new AgentFindInvocation(params);
-    }
-}
-exports.AgentFindTool = AgentFindTool;
-AgentFindTool.Name = 'agent_find';

package/dist/tools/orchestration/agent-list.d.ts

@@ -1,13 +0,0 @@
-/**
- * Agent List Tool - Lists all available agents
- * Wraps the SDK's codeboltAgent.getAgentsList() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface AgentListParams {
-}
-export declare class AgentListTool extends BaseDeclarativeTool<AgentListParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: AgentListParams): ToolInvocation<AgentListParams, ToolResult>;
-}

package/dist/tools/orchestration/agent-list.js

@@ -1,106 +0,0 @@
-"use strict";
-/**
- * Agent List Tool - Lists all available agents
- * Wraps the SDK's codeboltAgent.getAgentsList() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentListTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const agent_1 = __importDefault(require("../../modules/agent"));
-class AgentListInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const response = await agent_1.default.getAgentsList();
-            if (response && response.success === false) {
-                const errorMsg = typeof response.error === 'string'
-                    ? response.error
-                    : (response.error && typeof response.error === 'object' && 'message' in response.error)
-                        ? String(response.error.message)
-                        : 'Agent list failed';
-                return {
-                    llmContent: `Agent list failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.EXECUTION_FAILED,
-                    },
-                };
-            }
-            let output = 'Retrieved agent list';
-            if (response.agents && Array.isArray(response.agents)) {
-                output += `\n\nAvailable Agents (${response.agents.length}):\n`;
-                for (const agent of response.agents) {
-                    const agentId = this.getAgentId(agent);
-                    const agentDesc = this.getAgentDescription(agent);
-                    output += `- ${agentId}: ${agentDesc}\n`;
-                }
-            }
-            return {
-                llmContent: output,
-                returnDisplay: 'Retrieved agent list',
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error listing agents: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-    getAgentId(agent) {
-        if (this.isAgentToolFunctionDescriptor(agent)) {
-            return agent.function.name;
-        }
-        if (agent && typeof agent === 'object' && ('id' in agent || 'name' in agent)) {
-            return String(agent.id || agent.name);
-        }
-        return 'Unknown';
-    }
-    getAgentDescription(agent) {
-        if (this.isAgentToolFunctionDescriptor(agent)) {
-            return agent.function.description || 'No description';
-        }
-        if (agent && typeof agent === 'object' && 'description' in agent) {
-            return String(agent.description || 'No description');
-        }
-        return 'No description';
-    }
-    isAgentToolFunctionDescriptor(x) {
-        if (!x || typeof x !== 'object')
-            return false;
-        const maybe = x;
-        if (maybe.type !== 'function')
-            return false;
-        const fn = maybe.function;
-        if (!fn || typeof fn !== 'object')
-            return false;
-        const fnRec = fn;
-        return typeof fnRec.name === 'string';
-    }
-}
-class AgentListTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(AgentListTool.Name, 'AgentList', 'Lists all available agents.', types_1.Kind.Read, {
-            properties: {},
-            required: [],
-            type: 'object',
-        });
-    }
-    createInvocation(params) {
-        return new AgentListInvocation(params);
-    }
-}
-exports.AgentListTool = AgentListTool;
-AgentListTool.Name = 'agent_list';

package/dist/tools/orchestration/agent-management.d.ts

@@ -1,44 +0,0 @@
-/**
- * Agent Management Tool - Manages agents
- * Wraps the SDK's codeboltAgent methods
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Supported agent actions
- */
-export type AgentActionType = 'find' | 'start' | 'list' | 'details';
-/**
- * Parameters for the AgentManagement tool
- */
-export interface AgentManagementToolParams {
-    /**
-     * The agent action to perform
-     */
-    action: AgentActionType;
-    /**
-     * Task description (for find/start)
-     */
-    task?: string;
-    /**
-     * Agent ID (for start)
-     */
-    agent_id?: string;
-    /**
-     * List of agent IDs (for details)
-     */
-    agent_list?: string[];
-    /**
-     * Maximum results (for find)
-     */
-    max_results?: number;
-}
-/**
- * Implementation of the AgentManagement tool logic
- */
-export declare class AgentManagementTool extends BaseDeclarativeTool<AgentManagementToolParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: AgentManagementToolParams): string | null;
-    protected createInvocation(params: AgentManagementToolParams): ToolInvocation<AgentManagementToolParams, ToolResult>;
-}

package/dist/tools/orchestration/agent-management.js

@@ -1,250 +0,0 @@
-"use strict";
-/**
- * Agent Management Tool - Manages agents
- * Wraps the SDK's codeboltAgent methods
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentManagementTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const agent_1 = __importDefault(require("../../modules/agent"));
-const enum_1 = require("@codebolt/types/enum");
-function isAgentToolFunctionDescriptor(x) {
-    if (!x || typeof x !== 'object')
-        return false;
-    const maybe = x;
-    if (maybe.type !== 'function')
-        return false;
-    const fn = maybe.function;
-    if (!fn || typeof fn !== 'object')
-        return false;
-    const fnRec = fn;
-    return typeof fnRec.name === 'string';
-}
-class AgentManagementToolInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const action = this.params.action;
-            let response;
-            let successMessage;
-            switch (action) {
-                case 'find':
-                    if (!this.params.task) {
-                        return this.createError("'task' is required for find action");
-                    }
-                    // findAgent requires all 5 arguments
-                    response = await agent_1.default.findAgent(this.params.task, this.params.max_results || 3, [], // agents filter
-                    enum_1.AgentLocation.ALL, enum_1.FilterUsing.USE_VECTOR_DB);
-                    successMessage = `Found agents for task: ${this.params.task}`;
-                    break;
-                case 'start':
-                    if (!this.params.agent_id) {
-                        return this.createError("'agent_id' is required for start action");
-                    }
-                    if (!this.params.task) {
-                        return this.createError("'task' is required for start action");
-                    }
-                    response = await agent_1.default.startAgent(this.params.agent_id, this.params.task);
-                    successMessage = `Started agent ${this.params.agent_id} with task`;
-                    break;
-                case 'list':
-                    response = await agent_1.default.getAgentsList();
-                    successMessage = 'Retrieved agent list';
-                    break;
-                case 'details':
-                    response = await agent_1.default.getAgentsDetail(this.params.agent_list || []);
-                    successMessage = 'Retrieved agent details';
-                    break;
-                default:
-                    return this.createError(`Unknown action: ${action}`);
-            }
-            // Check for errors with strict type checking
-            if (response && response.success === false) {
-                const errorMsg = typeof response.error === 'string'
-                    ? response.error
-                    : (response.error && typeof response.error === 'object' && 'message' in response.error)
-                        ? String(response.error.message)
-                        : 'Agent operation failed';
-                return {
-                    llmContent: `Agent ${action} failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.AGENT_NOT_FOUND,
-                    },
-                };
-            }
-            // Format output with strict type checking
-            let output = successMessage;
-            if (action === 'find') {
-                const findResponse = response;
-                if (findResponse.agents && Array.isArray(findResponse.agents)) {
-                    output += `\n\nMatching Agents (${findResponse.agents.length}):\n`;
-                    for (const agent of findResponse.agents) {
-                        // findAgent commonly returns the same tool/function descriptor shape as listAgents
-                        const agentId = isAgentToolFunctionDescriptor(agent)
-                            ? agent.function.name
-                            : (agent && typeof agent === 'object' && ('id' in agent || 'name' in agent))
-                                ? String(agent.id || agent.name)
-                                : 'Unknown';
-                        const agentDesc = isAgentToolFunctionDescriptor(agent)
-                            ? (agent.function.description || 'No description')
-                            : (agent && typeof agent === 'object' && 'description' in agent)
-                                ? String(agent.description || 'No description')
-                                : 'No description';
-                        output += `- ${agentId}: ${agentDesc}\n`;
-                        if (agent && typeof agent === 'object' && 'score' in agent && typeof agent.score === 'number') {
-                            output += `  Score: ${(agent.score).toFixed(2)}\n`;
-                        }
-                    }
-                }
-            }
-            else if (action === 'list') {
-                const listResponse = response;
-                if (listResponse.agents && Array.isArray(listResponse.agents)) {
-                    output += `\n\nAvailable Agents (${listResponse.agents.length}):\n`;
-                    for (const agent of listResponse.agents) {
-                        const agentId = isAgentToolFunctionDescriptor(agent)
-                            ? agent.function.name
-                            : (agent && typeof agent === 'object' && ('id' in agent || 'name' in agent))
-                                ? String(agent.id || agent.name)
-                                : 'Unknown';
-                        const agentDesc = isAgentToolFunctionDescriptor(agent)
-                            ? (agent.function.description || 'No description')
-                            : (agent && typeof agent === 'object' && 'description' in agent)
-                                ? String(agent.description || 'No description')
-                                : 'No description';
-                        output += `- ${agentId}: ${agentDesc}\n`;
-                    }
-                }
-            }
-            else if (action === 'details') {
-                const detailResponse = response;
-                const agents = (_a = detailResponse.payload) === null || _a === void 0 ? void 0 : _a.agents;
-                if (agents && Array.isArray(agents)) {
-                    output += `\n\nAgent Details:\n`;
-                    for (const agent of agents) {
-                        if (agent && typeof agent === 'object') {
-                            const agentId = ('id' in agent || 'name' in agent)
-                                ? String(agent.id || agent.name)
-                                : 'Unknown';
-                            output += `\n--- ${agentId} ---\n`;
-                            const agentDesc = ('description' in agent)
-                                ? String(agent.description || 'N/A')
-                                : 'N/A';
-                            output += `Description: ${agentDesc}\n`;
-                            if ('capabilities' in agent && Array.isArray(agent.capabilities)) {
-                                const capabilities = agent.capabilities;
-                                output += `Capabilities: ${capabilities.map(c => String(c)).join(', ')}\n`;
-                            }
-                            if ('status' in agent) {
-                                output += `Status: ${String(agent.status)}\n`;
-                            }
-                        }
-                    }
-                }
-            }
-            else if (action === 'start') {
-                const startResponse = response;
-                output += `\n\nAgent started successfully.`;
-                if (startResponse.result !== undefined) {
-                    output += `\nResult: ${typeof startResponse.result === 'string' ? startResponse.result : JSON.stringify(startResponse.result, null, 2)}`;
-                }
-            }
-            return {
-                llmContent: output,
-                returnDisplay: successMessage,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error executing agent ${this.params.action}: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-    createError(message) {
-        return {
-            llmContent: `Error: ${message}`,
-            returnDisplay: `Error: ${message}`,
-            error: {
-                message,
-                type: types_1.ToolErrorType.INVALID_TOOL_PARAMS,
-            },
-        };
-    }
-}
-/**
- * Implementation of the AgentManagement tool logic
- */
-class AgentManagementTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(AgentManagementTool.Name, 'AgentManagement', `Manages agents - find agents for tasks, start agents, list available agents, and get agent details. Use this for multi-agent coordination.`, types_1.Kind.Other, {
-            properties: {
-                action: {
-                    description: "The agent action: 'find', 'start', 'list', or 'details'.",
-                    type: 'string',
-                    enum: ['find', 'start', 'list', 'details'],
-                },
-                task: {
-                    description: 'Task description (required for find/start).',
-                    type: 'string',
-                },
-                agent_id: {
-                    description: 'Agent ID (required for start).',
-                    type: 'string',
-                },
-                agent_list: {
-                    description: 'List of agent IDs (for details).',
-                    type: 'array',
-                    items: { type: 'string' },
-                },
-                max_results: {
-                    description: 'Maximum number of results (for find, default: 3).',
-                    type: 'number',
-                },
-            },
-            required: ['action'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        const validActions = ['find', 'start', 'list', 'details'];
-        if (!validActions.includes(params.action)) {
-            return `Invalid action: ${params.action}. Must be one of: ${validActions.join(', ')}`;
-        }
-        switch (params.action) {
-            case 'find':
-                if (!params.task) {
-                    return "'task' is required for find action";
-                }
-                break;
-            case 'start':
-                if (!params.agent_id) {
-                    return "'agent_id' is required for start action";
-                }
-                if (!params.task) {
-                    return "'task' is required for start action";
-                }
-                break;
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new AgentManagementToolInvocation(params);
-    }
-}
-exports.AgentManagementTool = AgentManagementTool;
-AgentManagementTool.Name = 'agent_management';

package/dist/tools/orchestration/agent-start.d.ts

@@ -1,18 +0,0 @@
-/**
- * Agent Start Tool - Starts an agent with a task
- * Wraps the SDK's codeboltAgent.startAgent() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface AgentStartParams {
-    /** The agent ID to start */
-    agent_id: string;
-    /** The task for the agent */
-    task: string;
-}
-export declare class AgentStartTool extends BaseDeclarativeTool<AgentStartParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: AgentStartParams): string | null;
-    protected createInvocation(params: AgentStartParams): ToolInvocation<AgentStartParams, ToolResult>;
-}

package/dist/tools/orchestration/agent-start.js

@@ -1,90 +0,0 @@
-"use strict";
-/**
- * Agent Start Tool - Starts an agent with a task
- * Wraps the SDK's codeboltAgent.startAgent() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentStartTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const agent_1 = __importDefault(require("../../modules/agent"));
-class AgentStartInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const response = await agent_1.default.startAgent(this.params.agent_id, this.params.task);
-            if (response && response.success === false) {
-                const errorMsg = typeof response.error === 'string'
-                    ? response.error
-                    : (response.error && typeof response.error === 'object' && 'message' in response.error)
-                        ? String(response.error.message)
-                        : 'Agent start failed';
-                return {
-                    llmContent: `Agent start failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.AGENT_NOT_FOUND,
-                    },
-                };
-            }
-            let output = `Started agent ${this.params.agent_id} with task`;
-            output += `\n\nAgent started successfully.`;
-            if (response.result !== undefined) {
-                output += `\nResult: ${typeof response.result === 'string' ? response.result : JSON.stringify(response.result, null, 2)}`;
-            }
-            return {
-                llmContent: output,
-                returnDisplay: `Started agent ${this.params.agent_id} with task`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error starting agent: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-class AgentStartTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(AgentStartTool.Name, 'AgentStart', 'Starts an agent with a specific task.', types_1.Kind.Execute, {
-            properties: {
-                agent_id: {
-                    description: 'The ID of the agent to start.',
-                    type: 'string',
-                },
-                task: {
-                    description: 'The task for the agent to execute.',
-                    type: 'string',
-                },
-            },
-            required: ['agent_id', 'task'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        if (!params.agent_id || params.agent_id.trim() === '') {
-            return "'agent_id' is required for agent start";
-        }
-        if (!params.task || params.task.trim() === '') {
-            return "'task' is required for agent start";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new AgentStartInvocation(params);
-    }
-}
-exports.AgentStartTool = AgentStartTool;
-AgentStartTool.Name = 'agent_start';