@codebolt/codeboltjs 2.0.13 → 2.0.15

package/dist/notificationfunctions/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Notification Functions Module
+ *
+ * This module provides wrapper functions for all notification types defined in the
+ * src/types/notifications directory. It allows users to send various types of
+ * notifications through the WebSocket connection to the Codebolt application.
+ *
+ * The notification system covers 15 different categories:
+ * - agent: Subagent task operations and completions
+ * - browser: Web fetch and search operations
+ * - chat: User messages and agent responses
+ * - codeutils: Search operations and results
+ * - crawler: Web crawling and search operations
+ * - dbmemory: Knowledge storage and retrieval operations
+ * - fs: File and folder operations
+ * - git: Version control operations
+ * - history: Conversation summarization operations
+ * - llm: Inference requests and token counting operations
+ * - mcp: MCP server operations and tool executions
+ * - search: Search initialization and query operations
+ * - system: Agent initialization and completion states
+ * - terminal: Command execution operations
+ * - todo: Task operations and lifecycle
+ */
+export * from './utils';
+export { NotificationError, NotificationErrorCodes } from './utils';
+export * from './agent';
+export * from './browser';
+export * from './chat';
+export * from './codeutils';
+export * from './crawler';
+export * from './dbmemory';
+export * from './fs';
+export * from './git';
+export * from './history';
+export * from './llm';
+export * from './mcp';
+export * from './search';
+export * from './system';
+export * from './terminal';
+export * from './todo';
+import { type AgentNotifications } from '../types/notificationFunctions/agent';
+import { type BrowserNotifications } from '../types/notificationFunctions/browser';
+import { type ChatNotifications } from '../types/notificationFunctions/chat';
+import { type CodeutilsNotifications } from '../types/notificationFunctions/codeutils';
+import { type CrawlerNotifications } from '../types/notificationFunctions/crawler';
+import { type DbmemoryNotifications } from '../types/notificationFunctions/dbmemory';
+import { type FsNotifications } from '../types/notificationFunctions/fs';
+import { type GitNotifications } from '../types/notificationFunctions/git';
+import { type HistoryNotifications } from '../types/notificationFunctions/history';
+import { type LlmNotifications } from '../types/notificationFunctions/llm';
+import { type McpNotifications } from '../types/notificationFunctions/mcp';
+import { type SearchNotifications } from '../types/notificationFunctions/search';
+import { type SystemNotifications } from '../types/notificationFunctions/system';
+import { type TerminalNotifications } from '../types/notificationFunctions/terminal';
+import { type TodoNotifications } from '../types/notificationFunctions/todo';
+export interface NotificationFunctions {
+    agent: AgentNotifications;
+    browser: BrowserNotifications;
+    chat: ChatNotifications;
+    codeutils: CodeutilsNotifications;
+    crawler: CrawlerNotifications;
+    dbmemory: DbmemoryNotifications;
+    fs: FsNotifications;
+    git: GitNotifications;
+    history: HistoryNotifications;
+    llm: LlmNotifications;
+    mcp: McpNotifications;
+    search: SearchNotifications;
+    system: SystemNotifications;
+    terminal: TerminalNotifications;
+    todo: TodoNotifications;
+}
+/**
+ * Complete notification functions object
+ * This object contains all notification functions organized by category
+ */
+export declare const notificationFunctions: NotificationFunctions;
+export default notificationFunctions;

package/dist/notificationfunctions/index.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Notification Functions Module
+ *
+ * This module provides wrapper functions for all notification types defined in the
+ * src/types/notifications directory. It allows users to send various types of
+ * notifications through the WebSocket connection to the Codebolt application.
+ *
+ * The notification system covers 15 different categories:
+ * - agent: Subagent task operations and completions
+ * - browser: Web fetch and search operations
+ * - chat: User messages and agent responses
+ * - codeutils: Search operations and results
+ * - crawler: Web crawling and search operations
+ * - dbmemory: Knowledge storage and retrieval operations
+ * - fs: File and folder operations
+ * - git: Version control operations
+ * - history: Conversation summarization operations
+ * - llm: Inference requests and token counting operations
+ * - mcp: MCP server operations and tool executions
+ * - search: Search initialization and query operations
+ * - system: Agent initialization and completion states
+ * - terminal: Command execution operations
+ * - todo: Task operations and lifecycle
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notificationFunctions = exports.NotificationErrorCodes = exports.NotificationError = void 0;
+// Export utilities for advanced usage
+__exportStar(require("./utils"), exports);
+// Export error types
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "NotificationError", { enumerable: true, get: function () { return utils_1.NotificationError; } });
+Object.defineProperty(exports, "NotificationErrorCodes", { enumerable: true, get: function () { return utils_1.NotificationErrorCodes; } });
+// Export all notification functions and types
+__exportStar(require("./agent"), exports);
+__exportStar(require("./browser"), exports);
+__exportStar(require("./chat"), exports);
+__exportStar(require("./codeutils"), exports);
+__exportStar(require("./crawler"), exports);
+__exportStar(require("./dbmemory"), exports);
+__exportStar(require("./fs"), exports);
+__exportStar(require("./git"), exports);
+__exportStar(require("./history"), exports);
+__exportStar(require("./llm"), exports);
+__exportStar(require("./mcp"), exports);
+__exportStar(require("./search"), exports);
+__exportStar(require("./system"), exports);
+__exportStar(require("./terminal"), exports);
+__exportStar(require("./todo"), exports);
+// Import notification objects
+const agent_1 = require("./agent");
+const browser_1 = require("./browser");
+const chat_1 = require("./chat");
+const codeutils_1 = require("./codeutils");
+const crawler_1 = require("./crawler");
+const dbmemory_1 = require("./dbmemory");
+const fs_1 = require("./fs");
+const git_1 = require("./git");
+const history_1 = require("./history");
+const llm_1 = require("./llm");
+const mcp_1 = require("./mcp");
+const search_1 = require("./search");
+const system_1 = require("./system");
+const terminal_1 = require("./terminal");
+const todo_1 = require("./todo");
+/**
+ * Complete notification functions object
+ * This object contains all notification functions organized by category
+ */
+exports.notificationFunctions = {
+    agent: agent_1.agentNotifications,
+    browser: browser_1.browserNotifications,
+    chat: chat_1.chatNotifications,
+    codeutils: codeutils_1.codeutilsNotifications,
+    crawler: crawler_1.crawlerNotifications,
+    dbmemory: dbmemory_1.dbmemoryNotifications,
+    fs: fs_1.fsNotifications,
+    git: git_1.gitNotifications,
+    history: history_1.historyNotifications,
+    llm: llm_1.llmNotifications,
+    mcp: mcp_1.mcpNotifications,
+    search: search_1.searchNotifications,
+    system: system_1.systemNotifications,
+    terminal: terminal_1.terminalNotifications,
+    todo: todo_1.todoNotifications
+};
+// Default export for the notification functions
+exports.default = exports.notificationFunctions;

package/dist/notificationfunctions/llm.d.ts

@@ -0,0 +1,39 @@
+/**
+ * LLM Notification Functions
+ *
+ * This module provides functions for sending LLM-related notifications,
+ * including inference requests and token counting operations.
+ */
+import { LLMRequestNotification, LLMGetTokenCountRequestNotification, LLMGetTokenCountResponseNotification } from '../types/notifications/llm';
+import { LlmNotifications } from '../types/notificationFunctions/llm';
+/**
+ * Sends an LLM inference request notification
+ * @param data - LLM inference data containing messages, tools, and other parameters
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function sendInferenceRequest(data: LLMRequestNotification['data'], toolUseId?: string): void;
+/**
+ * Sends an LLM inference response notification
+ * @param content - The inference result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function sendInferenceResponse(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends an LLM get token count request notification
+ * @param data - Token count request data containing text and optional model/encoding
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function getTokenCount(data: LLMGetTokenCountRequestNotification['data'], toolUseId?: string): void;
+/**
+ * Sends an LLM get token count response notification
+ * @param content - The token count result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ * @param data - Optional additional data containing token count details
+ */
+export declare function sendTokenCountResponse(content: string | any, isError?: boolean, toolUseId?: string, data?: LLMGetTokenCountResponseNotification['data']): void;
+/**
+ * LLM notification functions object
+ */
+export declare const llmNotifications: LlmNotifications;

package/dist/notificationfunctions/llm.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * LLM Notification Functions
+ *
+ * This module provides functions for sending LLM-related notifications,
+ * including inference requests and token counting operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.llmNotifications = exports.sendTokenCountResponse = exports.getTokenCount = exports.sendInferenceResponse = exports.sendInferenceRequest = void 0;
+const utils_1 = require("./utils");
+// ===== LLM INFERENCE FUNCTIONS =====
+/**
+ * Sends an LLM inference request notification
+ * @param data - LLM inference data containing messages, tools, and other parameters
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function sendInferenceRequest(data, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "llmnotify",
+        action: "inferenceRequest",
+        data
+    };
+    (0, utils_1.sendNotification)(notification, 'llm-inference-request');
+}
+exports.sendInferenceRequest = sendInferenceRequest;
+/**
+ * Sends an LLM inference response notification
+ * @param content - The inference result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function sendInferenceResponse(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[LlmNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "llmnotify",
+        action: "inferenceResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'llm-inference-response');
+}
+exports.sendInferenceResponse = sendInferenceResponse;
+// ===== LLM TOKEN COUNT FUNCTIONS =====
+/**
+ * Sends an LLM get token count request notification
+ * @param data - Token count request data containing text and optional model/encoding
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function getTokenCount(data, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)(data, ['text'], 'llm-token-count')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "llmnotify",
+        action: "getTokenCountRequest",
+        data
+    };
+    (0, utils_1.sendNotification)(notification, 'llm-token-count-request');
+}
+exports.getTokenCount = getTokenCount;
+/**
+ * Sends an LLM get token count response notification
+ * @param content - The token count result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ * @param data - Optional additional data containing token count details
+ */
+function sendTokenCountResponse(content, isError = false, toolUseId, data) {
+    if (!toolUseId) {
+        console.error('[LlmNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "llmnotify",
+        action: "getTokenCountResult",
+        content,
+        isError,
+        ...(data && { data })
+    };
+    (0, utils_1.sendNotification)(notification, 'llm-token-count-response');
+}
+exports.sendTokenCountResponse = sendTokenCountResponse;
+/**
+ * LLM notification functions object
+ */
+exports.llmNotifications = {
+    sendInferenceRequest,
+    sendInferenceResponse,
+    getTokenCount,
+    sendTokenCountResponse
+};

package/dist/notificationfunctions/mcp.d.ts

@@ -0,0 +1,67 @@
+/**
+ * MCP Notification Functions
+ *
+ * This module provides functions for sending MCP-related notifications,
+ * including MCP server operations and tool executions.
+ */
+import { McpNotifications } from '../types/notificationFunctions/mcp';
+/**
+ * Sends a get enabled MCP servers request notification
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GetEnabledMCPServersRequestNotify(toolUseId?: string): void;
+/**
+ * Sends a get enabled MCP servers result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GetEnabledMCPServersResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a list tools from MCP servers request notification
+ * @param toolboxes - Array of toolbox names to list tools from
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function ListToolsFromMCPServersRequestNotify(toolboxes: string[], toolUseId?: string): void;
+/**
+ * Sends a list tools from MCP servers result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function ListToolsFromMCPServersResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a get tools request notification
+ * @param tools - Array of tools with toolbox and toolName
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GetToolsRequestNotify(tools: {
+    toolbox: string;
+    toolName: string;
+}[], toolUseId?: string): void;
+/**
+ * Sends a get tools result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GetToolsResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends an execute tool request notification
+ * @param toolbox - The toolbox name
+ * @param toolName - The tool name to execute
+ * @param params - The parameters for the tool execution
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function ExecuteToolRequestNotify(toolbox: string, toolName: string, params: any, toolUseId?: string): void;
+/**
+ * Sends an execute tool result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function ExecuteToolResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * MCP notification functions object
+ */
+export declare const mcpNotifications: McpNotifications;

package/dist/notificationfunctions/mcp.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * MCP Notification Functions
+ *
+ * This module provides functions for sending MCP-related notifications,
+ * including MCP server operations and tool executions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpNotifications = exports.ExecuteToolResultNotify = exports.ExecuteToolRequestNotify = exports.GetToolsResultNotify = exports.GetToolsRequestNotify = exports.ListToolsFromMCPServersResultNotify = exports.ListToolsFromMCPServersRequestNotify = exports.GetEnabledMCPServersResultNotify = exports.GetEnabledMCPServersRequestNotify = void 0;
+const utils_1 = require("./utils");
+// ===== GET ENABLED MCP SERVERS FUNCTIONS =====
+/**
+ * Sends a get enabled MCP servers request notification
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function GetEnabledMCPServersRequestNotify(toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "mcpnotify",
+        action: "getEnabledMCPServersRequest",
+        data: {}
+    };
+    (0, utils_1.sendNotification)(notification, 'mcp-get-enabled-servers');
+}
+exports.GetEnabledMCPServersRequestNotify = GetEnabledMCPServersRequestNotify;
+/**
+ * Sends a get enabled MCP servers result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function GetEnabledMCPServersResultNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[McpNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "mcpnotify",
+        action: "getEnabledMCPServersResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'mcp-get-enabled-servers-result');
+}
+exports.GetEnabledMCPServersResultNotify = GetEnabledMCPServersResultNotify;
+// ===== LIST TOOLS FROM MCP SERVERS FUNCTIONS =====
+/**
+ * Sends a list tools from MCP servers request notification
+ * @param toolboxes - Array of toolbox names to list tools from
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function ListToolsFromMCPServersRequestNotify(toolboxes, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ toolboxes }, ['toolboxes'], 'mcp-list-tools')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "mcpnotify",
+        action: "listToolsFromMCPServersRequest",
+        data: {
+            toolboxes: toolboxes
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'mcp-list-tools');
+}
+exports.ListToolsFromMCPServersRequestNotify = ListToolsFromMCPServersRequestNotify;
+/**
+ * Sends a list tools from MCP servers result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function ListToolsFromMCPServersResultNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[McpNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "mcpnotify",
+        action: "listToolsFromMCPServersResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'mcp-list-tools-result');
+}
+exports.ListToolsFromMCPServersResultNotify = ListToolsFromMCPServersResultNotify;
+// ===== GET TOOLS FUNCTIONS =====
+/**
+ * Sends a get tools request notification
+ * @param tools - Array of tools with toolbox and toolName
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function GetToolsRequestNotify(tools, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ tools }, ['tools'], 'mcp-get-tools')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "mcpnotify",
+        action: "getToolsRequest",
+        data: {
+            tools: tools
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'mcp-get-tools');
+}
+exports.GetToolsRequestNotify = GetToolsRequestNotify;
+/**
+ * Sends a get tools result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function GetToolsResultNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[McpNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "mcpnotify",
+        action: "getToolsResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'mcp-get-tools-result');
+}
+exports.GetToolsResultNotify = GetToolsResultNotify;
+// ===== EXECUTE TOOL FUNCTIONS =====
+/**
+ * Sends an execute tool request notification
+ * @param toolbox - The toolbox name
+ * @param toolName - The tool name to execute
+ * @param params - The parameters for the tool execution
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function ExecuteToolRequestNotify(toolbox, toolName, params, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ toolbox, toolName, params }, ['toolbox', 'toolName', 'params'], 'mcp-execute-tool')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "mcpnotify",
+        action: "executeToolRequest",
+        data: {
+            toolbox: toolbox,
+            toolName: toolName,
+            params: params
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'mcp-execute-tool');
+}
+exports.ExecuteToolRequestNotify = ExecuteToolRequestNotify;
+/**
+ * Sends an execute tool result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function ExecuteToolResultNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[McpNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "mcpnotify",
+        action: "executeToolResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'mcp-execute-tool-result');
+}
+exports.ExecuteToolResultNotify = ExecuteToolResultNotify;
+/**
+ * MCP notification functions object
+ */
+exports.mcpNotifications = {
+    GetEnabledMCPServersRequestNotify,
+    GetEnabledMCPServersResultNotify,
+    ListToolsFromMCPServersRequestNotify,
+    ListToolsFromMCPServersResultNotify,
+    GetToolsRequestNotify,
+    GetToolsResultNotify,
+    ExecuteToolRequestNotify,
+    ExecuteToolResultNotify
+};

package/dist/notificationfunctions/search.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Search Notification Functions
+ *
+ * This module provides functions for sending search-related notifications,
+ * including search initialization and query operations.
+ */
+import { SearchNotifications } from '../types/notificationFunctions/search';
+/**
+ * Sends a search init request notification
+ * @param engine - Optional search engine to initialize
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function SearchInitRequestNotify(engine?: string, toolUseId?: string): void;
+/**
+ * Sends a search init result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function SearchInitResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a search request notification
+ * @param query - The search query string
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function SearchRequestNotify(query: string, toolUseId?: string): void;
+/**
+ * Sends a search result notification
+ * @param content - The search result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function SearchResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a get first link request notification
+ * @param query - The search query to get the first link for
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GetFirstLinkRequestNotify(query: string, toolUseId?: string): void;
+/**
+ * Sends a get first link result notification
+ * @param content - The first link result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GetFirstLinkResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Search notification functions object
+ */
+export declare const searchNotifications: SearchNotifications;