@codebolt/codeboltjs 5.0.8 → 5.1.10

package/dist/tools/kvStore/kv-store-create-instance.js

@@ -1,79 +0,0 @@
-"use strict";
-/**
- * Create KV Store Instance Tool - Creates a new key-value store instance
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateKVInstanceTool = void 0;
-const base_tool_1 = require("../base-tool");
-const kvStore_1 = __importDefault(require("../../modules/kvStore"));
-class CreateKVInstanceInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    toolLocations() {
-        return [];
-    }
-    async execute() {
-        try {
-            const response = await kvStore_1.default.createInstance(this.params.name, this.params.description);
-            if (!response.success || !response.instance) {
-                return {
-                    llmContent: `Error creating KV store instance: ${response.error || 'Unknown error'}`,
-                    returnDisplay: `Error creating KV store instance: ${response.error || 'Unknown error'}`,
-                    error: {
-                        message: response.error || 'Unknown error',
-                        type: 'unknown',
-                    },
-                };
-            }
-            const instance = response.instance;
-            const content = `KV store instance created successfully:\n` +
-                `ID: ${instance.id}\n` +
-                `Name: ${instance.name}\n` +
-                `Description: ${instance.description || 'N/A'}`;
-            return {
-                llmContent: content,
-                returnDisplay: content,
-            };
-        }
-        catch (error) {
-            return {
-                llmContent: `Error creating KV store instance: ${error}`,
-                returnDisplay: `Error creating KV store instance: ${error}`,
-                error: {
-                    message: String(error),
-                    type: 'unknown',
-                },
-            };
-        }
-    }
-}
-class CreateKVInstanceTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('kvStore_createInstance', 'Create a new key-value store instance for agent state persistence', {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Instance name',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Optional description',
-                },
-                explanation: {
-                    type: 'string',
-                    description: 'One sentence explanation of why this tool is being used',
-                },
-            },
-            required: ['name'],
-        });
-    }
-    createInvocation(params, invocationId) {
-        return new CreateKVInstanceInvocation(params);
-    }
-}
-exports.CreateKVInstanceTool = CreateKVInstanceTool;

package/dist/tools/kvStore/kv-store-get.d.ts

@@ -1,30 +0,0 @@
-/**
- * KV Store Get Tool - Gets a value from the key-value store
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the KVGet tool
- */
-export interface KVGetParams {
-    /**
-     * Instance ID
-     */
-    instanceId: string;
-    /**
-     * Key to retrieve
-     */
-    key: string;
-    /**
-     * Optional namespace
-     */
-    namespace?: string;
-    /**
-     * One sentence explanation of why this tool is being used
-     */
-    explanation?: string;
-}
-export declare class KVGetTool extends BaseDeclarativeTool<KVGetParams, ToolResult> {
-    constructor();
-    createInvocation(params: KVGetParams, invocationId: string): ToolInvocation;
-}

package/dist/tools/kvStore/kv-store-get.js

@@ -1,80 +0,0 @@
-"use strict";
-/**
- * KV Store Get Tool - Gets a value from the key-value store
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KVGetTool = void 0;
-const base_tool_1 = require("../base-tool");
-const kvStore_1 = __importDefault(require("../../modules/kvStore"));
-class KVGetInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    toolLocations() {
-        return [];
-    }
-    async execute() {
-        try {
-            const response = await kvStore_1.default.get(this.params.instanceId, this.params.key, this.params.namespace);
-            if (!response.success) {
-                return {
-                    llmContent: `Error getting value from KV store: ${response.error || 'Unknown error'}`,
-                    returnDisplay: `Error getting value from KV store: ${response.error || 'Unknown error'}`,
-                    error: {
-                        message: response.error || 'Unknown error',
-                        type: 'unknown',
-                    },
-                };
-            }
-            const value = response.value !== undefined ? JSON.stringify(response.value, null, 2) : 'undefined';
-            const content = `Retrieved value for key "${this.params.key}":\n${value}`;
-            return {
-                llmContent: content,
-                returnDisplay: content,
-            };
-        }
-        catch (error) {
-            return {
-                llmContent: `Error getting value from KV store: ${error}`,
-                returnDisplay: `Error getting value from KV store: ${error}`,
-                error: {
-                    message: String(error),
-                    type: 'unknown',
-                },
-            };
-        }
-    }
-}
-class KVGetTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('kvStore_get', 'Get a value from the key-value store by key', {
-            type: 'object',
-            properties: {
-                instanceId: {
-                    type: 'string',
-                    description: 'Instance ID',
-                },
-                key: {
-                    type: 'string',
-                    description: 'Key to retrieve',
-                },
-                namespace: {
-                    type: 'string',
-                    description: 'Optional namespace',
-                },
-                explanation: {
-                    type: 'string',
-                    description: 'One sentence explanation of why this tool is being used',
-                },
-            },
-            required: ['instanceId', 'key'],
-        });
-    }
-    createInvocation(params, invocationId) {
-        return new KVGetInvocation(params);
-    }
-}
-exports.KVGetTool = KVGetTool;

package/dist/tools/kvStore/kv-store-set.d.ts

@@ -1,38 +0,0 @@
-/**
- * KV Store Set Tool - Sets a value in the key-value store
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the KVSet tool
- */
-export interface KVSetParams {
-    /**
-     * Instance ID
-     */
-    instanceId: string;
-    /**
-     * Key to set
-     */
-    key: string;
-    /**
-     * Value to set (will be JSON stringified)
-     */
-    value: any;
-    /**
-     * Optional namespace
-     */
-    namespace?: string;
-    /**
-     * Optional TTL in seconds
-     */
-    ttl?: number;
-    /**
-     * One sentence explanation of why this tool is being used
-     */
-    explanation?: string;
-}
-export declare class KVSetTool extends BaseDeclarativeTool<KVSetParams, ToolResult> {
-    constructor();
-    createInvocation(params: KVSetParams, invocationId: string): ToolInvocation;
-}

package/dist/tools/kvStore/kv-store-set.js

@@ -1,86 +0,0 @@
-"use strict";
-/**
- * KV Store Set Tool - Sets a value in the key-value store
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KVSetTool = void 0;
-const base_tool_1 = require("../base-tool");
-const kvStore_1 = __importDefault(require("../../modules/kvStore"));
-class KVSetInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    toolLocations() {
-        return [];
-    }
-    async execute() {
-        try {
-            const response = await kvStore_1.default.set(this.params.instanceId, this.params.key, this.params.value, this.params.namespace, this.params.ttl);
-            if (!response.success) {
-                return {
-                    llmContent: `Error setting value in KV store: ${response.error || 'Unknown error'}`,
-                    returnDisplay: `Error setting value in KV store: ${response.error || 'Unknown error'}`,
-                    error: {
-                        message: response.error || 'Unknown error',
-                        type: 'unknown',
-                    },
-                };
-            }
-            const content = `Value set successfully for key "${this.params.key}" in instance "${this.params.instanceId}"`;
-            return {
-                llmContent: content,
-                returnDisplay: content,
-            };
-        }
-        catch (error) {
-            return {
-                llmContent: `Error setting value in KV store: ${error}`,
-                returnDisplay: `Error setting value in KV store: ${error}`,
-                error: {
-                    message: String(error),
-                    type: 'unknown',
-                },
-            };
-        }
-    }
-}
-class KVSetTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('kvStore_set', 'Set a value in the key-value store by key', {
-            type: 'object',
-            properties: {
-                instanceId: {
-                    type: 'string',
-                    description: 'Instance ID',
-                },
-                key: {
-                    type: 'string',
-                    description: 'Key to set',
-                },
-                value: {
-                    description: 'Value to set (will be JSON stringified)',
-                },
-                namespace: {
-                    type: 'string',
-                    description: 'Optional namespace',
-                },
-                ttl: {
-                    type: 'number',
-                    description: 'Optional TTL in seconds',
-                },
-                explanation: {
-                    type: 'string',
-                    description: 'One sentence explanation of why this tool is being used',
-                },
-            },
-            required: ['instanceId', 'key', 'value'],
-        });
-    }
-    createInvocation(params, invocationId) {
-        return new KVSetInvocation(params);
-    }
-}
-exports.KVSetTool = KVSetTool;

package/dist/tools/memoryIngestion/mi-create-pipeline.d.ts

@@ -1,44 +0,0 @@
-/**
- * Create Memory Ingestion Pipeline Tool - Creates a new memory ingestion pipeline
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the CreateMemoryIngestionPipeline tool
- */
-export interface CreateMemoryIngestionPipelineParams {
-    /**
-     * Pipeline ID
-     */
-    pipelineId: string;
-    /**
-     * Pipeline label/name
-     */
-    label: string;
-    /**
-     * Pipeline description
-     */
-    description?: string;
-    /**
-     * Source configuration
-     */
-    source: {
-        type: string;
-        [key: string]: any;
-    };
-    /**
-     * Processors configuration
-     */
-    processors: Array<{
-        type: string;
-        [key: string]: any;
-    }>;
-    /**
-     * One sentence explanation of why this tool is being used
-     */
-    explanation?: string;
-}
-export declare class CreateMemoryIngestionPipelineTool extends BaseDeclarativeTool<CreateMemoryIngestionPipelineParams, ToolResult> {
-    constructor();
-    createInvocation(params: CreateMemoryIngestionPipelineParams, invocationId: string): ToolInvocation;
-}

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