wave-agent-sdk 0.0.1

package/dist/managers/bashManager.js

@@ -0,0 +1,66 @@
+import { spawn } from "child_process";
+import { addBashCommandToHistory } from "../utils/bashHistory.js";
+export class BashManager {
+    constructor(options) {
+        this.isCommandRunning = false;
+        this.currentProcess = null;
+        this.workdir = options.workdir;
+        this.messageManager = options.messageManager;
+    }
+    setCommandRunning(isRunning) {
+        this.isCommandRunning = isRunning;
+    }
+    async executeCommand(command) {
+        if (this.isCommandRunning) {
+            throw new Error("Command already running");
+        }
+        this.setCommandRunning(true);
+        // Add command output placeholder
+        this.messageManager.addCommandOutputMessage(command);
+        return new Promise((resolve) => {
+            const child = spawn(command, {
+                shell: true,
+                stdio: "pipe",
+                cwd: this.workdir,
+                env: {
+                    ...process.env,
+                },
+            });
+            this.currentProcess = child;
+            let outputBuffer = "";
+            const updateOutput = (newData) => {
+                outputBuffer += newData;
+                this.messageManager.updateCommandOutputMessage(command, outputBuffer);
+            };
+            child.stdout?.on("data", (data) => {
+                updateOutput(data.toString());
+            });
+            child.stderr?.on("data", (data) => {
+                updateOutput(data.toString());
+            });
+            child.on("exit", (code, signal) => {
+                const exitCode = code === null && signal ? 130 : (code ?? 0);
+                // Add command to bash history
+                addBashCommandToHistory(command, this.workdir);
+                this.messageManager.completeCommandMessage(command, exitCode);
+                this.setCommandRunning(false);
+                this.currentProcess = null;
+                resolve(exitCode);
+            });
+            child.on("error", (error) => {
+                updateOutput(`\nError: ${error.message}\n`);
+                this.messageManager.completeCommandMessage(command, 1);
+                this.setCommandRunning(false);
+                this.currentProcess = null;
+                resolve(1);
+            });
+        });
+    }
+    abortCommand() {
+        if (this.currentProcess && this.isCommandRunning) {
+            this.currentProcess.kill("SIGKILL");
+            this.currentProcess = null;
+            this.isCommandRunning = false;
+        }
+    }
+}

package/dist/managers/mcpManager.d.ts

@@ -0,0 +1,63 @@
+import { ChatCompletionFunctionTool } from "openai/resources.js";
+import type { ToolPlugin, ToolResult, ToolContext } from "../tools/types.js";
+import type { Logger, McpServerConfig, McpConfig, McpTool, McpServerStatus } from "../types.js";
+export interface McpManagerCallbacks {
+    onServersChange?: (servers: McpServerStatus[]) => void;
+}
+export interface McpManagerOptions {
+    callbacks?: McpManagerCallbacks;
+    logger?: Logger;
+}
+export declare class McpManager {
+    private config;
+    private servers;
+    private connections;
+    private configPath;
+    private workdir;
+    private callbacks;
+    private logger?;
+    constructor(options?: McpManagerOptions);
+    /**
+     * Initialize MCP manager with working directory and optionally auto-connect
+     */
+    initialize(workdir: string, autoConnect?: boolean): Promise<void>;
+    ensureConfigLoaded(): Promise<McpConfig | null>;
+    loadConfig(): Promise<McpConfig | null>;
+    saveConfig(config: McpConfig): Promise<boolean>;
+    getConfig(): McpConfig | null;
+    getAllServers(): McpServerStatus[];
+    getServer(name: string): McpServerStatus | undefined;
+    updateServerStatus(name: string, updates: Partial<McpServerStatus>): void;
+    addServer(name: string, config: McpServerConfig): boolean;
+    removeServer(name: string): boolean;
+    connectServer(name: string): Promise<boolean>;
+    disconnectServer(name: string): Promise<boolean>;
+    getAllConnectedTools(): McpTool[];
+    executeMcpTool(toolName: string, args: Record<string, unknown>): Promise<{
+        success: boolean;
+        content: string;
+        serverName?: string;
+        images?: Array<{
+            data: string;
+            mediaType?: string;
+        }>;
+    }>;
+    cleanup(): Promise<void>;
+    /**
+     * Get all currently available MCP tools as plugins
+     */
+    getMcpToolPlugins(): ToolPlugin[];
+    /**
+     * Get all currently available MCP tools as OpenAI function tools
+     */
+    getMcpToolsConfig(): ChatCompletionFunctionTool[];
+    /**
+     * Execute an MCP tool by name (registry version)
+     */
+    executeMcpToolByRegistry(name: string, args: Record<string, unknown>, context: ToolContext): Promise<ToolResult>;
+    /**
+     * Check if a tool name belongs to an MCP tool
+     */
+    isMcpTool(name: string): boolean;
+}
+//# sourceMappingURL=mcpManager.d.ts.map

package/dist/managers/mcpManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpManager.d.ts","sourceRoot":"","sources":["../../src/managers/mcpManager.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EACV,MAAM,EACN,eAAe,EACf,SAAS,EACT,OAAO,EACP,eAAe,EAChB,MAAM,aAAa,CAAC;AAQrB,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CACxD;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,OAAO,CAA2C;IAC1D,OAAO,CAAC,WAAW,CAAyC;IAC5D,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEZ,OAAO,GAAE,iBAAsB;IAK3C;;OAEG;IACG,UAAU,CACd,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,OAAe,GAC3B,OAAO,CAAC,IAAI,CAAC;IA4CV,kBAAkB,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAO/C,UAAU,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IA0CvC,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAWrD,SAAS,IAAI,SAAS,GAAG,IAAI;IAI7B,aAAa,IAAI,eAAe,EAAE;IAIlC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIpD,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI;IASzE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO;IAyBzD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAgB7B,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA4F7C,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA2BtD,oBAAoB,IAAI,OAAO,EAAE;IAW3B,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACtD,CAAC;IAoEI,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B;;OAEG;IACH,iBAAiB,IAAI,UAAU,EAAE;IAuBjC;;OAEG;IACH,iBAAiB,IAAI,0BAA0B,EAAE;IAIjD;;OAEG;IACG,wBAAwB,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC;IActB;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAIjC"}

package/dist/managers/mcpManager.js

@@ -0,0 +1,378 @@
+import { promises as fs } from "fs";
+import { join } from "path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { createMcpToolPlugin, findToolServer } from "../utils/mcpUtils.js";
+export class McpManager {
+    constructor(options = {}) {
+        this.config = null;
+        this.servers = new Map();
+        this.connections = new Map();
+        this.configPath = "";
+        this.workdir = "";
+        this.callbacks = options.callbacks || {};
+        this.logger = options.logger;
+    }
+    /**
+     * Initialize MCP manager with working directory and optionally auto-connect
+     */
+    async initialize(workdir, autoConnect = false) {
+        this.configPath = join(workdir, ".mcp.json");
+        this.workdir = workdir;
+        if (autoConnect) {
+            this.logger?.info("Initializing MCP servers...");
+            // Ensure MCP configuration is loaded
+            const config = await this.ensureConfigLoaded();
+            if (config && config.mcpServers) {
+                // Connect to all configured servers
+                const connectionPromises = Object.keys(config.mcpServers).map(async (serverName) => {
+                    try {
+                        this.logger?.info(`Connecting to MCP server: ${serverName}`);
+                        const success = await this.connectServer(serverName);
+                        if (success) {
+                            this.logger?.info(`Successfully connected to MCP server: ${serverName}`);
+                        }
+                        else {
+                            this.logger?.warn(`Failed to connect to MCP server: ${serverName}`);
+                        }
+                    }
+                    catch {
+                        this.logger?.error(`Error connecting to MCP server ${serverName}`);
+                    }
+                });
+                // Wait for all connection attempts to complete
+                await Promise.all(connectionPromises);
+            }
+            this.logger?.info("MCP servers initialization completed");
+            // Trigger state change callback after initialization
+            this.callbacks.onServersChange?.(this.getAllServers());
+        }
+    }
+    async ensureConfigLoaded() {
+        if (!this.config) {
+            return this.loadConfig();
+        }
+        return this.config;
+    }
+    async loadConfig() {
+        if (!this.configPath) {
+            this.logger?.warn("MCP config path not set. Call initialize() first.");
+            return null;
+        }
+        try {
+            const configContent = await fs.readFile(this.configPath, "utf-8");
+            this.config = JSON.parse(configContent);
+            // Initialize server statuses (preserve existing status for already known servers)
+            if (this.config) {
+                for (const [name, config] of Object.entries(this.config.mcpServers)) {
+                    const existingServer = this.servers.get(name);
+                    if (existingServer) {
+                        // Update config but preserve status and other runtime info
+                        this.servers.set(name, {
+                            ...existingServer,
+                            config, // Update config in case it changed
+                        });
+                    }
+                    else {
+                        // New server, initialize with disconnected status
+                        this.servers.set(name, {
+                            name,
+                            config,
+                            status: "disconnected",
+                        });
+                    }
+                }
+            }
+            return this.config;
+        }
+        catch (error) {
+            // Only log error if it's not a "file not found" error
+            if (error.code !== "ENOENT") {
+                this.logger?.error("Failed to load .mcp.json:", error);
+            }
+            return null;
+        }
+    }
+    async saveConfig(config) {
+        try {
+            await fs.writeFile(this.configPath, JSON.stringify(config, null, 2));
+            this.config = config;
+            return true;
+        }
+        catch (error) {
+            this.logger?.error("Failed to save .mcp.json:", error);
+            return false;
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+    getAllServers() {
+        return Array.from(this.servers.values());
+    }
+    getServer(name) {
+        return this.servers.get(name);
+    }
+    updateServerStatus(name, updates) {
+        const server = this.servers.get(name);
+        if (server) {
+            this.servers.set(name, { ...server, ...updates });
+            // Trigger state change callback
+            this.callbacks.onServersChange?.(this.getAllServers());
+        }
+    }
+    addServer(name, config) {
+        if (this.servers.has(name)) {
+            return false;
+        }
+        const newServer = {
+            name,
+            config,
+            status: "disconnected",
+        };
+        this.servers.set(name, newServer);
+        // Update config
+        if (this.config) {
+            this.config.mcpServers[name] = config;
+        }
+        else {
+            this.config = {
+                mcpServers: { [name]: config },
+            };
+        }
+        return true;
+    }
+    removeServer(name) {
+        // Disconnect if connected
+        if (this.connections.has(name)) {
+            this.disconnectServer(name);
+        }
+        const removed = this.servers.delete(name);
+        if (removed && this.config) {
+            delete this.config.mcpServers[name];
+        }
+        return removed;
+    }
+    // Real MCP connection implementation
+    async connectServer(name) {
+        const server = this.servers.get(name);
+        if (!server)
+            return false;
+        // Already connected
+        if (this.connections.has(name))
+            return true;
+        this.updateServerStatus(name, { status: "connecting" });
+        try {
+            // Create transport - it will manage the process
+            const transport = new StdioClientTransport({
+                command: server.config.command,
+                args: server.config.args || [],
+                env: server.config.env || {},
+                cwd: this.workdir, // Use the agent's workdir as the process working directory
+            });
+            // Create client
+            const client = new Client({
+                name: "wave-code",
+                version: "1.0.0",
+            }, {
+                capabilities: {
+                    tools: {},
+                },
+            });
+            // Handle transport errors
+            transport.onerror = (error) => {
+                this.logger?.error(`MCP Server ${name} transport error:`, error);
+                this.updateServerStatus(name, {
+                    status: "error",
+                    error: error.message,
+                });
+            };
+            transport.onclose = () => {
+                this.logger?.info(`MCP Server ${name} transport closed`);
+                this.connections.delete(name);
+                this.updateServerStatus(name, {
+                    status: "disconnected",
+                    tools: [],
+                    toolCount: 0,
+                });
+            };
+            // Connect to transport
+            await client.connect(transport);
+            // List available tools
+            const toolsResponse = await client.listTools();
+            const tools = toolsResponse.tools?.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+            })) || [];
+            // Store connection (we don't have direct process access with StdioClientTransport)
+            this.connections.set(name, {
+                client,
+                transport,
+                process: null, // StdioClientTransport manages the process internally
+            });
+            // Update status
+            this.updateServerStatus(name, {
+                status: "connected",
+                tools,
+                toolCount: tools.length,
+                capabilities: ["tools"],
+                lastConnected: Date.now(),
+                error: undefined,
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger?.error(`Failed to connect to MCP server ${name}:`, error);
+            // updateServerStatus will trigger the callback
+            this.updateServerStatus(name, {
+                status: "error",
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    async disconnectServer(name) {
+        const connection = this.connections.get(name);
+        if (!connection)
+            return false;
+        try {
+            // Close client connection and transport
+            await connection.client.close();
+            await connection.transport.close();
+            // Remove connection
+            this.connections.delete(name);
+            // updateServerStatus will trigger the callback
+            this.updateServerStatus(name, {
+                status: "disconnected",
+                tools: [],
+                toolCount: 0,
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger?.error(`Error disconnecting from MCP server ${name}:`, error);
+            return false;
+        }
+    }
+    // Get all tools from connected servers
+    getAllConnectedTools() {
+        const allTools = [];
+        for (const server of this.servers.values()) {
+            if (server.status === "connected" && server.tools) {
+                allTools.push(...server.tools);
+            }
+        }
+        return allTools;
+    }
+    // Execute MCP tool
+    async executeMcpTool(toolName, args) {
+        // Find which server has this tool
+        for (const [serverName, server] of this.servers.entries()) {
+            if (server.status === "connected" && server.tools) {
+                const tool = server.tools.find((t) => t.name === toolName);
+                if (tool) {
+                    const connection = this.connections.get(serverName);
+                    if (connection) {
+                        try {
+                            const result = await connection.client.callTool({
+                                name: toolName,
+                                arguments: args,
+                            });
+                            // Separate text content and image data
+                            const textContent = [];
+                            const images = [];
+                            if (Array.isArray(result.content)) {
+                                result.content.forEach((c) => {
+                                    if (c.type === "text") {
+                                        textContent.push(c.text || "");
+                                    }
+                                    else if (c.type === "image" && c.data) {
+                                        images.push({
+                                            data: c.data,
+                                            mediaType: "image/png", // Default to PNG, can be adjusted according to actual situation
+                                        });
+                                    }
+                                    else if (c.type === "resource") {
+                                        textContent.push(`[Resource: ${c.resource?.uri || ""}]`);
+                                    }
+                                    else {
+                                        textContent.push(JSON.stringify(c));
+                                    }
+                                });
+                            }
+                            else if (result.content) {
+                                textContent.push(String(result.content));
+                            }
+                            return {
+                                success: true,
+                                content: textContent.length > 0
+                                    ? textContent.join("\n")
+                                    : "No content",
+                                images: images.length > 0 ? images : undefined,
+                                serverName,
+                            };
+                        }
+                        catch (error) {
+                            throw new Error(`Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                }
+            }
+        }
+        throw new Error(`Tool ${toolName} not found on any connected MCP server`);
+    }
+    // Cleanup all connections
+    async cleanup() {
+        const disconnectPromises = Array.from(this.connections.keys()).map((name) => this.disconnectServer(name));
+        await Promise.all(disconnectPromises);
+    }
+    // ========== Tools Registry Methods ==========
+    /**
+     * Get all currently available MCP tools as plugins
+     */
+    getMcpToolPlugins() {
+        const mcpTools = new Map();
+        // Get all connected MCP tools
+        const connectedTools = this.getAllConnectedTools();
+        const servers = this.getAllServers();
+        // Find server name for each tool and create plugins
+        for (const tool of connectedTools) {
+            // Find which server this tool belongs to
+            const server = findToolServer(tool.name, servers);
+            if (server) {
+                const plugin = createMcpToolPlugin(tool, server.name, (name, args) => this.executeMcpTool(name, args));
+                mcpTools.set(tool.name, plugin);
+            }
+        }
+        return Array.from(mcpTools.values());
+    }
+    /**
+     * Get all currently available MCP tools as OpenAI function tools
+     */
+    getMcpToolsConfig() {
+        return this.getMcpToolPlugins().map((tool) => tool.config);
+    }
+    /**
+     * Execute an MCP tool by name (registry version)
+     */
+    async executeMcpToolByRegistry(name, args, context) {
+        const plugins = this.getMcpToolPlugins();
+        const tool = plugins.find((plugin) => plugin.name === name);
+        if (!tool) {
+            return {
+                success: false,
+                content: "",
+                error: `MCP tool '${name}' not found or server disconnected`,
+            };
+        }
+        return tool.execute(args, context);
+    }
+    /**
+     * Check if a tool name belongs to an MCP tool
+     */
+    isMcpTool(name) {
+        const connectedTools = this.getAllConnectedTools();
+        return connectedTools.some((tool) => tool.name === name);
+    }
+}

package/dist/managers/messageManager.d.ts

@@ -0,0 +1,85 @@
+import { type AgentToolBlockUpdateParams } from "../utils/messageOperations.js";
+import type { Logger, Message } from "../types.js";
+import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
+export interface MessageManagerCallbacks {
+    onMessagesChange?: (messages: Message[]) => void;
+    onSessionIdChange?: (sessionId: string) => void;
+    onLatestTotalTokensChange?: (latestTotalTokens: number) => void;
+    onUserInputHistoryChange?: (history: string[]) => void;
+    onUserMessageAdded?: (content: string, images?: Array<{
+        path: string;
+        mimeType: string;
+    }>) => void;
+    onAssistantMessageAdded?: (content?: string, toolCalls?: ChatCompletionMessageFunctionToolCall[]) => void;
+    onToolBlockUpdated?: (params: AgentToolBlockUpdateParams) => void;
+    onDiffBlockAdded?: (filePath: string, diffResult: string) => void;
+    onErrorBlockAdded?: (error: string) => void;
+    onCompressBlockAdded?: (insertIndex: number, content: string) => void;
+    onCompressionStateChange?: (isCompressing: boolean) => void;
+    onMemoryBlockAdded?: (content: string, success: boolean, type: "project" | "user", storagePath: string) => void;
+    onAddCommandOutputMessage?: (command: string) => void;
+    onUpdateCommandOutputMessage?: (command: string, output: string) => void;
+    onCompleteCommandMessage?: (command: string, exitCode: number) => void;
+}
+export interface MessageManagerOptions {
+    callbacks: MessageManagerCallbacks;
+    workdir: string;
+    logger?: Logger;
+}
+export declare class MessageManager {
+    private sessionId;
+    private messages;
+    private latestTotalTokens;
+    private userInputHistory;
+    private sessionStartTime;
+    private workdir;
+    private logger?;
+    private callbacks;
+    constructor(options: MessageManagerOptions);
+    getSessionId(): string;
+    getMessages(): Message[];
+    getlatestTotalTokens(): number;
+    getUserInputHistory(): string[];
+    getTranscriptPath(): string;
+    setSessionId(sessionId: string): void;
+    setMessages(messages: Message[]): void;
+    /**
+     * Save current session
+     */
+    saveSession(): Promise<void>;
+    /**
+     * Handle session restoration logic
+     */
+    handleSessionRestoration(restoreSessionId?: string, continueLastSession?: boolean): Promise<void>;
+    setlatestTotalTokens(latestTotalTokens: number): void;
+    setUserInputHistory(userInputHistory: string[]): void;
+    /**
+     * Clear messages and input history
+     */
+    clearMessages(): void;
+    initializeFromSession(sessionId: string, messages: Message[], latestTotalTokens: number): void;
+    addToInputHistory(input: string): void;
+    clearInputHistory(): void;
+    addUserMessage(content: string, images?: Array<{
+        path: string;
+        mimeType: string;
+    }>): void;
+    addCustomCommandMessage(commandName: string, content: string, originalInput?: string): void;
+    addAssistantMessage(content?: string, toolCalls?: ChatCompletionMessageFunctionToolCall[]): void;
+    updateToolBlock(params: AgentToolBlockUpdateParams): void;
+    addDiffBlock(filePath: string, diffResult: Array<{
+        value: string;
+        added?: boolean;
+        removed?: boolean;
+    }>): void;
+    addErrorBlock(error: string): void;
+    /**
+     * Compress messages and update session, delete compressed messages, only keep compressed messages and subsequent messages
+     */
+    compressMessagesAndUpdateSession(insertIndex: number, compressedContent: string): void;
+    addMemoryBlock(content: string, success: boolean, type: "project" | "user", storagePath: string): void;
+    addCommandOutputMessage(command: string): void;
+    updateCommandOutputMessage(command: string, output: string): void;
+    completeCommandMessage(command: string, exitCode: number): void;
+}
+//# sourceMappingURL=messageManager.d.ts.map

package/dist/managers/messageManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageManager.d.ts","sourceRoot":"","sources":["../../src/managers/messageManager.ts"],"names":[],"mappings":"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"}