@codebolt/codeboltjs 5.0.6 → 5.0.8

package/dist/modules/agentEventQueue.js

@@ -11,22 +11,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentEventPriority = exports.AgentEventStatus = exports.AgentEventType = void 0;
 const websocket_1 = __importDefault(require("../core/websocket"));
 const crypto_1 = require("crypto");
-var agentEventQueue_1 = require("../types/agentEventQueue");
-Object.defineProperty(exports, "AgentEventType", { enumerable: true, get: function () { return agentEventQueue_1.AgentEventType; } });
-Object.defineProperty(exports, "AgentEventStatus", { enumerable: true, get: function () { return agentEventQueue_1.AgentEventStatus; } });
-Object.defineProperty(exports, "AgentEventPriority", { enumerable: true, get: function () { return agentEventQueue_1.AgentEventPriority; } });
+var lib_1 = require("@codebolt/types/lib");
+Object.defineProperty(exports, "AgentEventType", { enumerable: true, get: function () { return lib_1.AgentEventType; } });
+Object.defineProperty(exports, "AgentEventStatus", { enumerable: true, get: function () { return lib_1.AgentEventStatus; } });
+Object.defineProperty(exports, "AgentEventPriority", { enumerable: true, get: function () { return lib_1.AgentEventPriority; } });
 // ============================================================================
 // Local Event Cache
 // ============================================================================
-/** Local cache for events received via WebSocket */
+/** Local cache for agent events received via WebSocket */
 const localEventCache = new Map();
+/** Unified cache for all external events (queue events, background completions, grouped completions) */
+const pendingExternalEvents = [];
 /** Registered event handlers */
 const eventHandlers = new Set();
 /** Event emitter for waiting promises */
 const events_1 = require("events");
 const eventEmitter = new events_1.EventEmitter();
 // ============================================================================
-// WebSocket Subscription
+// WebSocket Subscriptions
 // ============================================================================
 // Subscribe to agentEvent messages from WebSocket
 const agentEventSubscription = websocket_1.default.messageManager.subscribe('agentEvent');
@@ -35,8 +37,11 @@ agentEventSubscription.on('message', (message) => {
     if (event && event.eventId) {
         // Store in local cache
         localEventCache.set(event.eventId, event);
+        // Also push to unified external events cache
+        pendingExternalEvents.push({ type: 'agentQueueEvent', data: event });
         // Notify waiting promises
         eventEmitter.emit('newEvent', event);
+        eventEmitter.emit('externalEvent', { type: 'agentQueueEvent', data: event });
         // Call registered handlers
         for (const handler of eventHandlers) {
             try {
@@ -48,6 +53,33 @@ agentEventSubscription.on('message', (message) => {
         }
     }
 });
+// Subscribe to background agent completion messages
+const backgroundAgentSubscription = websocket_1.default.messageManager.subscribe('startThreadResponse');
+backgroundAgentSubscription.on('message', (message) => {
+    if (message.threadId) {
+        const externalEvent = { type: 'backgroundAgentCompletion', data: message };
+        pendingExternalEvents.push(externalEvent);
+        eventEmitter.emit('externalEvent', externalEvent);
+    }
+});
+// Subscribe to ThreadCompleted as an alternative message type
+const threadCompletedSubscription = websocket_1.default.messageManager.subscribe('ThreadCompleted');
+threadCompletedSubscription.on('message', (message) => {
+    if (message.threadId) {
+        const externalEvent = { type: 'backgroundAgentCompletion', data: message };
+        pendingExternalEvents.push(externalEvent);
+        eventEmitter.emit('externalEvent', externalEvent);
+    }
+});
+// Subscribe to grouped agent completion messages
+const groupedAgentSubscription = websocket_1.default.messageManager.subscribe('backgroundGroupedAgentCompletion');
+groupedAgentSubscription.on('message', (message) => {
+    if (message.threadId) {
+        const externalEvent = { type: 'backgroundGroupedAgentCompletion', data: message };
+        pendingExternalEvents.push(externalEvent);
+        eventEmitter.emit('externalEvent', externalEvent);
+    }
+});
 // ============================================================================
 // Agent Event Queue Module
 // ============================================================================
@@ -66,7 +98,7 @@ const agentEventQueue = {
             type: 'agentEventQueue.addEventForAgent',
             requestId,
             params
-        }, 'agentEventQueueResponse');
+        }, 'agentEventQueue.addEventForAgentResponse');
     },
     /**
      * Send an inter-agent message (convenience wrapper)
@@ -79,7 +111,7 @@ const agentEventQueue = {
             type: 'agentEventQueue.sendAgentMessage',
             requestId,
             params
-        }, 'agentEventQueueResponse');
+        }, 'agentEventQueue.sendAgentMessageResponse');
     },
     /**
      * Get queue statistics
@@ -91,7 +123,7 @@ const agentEventQueue = {
             type: 'agentEventQueue.getQueueStats',
             requestId,
             params: {}
-        }, 'agentEventQueueResponse');
+        }, 'agentEventQueue.getQueueStatsResponse');
     },
     /**
      * Clear the queue for an agent
@@ -104,7 +136,7 @@ const agentEventQueue = {
             type: 'agentEventQueue.clearQueue',
             requestId,
             params: { agentId }
-        }, 'agentEventQueueResponse');
+        }, 'agentEventQueue.clearQueueResponse');
     },
     // ========================================================================
     // Internal Acknowledgement Helper
@@ -125,7 +157,7 @@ const agentEventQueue = {
                 success,
                 errorMessage
             }
-        }, 'agentEventQueueResponse');
+        }, 'agentEventQueue.ackEventResponse');
     },
     /**
      * Fetch pending events from backend
@@ -133,15 +165,37 @@ const agentEventQueue = {
      */
     _fetchPendingFromBackend: async (params = {}) => {
         const requestId = (0, crypto_1.randomUUID)();
-        const response = await websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: 'agentEventQueue.getPendingEvents',
-            requestId,
-            params
-        }, 'agentEventQueueResponse');
-        if (response.success && response.data) {
-            return response.data.events;
+        try {
+            const response = await websocket_1.default.messageManager.sendAndWaitForResponse({
+                type: 'agentEventQueue.getPendingEvents',
+                requestId,
+                params
+            }, 'agentEventQueue.getPendingEventsResponse');
+            console.log('[AgentEventQueue] Backend response:', JSON.stringify(response, null, 2));
+            if (response.success && response.data) {
+                // Handle case where data itself is the array
+                if (Array.isArray(response.data)) {
+                    return response.data;
+                }
+                // Handle case where events are nested under data.events
+                const events = response.data.events;
+                if (Array.isArray(events)) {
+                    return events;
+                }
+                console.warn('[AgentEventQueue] response.data.events is not an array:', typeof events, events);
+                return [];
+            }
+            // Handle case where events are at response root level (not nested under data)
+            const responseAny = response;
+            if (response.success && Array.isArray(responseAny.events)) {
+                return responseAny.events;
+            }
+            return [];
+        }
+        catch (error) {
+            console.error('[AgentEventQueue] Error fetching pending events from backend:', error);
+            return [];
         }
-        return [];
     },
     // ========================================================================
     // Local Event Management Functions
@@ -157,6 +211,7 @@ const agentEventQueue = {
     getPendingQueueEvents: async (maxDepth) => {
         const events = [];
         const eventIds = Array.from(localEventCache.keys());
+        console.log('[AgentEventQueue] getPendingQueueEvents - localEventCache size:', localEventCache.size);
         // Determine how many events to process
         const limit = maxDepth !== undefined ? Math.min(maxDepth, eventIds.length) : eventIds.length;
         // Get events from local cache
@@ -164,16 +219,27 @@ const agentEventQueue = {
             const eventId = eventIds[i];
             const event = localEventCache.get(eventId);
             if (event) {
+                console.log('[AgentEventQueue] Local cache event:', eventId, 'has eventId field:', !!event.eventId);
                 events.push(event);
             }
         }
         // If no local events, try fetching from backend
         if (events.length === 0) {
             const backendEvents = await agentEventQueue._fetchPendingFromBackend({ limit: maxDepth });
+            console.log('[AgentEventQueue] getPendingQueueEvents - backendEvents:', Array.isArray(backendEvents) ? `array of ${backendEvents.length}` : typeof backendEvents, JSON.stringify(backendEvents, null, 2));
+            // Ensure backendEvents is an array
+            if (!Array.isArray(backendEvents)) {
+                console.error('[AgentEventQueue] backendEvents is not an array, returning empty array');
+                return [];
+            }
             // Acknowledge backend events
             for (const event of backendEvents) {
                 try {
-                    await agentEventQueue._acknowledgeEvent(event.eventId, true);
+                    const ackResponse = await agentEventQueue._acknowledgeEvent(event.eventId, true);
+                    console.log(`[AgentEventQueue] Ack response for ${event.eventId}:`, JSON.stringify(ackResponse));
+                    if (!ackResponse.success) {
+                        console.error(`[AgentEventQueue] Failed to acknowledge event ${event.eventId}:`, ackResponse.message);
+                    }
                 }
                 catch (error) {
                     console.error(`[AgentEventQueue] Error acknowledging event ${event.eventId}:`, error);
@@ -283,6 +349,92 @@ const agentEventQueue = {
      */
     clearLocalCache: () => {
         localEventCache.clear();
+    },
+    // ========================================================================
+    // Unified External Event Handling
+    // ========================================================================
+    /**
+     * Check for any pending external events without waiting.
+     * Returns the first pending event or null if none available.
+     *
+     * @returns {UnifiedExternalEvent | null} The first pending event or null
+     */
+    checkForPendingExternalEvent: () => {
+        if (pendingExternalEvents.length > 0) {
+            return pendingExternalEvents.shift() || null;
+        }
+        return null;
+    },
+    /**
+     * Get all pending external events.
+     * Returns all pending events and clears the cache.
+     *
+     * @returns {UnifiedExternalEvent[]} Array of pending events
+     */
+    getPendingExternalEvents: () => {
+        const events = [...pendingExternalEvents];
+        pendingExternalEvents.length = 0;
+        return events;
+    },
+    /**
+     * Get the count of pending external events.
+     *
+     * @returns {number} Number of pending events
+     */
+    getPendingExternalEventCount: () => {
+        return pendingExternalEvents.length;
+    },
+    /**
+     * Waits for any external event from multiple sources:
+     * - Agent queue events (from local cache or WebSocket)
+     * - Background agent completions
+     * - Grouped agent completions
+     *
+     * Returns the first event that occurs from any source.
+     *
+     * @returns {Promise<UnifiedExternalEvent>} A promise that resolves with the event type and data
+     */
+    waitForAnyExternalEvent: async () => {
+        var _a;
+        // Check if there are already pending events
+        if (pendingExternalEvents.length > 0) {
+            const event = pendingExternalEvents.shift();
+            // If it's an agent queue event, acknowledge it
+            if (event.type === 'agentQueueEvent' && ((_a = event.data) === null || _a === void 0 ? void 0 : _a.eventId)) {
+                try {
+                    await agentEventQueue._acknowledgeEvent(event.data.eventId, true);
+                    localEventCache.delete(event.data.eventId);
+                }
+                catch (error) {
+                    console.error(`[AgentEventQueue] Error acknowledging event ${event.data.eventId}:`, error);
+                }
+            }
+            return event;
+        }
+        // Wait for the next external event
+        return new Promise((resolve) => {
+            const handler = async (event) => {
+                var _a;
+                eventEmitter.removeListener('externalEvent', handler);
+                // Remove from pending queue (it was added by the subscription)
+                const index = pendingExternalEvents.findIndex(e => e === event);
+                if (index !== -1) {
+                    pendingExternalEvents.splice(index, 1);
+                }
+                // If it's an agent queue event, acknowledge it
+                if (event.type === 'agentQueueEvent' && ((_a = event.data) === null || _a === void 0 ? void 0 : _a.eventId)) {
+                    try {
+                        await agentEventQueue._acknowledgeEvent(event.data.eventId, true);
+                        localEventCache.delete(event.data.eventId);
+                    }
+                    catch (error) {
+                        console.error(`[AgentEventQueue] Error acknowledging event ${event.data.eventId}:`, error);
+                    }
+                }
+                resolve(event);
+            };
+            eventEmitter.once('externalEvent', handler);
+        });
     }
 };
 exports.default = agentEventQueue;

package/dist/modules/autoTesting.d.ts

@@ -1,4 +1,4 @@
-import { IAddCaseToSuiteParams, IAddCaseToSuiteResponse, ICreateCaseParams, ICreateCaseResponse, ICreateRunParams, ICreateRunResponse, ICreateSuiteParams, ICreateSuiteResponse, IDeleteCaseParams, IDeleteCaseResponse, IDeleteSuiteParams, IDeleteSuiteResponse, IGetCaseParams, IGetCaseResponse, IGetRunParams, IGetRunResponse, IGetSuiteParams, IGetSuiteResponse, IListCasesParams, IListCasesResponse, IListRunsParams, IListRunsResponse, IListSuitesParams, IListSuitesResponse, IRemoveCaseFromSuiteParams, IRemoveCaseFromSuiteResponse, IUpdateCaseParams, IUpdateCaseResponse, IUpdateRunCaseParams, IUpdateRunCaseResponse, IUpdateRunStatusParams, IUpdateRunStatusResponse, IUpdateRunStepParams, IUpdateRunStepResponse, IUpdateSuiteParams, IUpdateSuiteResponse } from '../types/autoTesting';
+import { IAddCaseToSuiteParams, IAddCaseToSuiteResponse, ICreateCaseParams, ICreateCaseResponse, ICreateRunParams, ICreateRunResponse, ICreateSuiteParams, ICreateSuiteResponse, IDeleteCaseParams, IDeleteCaseResponse, IDeleteSuiteParams, IDeleteSuiteResponse, IGetCaseParams, IGetCaseResponse, IGetRunParams, IGetRunResponse, IGetSuiteParams, IGetSuiteResponse, IListCasesParams, IListCasesResponse, IListRunsParams, IListRunsResponse, IListSuitesParams, IListSuitesResponse, IRemoveCaseFromSuiteParams, IRemoveCaseFromSuiteResponse, IUpdateCaseParams, IUpdateCaseResponse, IUpdateRunCaseParams, IUpdateRunCaseResponse, IUpdateRunStatusParams, IUpdateRunStatusResponse, IUpdateRunStepParams, IUpdateRunStepResponse, IUpdateSuiteParams, IUpdateSuiteResponse } from '@codebolt/types/lib';
 declare const cbautoTesting: {
     createSuite: (params: ICreateSuiteParams) => Promise<ICreateSuiteResponse>;
     getSuite: (params: IGetSuiteParams) => Promise<IGetSuiteResponse>;

package/dist/modules/autoTesting.js

@@ -4,28 +4,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const websocket_1 = __importDefault(require("../core/websocket"));
-const autoTesting_1 = require("../types/autoTesting");
+const lib_1 = require("@codebolt/types/lib");
 const cbautoTesting = {
     // ---- Test Suites ----
-    createSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.SUITE_CREATE, ...params }, autoTesting_1.AutoTestingResponseType.SUITE_CREATE_RESPONSE),
-    getSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.SUITE_GET, ...params }, autoTesting_1.AutoTestingResponseType.SUITE_GET_RESPONSE),
-    listSuites: async (_params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.SUITE_LIST }, autoTesting_1.AutoTestingResponseType.SUITE_LIST_RESPONSE),
-    updateSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.SUITE_UPDATE, ...params }, autoTesting_1.AutoTestingResponseType.SUITE_UPDATE_RESPONSE),
-    deleteSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.SUITE_DELETE, ...params }, autoTesting_1.AutoTestingResponseType.SUITE_DELETE_RESPONSE),
-    addCaseToSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.SUITE_CASE_ADD, ...params }, autoTesting_1.AutoTestingResponseType.SUITE_CASE_ADD_RESPONSE),
-    removeCaseFromSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.SUITE_CASE_REMOVE, ...params }, autoTesting_1.AutoTestingResponseType.SUITE_CASE_REMOVE_RESPONSE),
+    createSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.SUITE_CREATE, ...params }, lib_1.AutoTestingResponseType.SUITE_CREATE_RESPONSE),
+    getSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.SUITE_GET, ...params }, lib_1.AutoTestingResponseType.SUITE_GET_RESPONSE),
+    listSuites: async (_params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.SUITE_LIST }, lib_1.AutoTestingResponseType.SUITE_LIST_RESPONSE),
+    updateSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.SUITE_UPDATE, ...params }, lib_1.AutoTestingResponseType.SUITE_UPDATE_RESPONSE),
+    deleteSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.SUITE_DELETE, ...params }, lib_1.AutoTestingResponseType.SUITE_DELETE_RESPONSE),
+    addCaseToSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.SUITE_CASE_ADD, ...params }, lib_1.AutoTestingResponseType.SUITE_CASE_ADD_RESPONSE),
+    removeCaseFromSuite: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.SUITE_CASE_REMOVE, ...params }, lib_1.AutoTestingResponseType.SUITE_CASE_REMOVE_RESPONSE),
     // ---- Test Cases ----
-    createCase: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.CASE_CREATE, ...params }, autoTesting_1.AutoTestingResponseType.CASE_CREATE_RESPONSE),
-    getCase: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.CASE_GET, ...params }, autoTesting_1.AutoTestingResponseType.CASE_GET_RESPONSE),
-    listCases: async (_params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.CASE_LIST }, autoTesting_1.AutoTestingResponseType.CASE_LIST_RESPONSE),
-    updateCase: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.CASE_UPDATE, ...params }, autoTesting_1.AutoTestingResponseType.CASE_UPDATE_RESPONSE),
-    deleteCase: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.CASE_DELETE, ...params }, autoTesting_1.AutoTestingResponseType.CASE_DELETE_RESPONSE),
+    createCase: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.CASE_CREATE, ...params }, lib_1.AutoTestingResponseType.CASE_CREATE_RESPONSE),
+    getCase: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.CASE_GET, ...params }, lib_1.AutoTestingResponseType.CASE_GET_RESPONSE),
+    listCases: async (_params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.CASE_LIST }, lib_1.AutoTestingResponseType.CASE_LIST_RESPONSE),
+    updateCase: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.CASE_UPDATE, ...params }, lib_1.AutoTestingResponseType.CASE_UPDATE_RESPONSE),
+    deleteCase: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.CASE_DELETE, ...params }, lib_1.AutoTestingResponseType.CASE_DELETE_RESPONSE),
     // ---- Test Runs ----
-    createRun: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.RUN_CREATE, ...params }, autoTesting_1.AutoTestingResponseType.RUN_CREATE_RESPONSE),
-    getRun: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.RUN_GET, ...params }, autoTesting_1.AutoTestingResponseType.RUN_GET_RESPONSE),
-    listRuns: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.RUN_LIST, ...(params || {}) }, autoTesting_1.AutoTestingResponseType.RUN_LIST_RESPONSE),
-    updateRunStatus: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.RUN_UPDATE_STATUS, ...params }, autoTesting_1.AutoTestingResponseType.RUN_UPDATE_STATUS_RESPONSE),
-    updateRunCaseStatus: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.RUN_CASE_UPDATE, ...params }, autoTesting_1.AutoTestingResponseType.RUN_CASE_UPDATE_RESPONSE),
-    updateRunStepStatus: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: autoTesting_1.AutoTestingAction.RUN_STEP_UPDATE, ...params }, autoTesting_1.AutoTestingResponseType.RUN_STEP_UPDATE_RESPONSE),
+    createRun: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.RUN_CREATE, ...params }, lib_1.AutoTestingResponseType.RUN_CREATE_RESPONSE),
+    getRun: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.RUN_GET, ...params }, lib_1.AutoTestingResponseType.RUN_GET_RESPONSE),
+    listRuns: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.RUN_LIST, ...(params || {}) }, lib_1.AutoTestingResponseType.RUN_LIST_RESPONSE),
+    updateRunStatus: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.RUN_UPDATE_STATUS, ...params }, lib_1.AutoTestingResponseType.RUN_UPDATE_STATUS_RESPONSE),
+    updateRunCaseStatus: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.RUN_CASE_UPDATE, ...params }, lib_1.AutoTestingResponseType.RUN_CASE_UPDATE_RESPONSE),
+    updateRunStepStatus: async (params) => websocket_1.default.messageManager.sendAndWaitForResponse({ type: lib_1.AutoTestingAction.RUN_STEP_UPDATE, ...params }, lib_1.AutoTestingResponseType.RUN_STEP_UPDATE_RESPONSE),
 };
 exports.default = cbautoTesting;

package/dist/modules/backgroundChildThreads.d.ts

@@ -1,3 +1,5 @@
+import type { BackgroundAgentData, BackgroundAgentCompletion, BackgroundExternalEvent } from '@codebolt/types/sdk';
+export type { BackgroundAgentData, BackgroundAgentCompletion, BackgroundExternalEvent };
 /**
  * Background Child Threads module for tracking and managing background agent threads.
  * This module provides APIs for tracking running background agents and their completion.
@@ -5,11 +7,11 @@
 declare const backgroundChildThreads: {
     /**
      * Adds a running background agent to tracking.
-     * @param {string} threadId - The thread ID
-     * @param {any} data - The agent data
-     * @param {string} [groupId] - Optional group ID
+     * @param threadId - The thread ID
+     * @param data - The agent data
+     * @param groupId - Optional group ID
      */
-    addRunningAgent: (threadId: string, data: any, groupId?: string) => void;
+    addRunningAgent: (threadId: string, data: BackgroundAgentData, groupId?: string) => void;
     /**
      * Gets the number of currently running background agents.
      * @returns {number} The count
@@ -17,32 +19,29 @@ declare const backgroundChildThreads: {
     getRunningAgentCount: () => number;
     /**
      * Checks if any background agent has completed.
-     * @returns {any} The completion data if available, or null
+     * @returns The completion data if available, or null
      */
-    checkForBackgroundAgentCompletion: () => any[] | null;
+    checkForBackgroundAgentCompletion: () => BackgroundAgentCompletion[] | null;
     /**
      * Waits for background agent completion.
-     * @returns {Promise<any>} A promise that resolves with the completion data
+     * @returns A promise that resolves with the completion data
      */
-    onBackgroundAgentCompletion: () => Promise<any>;
+    onBackgroundAgentCompletion: () => Promise<BackgroundAgentCompletion[] | null>;
     /**
      * Checks if any grouped background agent has completed.
-     * @returns {any} The completion data if available, or null
+     * @returns The completion data if available, or null
      */
-    checkForBackgroundGroupedAgentCompletion: () => any;
+    checkForBackgroundGroupedAgentCompletion: () => BackgroundAgentCompletion | null;
     /**
      * Waits for grouped background agent completion.
-     * @returns {Promise<any>} A promise that resolves with the completion data
+     * @returns A promise that resolves with the completion data
      */
-    onBackgroundGroupedAgentCompletion: () => Promise<any>;
+    onBackgroundGroupedAgentCompletion: () => Promise<BackgroundAgentCompletion | null>;
     /**
      * Waits for any external event (background agent completion, grouped agent completion, or agent event).
      * Returns the first event that occurs.
-     * @returns {Promise<{type: string, data: any}>} A promise that resolves with the event type and data
+     * @returns A promise that resolves with the event type and data
      */
-    waitForAnyExternalEvent: () => Promise<{
-        type: string;
-        data: any;
-    }>;
+    waitForAnyExternalEvent: () => Promise<BackgroundExternalEvent>;
 };
 export default backgroundChildThreads;

package/dist/modules/backgroundChildThreads.js

@@ -10,25 +10,45 @@ const runningBackgroundAgents = new Map();
 const completedBackgroundAgents = new Map();
 const groupedAgentCompletionMap = new Map();
 const backgroundAgentGroups = new Map();
-// Helper to cleanup group membership
-const cleanupAgentGroup = (threadId) => {
+// Track completed agents per group for grouped completion
+const groupCompletedAgents = new Map();
+// Helper to cleanup group membership and check for group completion
+const cleanupAgentGroup = (threadId, completion) => {
     for (const [groupId, agents] of backgroundAgentGroups.entries()) {
         if (agents.has(threadId)) {
+            // Track this completion in the group
+            if (!groupCompletedAgents.has(groupId)) {
+                groupCompletedAgents.set(groupId, []);
+            }
+            groupCompletedAgents.get(groupId).push(completion);
             agents.delete(threadId);
+            // Check if all agents in the group have completed
             if (agents.size === 0) {
+                // All agents in this group are done - emit grouped completion
+                const groupCompletions = groupCompletedAgents.get(groupId) || [];
+                groupedAgentSubscription.emit('message', {
+                    groupId,
+                    threadId, // Last completed thread
+                    completions: groupCompletions,
+                    success: groupCompletions.every(c => c.success !== false)
+                });
+                // Cleanup
                 backgroundAgentGroups.delete(groupId);
+                groupCompletedAgents.delete(groupId);
             }
         }
     }
 };
 // Handler for background agent completion messages
 const handleBackgroundAgentCompletion = (message) => {
+    if (!message.threadId)
+        return;
     // Add to completed queue for orchestrator to process
     completedBackgroundAgents.set(message.threadId, message);
     // Remove from running map since agent is now complete
     runningBackgroundAgents.delete(message.threadId);
-    // Clean up any group associations
-    cleanupAgentGroup(message.threadId);
+    // Clean up any group associations and check for group completion
+    cleanupAgentGroup(message.threadId, message);
 };
 // Subscribe to background agent completion - primary message type
 const backgroundAgentSubscription = websocket_1.default.messageManager.subscribe('startThreadResponse');
@@ -37,7 +57,7 @@ backgroundAgentSubscription.on('message', handleBackgroundAgentCompletion);
 const threadCompletedSubscription = websocket_1.default.messageManager.subscribe('ThreadCompleted');
 threadCompletedSubscription.on('message', (message) => {
     // Only handle if this thread was a background agent
-    if (runningBackgroundAgents.has(message.threadId)) {
+    if (message.threadId && runningBackgroundAgents.has(message.threadId)) {
         handleBackgroundAgentCompletion(message);
         // Also emit on the backgroundAgentSubscription for waiters
         backgroundAgentSubscription.emit('message', message);
@@ -45,7 +65,9 @@ threadCompletedSubscription.on('message', (message) => {
 });
 const groupedAgentSubscription = websocket_1.default.messageManager.subscribe('backgroundGroupedAgentCompletion');
 groupedAgentSubscription.on('message', (message) => {
-    groupedAgentCompletionMap.set(message.threadId, message);
+    if (message.threadId) {
+        groupedAgentCompletionMap.set(message.threadId, message);
+    }
 });
 /**
  * Background Child Threads module for tracking and managing background agent threads.
@@ -54,9 +76,9 @@ groupedAgentSubscription.on('message', (message) => {
 const backgroundChildThreads = {
     /**
      * Adds a running background agent to tracking.
-     * @param {string} threadId - The thread ID
-     * @param {any} data - The agent data
-     * @param {string} [groupId] - Optional group ID
+     * @param threadId - The thread ID
+     * @param data - The agent data
+     * @param groupId - Optional group ID
      */
     addRunningAgent: (threadId, data, groupId) => {
         runningBackgroundAgents.set(threadId, data);
@@ -76,7 +98,7 @@ const backgroundChildThreads = {
     },
     /**
      * Checks if any background agent has completed.
-     * @returns {any} The completion data if available, or null
+     * @returns The completion data if available, or null
      */
     checkForBackgroundAgentCompletion: () => {
         if (completedBackgroundAgents.size > 0) {
@@ -88,7 +110,7 @@ const backgroundChildThreads = {
     },
     /**
      * Waits for background agent completion.
-     * @returns {Promise<any>} A promise that resolves with the completion data
+     * @returns A promise that resolves with the completion data
      */
     onBackgroundAgentCompletion: async () => {
         const completion = backgroundChildThreads.checkForBackgroundAgentCompletion();
@@ -103,12 +125,13 @@ const backgroundChildThreads = {
     },
     /**
      * Checks if any grouped background agent has completed.
-     * @returns {any} The completion data if available, or null
+     * @returns The completion data if available, or null
      */
     checkForBackgroundGroupedAgentCompletion: () => {
         if (groupedAgentCompletionMap.size > 0) {
-            const [key, value] = groupedAgentCompletionMap.entries().next().value || [];
-            if (key) {
+            const entry = groupedAgentCompletionMap.entries().next().value;
+            if (entry) {
+                const [key, value] = entry;
                 groupedAgentCompletionMap.delete(key);
                 return value;
             }
@@ -117,7 +140,7 @@ const backgroundChildThreads = {
     },
     /**
      * Waits for grouped background agent completion.
-     * @returns {Promise<any>} A promise that resolves with the completion data
+     * @returns A promise that resolves with the completion data
      */
     onBackgroundGroupedAgentCompletion: async () => {
         const completion = backgroundChildThreads.checkForBackgroundGroupedAgentCompletion();
@@ -133,7 +156,7 @@ const backgroundChildThreads = {
     /**
      * Waits for any external event (background agent completion, grouped agent completion, or agent event).
      * Returns the first event that occurs.
-     * @returns {Promise<{type: string, data: any}>} A promise that resolves with the event type and data
+     * @returns A promise that resolves with the event type and data
      */
     waitForAnyExternalEvent: async () => {
         // First check if there are any already completed events

package/dist/modules/browser.d.ts

@@ -1,5 +1,6 @@
-import { GoToPageResponse, UrlResponse, GetMarkdownResponse, HtmlReceived, ExtractTextResponse, GetContentResponse, BrowserActionResponseData, BrowserScreenshotResponse, BrowserInfoResponse, BrowserSnapshotResponse } from '@codebolt/types/sdk';
+import { GoToPageResponse, UrlResponse, GetMarkdownResponse, HtmlReceived, ExtractTextResponse, GetContentResponse, BrowserActionResponseData, BrowserScreenshotResponse, BrowserInfoResponse, BrowserSnapshotResponse, BrowserOperationType, BrowserOperationParams, BrowserOperationResponse } from '@codebolt/types/sdk';
 import type { BrowserInstanceOptions, BrowserOperationOptions, BrowserInstanceInfo, BrowserScreenshotOptions } from '../types/libFunctionTypes';
+export type { BrowserOperationType, BrowserOperationParams, BrowserOperationResponse };
 /**
  * A module for interacting with a browser through WebSockets.
  */
@@ -148,12 +149,12 @@ declare const cbbrowser: {
     closeBrowserInstance: (instanceId: string) => Promise<boolean>;
     /**
      * Execute action on specific browser instance
-     * @param {string} instanceId - The instance ID to execute on
-     * @param {string} operation - The operation to execute
-     * @param {any} params - Parameters for the operation
-     * @returns {Promise<any>} The operation result
+     * @param instanceId - The instance ID to execute on
+     * @param operation - The operation to execute
+     * @param params - Parameters for the operation
+     * @returns The operation result
      */
-    executeOnInstance: (instanceId: string, operation: string, params: any) => Promise<any>;
+    executeOnInstance: (instanceId: string, operation: BrowserOperationType, params: BrowserOperationParams) => Promise<BrowserOperationResponse>;
 };
 export default cbbrowser;
 /***

package/dist/modules/browser.js

@@ -360,10 +360,10 @@ const cbbrowser = {
     },
     /**
      * Execute action on specific browser instance
-     * @param {string} instanceId - The instance ID to execute on
-     * @param {string} operation - The operation to execute
-     * @param {any} params - Parameters for the operation
-     * @returns {Promise<any>} The operation result
+     * @param instanceId - The instance ID to execute on
+     * @param operation - The operation to execute
+     * @param params - Parameters for the operation
+     * @returns The operation result
      */
     executeOnInstance: async (instanceId, operation, params) => {
         // This will be implemented with proper backend communication