@codebolt/codeboltjs 5.0.2 → 5.0.4

package/dist/modules/mcp.js

@@ -5,7 +5,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // To use UserMessage functionality, install @codebolt/agent-utils
 const websocket_1 = __importDefault(require("../core/websocket"));
+const tools_1 = __importDefault(require("../tools"));
 const enum_1 = require("@codebolt/types/enum");
+const CODEBOLT_TOOLBOX = 'codebolt';
+/**
+ * Checks if toolbox is the codebolt local toolbox (case-insensitive)
+ */
+function isCodeboltToolbox(toolbox) {
+    return toolbox.toLowerCase() === CODEBOLT_TOOLBOX;
+}
+/**
+ * Converts a local declarative tool to OpenAI tool format.
+ * Prefixes tool name with 'codebolt--' for consistent naming.
+ */
+function convertLocalToolToOpenAIFormat(tool) {
+    return {
+        type: 'function',
+        function: {
+            name: `${CODEBOLT_TOOLBOX}--${tool.name}`,
+            description: tool.description,
+            parameters: tool.schema.function.parameters
+        }
+    };
+}
+/**
+ * Extracts the actual tool name from a prefixed tool name.
+ * e.g., "codebolt--read_file" -> "read_file"
+ */
+function extractToolName(prefixedName) {
+    const prefix = `${CODEBOLT_TOOLBOX}--`;
+    return prefixedName.startsWith(prefix)
+        ? prefixedName.substring(prefix.length)
+        : prefixedName;
+}
 /**
  * Object containing methods for interacting with Codebolt MCP (Model Context Protocol) tools.
  * Provides functionality to discover, list, and execute tools.
@@ -62,14 +94,31 @@ const codeboltMCP = {
      * Lists all tools from the specified toolboxes.
      *
      * @param toolBoxes - Array of toolbox names to list tools from
-     * @returns Promise with tools from the specified toolboxes
+     * @returns Promise with tools from the specified toolboxes (in OpenAI format)
      */
-    listMcpFromServers: (toolBoxes) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
-            "action": enum_1.CodeboltToolsAction.ListToolsFromToolBoxes,
-            "toolBoxes": toolBoxes
-        }, enum_1.CodeboltToolsResponse.ListToolsFromToolBoxesResponse);
+    listMcpFromServers: async (toolBoxes) => {
+        var _a;
+        const hasCodebolt = toolBoxes.some(tb => isCodeboltToolbox(tb));
+        const otherToolBoxes = toolBoxes.filter(tb => !isCodeboltToolbox(tb));
+        // Type matches ListToolsFromToolBoxesResponse.data.tools (OpenAI format)
+        const toolsList = [];
+        // Get local codebolt tools in OpenAI format (names prefixed as codebolt--<toolName>)
+        if (hasCodebolt) {
+            const localTools = tools_1.default.getAllTools().map(tool => convertLocalToolToOpenAIFormat(tool));
+            toolsList.push(...localTools);
+        }
+        // Get remote tools if needed
+        if (otherToolBoxes.length > 0) {
+            const response = await websocket_1.default.messageManager.sendAndWaitForResponse({
+                "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
+                "action": enum_1.CodeboltToolsAction.ListToolsFromToolBoxes,
+                "toolBoxes": otherToolBoxes
+            }, enum_1.CodeboltToolsResponse.ListToolsFromToolBoxesResponse);
+            if ((_a = response.data) === null || _a === void 0 ? void 0 : _a.tools) {
+                toolsList.push(...response.data.tools);
+            }
+        }
+        return { data: { tools: toolsList } };
     },
     /**
      * Configures a specific toolbox with provided configuration.
@@ -89,15 +138,40 @@ const codeboltMCP = {
     /**
      * Gets detailed information about specific tools.
      *
-     * @param tools - Array of toolbox and tool name pairs
+     * @param toolRequests - Array of toolbox and tool name pairs
      * @returns Promise with detailed information about the tools
      */
-    getTools: (tools) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
-            "action": enum_1.CodeboltToolsAction.GetTools,
-            "toolboxes": tools
-        }, enum_1.CodeboltToolsResponse.GetToolsResponse);
+    getTools: async (toolRequests) => {
+        const codeboltRequests = toolRequests.filter(t => isCodeboltToolbox(t.toolbox));
+        const otherRequests = toolRequests.filter(t => !isCodeboltToolbox(t.toolbox));
+        let result = [];
+        // Get local codebolt tools
+        if (codeboltRequests.length > 0) {
+            for (const req of codeboltRequests) {
+                const actualToolName = extractToolName(req.toolName);
+                const tool = tools_1.default.getTool(actualToolName);
+                if (tool) {
+                    result.push({
+                        toolbox: CODEBOLT_TOOLBOX,
+                        toolName: `${CODEBOLT_TOOLBOX}--${tool.name}`,
+                        description: tool.description,
+                        parameters: tool.schema.function.parameters
+                    });
+                }
+            }
+        }
+        // Get remote tools if needed
+        if (otherRequests.length > 0) {
+            const response = await websocket_1.default.messageManager.sendAndWaitForResponse({
+                "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
+                "action": enum_1.CodeboltToolsAction.GetTools,
+                "toolboxes": otherRequests
+            }, enum_1.CodeboltToolsResponse.GetToolsResponse);
+            if (response.data) {
+                result = [...result, ...response.data];
+            }
+        }
+        return { data: result };
     },
     /**
      * Executes a specific tool with provided parameters.
@@ -107,13 +181,130 @@ const codeboltMCP = {
      * @param params - Parameters to pass to the tool
      * @returns Promise with the execution result
      */
-    executeTool: (toolbox, toolName, params) => {
+    executeTool: async (toolbox, toolName, params) => {
+        // Handle local codebolt tools
+        if (isCodeboltToolbox(toolbox)) {
+            // Extract actual tool name (in case it comes prefixed)
+            const actualToolName = extractToolName(toolName);
+            if (!tools_1.default.hasTool(actualToolName)) {
+                return {
+                    success: false,
+                    error: `Tool '${actualToolName}' not found in codebolt toolbox`
+                };
+            }
+            const result = await tools_1.default.executeTool(actualToolName, params);
+            // Match MCP service "executeToolResponse" semantics used by the app:
+            // - data: [false, toolResponse] on success
+            // - data: [true, errorMessage] on error
+            const toolResponse = typeof result.llmContent === 'string'
+                ? result.llmContent
+                : JSON.stringify(result.llmContent);
+            if (result.error) {
+                return {
+                    success: false,
+                    status: 'error',
+                    error: result.error.message,
+                    result: toolResponse,
+                    data: [true, result.error.message],
+                };
+            }
+            return {
+                success: true,
+                status: 'success',
+                result: toolResponse,
+                data: [false, toolResponse],
+            };
+        }
+        // Use websocket for other toolboxes
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
             "action": enum_1.CodeboltToolsAction.ExecuteTool,
             "toolName": `${toolbox}--${toolName}`,
             "params": params
         }, enum_1.CodeboltToolsResponse.ExecuteToolResponse);
+    },
+    /**
+     * Gets MCP tools from the specified servers.
+     *
+     * @param mcpNames - Array of MCP server names to get tools from
+     * @returns Promise with MCP tools data
+     */
+    getMcpTools: async (mcpNames) => {
+        const includesCodebolt = !mcpNames || mcpNames.some(n => isCodeboltToolbox(n));
+        const otherMcpNames = mcpNames === null || mcpNames === void 0 ? void 0 : mcpNames.filter(n => !isCodeboltToolbox(n));
+        let result = [];
+        // Include local codebolt tools (names prefixed as codebolt--<toolName>)
+        if (includesCodebolt) {
+            const localTools = tools_1.default.getAllTools().map(convertLocalToolToOpenAIFormat);
+            result = [...result, ...localTools];
+        }
+        // Get remote MCP tools if needed
+        if (!mcpNames || (otherMcpNames && otherMcpNames.length > 0)) {
+            const response = await websocket_1.default.messageManager.sendAndWaitForResponse({
+                "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
+                "action": enum_1.CodeboltToolsAction.GetMcpTools,
+                "mcpNames": otherMcpNames
+            }, enum_1.CodeboltToolsResponse.GetMcpToolsResponse);
+            if (response.tools) {
+                result = [...result, ...response.tools];
+            }
+        }
+        return { tools: result };
+    },
+    /**
+     * Gets the list of available MCP servers.
+     *
+     * @returns Promise with MCP server list
+     */
+    getMcpList: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
+            "action": enum_1.CodeboltToolsAction.GetMcpList
+        }, enum_1.CodeboltToolsResponse.GetMcpListResponse);
+    },
+    /**
+     * Gets all tools from all enabled MCP servers.
+     *
+     * @returns Promise with all MCP tools data
+     */
+    getAllMcpTools: async () => {
+        // Get local codebolt tools
+        const localTools = tools_1.default.getAllTools().map(convertLocalToolToOpenAIFormat);
+        // Get remote MCP tools
+        const response = await websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
+            "action": enum_1.CodeboltToolsAction.GetAllMcpTools
+        }, enum_1.CodeboltToolsResponse.GetAllMcpToolsResponse);
+        const remoteTools = response.tools || [];
+        return { tools: [...localTools, ...remoteTools] };
+    },
+    /**
+     * Gets the list of enabled MCP servers.
+     *
+     * @returns Promise with enabled MCP servers data
+     */
+    getEnabledMcps: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
+            "action": enum_1.CodeboltToolsAction.GetEnabledMcps
+        }, enum_1.CodeboltToolsResponse.GetEnabledMcpsResponse);
+    },
+    /**
+     * Configures a specific MCP tool with provided configuration.
+     *
+     * @param mcpName - The name of the MCP server
+     * @param toolName - The name of the tool to configure
+     * @param config - Configuration object for the tool
+     * @returns Promise with the configuration result
+     */
+    configureMcpTool: (mcpName, toolName, config) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.CODEBOLT_TOOLS_EVENT,
+            "action": enum_1.CodeboltToolsAction.ConfigureMcpTool,
+            "mcpName": mcpName,
+            "toolName": toolName,
+            "config": config
+        }, enum_1.CodeboltToolsResponse.ConfigureMcpToolResponse);
     }
 };
 exports.default = codeboltMCP;

package/dist/modules/memoryIngestion.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Memory Ingestion Module
+ * Provides memory ingestion pipeline management
+ */
+import type { IngestionPipelineResponse, IngestionPipelineListResponse, IngestionExecuteResponse, IngestionValidateResponse, IngestionProcessorSpecsResponse, CreateIngestionPipelineParams, UpdateIngestionPipelineParams, ListIngestionPipelineParams, ExecuteIngestionParams } from '../types/memoryIngestion';
+declare const memoryIngestion: {
+    /**
+     * Create a new ingestion pipeline
+     * @param config - Pipeline configuration
+     */
+    create: (config: CreateIngestionPipelineParams) => Promise<IngestionPipelineResponse>;
+    /**
+     * Get an ingestion pipeline by ID
+     * @param pipelineId - Pipeline ID
+     */
+    get: (pipelineId: string) => Promise<IngestionPipelineResponse>;
+    /**
+     * List ingestion pipelines
+     * @param filters - Optional filters
+     */
+    list: (filters?: ListIngestionPipelineParams) => Promise<IngestionPipelineListResponse>;
+    /**
+     * Update an ingestion pipeline
+     * @param pipelineId - Pipeline ID
+     * @param updates - Update parameters
+     */
+    update: (pipelineId: string, updates: UpdateIngestionPipelineParams) => Promise<IngestionPipelineResponse>;
+    /**
+     * Delete an ingestion pipeline
+     * @param pipelineId - Pipeline ID
+     */
+    delete: (pipelineId: string) => Promise<IngestionPipelineResponse>;
+    /**
+     * Execute an ingestion pipeline
+     * @param params - Execution parameters
+     */
+    execute: (params: ExecuteIngestionParams) => Promise<IngestionExecuteResponse>;
+    /**
+     * Validate a pipeline configuration
+     * @param pipeline - Pipeline configuration to validate
+     */
+    validate: (pipeline: CreateIngestionPipelineParams) => Promise<IngestionValidateResponse>;
+    /**
+     * Get available processor specifications
+     */
+    getProcessorSpecs: () => Promise<IngestionProcessorSpecsResponse>;
+    /**
+     * Activate an ingestion pipeline
+     * @param pipelineId - Pipeline ID
+     */
+    activate: (pipelineId: string) => Promise<IngestionPipelineResponse>;
+    /**
+     * Disable an ingestion pipeline
+     * @param pipelineId - Pipeline ID
+     */
+    disable: (pipelineId: string) => Promise<IngestionPipelineResponse>;
+    /**
+     * Duplicate an ingestion pipeline
+     * @param pipelineId - Pipeline ID to duplicate
+     * @param newId - Optional new ID
+     * @param newLabel - Optional new label
+     */
+    duplicate: (pipelineId: string, newId?: string, newLabel?: string) => Promise<IngestionPipelineResponse>;
+};
+export default memoryIngestion;

package/dist/modules/memoryIngestion.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Memory Ingestion Module
+ * Provides memory ingestion pipeline management
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+const crypto_1 = require("crypto");
+const memoryIngestion = {
+    /**
+     * Create a new ingestion pipeline
+     * @param config - Pipeline configuration
+     */
+    create: async (config) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.create',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: config
+        }, 'memoryIngestion.create');
+    },
+    /**
+     * Get an ingestion pipeline by ID
+     * @param pipelineId - Pipeline ID
+     */
+    get: async (pipelineId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.get',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { pipelineId }
+        }, 'memoryIngestion.get');
+    },
+    /**
+     * List ingestion pipelines
+     * @param filters - Optional filters
+     */
+    list: async (filters) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.list',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: filters || {}
+        }, 'memoryIngestion.list');
+    },
+    /**
+     * Update an ingestion pipeline
+     * @param pipelineId - Pipeline ID
+     * @param updates - Update parameters
+     */
+    update: async (pipelineId, updates) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.update',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { pipelineId, ...updates }
+        }, 'memoryIngestion.update');
+    },
+    /**
+     * Delete an ingestion pipeline
+     * @param pipelineId - Pipeline ID
+     */
+    delete: async (pipelineId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.delete',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { pipelineId }
+        }, 'memoryIngestion.delete');
+    },
+    /**
+     * Execute an ingestion pipeline
+     * @param params - Execution parameters
+     */
+    execute: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.execute',
+            requestId: (0, crypto_1.randomUUID)(),
+            params
+        }, 'memoryIngestion.execute');
+    },
+    /**
+     * Validate a pipeline configuration
+     * @param pipeline - Pipeline configuration to validate
+     */
+    validate: async (pipeline) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.validate',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { pipeline }
+        }, 'memoryIngestion.validate');
+    },
+    /**
+     * Get available processor specifications
+     */
+    getProcessorSpecs: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.getProcessorSpecs',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: {}
+        }, 'memoryIngestion.getProcessorSpecs');
+    },
+    /**
+     * Activate an ingestion pipeline
+     * @param pipelineId - Pipeline ID
+     */
+    activate: async (pipelineId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.activate',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { pipelineId }
+        }, 'memoryIngestion.activate');
+    },
+    /**
+     * Disable an ingestion pipeline
+     * @param pipelineId - Pipeline ID
+     */
+    disable: async (pipelineId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.disable',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { pipelineId }
+        }, 'memoryIngestion.disable');
+    },
+    /**
+     * Duplicate an ingestion pipeline
+     * @param pipelineId - Pipeline ID to duplicate
+     * @param newId - Optional new ID
+     * @param newLabel - Optional new label
+     */
+    duplicate: async (pipelineId, newId, newLabel) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'memoryIngestion.duplicate',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { pipelineId, newId, newLabel }
+        }, 'memoryIngestion.duplicate');
+    }
+};
+exports.default = memoryIngestion;

package/dist/modules/orchestrator.d.ts

@@ -0,0 +1,81 @@
+export interface OrchestratorInstance {
+    id: string;
+    name: string;
+    description: string;
+    agentId: string;
+    defaultWorkerAgentId?: string | null;
+    threadId: string;
+    status: 'idle' | 'running' | 'paused';
+    metadata?: Record<string, any>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface OrchestratorResponse {
+    success: boolean;
+    requestId?: string;
+    data?: any;
+    error?: {
+        code: string;
+        message: string;
+        details?: any;
+    };
+}
+export interface CreateOrchestratorParams {
+    name: string;
+    description: string;
+    agentId: string;
+    defaultWorkerAgentId?: string;
+    metadata?: Record<string, any>;
+}
+export interface UpdateOrchestratorParams {
+    name?: string;
+    description?: string;
+    agentId?: string;
+    defaultWorkerAgentId?: string;
+    metadata?: Record<string, any>;
+}
+export interface UpdateOrchestratorSettingsParams {
+    name?: string;
+    description?: string;
+    defaultWorkerAgentId?: string;
+    metadata?: Record<string, any>;
+}
+declare const orchestrator: {
+    /**
+     * Lists all orchestrators
+     */
+    listOrchestrators: () => Promise<OrchestratorResponse>;
+    /**
+     * Gets a specific orchestrator by ID
+     */
+    getOrchestrator: (orchestratorId: string) => Promise<OrchestratorResponse>;
+    /**
+     * Gets orchestrator settings
+     */
+    getOrchestratorSettings: (orchestratorId: string) => Promise<OrchestratorResponse>;
+    /**
+     * Creates a new orchestrator
+     */
+    createOrchestrator: (data: CreateOrchestratorParams) => Promise<OrchestratorResponse>;
+    /**
+     * Updates an orchestrator
+     */
+    updateOrchestrator: (orchestratorId: string, data: UpdateOrchestratorParams) => Promise<OrchestratorResponse>;
+    /**
+     * Updates orchestrator settings
+     */
+    updateOrchestratorSettings: (orchestratorId: string, settings: UpdateOrchestratorSettingsParams) => Promise<OrchestratorResponse>;
+    /**
+     * Deletes an orchestrator
+     */
+    deleteOrchestrator: (orchestratorId: string) => Promise<OrchestratorResponse>;
+    /**
+     * Updates orchestrator status
+     */
+    updateOrchestratorStatus: (orchestratorId: string, status: "idle" | "running" | "paused") => Promise<OrchestratorResponse>;
+    /**
+     * Initiates a Codebolt JS update
+     */
+    updateCodeboltJs: () => Promise<OrchestratorResponse>;
+};
+export default orchestrator;

package/dist/modules/orchestrator.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+// We use a custom event type string for orchestrator events since we can't add to the enum 
+// The server parses 'orchestrator.<action>' type strings
+const ORCHESTRATOR_EVENT_PREFIX = 'orchestrator.';
+const orchestrator = {
+    /**
+     * Lists all orchestrators
+     */
+    listOrchestrators: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: `${ORCHESTRATOR_EVENT_PREFIX}list`,
+        }, 
+        // We expect a generic response type since we don't have specific enum for it
+        'orchestratorResponse');
+    },
+    /**
+     * Gets a specific orchestrator by ID
+     */
+    getOrchestrator: (orchestratorId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: `${ORCHESTRATOR_EVENT_PREFIX}get`,
+            orchestratorId
+        }, 'orchestratorResponse');
+    },
+    /**
+     * Gets orchestrator settings
+     */
+    getOrchestratorSettings: (orchestratorId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: `${ORCHESTRATOR_EVENT_PREFIX}getSettings`,
+            orchestratorId
+        }, 'orchestratorResponse');
+    },
+    /**
+     * Creates a new orchestrator
+     */
+    createOrchestrator: (data) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: `${ORCHESTRATOR_EVENT_PREFIX}create`,
+            data
+        }, 'orchestratorResponse');
+    },
+    /**
+     * Updates an orchestrator
+     */
+    updateOrchestrator: (orchestratorId, data) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: `${ORCHESTRATOR_EVENT_PREFIX}update`,
+            orchestratorId,
+            data
+        }, 'orchestratorResponse');
+    },
+    /**
+     * Updates orchestrator settings
+     */
+    updateOrchestratorSettings: (orchestratorId, settings) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: `${ORCHESTRATOR_EVENT_PREFIX}updateSettings`,
+            orchestratorId,
+            settings
+        }, 'orchestratorResponse');
+    },
+    /**
+     * Deletes an orchestrator
+     */
+    deleteOrchestrator: (orchestratorId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: `${ORCHESTRATOR_EVENT_PREFIX}delete`,
+            orchestratorId
+        }, 'orchestratorResponse');
+    },
+    /**
+     * Updates orchestrator status
+     */
+    updateOrchestratorStatus: (orchestratorId, status) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: `${ORCHESTRATOR_EVENT_PREFIX}updateStatus`,
+            orchestratorId,
+            status
+        }, 'orchestratorResponse');
+    },
+    /**
+     * Initiates a Codebolt JS update
+     */
+    updateCodeboltJs: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: `${ORCHESTRATOR_EVENT_PREFIX}updateCodeboltJs`,
+        }, 'orchestratorResponse');
+    }
+};
+exports.default = orchestrator;

package/dist/modules/persistentMemory.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Persistent Memory Module
+ * Provides persistent memory retrieval management for agents
+ */
+import type { PersistentMemoryResponse, PersistentMemoryListResponse, PersistentMemoryExecuteResponse, PersistentMemoryValidateResponse, PersistentMemoryStepSpecsResponse, CreatePersistentMemoryParams, UpdatePersistentMemoryParams, ListPersistentMemoryParams, PipelineExecutionIntent } from '../types/persistentMemory';
+declare const persistentMemory: {
+    /**
+     * Create a new persistent memory configuration
+     * @param config - Memory configuration
+     */
+    create: (config: CreatePersistentMemoryParams) => Promise<PersistentMemoryResponse>;
+    /**
+     * Get a persistent memory by ID
+     * @param memoryId - Memory ID
+     */
+    get: (memoryId: string) => Promise<PersistentMemoryResponse>;
+    /**
+     * List persistent memories
+     * @param filters - Optional filters
+     */
+    list: (filters?: ListPersistentMemoryParams) => Promise<PersistentMemoryListResponse>;
+    /**
+     * Update a persistent memory
+     * @param memoryId - Memory ID
+     * @param updates - Update parameters
+     */
+    update: (memoryId: string, updates: UpdatePersistentMemoryParams) => Promise<PersistentMemoryResponse>;
+    /**
+     * Delete a persistent memory
+     * @param memoryId - Memory ID
+     */
+    delete: (memoryId: string) => Promise<PersistentMemoryResponse>;
+    /**
+     * Execute memory retrieval pipeline
+     * @param memoryId - Memory ID
+     * @param intent - Execution intent with context
+     */
+    executeRetrieval: (memoryId: string, intent: PipelineExecutionIntent) => Promise<PersistentMemoryExecuteResponse>;
+    /**
+     * Validate a memory configuration
+     * @param memory - Memory configuration to validate
+     */
+    validate: (memory: CreatePersistentMemoryParams) => Promise<PersistentMemoryValidateResponse>;
+    /**
+     * Get available step specifications
+     */
+    getStepSpecs: () => Promise<PersistentMemoryStepSpecsResponse>;
+};
+export default persistentMemory;