@codebolt/codeboltjs 2.0.13 → 2.0.16

package/dist/modules/task.js

@@ -5,46 +5,288 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const websocket_1 = __importDefault(require("../core/websocket"));
 /**
- * Manages task operations via WebSocket communication.
+ * Enhanced task planner with agent-based organization and comprehensive task management.
  */
 const taskplaner = {
     /**
-     * Adds a task using a WebSocket message.
-     * @param {string} task - The task to be added.
-     * @returns {Promise<AddTaskResponse>} A promise that resolves with the response from the add task event.
+     * Adds a new task with enhanced parameters.
+     * @param {TaskCreateOptions} params - The task parameters including title, agentId, description, etc.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add task event.
      */
-    addTask: async (task) => {
+    addTask: async (params) => {
+        const { title, agentId = 'default-agent', description, phase, category, priority, tags } = params;
         return websocket_1.default.messageManager.sendAndWaitForResponse({
-            "type": "taskEvent",
-            "action": "addTask",
+            type: "taskEvent",
+            action: "addTask",
+            agentId: agentId,
             message: {
-                "task": task
+                title: title,
+                description: description,
+                phase: phase,
+                category: category,
+                priority: priority,
+                tags: tags
             }
         }, "addTaskResponse");
     },
     /**
-     * Retrieves all tasks using a WebSocket message.
-     * @returns {Promise<GetTasksResponse>} A promise that resolves with the response from the get tasks event.
+     * Adds a task using simple string parameter (legacy support).
+     * @param {string} task - The task title.
+     * @param {string} agentId - The agent ID (optional, defaults to 'default-agent').
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add task event.
      */
-    getTasks: async () => {
+    addSimpleTask: async (task, agentId = 'default-agent') => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
-            "type": "taskEvent",
-            "action": "getTasks"
+            type: "taskEvent",
+            action: "addTask",
+            agentId: agentId,
+            message: {
+                task: task
+            }
+        }, "addTaskResponse");
+    },
+    /**
+     * Retrieves all tasks with optional filtering.
+     * @param {TaskFilterOptions} filters - Optional filters for agentId, category, phase, etc.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the get tasks event.
+     */
+    getTasks: async (filters = {}) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "getTasks",
+            message: filters
         }, "getTasksResponse");
     },
     /**
-     * Updates an existing task using a WebSocket message.
+     * Retrieves tasks for a specific agent.
+     * @param {string} agentId - The agent ID.
+     * @returns {Promise<TaskResponse>} A promise that resolves with tasks for the specified agent.
+     */
+    getTasksByAgent: async (agentId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "getTasksByAgent",
+            message: {
+                agentId: agentId
+            }
+        }, "getTasksByAgentResponse");
+    },
+    /**
+     * Retrieves tasks by category.
+     * @param {string} category - The category name.
+     * @returns {Promise<TaskResponse>} A promise that resolves with tasks in the specified category.
+     */
+    getTasksByCategory: async (category) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "getTasksByCategory",
+            message: {
+                category: category
+            }
+        }, "getTasksByCategoryResponse");
+    },
+    /**
+     * Retrieves all available agents.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the list of all agents.
+     */
+    getAllAgents: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "getAllAgents"
+        }, "getAllAgentsResponse");
+    },
+    /**
+     * Updates an existing task.
+     * @param {TaskUpdateOptions} params - The task update parameters.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     */
+    updateTask: async (params) => {
+        const { taskId, ...updates } = params;
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "updateTask",
+            message: {
+                taskId: taskId,
+                ...updates
+            }
+        }, "updateTasksResponse");
+    },
+    /**
+     * Updates an existing task using legacy string parameter.
+     * @param {string} taskId - The task ID.
      * @param {string} task - The updated task information.
-     * @returns {Promise<UpdateTasksResponse>} A promise that resolves with the response from the update task event.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
      */
-    updateTask: async (task) => {
+    updateSimpleTask: async (taskId, task) => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
-            "type": "taskEvent",
-            "action": "updateTask",
+            type: "taskEvent",
+            action: "updateTask",
             message: {
-                "task": task
+                taskId: taskId,
+                task: task
             }
-        }, "updateTaskResponse");
+        }, "updateTasksResponse");
+    },
+    /**
+     * Deletes a task.
+     * @param {string} taskId - The task ID to delete.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the delete task event.
+     */
+    deleteTask: async (taskId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "deleteTask",
+            message: {
+                taskId: taskId
+            }
+        }, "deleteTaskResponse");
+    },
+    /**
+     * Adds a subtask to an existing task.
+     * @param {AddSubTaskOptions} params - The subtask parameters.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add subtask event.
+     */
+    addSubTask: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "addSubTask",
+            message: params
+        }, "addSubTaskResponse");
+    },
+    /**
+     * Updates an existing subtask.
+     * @param {UpdateSubTaskOptions} params - The subtask update parameters.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update subtask event.
+     */
+    updateSubTask: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "updateSubTask",
+            message: params
+        }, "updateSubTaskResponse");
+    },
+    /**
+     * Deletes a subtask.
+     * @param {string} taskId - The parent task ID.
+     * @param {string} subtaskId - The subtask ID to delete.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the delete subtask event.
+     */
+    deleteSubTask: async (taskId, subtaskId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "deleteSubTask",
+            message: {
+                taskId: taskId,
+                subtaskId: subtaskId
+            }
+        }, "deleteSubTaskResponse");
+    },
+    /**
+     * Creates tasks from markdown content.
+     * @param {TaskMarkdownImportOptions} params - The markdown parameters including content, agentId, phase, and category.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the create tasks from markdown event.
+     */
+    createTasksFromMarkdown: async (params) => {
+        const { markdown, agentId = 'default-agent', phase, category } = params;
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "createTasksFromMarkdown",
+            agentId: agentId,
+            message: {
+                markdown: markdown,
+                phase: phase,
+                category: category
+            }
+        }, "createTasksFromMarkdownResponse");
+    },
+    /**
+     * Exports tasks to markdown format.
+     * @param {TaskMarkdownExportOptions} params - The export parameters including optional phase, agentId, and category filters.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the markdown content.
+     */
+    exportTasksToMarkdown: async (params = {}) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: "taskEvent",
+            action: "exportTasksToMarkdown",
+            message: params
+        }, "exportTasksToMarkdownResponse");
+    },
+    /**
+     * Utility function to toggle task completion status.
+     * @param {string} taskId - The task ID.
+     * @param {boolean} completed - The new completion status.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     */
+    toggleTaskCompletion: async (taskId, completed) => {
+        return taskplaner.updateTask({
+            taskId: taskId,
+            completed: completed
+        });
+    },
+    /**
+     * Utility function to toggle subtask completion status.
+     * @param {string} taskId - The parent task ID.
+     * @param {string} subtaskId - The subtask ID.
+     * @param {boolean} completed - The new completion status.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update subtask event.
+     */
+    toggleSubTaskCompletion: async (taskId, subtaskId, completed) => {
+        return taskplaner.updateSubTask({
+            taskId: taskId,
+            subtaskId: subtaskId,
+            completed: completed
+        });
+    },
+    /**
+     * Utility function to move a task to a different agent.
+     * @param {string} taskId - The task ID.
+     * @param {string} newAgentId - The new agent ID.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     */
+    moveTaskToAgent: async (taskId, newAgentId) => {
+        return taskplaner.updateTask({
+            taskId: taskId,
+            agentId: newAgentId
+        });
+    },
+    /**
+     * Utility function to set task priority.
+     * @param {string} taskId - The task ID.
+     * @param {'low' | 'medium' | 'high'} priority - The priority level.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     */
+    setTaskPriority: async (taskId, priority) => {
+        return taskplaner.updateTask({
+            taskId: taskId,
+            priority: priority
+        });
+    },
+    /**
+     * Utility function to add tags to a task.
+     * @param {string} taskId - The task ID.
+     * @param {string[]} tags - The tags to add.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     */
+    addTaskTags: async (taskId, tags) => {
+        return taskplaner.updateTask({
+            taskId: taskId,
+            tags: tags
+        });
+    },
+    /**
+     * Utility function to create a quick task with minimal parameters.
+     * @param {string} title - The task title.
+     * @param {string} agentId - The agent ID (optional, defaults to 'default-agent').
+     * @param {string} category - The category (optional).
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add task event.
+     */
+    createQuickTask: async (title, agentId = 'default-agent', category) => {
+        return taskplaner.addTask({
+            title: title,
+            agentId: agentId,
+            category: category,
+            priority: 'medium'
+        });
     }
 };
 exports.default = taskplaner;

package/dist/notificationfunctions/agent.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Agent Notification Functions
+ *
+ * This module provides functions for sending agent-related notifications,
+ * including subagent task operations and completions.
+ */
+import { AgentNotifications } from '../types/notificationFunctions/agent';
+/**
+ * Sends a request to start a subagent task
+ *
+ * @param parentAgentId - The parent agent ID
+ * @param subagentId - The subagent ID
+ * @param task - The task description
+ * @param priority - Optional task priority
+ * @param dependencies - Optional array of dependencies
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.1 - WHEN I call `codebolt.notify.agent.StartSubagentTaskRequestNotify()` THEN the system SHALL send a StartSubagentTaskRequestNotification via WebSocket
+ */
+export declare function StartSubagentTaskRequestNotify(parentAgentId: string, subagentId: string, task: string, priority?: string, dependencies?: string[], toolUseId?: string): void;
+/**
+ * Sends a response to a subagent task request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.2 - WHEN I call `codebolt.notify.agent.StartSubagentTaskResponseNotify()` THEN the system SHALL send a StartSubagentTaskResponseNotification via WebSocket
+ */
+export declare function StartSubagentTaskResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Notifies that a subagent task has been completed
+ *
+ * @param parentAgentId - The parent agent ID
+ * @param subagentId - The subagent ID
+ * @param taskId - The task ID
+ * @param result - The task result
+ * @param status - The task status
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.3 - WHEN I call `codebolt.notify.agent.SubagentTaskCompletedNotify()` THEN the system SHALL send a SubagentTaskCompletedNotification via WebSocket
+ */
+export declare function SubagentTaskCompletedNotify(parentAgentId: string, subagentId: string, taskId: string, result: any, status: string, toolUseId?: string): void;
+/**
+ * Agent notification functions object
+ */
+export declare const agentNotifications: AgentNotifications;
+export default agentNotifications;

package/dist/notificationfunctions/agent.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Agent Notification Functions
+ *
+ * This module provides functions for sending agent-related notifications,
+ * including subagent task operations and completions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentNotifications = exports.SubagentTaskCompletedNotify = exports.StartSubagentTaskResponseNotify = exports.StartSubagentTaskRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a request to start a subagent task
+ *
+ * @param parentAgentId - The parent agent ID
+ * @param subagentId - The subagent ID
+ * @param task - The task description
+ * @param priority - Optional task priority
+ * @param dependencies - Optional array of dependencies
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.1 - WHEN I call `codebolt.notify.agent.StartSubagentTaskRequestNotify()` THEN the system SHALL send a StartSubagentTaskRequestNotification via WebSocket
+ */
+function StartSubagentTaskRequestNotify(parentAgentId, subagentId, task, priority, dependencies, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ parentAgentId, subagentId, task }, ['parentAgentId', 'subagentId', 'task'], 'agent.StartSubagentTaskRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "agentnotify",
+        action: "startSubagentTaskRequest",
+        data: {
+            parentAgentId: parentAgentId,
+            subagentId: subagentId,
+            task: task,
+            priority: priority,
+            dependencies: dependencies
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'agent.StartSubagentTaskRequestNotify');
+}
+exports.StartSubagentTaskRequestNotify = StartSubagentTaskRequestNotify;
+/**
+ * Sends a response to a subagent task request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.2 - WHEN I call `codebolt.notify.agent.StartSubagentTaskResponseNotify()` THEN the system SHALL send a StartSubagentTaskResponseNotification via WebSocket
+ */
+function StartSubagentTaskResponseNotify(content, isError = false, toolUseId) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for agent.StartSubagentTaskResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "agentnotify",
+        action: "startSubagentTaskResult",
+        content: content,
+        isError: isError
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'agent.StartSubagentTaskResponseNotify');
+}
+exports.StartSubagentTaskResponseNotify = StartSubagentTaskResponseNotify;
+/**
+ * Notifies that a subagent task has been completed
+ *
+ * @param parentAgentId - The parent agent ID
+ * @param subagentId - The subagent ID
+ * @param taskId - The task ID
+ * @param result - The task result
+ * @param status - The task status
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.3 - WHEN I call `codebolt.notify.agent.SubagentTaskCompletedNotify()` THEN the system SHALL send a SubagentTaskCompletedNotification via WebSocket
+ */
+function SubagentTaskCompletedNotify(parentAgentId, subagentId, taskId, result, status, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ parentAgentId, subagentId, taskId, result, status }, ['parentAgentId', 'subagentId', 'taskId', 'result', 'status'], 'agent.SubagentTaskCompletedNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "agentnotify",
+        action: "subagentTaskCompleted",
+        data: {
+            parentAgentId: parentAgentId,
+            subagentId: subagentId,
+            taskId: taskId,
+            result: result,
+            status: status
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'agent.SubagentTaskCompletedNotify');
+}
+exports.SubagentTaskCompletedNotify = SubagentTaskCompletedNotify;
+/**
+ * Agent notification functions object
+ */
+exports.agentNotifications = {
+    StartSubagentTaskRequestNotify,
+    StartSubagentTaskResponseNotify,
+    SubagentTaskCompletedNotify
+};
+// Default export
+exports.default = exports.agentNotifications;

package/dist/notificationfunctions/browser.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Browser Notification Functions
+ *
+ * This module provides functions for sending browser-related notifications,
+ * including web fetch and web search operations.
+ */
+import { WebFetchResponseNotification, WebSearchResponseNotification } from '../types/notifications/browser';
+import { BrowserNotifications } from '../types/notificationFunctions/browser';
+/**
+ * Sends a web fetch request notification
+ *
+ * @param url - The URL to fetch
+ * @param method - Optional HTTP method
+ * @param headers - Optional headers object
+ * @param body - Optional request body
+ * @param timeout - Optional timeout in milliseconds
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 2.1 - WHEN I call `codebolt.notify.browser.WebFetchRequestNotify()` THEN the system SHALL send a WebFetchRequestNotification via WebSocket
+ */
+export declare function WebFetchRequestNotify(url: string, method?: string, headers?: Record<string, string>, body?: any, timeout?: number, toolUseId?: string): void;
+/**
+ * Sends a web fetch response notification
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data including status, statusText, headers, and url
+ *
+ * Requirements: 2.2 - WHEN I call `codebolt.notify.browser.WebFetchResponseNotify()` THEN the system SHALL send a WebFetchResponseNotification via WebSocket
+ */
+export declare function WebFetchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: WebFetchResponseNotification['data']): void;
+/**
+ * Sends a web search request notification
+ *
+ * @param query - The search query string
+ * @param maxResults - Optional maximum number of results
+ * @param searchEngine - Optional search engine to use
+ * @param filters - Optional search filters
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 2.3 - WHEN I call `codebolt.notify.browser.WebSearchRequestNotify()` THEN the system SHALL send a WebSearchRequestNotification via WebSocket
+ */
+export declare function WebSearchRequestNotify(query: string, maxResults?: number, searchEngine?: string, filters?: any, toolUseId?: string): void;
+/**
+ * Sends a web search response notification
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data including results, totalResults, and searchTime
+ *
+ * Requirements: 2.4 - WHEN I call `codebolt.notify.browser.WebSearchResponseNotify()` THEN the system SHALL send a WebSearchResponseNotification via WebSocket
+ */
+export declare function WebSearchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: WebSearchResponseNotification['data']): void;
+/**
+ * Browser notification functions object
+ */
+export declare const browserNotifications: BrowserNotifications;
+export default browserNotifications;

package/dist/notificationfunctions/browser.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Browser Notification Functions
+ *
+ * This module provides functions for sending browser-related notifications,
+ * including web fetch and web search operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserNotifications = exports.WebSearchResponseNotify = exports.WebSearchRequestNotify = exports.WebFetchResponseNotify = exports.WebFetchRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a web fetch request notification
+ *
+ * @param url - The URL to fetch
+ * @param method - Optional HTTP method
+ * @param headers - Optional headers object
+ * @param body - Optional request body
+ * @param timeout - Optional timeout in milliseconds
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 2.1 - WHEN I call `codebolt.notify.browser.WebFetchRequestNotify()` THEN the system SHALL send a WebFetchRequestNotification via WebSocket
+ */
+function WebFetchRequestNotify(url, method, headers, body, timeout, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ url }, ['url'], 'browser.WebFetchRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "browsernotify",
+        action: "webFetchRequest",
+        data: {
+            url: url,
+            method: method,
+            headers: headers,
+            body: body,
+            timeout: timeout
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'browser.WebFetchRequestNotify');
+}
+exports.WebFetchRequestNotify = WebFetchRequestNotify;
+/**
+ * Sends a web fetch response notification
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data including status, statusText, headers, and url
+ *
+ * Requirements: 2.2 - WHEN I call `codebolt.notify.browser.WebFetchResponseNotify()` THEN the system SHALL send a WebFetchResponseNotification via WebSocket
+ */
+function WebFetchResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for browser.WebFetchResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "browsernotify",
+        action: "webFetchResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'browser.WebFetchResponseNotify');
+}
+exports.WebFetchResponseNotify = WebFetchResponseNotify;
+/**
+ * Sends a web search request notification
+ *
+ * @param query - The search query string
+ * @param maxResults - Optional maximum number of results
+ * @param searchEngine - Optional search engine to use
+ * @param filters - Optional search filters
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 2.3 - WHEN I call `codebolt.notify.browser.WebSearchRequestNotify()` THEN the system SHALL send a WebSearchRequestNotification via WebSocket
+ */
+function WebSearchRequestNotify(query, maxResults, searchEngine, filters, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ query }, ['query'], 'browser.WebSearchRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "browsernotify",
+        action: "webSearchRequest",
+        data: {
+            query: query,
+            maxResults: maxResults,
+            searchEngine: searchEngine,
+            filters: filters
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'browser.WebSearchRequestNotify');
+}
+exports.WebSearchRequestNotify = WebSearchRequestNotify;
+/**
+ * Sends a web search response notification
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data including results, totalResults, and searchTime
+ *
+ * Requirements: 2.4 - WHEN I call `codebolt.notify.browser.WebSearchResponseNotify()` THEN the system SHALL send a WebSearchResponseNotification via WebSocket
+ */
+function WebSearchResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for browser.WebSearchResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "browsernotify",
+        action: "webSearchResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'browser.WebSearchResponseNotify');
+}
+exports.WebSearchResponseNotify = WebSearchResponseNotify;
+/**
+ * Browser notification functions object
+ */
+exports.browserNotifications = {
+    WebFetchRequestNotify,
+    WebFetchResponseNotify,
+    WebSearchRequestNotify,
+    WebSearchResponseNotify
+};
+// Default export
+exports.default = exports.browserNotifications;