@codebolt/codeboltjs 2.0.13 → 2.0.15

package/dist/notificationfunctions/chat.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Chat Notification Functions
+ *
+ * This module provides functions for sending chat-related notifications,
+ * including user messages, agent responses, and chat history operations.
+ */
+import { AgentTextResponseNotification, GetChatHistoryRequestNotification } from '../types/notifications/chat';
+import { ChatNotifications } from '../types/notificationFunctions/chat';
+/**
+ * Sends a user message request
+ *
+ * @param message - The user message
+ * @param payload - Optional payload data
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.1 - WHEN I call `codebolt.notify.chat.UserMessageRequestNotify()` THEN the system SHALL send a UserMessageRequestNotification via WebSocket
+ */
+export declare function UserMessageRequestNotify(message: string, payload?: any, toolUseId?: string): void;
+/**
+ * Sends an agent text response
+ *
+ * @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 additional data including message, timestamp, agentId, and conversationId
+ *
+ * Requirements: 3.2 - WHEN I call `codebolt.notify.chat.AgentTextResponseNotify()` THEN the system SHALL send an AgentTextResponseNotification via WebSocket
+ */
+export declare function AgentTextResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: AgentTextResponseNotification['data']): void;
+/**
+ * Requests chat history
+ *
+ * @param data - Optional data including sessionId
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.3 - WHEN I call `codebolt.notify.chat.GetChatHistoryRequestNotify()` THEN the system SHALL send a GetChatHistoryRequestNotification via WebSocket
+ */
+export declare function GetChatHistoryRequestNotify(data?: GetChatHistoryRequestNotification['data'], toolUseId?: string): void;
+/**
+ * Sends chat history result
+ *
+ * @param content - The chat history 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: 3.4 - WHEN I call `codebolt.notify.chat.GetChatHistoryResultNotify()` THEN the system SHALL send a GetChatHistoryResultNotification via WebSocket
+ */
+export declare function GetChatHistoryResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Chat notification functions object
+ */
+export declare const chatNotifications: ChatNotifications;
+export default chatNotifications;

package/dist/notificationfunctions/chat.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Chat Notification Functions
+ *
+ * This module provides functions for sending chat-related notifications,
+ * including user messages, agent responses, and chat history operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatNotifications = exports.GetChatHistoryResultNotify = exports.GetChatHistoryRequestNotify = exports.AgentTextResponseNotify = exports.UserMessageRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a user message request
+ *
+ * @param message - The user message
+ * @param payload - Optional payload data
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.1 - WHEN I call `codebolt.notify.chat.UserMessageRequestNotify()` THEN the system SHALL send a UserMessageRequestNotification via WebSocket
+ */
+function UserMessageRequestNotify(message, payload, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ message }, ['message'], 'chat.UserMessageRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "sendMessageRequest",
+        data: {
+            message: message,
+            payload: payload
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'chat.UserMessageRequestNotify');
+}
+exports.UserMessageRequestNotify = UserMessageRequestNotify;
+/**
+ * Sends an agent text response
+ *
+ * @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 additional data including message, timestamp, agentId, and conversationId
+ *
+ * Requirements: 3.2 - WHEN I call `codebolt.notify.chat.AgentTextResponseNotify()` THEN the system SHALL send an AgentTextResponseNotification via WebSocket
+ */
+function AgentTextResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for chat.AgentTextResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "agentTextResponse",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'chat.AgentTextResponseNotify');
+}
+exports.AgentTextResponseNotify = AgentTextResponseNotify;
+/**
+ * Requests chat history
+ *
+ * @param data - Optional data including sessionId
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.3 - WHEN I call `codebolt.notify.chat.GetChatHistoryRequestNotify()` THEN the system SHALL send a GetChatHistoryRequestNotification via WebSocket
+ */
+function GetChatHistoryRequestNotify(data, toolUseId) {
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "getChatHistoryRequest",
+        data: data || {}
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'chat.GetChatHistoryRequestNotify');
+}
+exports.GetChatHistoryRequestNotify = GetChatHistoryRequestNotify;
+/**
+ * Sends chat history result
+ *
+ * @param content - The chat history 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: 3.4 - WHEN I call `codebolt.notify.chat.GetChatHistoryResultNotify()` THEN the system SHALL send a GetChatHistoryResultNotification via WebSocket
+ */
+function GetChatHistoryResultNotify(content, isError = false, toolUseId) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for chat.GetChatHistoryResultNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "getChatHistoryResult",
+        content: content,
+        isError: isError
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'chat.GetChatHistoryResultNotify');
+}
+exports.GetChatHistoryResultNotify = GetChatHistoryResultNotify;
+/**
+ * Chat notification functions object
+ */
+exports.chatNotifications = {
+    UserMessageRequestNotify,
+    AgentTextResponseNotify,
+    GetChatHistoryRequestNotify,
+    GetChatHistoryResultNotify
+};
+// Default export
+exports.default = exports.chatNotifications;

package/dist/notificationfunctions/codeutils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Code Utils Notification Functions
+ *
+ * This module provides functions for sending code utilities-related notifications,
+ * including grep search and glob search operations.
+ */
+import { GrepSearchResponseNotification, GlobSearchResponseNotification } from '../types/notifications/codeutils';
+import { CodeutilsNotifications } from '../types/notificationFunctions/codeutils';
+/**
+ * Sends a grep search request
+ *
+ * @param pattern - The search pattern
+ * @param filePath - Optional file path to search in
+ * @param recursive - Optional recursive search flag
+ * @param ignoreCase - Optional ignore case flag
+ * @param maxResults - Optional maximum number of results
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 4.1 - WHEN I call `codebolt.notify.codeutils.GrepSearchRequestNotify()` THEN the system SHALL send a GrepSearchRequestNotification via WebSocket
+ */
+export declare function GrepSearchRequestNotify(pattern: string, filePath?: string, recursive?: boolean, ignoreCase?: boolean, maxResults?: number, toolUseId?: string): void;
+/**
+ * Sends a response to a grep search 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
+ * @param data - Optional response data with matches and totalMatches
+ *
+ * Requirements: 4.2 - WHEN I call `codebolt.notify.codeutils.GrepSearchResponseNotify()` THEN the system SHALL send a GrepSearchResponseNotification via WebSocket
+ */
+export declare function GrepSearchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: GrepSearchResponseNotification['data']): void;
+/**
+ * Sends a glob search request
+ *
+ * @param pattern - The glob pattern
+ * @param basePath - Optional base path to search in
+ * @param maxDepth - Optional maximum search depth
+ * @param includeDirectories - Optional flag to include directories
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 4.3 - WHEN I call `codebolt.notify.codeutils.GlobSearchRequestNotify()` THEN the system SHALL send a GlobSearchRequestNotification via WebSocket
+ */
+export declare function GlobSearchRequestNotify(pattern: string, basePath?: string, maxDepth?: number, includeDirectories?: boolean, toolUseId?: string): void;
+/**
+ * Sends a response to a glob search 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
+ * @param data - Optional response data with files and totalFiles
+ *
+ * Requirements: 4.4 - WHEN I call `codebolt.notify.codeutils.GlobSearchResponseNotify()` THEN the system SHALL send a GlobSearchResponseNotification via WebSocket
+ */
+export declare function GlobSearchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: GlobSearchResponseNotification['data']): void;
+/**
+ * Codeutils notification functions object
+ */
+export declare const codeutilsNotifications: CodeutilsNotifications;
+export default codeutilsNotifications;

package/dist/notificationfunctions/codeutils.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Code Utils Notification Functions
+ *
+ * This module provides functions for sending code utilities-related notifications,
+ * including grep search and glob search operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeutilsNotifications = exports.GlobSearchResponseNotify = exports.GlobSearchRequestNotify = exports.GrepSearchResponseNotify = exports.GrepSearchRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a grep search request
+ *
+ * @param pattern - The search pattern
+ * @param filePath - Optional file path to search in
+ * @param recursive - Optional recursive search flag
+ * @param ignoreCase - Optional ignore case flag
+ * @param maxResults - Optional maximum number of results
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 4.1 - WHEN I call `codebolt.notify.codeutils.GrepSearchRequestNotify()` THEN the system SHALL send a GrepSearchRequestNotification via WebSocket
+ */
+function GrepSearchRequestNotify(pattern, filePath, recursive, ignoreCase, maxResults, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ pattern }, ['pattern'], 'codeutils.GrepSearchRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "codeutilsnotify",
+        action: "grepSearchRequest",
+        data: {
+            pattern: pattern,
+            filePath: filePath,
+            recursive: recursive,
+            ignoreCase: ignoreCase,
+            maxResults: maxResults
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'codeutils.GrepSearchRequestNotify');
+}
+exports.GrepSearchRequestNotify = GrepSearchRequestNotify;
+/**
+ * Sends a response to a grep search 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
+ * @param data - Optional response data with matches and totalMatches
+ *
+ * Requirements: 4.2 - WHEN I call `codebolt.notify.codeutils.GrepSearchResponseNotify()` THEN the system SHALL send a GrepSearchResponseNotification via WebSocket
+ */
+function GrepSearchResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for codeutils.GrepSearchResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "codeutilsnotify",
+        action: "grepSearchResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'codeutils.GrepSearchResponseNotify');
+}
+exports.GrepSearchResponseNotify = GrepSearchResponseNotify;
+/**
+ * Sends a glob search request
+ *
+ * @param pattern - The glob pattern
+ * @param basePath - Optional base path to search in
+ * @param maxDepth - Optional maximum search depth
+ * @param includeDirectories - Optional flag to include directories
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 4.3 - WHEN I call `codebolt.notify.codeutils.GlobSearchRequestNotify()` THEN the system SHALL send a GlobSearchRequestNotification via WebSocket
+ */
+function GlobSearchRequestNotify(pattern, basePath, maxDepth, includeDirectories, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ pattern }, ['pattern'], 'codeutils.GlobSearchRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "codeutilsnotify",
+        action: "globSearchRequest",
+        data: {
+            pattern: pattern,
+            basePath: basePath,
+            maxDepth: maxDepth,
+            includeDirectories: includeDirectories
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'codeutils.GlobSearchRequestNotify');
+}
+exports.GlobSearchRequestNotify = GlobSearchRequestNotify;
+/**
+ * Sends a response to a glob search 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
+ * @param data - Optional response data with files and totalFiles
+ *
+ * Requirements: 4.4 - WHEN I call `codebolt.notify.codeutils.GlobSearchResponseNotify()` THEN the system SHALL send a GlobSearchResponseNotification via WebSocket
+ */
+function GlobSearchResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for codeutils.GlobSearchResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "codeutilsnotify",
+        action: "globSearchResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'codeutils.GlobSearchResponseNotify');
+}
+exports.GlobSearchResponseNotify = GlobSearchResponseNotify;
+/**
+ * Codeutils notification functions object
+ */
+exports.codeutilsNotifications = {
+    GrepSearchRequestNotify,
+    GrepSearchResponseNotify,
+    GlobSearchRequestNotify,
+    GlobSearchResponseNotify
+};
+// Default export
+exports.default = exports.codeutilsNotifications;

package/dist/notificationfunctions/crawler.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Crawler Notification Functions
+ *
+ * This module provides functions for sending crawler-related notifications,
+ * including web crawling search operations and crawler initialization.
+ */
+import { CrawlerSearchResponseNotification, CrawlerStartResponseNotification } from '../types/notifications/crawler';
+import { CrawlerNotifications } from '../types/notificationFunctions/crawler';
+/**
+ * Sends a request to perform a crawler search
+ *
+ * @param url - The URL to crawl
+ * @param searchQuery - Optional search query
+ * @param maxDepth - Optional maximum crawl depth
+ * @param maxPages - Optional maximum pages to crawl
+ * @param includeSubdomains - Optional flag to include subdomains
+ * @param followRedirects - Optional flag to follow redirects
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 5.1 - WHEN I call `codebolt.notify.crawler.CrawlerSearchRequestNotify()` THEN the system SHALL send a CrawlerSearchRequestNotification via WebSocket
+ */
+export declare function CrawlerSearchRequestNotify(url: string, searchQuery?: string, maxDepth?: number, maxPages?: number, includeSubdomains?: boolean, followRedirects?: boolean, toolUseId?: string): void;
+/**
+ * Sends a response to a crawler search 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
+ * @param data - Optional response data containing pages, totalPages, and crawlTime
+ *
+ * Requirements: 5.2 - WHEN I call `codebolt.notify.crawler.CrawlerSearchResponseNotify()` THEN the system SHALL send a CrawlerSearchResponseNotification via WebSocket
+ */
+export declare function CrawlerSearchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: CrawlerSearchResponseNotification['data']): void;
+/**
+ * Sends a request to start a crawler
+ *
+ * @param startUrl - The URL to start crawling from
+ * @param options - Optional crawler configuration options
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 5.3 - WHEN I call `codebolt.notify.crawler.CrawlerStartRequestNotify()` THEN the system SHALL send a CrawlerStartRequestNotification via WebSocket
+ */
+export declare function CrawlerStartRequestNotify(startUrl: string, options?: any, toolUseId?: string): void;
+/**
+ * Sends a response to a crawler start 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
+ * @param data - Optional response data containing sessionId and status
+ *
+ * Requirements: 5.4 - WHEN I call `codebolt.notify.crawler.CrawlerStartResponseNotify()` THEN the system SHALL send a CrawlerStartResponseNotification via WebSocket
+ */
+export declare function CrawlerStartResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: CrawlerStartResponseNotification['data']): void;
+/**
+ * Crawler notification functions object
+ */
+export declare const crawlerNotifications: CrawlerNotifications;
+export default crawlerNotifications;

package/dist/notificationfunctions/crawler.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Crawler Notification Functions
+ *
+ * This module provides functions for sending crawler-related notifications,
+ * including web crawling search operations and crawler initialization.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crawlerNotifications = exports.CrawlerStartResponseNotify = exports.CrawlerStartRequestNotify = exports.CrawlerSearchResponseNotify = exports.CrawlerSearchRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a request to perform a crawler search
+ *
+ * @param url - The URL to crawl
+ * @param searchQuery - Optional search query
+ * @param maxDepth - Optional maximum crawl depth
+ * @param maxPages - Optional maximum pages to crawl
+ * @param includeSubdomains - Optional flag to include subdomains
+ * @param followRedirects - Optional flag to follow redirects
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 5.1 - WHEN I call `codebolt.notify.crawler.CrawlerSearchRequestNotify()` THEN the system SHALL send a CrawlerSearchRequestNotification via WebSocket
+ */
+function CrawlerSearchRequestNotify(url, searchQuery, maxDepth, maxPages, includeSubdomains, followRedirects, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ url }, ['url'], 'crawler.CrawlerSearchRequestNotify')) {
+        return;
+    }
+    // Validate URL format
+    try {
+        new URL(url);
+    }
+    catch (error) {
+        console.error('[NotificationFunctions] Invalid URL format for crawler.CrawlerSearchRequestNotify:', url);
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "crawlernotify",
+        action: "crawlerSearchRequest",
+        data: {
+            url: url,
+            searchQuery: searchQuery,
+            maxDepth: maxDepth,
+            maxPages: maxPages,
+            includeSubdomains: includeSubdomains,
+            followRedirects: followRedirects
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'crawler.CrawlerSearchRequestNotify');
+}
+exports.CrawlerSearchRequestNotify = CrawlerSearchRequestNotify;
+/**
+ * Sends a response to a crawler search 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
+ * @param data - Optional response data containing pages, totalPages, and crawlTime
+ *
+ * Requirements: 5.2 - WHEN I call `codebolt.notify.crawler.CrawlerSearchResponseNotify()` THEN the system SHALL send a CrawlerSearchResponseNotification via WebSocket
+ */
+function CrawlerSearchResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for crawler.CrawlerSearchResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "crawlernotify",
+        action: "crawlerSearchResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'crawler.CrawlerSearchResponseNotify');
+}
+exports.CrawlerSearchResponseNotify = CrawlerSearchResponseNotify;
+/**
+ * Sends a request to start a crawler
+ *
+ * @param startUrl - The URL to start crawling from
+ * @param options - Optional crawler configuration options
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 5.3 - WHEN I call `codebolt.notify.crawler.CrawlerStartRequestNotify()` THEN the system SHALL send a CrawlerStartRequestNotification via WebSocket
+ */
+function CrawlerStartRequestNotify(startUrl, options, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ startUrl }, ['startUrl'], 'crawler.CrawlerStartRequestNotify')) {
+        return;
+    }
+    // Validate URL format
+    try {
+        new URL(startUrl);
+    }
+    catch (error) {
+        console.error('[NotificationFunctions] Invalid URL format for crawler.CrawlerStartRequestNotify:', startUrl);
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "crawlernotify",
+        action: "crawlerStartRequest",
+        data: {
+            startUrl: startUrl,
+            options: options
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'crawler.CrawlerStartRequestNotify');
+}
+exports.CrawlerStartRequestNotify = CrawlerStartRequestNotify;
+/**
+ * Sends a response to a crawler start 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
+ * @param data - Optional response data containing sessionId and status
+ *
+ * Requirements: 5.4 - WHEN I call `codebolt.notify.crawler.CrawlerStartResponseNotify()` THEN the system SHALL send a CrawlerStartResponseNotification via WebSocket
+ */
+function CrawlerStartResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for crawler.CrawlerStartResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "crawlernotify",
+        action: "crawlerStartResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'crawler.CrawlerStartResponseNotify');
+}
+exports.CrawlerStartResponseNotify = CrawlerStartResponseNotify;
+/**
+ * Crawler notification functions object
+ */
+exports.crawlerNotifications = {
+    CrawlerSearchRequestNotify,
+    CrawlerSearchResponseNotify,
+    CrawlerStartRequestNotify,
+    CrawlerStartResponseNotify
+};
+// Default export
+exports.default = exports.crawlerNotifications;

package/dist/notificationfunctions/dbmemory.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Database Memory Notification Functions
+ *
+ * This module provides functions for sending database memory-related notifications,
+ * including knowledge storage and retrieval operations.
+ */
+import { DbmemoryNotifications } from '../types/notificationFunctions/dbmemory';
+/**
+ * Sends a request to add knowledge to memory
+ *
+ * @param key - The memory key
+ * @param value - The memory value
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 6.1 - WHEN I call `codebolt.notify.dbmemory.AddMemoryRequestNotify()` THEN the system SHALL send an AddMemoryRequestNotification via WebSocket
+ */
+export declare function AddMemoryRequestNotify(key: string, value: any, toolUseId?: string): void;
+/**
+ * Sends a result response for an add memory operation
+ *
+ * @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: 6.2 - WHEN I call `codebolt.notify.dbmemory.AddMemoryResultNotify()` THEN the system SHALL send an AddMemoryResultNotification via WebSocket
+ */
+export declare function AddMemoryResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a request to get knowledge from memory
+ *
+ * @param key - The memory key to retrieve
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 6.3 - WHEN I call `codebolt.notify.dbmemory.GetMemoryRequestNotify()` THEN the system SHALL send a GetMemoryRequestNotification via WebSocket
+ */
+export declare function GetMemoryRequestNotify(key: string, toolUseId?: string): void;
+/**
+ * Sends a result response for a get memory operation
+ *
+ * @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: 6.4 - WHEN I call `codebolt.notify.dbmemory.GetMemoryResultNotify()` THEN the system SHALL send a GetMemoryResultNotification via WebSocket
+ */
+export declare function GetMemoryResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Database memory notification functions object
+ */
+export declare const dbmemoryNotifications: DbmemoryNotifications;