@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/memory/memory-markdown-update.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Memory Markdown Update Tool - Updates existing markdown data in memory storage
+ * Wraps the SDK's cbmemory.markdown.update() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryMarkdownUpdateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const memory_1 = __importDefault(require("../../modules/memory"));
+class MemoryMarkdownUpdateToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const metadata = this.params.metadata || {};
+            const response = await memory_1.default.markdown.update(this.params.memoryId, this.params.markdown, metadata);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error updating markdown in memory: ${errorMsg}`,
+                    returnDisplay: `Error updating markdown in memory: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.MEMORY_TOOL_EXECUTION_ERROR,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully updated markdown in memory. Memory ID: ${response.memoryId}`,
+                returnDisplay: `Successfully updated markdown in memory (ID: ${response.memoryId})`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error updating markdown in memory: ${errorMessage}`,
+                returnDisplay: `Error updating markdown in memory: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the MemoryMarkdownUpdate tool logic
+ */
+class MemoryMarkdownUpdateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(MemoryMarkdownUpdateTool.Name, 'MemoryMarkdownUpdate', 'Updates existing markdown content in memory storage by its memory ID. The new markdown content will replace the existing data.', types_1.Kind.Edit, {
+            properties: {
+                memoryId: {
+                    description: 'The unique identifier of the memory entry to update.',
+                    type: 'string',
+                },
+                markdown: {
+                    description: 'The new markdown content to replace the existing data.',
+                    type: 'string',
+                },
+                metadata: {
+                    description: 'Optional metadata to update along with the markdown content.',
+                    type: 'object',
+                },
+            },
+            required: ['memoryId', 'markdown'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.memoryId || params.memoryId.trim() === '') {
+            return "The 'memoryId' parameter must be a non-empty string.";
+        }
+        if (params.markdown === null || params.markdown === undefined) {
+            return "The 'markdown' parameter is required.";
+        }
+        if (typeof params.markdown !== 'string') {
+            return "The 'markdown' parameter must be a string.";
+        }
+        if (params.metadata !== undefined && params.metadata !== null) {
+            if (typeof params.metadata !== 'object' || Array.isArray(params.metadata)) {
+                return "The 'metadata' parameter must be an object.";
+            }
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new MemoryMarkdownUpdateToolInvocation(params);
+    }
+}
+exports.MemoryMarkdownUpdateTool = MemoryMarkdownUpdateTool;
+MemoryMarkdownUpdateTool.Name = 'memory_markdown_update';

package/dist/tools/memory/memory-todo-delete.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Memory Todo Delete Tool - Deletes todo data from memory storage
+ * Wraps the SDK's cbmemory.todo.delete() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the MemoryTodoDelete tool
+ */
+export interface MemoryTodoDeleteToolParams {
+    /**
+     * The memory ID of the entry to delete
+     */
+    memoryId: string;
+}
+/**
+ * Implementation of the MemoryTodoDelete tool logic
+ */
+export declare class MemoryTodoDeleteTool extends BaseDeclarativeTool<MemoryTodoDeleteToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: MemoryTodoDeleteToolParams): string | null;
+    protected createInvocation(params: MemoryTodoDeleteToolParams): ToolInvocation<MemoryTodoDeleteToolParams, ToolResult>;
+}

package/dist/tools/memory/memory-todo-delete.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Memory Todo Delete Tool - Deletes todo data from memory storage
+ * Wraps the SDK's cbmemory.todo.delete() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryTodoDeleteTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const memory_1 = __importDefault(require("../../modules/memory"));
+class MemoryTodoDeleteToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await memory_1.default.todo.delete(this.params.memoryId);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error deleting todo from memory: ${errorMsg}`,
+                    returnDisplay: `Error deleting todo from memory: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.MEMORY_TOOL_EXECUTION_ERROR,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully deleted todo from memory. Memory ID: ${this.params.memoryId}`,
+                returnDisplay: `Successfully deleted todo from memory (ID: ${this.params.memoryId})`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error deleting todo from memory: ${errorMessage}`,
+                returnDisplay: `Error deleting todo from memory: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the MemoryTodoDelete tool logic
+ */
+class MemoryTodoDeleteTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(MemoryTodoDeleteTool.Name, 'MemoryTodoDelete', 'Deletes a todo item from memory storage by its memory ID. This action is permanent and cannot be undone.', types_1.Kind.Delete, {
+            properties: {
+                memoryId: {
+                    description: 'The unique identifier of the memory entry to delete.',
+                    type: 'string',
+                },
+            },
+            required: ['memoryId'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.memoryId || params.memoryId.trim() === '') {
+            return "The 'memoryId' parameter must be a non-empty string.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new MemoryTodoDeleteToolInvocation(params);
+    }
+}
+exports.MemoryTodoDeleteTool = MemoryTodoDeleteTool;
+MemoryTodoDeleteTool.Name = 'memory_todo_delete';

package/dist/tools/memory/memory-todo-list.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Memory Todo List Tool - Lists todo data from memory storage
+ * Wraps the SDK's cbmemory.todo.list() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the MemoryTodoList tool
+ */
+export interface MemoryTodoListToolParams {
+    /**
+     * Optional filters to apply when listing todo entries
+     */
+    filters?: object;
+}
+/**
+ * Implementation of the MemoryTodoList tool logic
+ */
+export declare class MemoryTodoListTool extends BaseDeclarativeTool<MemoryTodoListToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: MemoryTodoListToolParams): string | null;
+    protected createInvocation(params: MemoryTodoListToolParams): ToolInvocation<MemoryTodoListToolParams, ToolResult>;
+}

package/dist/tools/memory/memory-todo-list.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Memory Todo List Tool - Lists todo data from memory storage
+ * Wraps the SDK's cbmemory.todo.list() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryTodoListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const memory_1 = __importDefault(require("../../modules/memory"));
+class MemoryTodoListToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const filters = this.params.filters || {};
+            const response = await memory_1.default.todo.list(filters);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error listing todos from memory: ${errorMsg}`,
+                    returnDisplay: `Error listing todos from memory: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.MEMORY_TOOL_EXECUTION_ERROR,
+                    },
+                };
+            }
+            const items = response.items || [];
+            const itemCount = items.length;
+            return {
+                llmContent: `Found ${itemCount} todo entries in memory.\n\n${JSON.stringify(items, null, 2)}`,
+                returnDisplay: `Successfully listed ${itemCount} todo entries from memory`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing todos from memory: ${errorMessage}`,
+                returnDisplay: `Error listing todos from memory: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the MemoryTodoList tool logic
+ */
+class MemoryTodoListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(MemoryTodoListTool.Name, 'MemoryTodoList', 'Lists todo items from memory storage. Optionally accepts filters to narrow down the results.', types_1.Kind.Read, {
+            properties: {
+                filters: {
+                    description: 'Optional filters to apply when listing todo entries. The structure depends on the memory storage implementation.',
+                    type: 'object',
+                },
+            },
+            required: [],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (params.filters !== undefined && params.filters !== null) {
+            if (typeof params.filters !== 'object' || Array.isArray(params.filters)) {
+                return "The 'filters' parameter must be a JSON object.";
+            }
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new MemoryTodoListToolInvocation(params);
+    }
+}
+exports.MemoryTodoListTool = MemoryTodoListTool;
+MemoryTodoListTool.Name = 'memory_todo_list';

package/dist/tools/memory/memory-todo-save.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Memory Todo Save Tool - Saves todo data to memory storage
+ * Wraps the SDK's cbmemory.todo.save() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the MemoryTodoSave tool
+ */
+export interface MemoryTodoSaveToolParams {
+    /**
+     * The todo object to save to memory
+     */
+    todo: object;
+    /**
+     * Optional metadata associated with the todo
+     */
+    metadata?: object;
+}
+/**
+ * Implementation of the MemoryTodoSave tool logic
+ */
+export declare class MemoryTodoSaveTool extends BaseDeclarativeTool<MemoryTodoSaveToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: MemoryTodoSaveToolParams): string | null;
+    protected createInvocation(params: MemoryTodoSaveToolParams): ToolInvocation<MemoryTodoSaveToolParams, ToolResult>;
+}

package/dist/tools/memory/memory-todo-save.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Memory Todo Save Tool - Saves todo data to memory storage
+ * Wraps the SDK's cbmemory.todo.save() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryTodoSaveTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const memory_1 = __importDefault(require("../../modules/memory"));
+class MemoryTodoSaveToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const metadata = this.params.metadata || {};
+            const response = await memory_1.default.todo.save(this.params.todo, metadata);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error saving todo to memory: ${errorMsg}`,
+                    returnDisplay: `Error saving todo to memory: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.MEMORY_TOOL_EXECUTION_ERROR,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully saved todo to memory. Memory ID: ${response.memoryId}`,
+                returnDisplay: `Successfully saved todo to memory (ID: ${response.memoryId})`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error saving todo to memory: ${errorMessage}`,
+                returnDisplay: `Error saving todo to memory: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the MemoryTodoSave tool logic
+ */
+class MemoryTodoSaveTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(MemoryTodoSaveTool.Name, 'MemoryTodoSave', 'Saves a todo item to memory storage. Returns the memory ID of the saved entry which can be used for later retrieval, updates, or deletion.', types_1.Kind.Edit, {
+            properties: {
+                todo: {
+                    description: 'The todo object to save to memory storage. Should contain task details like title, description, status, etc.',
+                    type: 'object',
+                },
+                metadata: {
+                    description: 'Optional metadata to associate with the todo item.',
+                    type: 'object',
+                },
+            },
+            required: ['todo'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (params.todo === null || params.todo === undefined) {
+            return "The 'todo' parameter must be a valid object.";
+        }
+        if (typeof params.todo !== 'object' || Array.isArray(params.todo)) {
+            return "The 'todo' parameter must be an object, not an array or primitive.";
+        }
+        if (params.metadata !== undefined && params.metadata !== null) {
+            if (typeof params.metadata !== 'object' || Array.isArray(params.metadata)) {
+                return "The 'metadata' parameter must be an object.";
+            }
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new MemoryTodoSaveToolInvocation(params);
+    }
+}
+exports.MemoryTodoSaveTool = MemoryTodoSaveTool;
+MemoryTodoSaveTool.Name = 'memory_todo_save';

package/dist/tools/memory/memory-todo-update.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Memory Todo Update Tool - Updates existing todo data in memory storage
+ * Wraps the SDK's cbmemory.todo.update() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the MemoryTodoUpdate tool
+ */
+export interface MemoryTodoUpdateToolParams {
+    /**
+     * The memory ID of the entry to update
+     */
+    memoryId: string;
+    /**
+     * The new todo object to replace the existing data
+     */
+    todo: object;
+}
+/**
+ * Implementation of the MemoryTodoUpdate tool logic
+ */
+export declare class MemoryTodoUpdateTool extends BaseDeclarativeTool<MemoryTodoUpdateToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: MemoryTodoUpdateToolParams): string | null;
+    protected createInvocation(params: MemoryTodoUpdateToolParams): ToolInvocation<MemoryTodoUpdateToolParams, ToolResult>;
+}

package/dist/tools/memory/memory-todo-update.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Memory Todo Update Tool - Updates existing todo data in memory storage
+ * Wraps the SDK's cbmemory.todo.update() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryTodoUpdateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const memory_1 = __importDefault(require("../../modules/memory"));
+class MemoryTodoUpdateToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await memory_1.default.todo.update(this.params.memoryId, this.params.todo);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error updating todo in memory: ${errorMsg}`,
+                    returnDisplay: `Error updating todo in memory: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.MEMORY_TOOL_EXECUTION_ERROR,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully updated todo in memory. Memory ID: ${response.memoryId}`,
+                returnDisplay: `Successfully updated todo in memory (ID: ${response.memoryId})`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error updating todo in memory: ${errorMessage}`,
+                returnDisplay: `Error updating todo in memory: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the MemoryTodoUpdate tool logic
+ */
+class MemoryTodoUpdateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(MemoryTodoUpdateTool.Name, 'MemoryTodoUpdate', 'Updates an existing todo item in memory storage by its memory ID. The new todo object will replace the existing data.', types_1.Kind.Edit, {
+            properties: {
+                memoryId: {
+                    description: 'The unique identifier of the memory entry to update.',
+                    type: 'string',
+                },
+                todo: {
+                    description: 'The new todo object to replace the existing data.',
+                    type: 'object',
+                },
+            },
+            required: ['memoryId', 'todo'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.memoryId || params.memoryId.trim() === '') {
+            return "The 'memoryId' parameter must be a non-empty string.";
+        }
+        if (params.todo === null || params.todo === undefined) {
+            return "The 'todo' parameter must be a valid object.";
+        }
+        if (typeof params.todo !== 'object' || Array.isArray(params.todo)) {
+            return "The 'todo' parameter must be an object, not an array or primitive.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new MemoryTodoUpdateToolInvocation(params);
+    }
+}
+exports.MemoryTodoUpdateTool = MemoryTodoUpdateTool;
+MemoryTodoUpdateTool.Name = 'memory_todo_update';

package/dist/tools/memory/persistent-memory-create.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Persistent Memory Create Tool - Creates a new persistent memory configuration
+ * Wraps the SDK's persistentMemory.create() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Retrieval configuration for persistent memory
+ */
+export interface RetrievalConfigParams {
+    source_type: 'vectordb' | 'kv' | 'eventlog' | 'kg';
+    source_id: string;
+    query_template?: string;
+    limit?: number;
+    filters?: Record<string, any>;
+}
+/**
+ * Contribution configuration for persistent memory
+ */
+export interface ContributionConfigParams {
+    format: 'text' | 'json' | 'markdown';
+    template?: string;
+    max_tokens?: number;
+}
+/**
+ * Parameters for the PersistentMemoryCreate tool
+ */
+export interface PersistentMemoryCreateToolParams {
+    /**
+     * Optional ID for the memory (auto-generated if not provided)
+     */
+    id?: string;
+    /**
+     * Label/name for the persistent memory
+     */
+    label: string;
+    /**
+     * Optional description of the memory's purpose
+     */
+    description?: string;
+    /**
+     * Input scopes for when this memory should be activated
+     */
+    inputs_scope?: string[];
+    /**
+     * Additional variables for memory configuration
+     */
+    additional_variables?: Record<string, any>;
+    /**
+     * Retrieval configuration
+     */
+    retrieval: RetrievalConfigParams;
+    /**
+     * Contribution configuration
+     */
+    contribution: ContributionConfigParams;
+}
+/**
+ * Implementation of the PersistentMemoryCreate tool logic
+ */
+export declare class PersistentMemoryCreateTool extends BaseDeclarativeTool<PersistentMemoryCreateToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: PersistentMemoryCreateToolParams): string | null;
+    protected createInvocation(params: PersistentMemoryCreateToolParams): ToolInvocation<PersistentMemoryCreateToolParams, ToolResult>;
+}