@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/memory/episodic-memory-query-events.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Episodic Memory Query Events Tool - Queries events from an episodic memory
+ * Wraps the SDK's cbepisodicMemory.queryEvents() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the EpisodicMemoryQueryEvents tool
+ */
+export interface EpisodicMemoryQueryEventsToolParams {
+    /**
+     * The ID of the episodic memory to query events from
+     */
+    memoryId?: string;
+    /**
+     * The ID of the swarm to query events from
+     */
+    swarmId?: string;
+    /**
+     * Filter events from the last N minutes
+     */
+    lastMinutes?: number;
+    /**
+     * Limit the number of events returned
+     */
+    lastCount?: number;
+    /**
+     * Filter events by tags
+     */
+    tags?: string[];
+    /**
+     * Filter events by event type
+     */
+    event_type?: string;
+    /**
+     * Filter events by emitting agent ID
+     */
+    emitting_agent_id?: string;
+    /**
+     * Filter events by team ID
+     */
+    team_id?: string;
+    /**
+     * Filter events since a specific timestamp
+     */
+    since?: string;
+}
+/**
+ * Implementation of the EpisodicMemoryQueryEvents tool logic
+ */
+export declare class EpisodicMemoryQueryEventsTool extends BaseDeclarativeTool<EpisodicMemoryQueryEventsToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: EpisodicMemoryQueryEventsToolParams): string | null;
+    protected createInvocation(params: EpisodicMemoryQueryEventsToolParams): ToolInvocation<EpisodicMemoryQueryEventsToolParams, ToolResult>;
+}

package/dist/tools/memory/episodic-memory-query-events.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Episodic Memory Query Events Tool - Queries events from an episodic memory
+ * Wraps the SDK's cbepisodicMemory.queryEvents() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodicMemoryQueryEventsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const episodicMemory_1 = __importDefault(require("../../modules/episodicMemory"));
+class EpisodicMemoryQueryEventsToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await episodicMemory_1.default.queryEvents({
+                memoryId: this.params.memoryId,
+                swarmId: this.params.swarmId,
+                lastMinutes: this.params.lastMinutes,
+                lastCount: this.params.lastCount,
+                tags: this.params.tags,
+                event_type: this.params.event_type,
+                emitting_agent_id: this.params.emitting_agent_id,
+                team_id: this.params.team_id,
+                since: this.params.since,
+            });
+            if (!response.success) {
+                const errorMsg = ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Unknown error';
+                return {
+                    llmContent: `Error querying events from episodic memory: ${errorMsg}`,
+                    returnDisplay: `Error querying events from episodic memory: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.MEMORY_TOOL_EXECUTION_ERROR,
+                    },
+                };
+            }
+            const data = response.data;
+            const events = (data === null || data === void 0 ? void 0 : data.events) || [];
+            const total = (data === null || data === void 0 ? void 0 : data.total) || 0;
+            const filtered = (data === null || data === void 0 ? void 0 : data.filtered) || false;
+            return {
+                llmContent: `Found ${events.length} events (total: ${total}, filtered: ${filtered}).\n\n${JSON.stringify(events, null, 2)}`,
+                returnDisplay: `Successfully queried ${events.length} events from episodic memory`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error querying events from episodic memory: ${errorMessage}`,
+                returnDisplay: `Error querying events from episodic memory: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the EpisodicMemoryQueryEvents tool logic
+ */
+class EpisodicMemoryQueryEventsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EpisodicMemoryQueryEventsTool.Name, 'EpisodicMemoryQueryEvents', 'Queries and filters events from an episodic memory. Supports filtering by time range, event type, agent, team, and tags. Returns matching events with metadata.', types_1.Kind.Read, {
+            properties: {
+                memoryId: {
+                    description: 'The unique identifier of the episodic memory to query events from.',
+                    type: 'string',
+                },
+                swarmId: {
+                    description: 'The swarm ID to query events from (alternative to memoryId).',
+                    type: 'string',
+                },
+                lastMinutes: {
+                    description: 'Filter events from the last N minutes.',
+                    type: 'number',
+                },
+                lastCount: {
+                    description: 'Limit the number of events returned.',
+                    type: 'number',
+                },
+                tags: {
+                    description: 'Filter events that have any of the specified tags.',
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+                event_type: {
+                    description: 'Filter events by event type.',
+                    type: 'string',
+                },
+                emitting_agent_id: {
+                    description: 'Filter events by the agent that emitted them.',
+                    type: 'string',
+                },
+                team_id: {
+                    description: 'Filter events by team ID.',
+                    type: 'string',
+                },
+                since: {
+                    description: 'Filter events since a specific timestamp (ISO 8601 format).',
+                    type: 'string',
+                },
+            },
+            required: [],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.memoryId && !params.swarmId) {
+            return "Either 'memoryId' or 'swarmId' must be provided.";
+        }
+        if (params.lastMinutes !== undefined && params.lastMinutes < 0) {
+            return "The 'lastMinutes' parameter must be a non-negative number.";
+        }
+        if (params.lastCount !== undefined && params.lastCount < 0) {
+            return "The 'lastCount' parameter must be a non-negative number.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new EpisodicMemoryQueryEventsToolInvocation(params);
+    }
+}
+exports.EpisodicMemoryQueryEventsTool = EpisodicMemoryQueryEventsTool;
+EpisodicMemoryQueryEventsTool.Name = 'episodic_memory_query_events';

package/dist/tools/memory/episodic-memory-update-title.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Episodic Memory Update Title Tool - Updates the title of an episodic memory
+ * Wraps the SDK's cbepisodicMemory.updateTitle() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the EpisodicMemoryUpdateTitle tool
+ */
+export interface EpisodicMemoryUpdateTitleToolParams {
+    /**
+     * The ID of the episodic memory to update
+     */
+    memoryId: string;
+    /**
+     * The new title for the episodic memory
+     */
+    title: string;
+}
+/**
+ * Implementation of the EpisodicMemoryUpdateTitle tool logic
+ */
+export declare class EpisodicMemoryUpdateTitleTool extends BaseDeclarativeTool<EpisodicMemoryUpdateTitleToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: EpisodicMemoryUpdateTitleToolParams): string | null;
+    protected createInvocation(params: EpisodicMemoryUpdateTitleToolParams): ToolInvocation<EpisodicMemoryUpdateTitleToolParams, ToolResult>;
+}

package/dist/tools/memory/episodic-memory-update-title.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Episodic Memory Update Title Tool - Updates the title of an episodic memory
+ * Wraps the SDK's cbepisodicMemory.updateTitle() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodicMemoryUpdateTitleTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const episodicMemory_1 = __importDefault(require("../../modules/episodicMemory"));
+class EpisodicMemoryUpdateTitleToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            const response = await episodicMemory_1.default.updateTitle({
+                memoryId: this.params.memoryId,
+                title: this.params.title,
+            });
+            if (!response.success) {
+                const errorMsg = ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Unknown error';
+                return {
+                    llmContent: `Error updating episodic memory title: ${errorMsg}`,
+                    returnDisplay: `Error updating episodic memory title: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.MEMORY_TOOL_EXECUTION_ERROR,
+                    },
+                };
+            }
+            const message = ((_b = response.data) === null || _b === void 0 ? void 0 : _b.message) || 'Title updated successfully';
+            return {
+                llmContent: `Successfully updated episodic memory title to "${this.params.title}".\n\n${message}`,
+                returnDisplay: `Successfully updated title for episodic memory (ID: ${this.params.memoryId})`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error updating episodic memory title: ${errorMessage}`,
+                returnDisplay: `Error updating episodic memory title: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the EpisodicMemoryUpdateTitle tool logic
+ */
+class EpisodicMemoryUpdateTitleTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EpisodicMemoryUpdateTitleTool.Name, 'EpisodicMemoryUpdateTitle', 'Updates the title of an existing episodic memory. Useful for renaming memories to better reflect their content or purpose.', types_1.Kind.Edit, {
+            properties: {
+                memoryId: {
+                    description: 'The unique identifier of the episodic memory to update.',
+                    type: 'string',
+                },
+                title: {
+                    description: 'The new title for the episodic memory.',
+                    type: 'string',
+                },
+            },
+            required: ['memoryId', 'title'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.memoryId || params.memoryId.trim() === '') {
+            return "The 'memoryId' parameter must be a non-empty string.";
+        }
+        if (!params.title || params.title.trim() === '') {
+            return "The 'title' parameter must be a non-empty string.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new EpisodicMemoryUpdateTitleToolInvocation(params);
+    }
+}
+exports.EpisodicMemoryUpdateTitleTool = EpisodicMemoryUpdateTitleTool;
+EpisodicMemoryUpdateTitleTool.Name = 'episodic_memory_update_title';

package/dist/tools/memory/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Memory operations tools
+ */
+export { MemoryJsonSaveTool, type MemoryJsonSaveToolParams } from './memory-json-save';
+export { MemoryJsonUpdateTool, type MemoryJsonUpdateToolParams } from './memory-json-update';
+export { MemoryJsonDeleteTool, type MemoryJsonDeleteToolParams } from './memory-json-delete';
+export { MemoryJsonListTool, type MemoryJsonListToolParams } from './memory-json-list';
+export { MemoryTodoSaveTool, type MemoryTodoSaveToolParams } from './memory-todo-save';
+export { MemoryTodoUpdateTool, type MemoryTodoUpdateToolParams } from './memory-todo-update';
+export { MemoryTodoDeleteTool, type MemoryTodoDeleteToolParams } from './memory-todo-delete';
+export { MemoryTodoListTool, type MemoryTodoListToolParams } from './memory-todo-list';
+export { MemoryMarkdownSaveTool, type MemoryMarkdownSaveToolParams } from './memory-markdown-save';
+export { MemoryMarkdownUpdateTool, type MemoryMarkdownUpdateToolParams } from './memory-markdown-update';
+export { MemoryMarkdownDeleteTool, type MemoryMarkdownDeleteToolParams } from './memory-markdown-delete';
+export { MemoryMarkdownListTool, type MemoryMarkdownListToolParams } from './memory-markdown-list';
+export { EpisodicMemoryCreateTool, type EpisodicMemoryCreateToolParams } from './episodic-memory-create';
+export { EpisodicMemoryListTool, type EpisodicMemoryListToolParams } from './episodic-memory-list';
+export { EpisodicMemoryGetTool, type EpisodicMemoryGetToolParams } from './episodic-memory-get';
+export { EpisodicMemoryAppendEventTool, type EpisodicMemoryAppendEventToolParams } from './episodic-memory-append-event';
+export { EpisodicMemoryQueryEventsTool, type EpisodicMemoryQueryEventsToolParams } from './episodic-memory-query-events';
+export { EpisodicMemoryGetEventTypesTool, type EpisodicMemoryGetEventTypesToolParams } from './episodic-memory-get-event-types';
+export { EpisodicMemoryArchiveTool, type EpisodicMemoryArchiveToolParams } from './episodic-memory-archive';
+export { EpisodicMemoryUpdateTitleTool, type EpisodicMemoryUpdateTitleToolParams } from './episodic-memory-update-title';
+export { PersistentMemoryCreateTool, type PersistentMemoryCreateToolParams } from './persistent-memory-create';
+export { PersistentMemoryGetTool, type PersistentMemoryGetToolParams } from './persistent-memory-get';
+export { PersistentMemoryListTool, type PersistentMemoryListToolParams } from './persistent-memory-list';
+export { PersistentMemoryUpdateTool, type PersistentMemoryUpdateToolParams } from './persistent-memory-update';
+export { PersistentMemoryRetrieveTool, type PersistentMemoryRetrieveToolParams } from './persistent-memory-retrieve';
+import { MemoryJsonSaveTool } from './memory-json-save';
+import { MemoryJsonUpdateTool } from './memory-json-update';
+import { MemoryJsonDeleteTool } from './memory-json-delete';
+import { MemoryJsonListTool } from './memory-json-list';
+import { MemoryTodoSaveTool } from './memory-todo-save';
+import { MemoryTodoUpdateTool } from './memory-todo-update';
+import { MemoryTodoDeleteTool } from './memory-todo-delete';
+import { MemoryTodoListTool } from './memory-todo-list';
+import { MemoryMarkdownSaveTool } from './memory-markdown-save';
+import { MemoryMarkdownUpdateTool } from './memory-markdown-update';
+import { MemoryMarkdownDeleteTool } from './memory-markdown-delete';
+import { MemoryMarkdownListTool } from './memory-markdown-list';
+import { EpisodicMemoryCreateTool } from './episodic-memory-create';
+import { EpisodicMemoryListTool } from './episodic-memory-list';
+import { EpisodicMemoryGetTool } from './episodic-memory-get';
+import { EpisodicMemoryAppendEventTool } from './episodic-memory-append-event';
+import { EpisodicMemoryQueryEventsTool } from './episodic-memory-query-events';
+import { EpisodicMemoryGetEventTypesTool } from './episodic-memory-get-event-types';
+import { EpisodicMemoryArchiveTool } from './episodic-memory-archive';
+import { EpisodicMemoryUpdateTitleTool } from './episodic-memory-update-title';
+import { PersistentMemoryCreateTool } from './persistent-memory-create';
+import { PersistentMemoryGetTool } from './persistent-memory-get';
+import { PersistentMemoryListTool } from './persistent-memory-list';
+import { PersistentMemoryUpdateTool } from './persistent-memory-update';
+import { PersistentMemoryRetrieveTool } from './persistent-memory-retrieve';
+/**
+ * All memory operation tools
+ */
+export declare const memoryTools: (MemoryJsonSaveTool | MemoryJsonUpdateTool | MemoryJsonDeleteTool | MemoryJsonListTool | MemoryTodoSaveTool | MemoryTodoUpdateTool | MemoryTodoDeleteTool | MemoryTodoListTool | MemoryMarkdownSaveTool | MemoryMarkdownUpdateTool | MemoryMarkdownDeleteTool | MemoryMarkdownListTool | EpisodicMemoryCreateTool | EpisodicMemoryListTool | EpisodicMemoryGetTool | EpisodicMemoryAppendEventTool | EpisodicMemoryQueryEventsTool | EpisodicMemoryGetEventTypesTool | EpisodicMemoryArchiveTool | EpisodicMemoryUpdateTitleTool | PersistentMemoryCreateTool | PersistentMemoryGetTool | PersistentMemoryListTool | PersistentMemoryUpdateTool | PersistentMemoryRetrieveTool)[];

package/dist/tools/memory/index.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Memory operations tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryTools = exports.PersistentMemoryRetrieveTool = exports.PersistentMemoryUpdateTool = exports.PersistentMemoryListTool = exports.PersistentMemoryGetTool = exports.PersistentMemoryCreateTool = exports.EpisodicMemoryUpdateTitleTool = exports.EpisodicMemoryArchiveTool = exports.EpisodicMemoryGetEventTypesTool = exports.EpisodicMemoryQueryEventsTool = exports.EpisodicMemoryAppendEventTool = exports.EpisodicMemoryGetTool = exports.EpisodicMemoryListTool = exports.EpisodicMemoryCreateTool = exports.MemoryMarkdownListTool = exports.MemoryMarkdownDeleteTool = exports.MemoryMarkdownUpdateTool = exports.MemoryMarkdownSaveTool = exports.MemoryTodoListTool = exports.MemoryTodoDeleteTool = exports.MemoryTodoUpdateTool = exports.MemoryTodoSaveTool = exports.MemoryJsonListTool = exports.MemoryJsonDeleteTool = exports.MemoryJsonUpdateTool = exports.MemoryJsonSaveTool = void 0;
+// JSON Memory Tools
+var memory_json_save_1 = require("./memory-json-save");
+Object.defineProperty(exports, "MemoryJsonSaveTool", { enumerable: true, get: function () { return memory_json_save_1.MemoryJsonSaveTool; } });
+var memory_json_update_1 = require("./memory-json-update");
+Object.defineProperty(exports, "MemoryJsonUpdateTool", { enumerable: true, get: function () { return memory_json_update_1.MemoryJsonUpdateTool; } });
+var memory_json_delete_1 = require("./memory-json-delete");
+Object.defineProperty(exports, "MemoryJsonDeleteTool", { enumerable: true, get: function () { return memory_json_delete_1.MemoryJsonDeleteTool; } });
+var memory_json_list_1 = require("./memory-json-list");
+Object.defineProperty(exports, "MemoryJsonListTool", { enumerable: true, get: function () { return memory_json_list_1.MemoryJsonListTool; } });
+// Todo Memory Tools
+var memory_todo_save_1 = require("./memory-todo-save");
+Object.defineProperty(exports, "MemoryTodoSaveTool", { enumerable: true, get: function () { return memory_todo_save_1.MemoryTodoSaveTool; } });
+var memory_todo_update_1 = require("./memory-todo-update");
+Object.defineProperty(exports, "MemoryTodoUpdateTool", { enumerable: true, get: function () { return memory_todo_update_1.MemoryTodoUpdateTool; } });
+var memory_todo_delete_1 = require("./memory-todo-delete");
+Object.defineProperty(exports, "MemoryTodoDeleteTool", { enumerable: true, get: function () { return memory_todo_delete_1.MemoryTodoDeleteTool; } });
+var memory_todo_list_1 = require("./memory-todo-list");
+Object.defineProperty(exports, "MemoryTodoListTool", { enumerable: true, get: function () { return memory_todo_list_1.MemoryTodoListTool; } });
+// Markdown Memory Tools
+var memory_markdown_save_1 = require("./memory-markdown-save");
+Object.defineProperty(exports, "MemoryMarkdownSaveTool", { enumerable: true, get: function () { return memory_markdown_save_1.MemoryMarkdownSaveTool; } });
+var memory_markdown_update_1 = require("./memory-markdown-update");
+Object.defineProperty(exports, "MemoryMarkdownUpdateTool", { enumerable: true, get: function () { return memory_markdown_update_1.MemoryMarkdownUpdateTool; } });
+var memory_markdown_delete_1 = require("./memory-markdown-delete");
+Object.defineProperty(exports, "MemoryMarkdownDeleteTool", { enumerable: true, get: function () { return memory_markdown_delete_1.MemoryMarkdownDeleteTool; } });
+var memory_markdown_list_1 = require("./memory-markdown-list");
+Object.defineProperty(exports, "MemoryMarkdownListTool", { enumerable: true, get: function () { return memory_markdown_list_1.MemoryMarkdownListTool; } });
+// Episodic Memory Tools
+var episodic_memory_create_1 = require("./episodic-memory-create");
+Object.defineProperty(exports, "EpisodicMemoryCreateTool", { enumerable: true, get: function () { return episodic_memory_create_1.EpisodicMemoryCreateTool; } });
+var episodic_memory_list_1 = require("./episodic-memory-list");
+Object.defineProperty(exports, "EpisodicMemoryListTool", { enumerable: true, get: function () { return episodic_memory_list_1.EpisodicMemoryListTool; } });
+var episodic_memory_get_1 = require("./episodic-memory-get");
+Object.defineProperty(exports, "EpisodicMemoryGetTool", { enumerable: true, get: function () { return episodic_memory_get_1.EpisodicMemoryGetTool; } });
+var episodic_memory_append_event_1 = require("./episodic-memory-append-event");
+Object.defineProperty(exports, "EpisodicMemoryAppendEventTool", { enumerable: true, get: function () { return episodic_memory_append_event_1.EpisodicMemoryAppendEventTool; } });
+var episodic_memory_query_events_1 = require("./episodic-memory-query-events");
+Object.defineProperty(exports, "EpisodicMemoryQueryEventsTool", { enumerable: true, get: function () { return episodic_memory_query_events_1.EpisodicMemoryQueryEventsTool; } });
+var episodic_memory_get_event_types_1 = require("./episodic-memory-get-event-types");
+Object.defineProperty(exports, "EpisodicMemoryGetEventTypesTool", { enumerable: true, get: function () { return episodic_memory_get_event_types_1.EpisodicMemoryGetEventTypesTool; } });
+var episodic_memory_archive_1 = require("./episodic-memory-archive");
+Object.defineProperty(exports, "EpisodicMemoryArchiveTool", { enumerable: true, get: function () { return episodic_memory_archive_1.EpisodicMemoryArchiveTool; } });
+var episodic_memory_update_title_1 = require("./episodic-memory-update-title");
+Object.defineProperty(exports, "EpisodicMemoryUpdateTitleTool", { enumerable: true, get: function () { return episodic_memory_update_title_1.EpisodicMemoryUpdateTitleTool; } });
+// Persistent Memory Tools
+var persistent_memory_create_1 = require("./persistent-memory-create");
+Object.defineProperty(exports, "PersistentMemoryCreateTool", { enumerable: true, get: function () { return persistent_memory_create_1.PersistentMemoryCreateTool; } });
+var persistent_memory_get_1 = require("./persistent-memory-get");
+Object.defineProperty(exports, "PersistentMemoryGetTool", { enumerable: true, get: function () { return persistent_memory_get_1.PersistentMemoryGetTool; } });
+var persistent_memory_list_1 = require("./persistent-memory-list");
+Object.defineProperty(exports, "PersistentMemoryListTool", { enumerable: true, get: function () { return persistent_memory_list_1.PersistentMemoryListTool; } });
+var persistent_memory_update_1 = require("./persistent-memory-update");
+Object.defineProperty(exports, "PersistentMemoryUpdateTool", { enumerable: true, get: function () { return persistent_memory_update_1.PersistentMemoryUpdateTool; } });
+var persistent_memory_retrieve_1 = require("./persistent-memory-retrieve");
+Object.defineProperty(exports, "PersistentMemoryRetrieveTool", { enumerable: true, get: function () { return persistent_memory_retrieve_1.PersistentMemoryRetrieveTool; } });
+// Create instances for convenience
+const memory_json_save_2 = require("./memory-json-save");
+const memory_json_update_2 = require("./memory-json-update");
+const memory_json_delete_2 = require("./memory-json-delete");
+const memory_json_list_2 = require("./memory-json-list");
+const memory_todo_save_2 = require("./memory-todo-save");
+const memory_todo_update_2 = require("./memory-todo-update");
+const memory_todo_delete_2 = require("./memory-todo-delete");
+const memory_todo_list_2 = require("./memory-todo-list");
+const memory_markdown_save_2 = require("./memory-markdown-save");
+const memory_markdown_update_2 = require("./memory-markdown-update");
+const memory_markdown_delete_2 = require("./memory-markdown-delete");
+const memory_markdown_list_2 = require("./memory-markdown-list");
+const episodic_memory_create_2 = require("./episodic-memory-create");
+const episodic_memory_list_2 = require("./episodic-memory-list");
+const episodic_memory_get_2 = require("./episodic-memory-get");
+const episodic_memory_append_event_2 = require("./episodic-memory-append-event");
+const episodic_memory_query_events_2 = require("./episodic-memory-query-events");
+const episodic_memory_get_event_types_2 = require("./episodic-memory-get-event-types");
+const episodic_memory_archive_2 = require("./episodic-memory-archive");
+const episodic_memory_update_title_2 = require("./episodic-memory-update-title");
+const persistent_memory_create_2 = require("./persistent-memory-create");
+const persistent_memory_get_2 = require("./persistent-memory-get");
+const persistent_memory_list_2 = require("./persistent-memory-list");
+const persistent_memory_update_2 = require("./persistent-memory-update");
+const persistent_memory_retrieve_2 = require("./persistent-memory-retrieve");
+/**
+ * All memory operation tools
+ */
+exports.memoryTools = [
+    // JSON Memory Tools
+    new memory_json_save_2.MemoryJsonSaveTool(),
+    new memory_json_update_2.MemoryJsonUpdateTool(),
+    new memory_json_delete_2.MemoryJsonDeleteTool(),
+    new memory_json_list_2.MemoryJsonListTool(),
+    // Todo Memory Tools
+    new memory_todo_save_2.MemoryTodoSaveTool(),
+    new memory_todo_update_2.MemoryTodoUpdateTool(),
+    new memory_todo_delete_2.MemoryTodoDeleteTool(),
+    new memory_todo_list_2.MemoryTodoListTool(),
+    // Markdown Memory Tools
+    new memory_markdown_save_2.MemoryMarkdownSaveTool(),
+    new memory_markdown_update_2.MemoryMarkdownUpdateTool(),
+    new memory_markdown_delete_2.MemoryMarkdownDeleteTool(),
+    new memory_markdown_list_2.MemoryMarkdownListTool(),
+    // Episodic Memory Tools
+    new episodic_memory_create_2.EpisodicMemoryCreateTool(),
+    new episodic_memory_list_2.EpisodicMemoryListTool(),
+    new episodic_memory_get_2.EpisodicMemoryGetTool(),
+    new episodic_memory_append_event_2.EpisodicMemoryAppendEventTool(),
+    new episodic_memory_query_events_2.EpisodicMemoryQueryEventsTool(),
+    new episodic_memory_get_event_types_2.EpisodicMemoryGetEventTypesTool(),
+    new episodic_memory_archive_2.EpisodicMemoryArchiveTool(),
+    new episodic_memory_update_title_2.EpisodicMemoryUpdateTitleTool(),
+    // Persistent Memory Tools
+    new persistent_memory_create_2.PersistentMemoryCreateTool(),
+    new persistent_memory_get_2.PersistentMemoryGetTool(),
+    new persistent_memory_list_2.PersistentMemoryListTool(),
+    new persistent_memory_update_2.PersistentMemoryUpdateTool(),
+    new persistent_memory_retrieve_2.PersistentMemoryRetrieveTool(),
+];

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

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

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

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Memory JSON Delete Tool - Deletes JSON data from memory storage
+ * Wraps the SDK's cbmemory.json.delete() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryJsonDeleteTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const memory_1 = __importDefault(require("../../modules/memory"));
+class MemoryJsonDeleteToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await memory_1.default.json.delete(this.params.memoryId);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error deleting JSON from memory: ${errorMsg}`,
+                    returnDisplay: `Error deleting JSON from memory: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.MEMORY_TOOL_EXECUTION_ERROR,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully deleted JSON from memory. Memory ID: ${this.params.memoryId}`,
+                returnDisplay: `Successfully deleted JSON from memory (ID: ${this.params.memoryId})`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error deleting JSON from memory: ${errorMessage}`,
+                returnDisplay: `Error deleting JSON from memory: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the MemoryJsonDelete tool logic
+ */
+class MemoryJsonDeleteTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(MemoryJsonDeleteTool.Name, 'MemoryJsonDelete', 'Deletes a JSON object 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 MemoryJsonDeleteToolInvocation(params);
+    }
+}
+exports.MemoryJsonDeleteTool = MemoryJsonDeleteTool;
+MemoryJsonDeleteTool.Name = 'memory_json_delete';

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

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