@codebolt/codeboltjs 5.0.8 → 5.0.9

package/dist/tools/memoryIngestion/mi-create-pipeline.js

@@ -1,114 +0,0 @@
-"use strict";
-/**
- * Create Memory Ingestion Pipeline Tool - Creates a new memory ingestion pipeline
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateMemoryIngestionPipelineTool = void 0;
-const base_tool_1 = require("../base-tool");
-const memoryIngestion_1 = __importDefault(require("../../modules/memoryIngestion"));
-class CreateMemoryIngestionPipelineInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    toolLocations() {
-        return [];
-    }
-    async execute() {
-        try {
-            const response = await memoryIngestion_1.default.create({
-                pipelineId: this.params.pipelineId,
-                label: this.params.label,
-                description: this.params.description,
-                source: this.params.source,
-                processors: this.params.processors,
-            });
-            if (!response.success || !response.pipeline) {
-                return {
-                    llmContent: `Error creating memory ingestion pipeline: ${response.error || 'Unknown error'}`,
-                    returnDisplay: `Error creating memory ingestion pipeline: ${response.error || 'Unknown error'}`,
-                    error: {
-                        message: response.error || 'Unknown error',
-                        type: 'unknown',
-                    },
-                };
-            }
-            const pipeline = response.pipeline;
-            const content = `Memory ingestion pipeline created successfully:\n` +
-                `ID: ${pipeline.id}\n` +
-                `Label: ${pipeline.label}\n` +
-                `Status: ${pipeline.status}`;
-            return {
-                llmContent: content,
-                returnDisplay: content,
-            };
-        }
-        catch (error) {
-            return {
-                llmContent: `Error creating memory ingestion pipeline: ${error}`,
-                returnDisplay: `Error creating memory ingestion pipeline: ${error}`,
-                error: {
-                    message: String(error),
-                    type: 'unknown',
-                },
-            };
-        }
-    }
-}
-class CreateMemoryIngestionPipelineTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('memoryIngestion_create', 'Create a new memory ingestion pipeline for processing data into memory', {
-            type: 'object',
-            properties: {
-                pipelineId: {
-                    type: 'string',
-                    description: 'Pipeline ID',
-                },
-                label: {
-                    type: 'string',
-                    description: 'Pipeline label/name',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Pipeline description',
-                },
-                source: {
-                    type: 'object',
-                    description: 'Source configuration',
-                    properties: {
-                        type: {
-                            type: 'string',
-                            description: 'Source type',
-                        },
-                    },
-                    required: ['type'],
-                },
-                processors: {
-                    type: 'array',
-                    description: 'Processors configuration',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            type: {
-                                type: 'string',
-                                description: 'Processor type',
-                            },
-                        },
-                        required: ['type'],
-                    },
-                },
-                explanation: {
-                    type: 'string',
-                    description: 'One sentence explanation of why this tool is being used',
-                },
-            },
-            required: ['pipelineId', 'label', 'source', 'processors'],
-        });
-    }
-    createInvocation(params, invocationId) {
-        return new CreateMemoryIngestionPipelineInvocation(params);
-    }
-}
-exports.CreateMemoryIngestionPipelineTool = CreateMemoryIngestionPipelineTool;

package/dist/tools/memoryIngestion/mi-list.d.ts

@@ -1,22 +0,0 @@
-/**
- * List Memory Ingestion Pipelines Tool - Lists memory ingestion pipelines
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the ListMemoryIngestionPipelines tool
- */
-export interface ListMemoryIngestionPipelinesParams {
-    /**
-     * Optional status filter
-     */
-    status?: string;
-    /**
-     * One sentence explanation of why this tool is being used
-     */
-    explanation?: string;
-}
-export declare class ListMemoryIngestionPipelinesTool extends BaseDeclarativeTool<ListMemoryIngestionPipelinesParams, ToolResult> {
-    constructor();
-    createInvocation(params: ListMemoryIngestionPipelinesParams, invocationId: string): ToolInvocation;
-}

package/dist/tools/memoryIngestion/mi-list.js

@@ -1,66 +0,0 @@
-"use strict";
-/**
- * List Memory Ingestion Pipelines Tool - Lists memory ingestion pipelines
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListMemoryIngestionPipelinesTool = void 0;
-const base_tool_1 = require("../base-tool");
-const memoryIngestion_1 = __importDefault(require("../../modules/memoryIngestion"));
-class ListMemoryIngestionPipelinesInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    toolLocations() {
-        return [];
-    }
-    async execute() {
-        try {
-            const filters = {};
-            if (this.params.status) {
-                filters.status = this.params.status;
-            }
-            const response = await memoryIngestion_1.default.list(filters);
-            const pipelines = response.pipelines || [];
-            const content = `Found ${pipelines.length} memory ingestion pipeline(s):\n` +
-                pipelines.map((p) => `- ${p.id}: ${p.label} (${p.status})${p.description ? ' - ' + p.description : ''}`).join('\n');
-            return {
-                llmContent: content,
-                returnDisplay: content,
-            };
-        }
-        catch (error) {
-            return {
-                llmContent: `Error listing memory ingestion pipelines: ${error}`,
-                returnDisplay: `Error listing memory ingestion pipelines: ${error}`,
-                error: {
-                    message: String(error),
-                    type: 'unknown',
-                },
-            };
-        }
-    }
-}
-class ListMemoryIngestionPipelinesTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('memoryIngestion_list', 'List all memory ingestion pipelines with optional status filter', {
-            type: 'object',
-            properties: {
-                status: {
-                    type: 'string',
-                    description: 'Optional status filter',
-                },
-                explanation: {
-                    type: 'string',
-                    description: 'One sentence explanation of why this tool is being used',
-                },
-            },
-        });
-    }
-    createInvocation(params, invocationId) {
-        return new ListMemoryIngestionPipelinesInvocation(params);
-    }
-}
-exports.ListMemoryIngestionPipelinesTool = ListMemoryIngestionPipelinesTool;

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

@@ -1,15 +0,0 @@
-/**
- * Agent Details Tool - Gets details of specific agents
- * Wraps the SDK's codeboltAgent.getAgentsDetail() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface AgentDetailsParams {
-    /** List of agent IDs to get details for */
-    agent_list?: string[];
-}
-export declare class AgentDetailsTool extends BaseDeclarativeTool<AgentDetailsParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: AgentDetailsParams): ToolInvocation<AgentDetailsParams, ToolResult>;
-}

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

@@ -1,98 +0,0 @@
-"use strict";
-/**
- * Agent Details Tool - Gets details of specific agents
- * Wraps the SDK's codeboltAgent.getAgentsDetail() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentDetailsTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const agent_1 = __importDefault(require("../../modules/agent"));
-class AgentDetailsInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const response = await agent_1.default.getAgentsDetail(this.params.agent_list || []);
-            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 details failed';
-                return {
-                    llmContent: `Agent details failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.AGENT_NOT_FOUND,
-                    },
-                };
-            }
-            let output = 'Retrieved agent details';
-            const agents = (_a = response.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`;
-                        }
-                    }
-                }
-            }
-            return {
-                llmContent: output,
-                returnDisplay: 'Retrieved agent details',
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error getting agent details: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-class AgentDetailsTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(AgentDetailsTool.Name, 'AgentDetails', 'Retrieves details of specific agents.', types_1.Kind.Read, {
-            properties: {
-                agent_list: {
-                    description: 'List of agent IDs to get details for.',
-                    type: 'array',
-                    items: { type: 'string' },
-                },
-            },
-            required: [],
-            type: 'object',
-        });
-    }
-    createInvocation(params) {
-        return new AgentDetailsInvocation(params);
-    }
-}
-exports.AgentDetailsTool = AgentDetailsTool;
-AgentDetailsTool.Name = 'agent_details';

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>;
-}