@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/episodicMemory/episodic-get-memory.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodicGetMemoryTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const episodicMemory_1 = __importDefault(require("../../modules/episodicMemory"));
+class EpisodicGetMemoryInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a, _b, _c;
+        try {
+            const response = await episodicMemory_1.default.getMemory(this.params);
+            if (!response.success || !response.data) {
+                return {
+                    llmContent: `Error: ${((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Episodic memory not found'}`,
+                    returnDisplay: `Error: ${((_b = response.error) === null || _b === void 0 ? void 0 : _b.message) || 'Episodic memory not found'}`,
+                    error: { message: ((_c = response.error) === null || _c === void 0 ? void 0 : _c.message) || 'Episodic memory not found', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const memory = response.data;
+            return {
+                llmContent: `Episodic memory "${memory.title}" retrieved successfully`,
+                returnDisplay: JSON.stringify(memory, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EpisodicGetMemoryTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('episodic_get_memory', 'Get Episodic Memory', 'Get an episodic memory by ID', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string', description: 'ID of the episodic memory' },
+                swarmId: { type: 'string', description: 'Swarm ID (alternative to memoryId)' },
+            },
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new EpisodicGetMemoryInvocation(params);
+    }
+}
+exports.EpisodicGetMemoryTool = EpisodicGetMemoryTool;

package/dist/tools/episodicMemory/episodic-get-tags.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { IGetTagsParams } from '../../modules/episodicMemory';
+export interface EpisodicGetTagsParams extends IGetTagsParams {
+}
+export declare class EpisodicGetTagsTool extends BaseDeclarativeTool<EpisodicGetTagsParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: EpisodicGetTagsParams): ToolInvocation<EpisodicGetTagsParams, ToolResult>;
+}

package/dist/tools/episodicMemory/episodic-get-tags.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodicGetTagsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const episodicMemory_1 = __importDefault(require("../../modules/episodicMemory"));
+class EpisodicGetTagsInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a, _b, _c;
+        try {
+            const response = await episodicMemory_1.default.getTags(this.params);
+            if (!response.success || !response.data) {
+                return {
+                    llmContent: `Error: ${((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Failed to get tags'}`,
+                    returnDisplay: `Error: ${((_b = response.error) === null || _b === void 0 ? void 0 : _b.message) || 'Failed to get tags'}`,
+                    error: { message: ((_c = response.error) === null || _c === void 0 ? void 0 : _c.message) || 'Failed to get tags', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const tags = response.data;
+            return {
+                llmContent: `Found ${tags.length} unique tag(s)`,
+                returnDisplay: JSON.stringify(tags, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EpisodicGetTagsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('episodic_get_tags', 'Get Tags', 'Get unique tags from an episodic memory', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string', description: 'ID of the episodic memory' },
+                swarmId: { type: 'string', description: 'Swarm ID (alternative to memoryId)' },
+            },
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new EpisodicGetTagsInvocation(params);
+    }
+}
+exports.EpisodicGetTagsTool = EpisodicGetTagsTool;

package/dist/tools/episodicMemory/episodic-list-memories.d.ts

@@ -0,0 +1,8 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface EpisodicListMemoriesParams {
+}
+export declare class EpisodicListMemoriesTool extends BaseDeclarativeTool<EpisodicListMemoriesParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: EpisodicListMemoriesParams): ToolInvocation<EpisodicListMemoriesParams, ToolResult>;
+}

package/dist/tools/episodicMemory/episodic-list-memories.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodicListMemoriesTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const episodicMemory_1 = __importDefault(require("../../modules/episodicMemory"));
+class EpisodicListMemoriesInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a, _b, _c;
+        try {
+            const response = await episodicMemory_1.default.listMemories();
+            if (!response.success || !response.data) {
+                return {
+                    llmContent: `Error: ${((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Failed to list episodic memories'}`,
+                    returnDisplay: `Error: ${((_b = response.error) === null || _b === void 0 ? void 0 : _b.message) || 'Failed to list episodic memories'}`,
+                    error: { message: ((_c = response.error) === null || _c === void 0 ? void 0 : _c.message) || 'Failed to list episodic memories', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const memories = response.data;
+            return {
+                llmContent: `Found ${memories.length} episodic memor${memories.length === 1 ? 'y' : 'ies'}`,
+                returnDisplay: JSON.stringify(memories, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EpisodicListMemoriesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('episodic_list_memories', 'List Episodic Memories', 'List all episodic memories', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new EpisodicListMemoriesInvocation(params);
+    }
+}
+exports.EpisodicListMemoriesTool = EpisodicListMemoriesTool;

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

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { IQueryEventsParams } from '../../modules/episodicMemory';
+export interface EpisodicQueryEventsParams extends IQueryEventsParams {
+}
+export declare class EpisodicQueryEventsTool extends BaseDeclarativeTool<EpisodicQueryEventsParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: EpisodicQueryEventsParams): ToolInvocation<EpisodicQueryEventsParams, ToolResult>;
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodicQueryEventsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const episodicMemory_1 = __importDefault(require("../../modules/episodicMemory"));
+class EpisodicQueryEventsInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a, _b, _c;
+        try {
+            const response = await episodicMemory_1.default.queryEvents(this.params);
+            if (!response.success || !response.data) {
+                return {
+                    llmContent: `Error: ${((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Failed to query events'}`,
+                    returnDisplay: `Error: ${((_b = response.error) === null || _b === void 0 ? void 0 : _b.message) || 'Failed to query events'}`,
+                    error: { message: ((_c = response.error) === null || _c === void 0 ? void 0 : _c.message) || 'Failed to query events', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const { events, total, filtered } = response.data;
+            return {
+                llmContent: `Found ${events.length} event(s) out of ${total} total${filtered ? ' (filtered)' : ''}`,
+                returnDisplay: JSON.stringify(events, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EpisodicQueryEventsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('episodic_query_events', 'Query Events', 'Query events from an episodic memory', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string', description: 'ID of the episodic memory' },
+                swarmId: { type: 'string', description: 'Swarm ID (alternative to memoryId)' },
+                lastMinutes: { type: 'number', description: 'Filter events from last N minutes' },
+                lastCount: { type: 'number', description: 'Get last N events' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Filter by tags' },
+                event_type: { type: 'string', description: 'Filter by event type' },
+                emitting_agent_id: { type: 'string', description: 'Filter by emitting agent ID' },
+                team_id: { type: 'string', description: 'Filter by team ID' },
+                since: { type: 'string', description: 'Filter events since timestamp' },
+            },
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new EpisodicQueryEventsInvocation(params);
+    }
+}
+exports.EpisodicQueryEventsTool = EpisodicQueryEventsTool;

package/dist/tools/episodicMemory/episodic-unarchive-memory.d.ts

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { IUnarchiveMemoryParams } from '../../modules/episodicMemory';
+export interface EpisodicUnarchiveMemoryParams extends IUnarchiveMemoryParams {
+}
+export declare class EpisodicUnarchiveMemoryTool extends BaseDeclarativeTool<EpisodicUnarchiveMemoryParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: EpisodicUnarchiveMemoryParams): ToolInvocation<EpisodicUnarchiveMemoryParams, ToolResult>;
+}

package/dist/tools/episodicMemory/episodic-unarchive-memory.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodicUnarchiveMemoryTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const episodicMemory_1 = __importDefault(require("../../modules/episodicMemory"));
+class EpisodicUnarchiveMemoryInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a, _b, _c;
+        try {
+            const response = await episodicMemory_1.default.unarchiveMemory(this.params);
+            if (!response.success || !response.data) {
+                return {
+                    llmContent: `Error: ${((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Failed to unarchive episodic memory'}`,
+                    returnDisplay: `Error: ${((_b = response.error) === null || _b === void 0 ? void 0 : _b.message) || 'Failed to unarchive episodic memory'}`,
+                    error: { message: ((_c = response.error) === null || _c === void 0 ? void 0 : _c.message) || 'Failed to unarchive episodic memory', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Episodic memory unarchived successfully`,
+                returnDisplay: response.data.message || 'Memory unarchived',
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EpisodicUnarchiveMemoryTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('episodic_unarchive_memory', 'Unarchive Memory', 'Unarchive an episodic memory', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string', description: 'ID of the episodic memory' },
+                swarmId: { type: 'string', description: 'Swarm ID (alternative to memoryId)' },
+            },
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new EpisodicUnarchiveMemoryInvocation(params);
+    }
+}
+exports.EpisodicUnarchiveMemoryTool = EpisodicUnarchiveMemoryTool;

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

@@ -0,0 +1,9 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+import type { IUpdateTitleParams } from '../../modules/episodicMemory';
+export interface EpisodicUpdateTitleParams extends IUpdateTitleParams {
+}
+export declare class EpisodicUpdateTitleTool extends BaseDeclarativeTool<EpisodicUpdateTitleParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: EpisodicUpdateTitleParams): ToolInvocation<EpisodicUpdateTitleParams, ToolResult>;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodicUpdateTitleTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const episodicMemory_1 = __importDefault(require("../../modules/episodicMemory"));
+class EpisodicUpdateTitleInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a, _b, _c;
+        try {
+            const response = await episodicMemory_1.default.updateTitle(this.params);
+            if (!response.success || !response.data) {
+                return {
+                    llmContent: `Error: ${((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Failed to update episodic memory title'}`,
+                    returnDisplay: `Error: ${((_b = response.error) === null || _b === void 0 ? void 0 : _b.message) || 'Failed to update episodic memory title'}`,
+                    error: { message: ((_c = response.error) === null || _c === void 0 ? void 0 : _c.message) || 'Failed to update episodic memory title', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Episodic memory title updated successfully to "${this.params.title}"`,
+                returnDisplay: response.data.message || `Title updated to: ${this.params.title}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EpisodicUpdateTitleTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('episodic_update_title', 'Update Memory Title', 'Update the title of an episodic memory', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string', description: 'ID of the episodic memory' },
+                swarmId: { type: 'string', description: 'Swarm ID (alternative to memoryId)' },
+                title: { type: 'string', description: 'New title for the episodic memory' },
+            },
+            required: ['title'],
+        });
+    }
+    createInvocation(params) {
+        return new EpisodicUpdateTitleInvocation(params);
+    }
+}
+exports.EpisodicUpdateTitleTool = EpisodicUpdateTitleTool;

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

@@ -0,0 +1,31 @@
+/**
+ * Episodic Memory Tools
+ *
+ * Tools for managing episodic memories and events.
+ */
+export { EpisodicCreateMemoryTool } from './episodic-create-memory';
+export { EpisodicListMemoriesTool } from './episodic-list-memories';
+export { EpisodicGetMemoryTool } from './episodic-get-memory';
+export { EpisodicAppendEventTool } from './episodic-append-event';
+export { EpisodicQueryEventsTool } from './episodic-query-events';
+export { EpisodicGetEventTypesTool } from './episodic-get-event-types';
+export { EpisodicGetTagsTool } from './episodic-get-tags';
+export { EpisodicGetAgentsTool } from './episodic-get-agents';
+export { EpisodicArchiveMemoryTool } from './episodic-archive-memory';
+export { EpisodicUnarchiveMemoryTool } from './episodic-unarchive-memory';
+export { EpisodicUpdateTitleTool } from './episodic-update-title';
+import { EpisodicCreateMemoryTool } from './episodic-create-memory';
+import { EpisodicListMemoriesTool } from './episodic-list-memories';
+import { EpisodicGetMemoryTool } from './episodic-get-memory';
+import { EpisodicAppendEventTool } from './episodic-append-event';
+import { EpisodicQueryEventsTool } from './episodic-query-events';
+import { EpisodicGetEventTypesTool } from './episodic-get-event-types';
+import { EpisodicGetTagsTool } from './episodic-get-tags';
+import { EpisodicGetAgentsTool } from './episodic-get-agents';
+import { EpisodicArchiveMemoryTool } from './episodic-archive-memory';
+import { EpisodicUnarchiveMemoryTool } from './episodic-unarchive-memory';
+import { EpisodicUpdateTitleTool } from './episodic-update-title';
+/**
+ * Array of all episodic memory tools
+ */
+export declare const episodicMemoryTools: (EpisodicCreateMemoryTool | EpisodicListMemoriesTool | EpisodicGetMemoryTool | EpisodicAppendEventTool | EpisodicQueryEventsTool | EpisodicGetEventTypesTool | EpisodicGetTagsTool | EpisodicGetAgentsTool | EpisodicArchiveMemoryTool | EpisodicUnarchiveMemoryTool | EpisodicUpdateTitleTool)[];

package/dist/tools/episodicMemory/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Episodic Memory Tools
+ *
+ * Tools for managing episodic memories and events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.episodicMemoryTools = exports.EpisodicUpdateTitleTool = exports.EpisodicUnarchiveMemoryTool = exports.EpisodicArchiveMemoryTool = exports.EpisodicGetAgentsTool = exports.EpisodicGetTagsTool = exports.EpisodicGetEventTypesTool = exports.EpisodicQueryEventsTool = exports.EpisodicAppendEventTool = exports.EpisodicGetMemoryTool = exports.EpisodicListMemoriesTool = exports.EpisodicCreateMemoryTool = void 0;
+var episodic_create_memory_1 = require("./episodic-create-memory");
+Object.defineProperty(exports, "EpisodicCreateMemoryTool", { enumerable: true, get: function () { return episodic_create_memory_1.EpisodicCreateMemoryTool; } });
+var episodic_list_memories_1 = require("./episodic-list-memories");
+Object.defineProperty(exports, "EpisodicListMemoriesTool", { enumerable: true, get: function () { return episodic_list_memories_1.EpisodicListMemoriesTool; } });
+var episodic_get_memory_1 = require("./episodic-get-memory");
+Object.defineProperty(exports, "EpisodicGetMemoryTool", { enumerable: true, get: function () { return episodic_get_memory_1.EpisodicGetMemoryTool; } });
+var episodic_append_event_1 = require("./episodic-append-event");
+Object.defineProperty(exports, "EpisodicAppendEventTool", { enumerable: true, get: function () { return episodic_append_event_1.EpisodicAppendEventTool; } });
+var episodic_query_events_1 = require("./episodic-query-events");
+Object.defineProperty(exports, "EpisodicQueryEventsTool", { enumerable: true, get: function () { return episodic_query_events_1.EpisodicQueryEventsTool; } });
+var episodic_get_event_types_1 = require("./episodic-get-event-types");
+Object.defineProperty(exports, "EpisodicGetEventTypesTool", { enumerable: true, get: function () { return episodic_get_event_types_1.EpisodicGetEventTypesTool; } });
+var episodic_get_tags_1 = require("./episodic-get-tags");
+Object.defineProperty(exports, "EpisodicGetTagsTool", { enumerable: true, get: function () { return episodic_get_tags_1.EpisodicGetTagsTool; } });
+var episodic_get_agents_1 = require("./episodic-get-agents");
+Object.defineProperty(exports, "EpisodicGetAgentsTool", { enumerable: true, get: function () { return episodic_get_agents_1.EpisodicGetAgentsTool; } });
+var episodic_archive_memory_1 = require("./episodic-archive-memory");
+Object.defineProperty(exports, "EpisodicArchiveMemoryTool", { enumerable: true, get: function () { return episodic_archive_memory_1.EpisodicArchiveMemoryTool; } });
+var episodic_unarchive_memory_1 = require("./episodic-unarchive-memory");
+Object.defineProperty(exports, "EpisodicUnarchiveMemoryTool", { enumerable: true, get: function () { return episodic_unarchive_memory_1.EpisodicUnarchiveMemoryTool; } });
+var episodic_update_title_1 = require("./episodic-update-title");
+Object.defineProperty(exports, "EpisodicUpdateTitleTool", { enumerable: true, get: function () { return episodic_update_title_1.EpisodicUpdateTitleTool; } });
+const episodic_create_memory_2 = require("./episodic-create-memory");
+const episodic_list_memories_2 = require("./episodic-list-memories");
+const episodic_get_memory_2 = require("./episodic-get-memory");
+const episodic_append_event_2 = require("./episodic-append-event");
+const episodic_query_events_2 = require("./episodic-query-events");
+const episodic_get_event_types_2 = require("./episodic-get-event-types");
+const episodic_get_tags_2 = require("./episodic-get-tags");
+const episodic_get_agents_2 = require("./episodic-get-agents");
+const episodic_archive_memory_2 = require("./episodic-archive-memory");
+const episodic_unarchive_memory_2 = require("./episodic-unarchive-memory");
+const episodic_update_title_2 = require("./episodic-update-title");
+/**
+ * Array of all episodic memory tools
+ */
+exports.episodicMemoryTools = [
+    new episodic_create_memory_2.EpisodicCreateMemoryTool(),
+    new episodic_list_memories_2.EpisodicListMemoriesTool(),
+    new episodic_get_memory_2.EpisodicGetMemoryTool(),
+    new episodic_append_event_2.EpisodicAppendEventTool(),
+    new episodic_query_events_2.EpisodicQueryEventsTool(),
+    new episodic_get_event_types_2.EpisodicGetEventTypesTool(),
+    new episodic_get_tags_2.EpisodicGetTagsTool(),
+    new episodic_get_agents_2.EpisodicGetAgentsTool(),
+    new episodic_archive_memory_2.EpisodicArchiveMemoryTool(),
+    new episodic_unarchive_memory_2.EpisodicUnarchiveMemoryTool(),
+    new episodic_update_title_2.EpisodicUpdateTitleTool(),
+];

package/dist/tools/event/event-add-running-agent.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Event Add Running Agent Tool - Adds a running background agent to tracking
+ * Wraps the SDK's codeboltEvent.addRunningAgent() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the EventAddRunningAgent tool
+ */
+export interface EventAddRunningAgentParams {
+    /**
+     * The thread ID of the background agent
+     */
+    thread_id: string;
+    /**
+     * The agent data to store
+     */
+    data: any;
+    /**
+     * Optional group ID for grouping agents
+     */
+    group_id?: string;
+}
+/**
+ * Tool for adding a running background agent to tracking
+ */
+export declare class EventAddRunningAgentTool extends BaseDeclarativeTool<EventAddRunningAgentParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: EventAddRunningAgentParams): string | null;
+    protected createInvocation(params: EventAddRunningAgentParams): ToolInvocation<EventAddRunningAgentParams, ToolResult>;
+}

package/dist/tools/event/event-add-running-agent.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Event Add Running Agent Tool - Adds a running background agent to tracking
+ * Wraps the SDK's codeboltEvent.addRunningAgent() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventAddRunningAgentTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
+class EventAddRunningAgentInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            codeboltEvent_1.default.addRunningAgent(this.params.thread_id, this.params.data, this.params.group_id);
+            let llmContent = `Background agent added to tracking.\nThread ID: ${this.params.thread_id}`;
+            if (this.params.group_id) {
+                llmContent += `\nGroup ID: ${this.params.group_id}`;
+            }
+            return {
+                llmContent,
+                returnDisplay: `Agent added: ${this.params.thread_id}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error adding running agent: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for adding a running background agent to tracking
+ */
+class EventAddRunningAgentTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EventAddRunningAgentTool.Name, 'Add Running Agent', 'Add a running background agent to the tracking system. This allows monitoring and waiting for agent completion.', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                thread_id: {
+                    type: 'string',
+                    description: 'The thread ID of the background agent'
+                },
+                data: {
+                    description: 'The agent data to store'
+                },
+                group_id: {
+                    type: 'string',
+                    description: 'Optional group ID for grouping agents'
+                }
+            },
+            required: ['thread_id', 'data']
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.thread_id || params.thread_id.trim() === '') {
+            return "The 'thread_id' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new EventAddRunningAgentInvocation(params);
+    }
+}
+exports.EventAddRunningAgentTool = EventAddRunningAgentTool;
+EventAddRunningAgentTool.Name = 'event_add_running_agent';

package/dist/tools/event/event-check-agent-event.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Event Check Agent Event Tool - Checks if any agent event has been received
+ * Wraps the SDK's codeboltEvent.checkForAgentEventReceived() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the EventCheckAgentEvent tool
+ */
+export interface EventCheckAgentEventParams {
+}
+/**
+ * Tool for checking if any agent event has been received
+ */
+export declare class EventCheckAgentEventTool extends BaseDeclarativeTool<EventCheckAgentEventParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EventCheckAgentEventParams): ToolInvocation<EventCheckAgentEventParams, ToolResult>;
+}