@herdctl/core 4.2.0 → 5.0.0

package/dist/fleet-manager/discord-manager.js

@@ -1,1087 +0,0 @@
-/**
- * Discord Manager Module
- *
- * Manages Discord connectors for agents that have `chat.discord` configured.
- * This module is responsible for:
- * - Creating one DiscordConnector instance per Discord-enabled agent
- * - Managing connector lifecycle (start/stop)
- * - Providing access to connectors for status queries
- *
- * Note: This module dynamically imports @herdctl/discord at runtime to avoid
- * a hard dependency. The @herdctl/core package can be used without Discord support.
- *
- * @module discord-manager
- */
-/**
- * Lazy import the Discord package to avoid hard dependency
- * This allows @herdctl/core to be used without @herdctl/discord installed
- */
-async function importDiscordPackage() {
-    try {
-        // Dynamic import - will be resolved at runtime
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const pkg = (await import("@herdctl/discord"));
-        return pkg;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * StreamingResponder handles incremental message delivery to Discord
- *
- * Instead of collecting all output and sending at the end, this class:
- * - Buffers incoming content
- * - Sends messages as complete chunks arrive (detected by double newlines or size)
- * - Respects rate limits by enforcing minimum intervals between sends
- * - Handles message splitting for content exceeding Discord's 2000 char limit
- */
-class StreamingResponder {
-    buffer = "";
-    lastSendTime = 0;
-    messagesSent = 0;
-    reply;
-    splitResponse;
-    logger;
-    agentName;
-    minMessageInterval;
-    maxBufferSize;
-    constructor(options) {
-        this.reply = options.reply;
-        this.splitResponse = options.splitResponse;
-        this.logger = options.logger;
-        this.agentName = options.agentName;
-        this.minMessageInterval = options.minMessageInterval ?? 1000; // 1 second default
-        this.maxBufferSize = options.maxBufferSize ?? 1500; // Leave room for Discord's 2000 limit
-    }
-    /**
-     * Add a complete message and send it immediately (with rate limiting)
-     *
-     * Use this for complete assistant message turns from the SDK.
-     * Each assistant message is a complete response that should be sent.
-     */
-    async addMessageAndSend(content) {
-        if (!content || content.trim().length === 0) {
-            return;
-        }
-        // Add to any existing buffer (in case there's leftover content)
-        this.buffer += content;
-        // Send everything in the buffer
-        await this.sendAll();
-    }
-    /**
-     * Send all buffered content immediately (with rate limiting)
-     */
-    async sendAll() {
-        if (this.buffer.trim().length === 0) {
-            return;
-        }
-        const content = this.buffer.trim();
-        this.buffer = "";
-        // Respect rate limiting - wait if needed
-        const now = Date.now();
-        const timeSinceLastSend = now - this.lastSendTime;
-        if (timeSinceLastSend < this.minMessageInterval && this.lastSendTime > 0) {
-            const waitTime = this.minMessageInterval - timeSinceLastSend;
-            await this.sleep(waitTime);
-        }
-        // Split if needed for Discord's limit
-        const chunks = this.splitResponse(content);
-        for (const chunk of chunks) {
-            try {
-                await this.reply(chunk);
-                this.messagesSent++;
-                this.lastSendTime = Date.now();
-                this.logger.debug(`Streamed message to Discord`, {
-                    agentName: this.agentName,
-                    chunkLength: chunk.length,
-                    totalSent: this.messagesSent,
-                });
-                // Small delay between multiple chunks from same content
-                if (chunks.length > 1) {
-                    await this.sleep(500);
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                this.logger.error(`Failed to send Discord message`, {
-                    agentName: this.agentName,
-                    error: errorMessage,
-                });
-                throw error;
-            }
-        }
-    }
-    /**
-     * Flush any remaining content in the buffer
-     */
-    async flush() {
-        await this.sendAll();
-    }
-    /**
-     * Check if any messages have been sent
-     */
-    hasSentMessages() {
-        return this.messagesSent > 0;
-    }
-    /**
-     * Sleep for a given number of milliseconds
-     */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-}
-// =============================================================================
-// Discord Manager
-// =============================================================================
-/**
- * DiscordManager handles Discord connections for agents
- *
- * This class encapsulates the creation and lifecycle management of
- * DiscordConnector instances for agents that have Discord chat configured.
- */
-export class DiscordManager {
-    ctx;
-    connectors = new Map();
-    initialized = false;
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    /**
-     * Initialize Discord connectors for all configured agents
-     *
-     * This method:
-     * 1. Checks if @herdctl/discord package is available
-     * 2. Iterates through agents to find those with Discord configured
-     * 3. Creates a DiscordConnector for each Discord-enabled agent
-     *
-     * Should be called during FleetManager initialization.
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        const logger = this.ctx.getLogger();
-        const config = this.ctx.getConfig();
-        if (!config) {
-            logger.debug("No config available, skipping Discord initialization");
-            return;
-        }
-        // Try to import the discord package
-        const discordPkg = await importDiscordPackage();
-        if (!discordPkg) {
-            logger.debug("@herdctl/discord not installed, skipping Discord connectors");
-            return;
-        }
-        const { DiscordConnector, SessionManager } = discordPkg;
-        const stateDir = this.ctx.getStateDir();
-        // Find agents with Discord configured
-        const discordAgents = config.agents.filter((agent) => agent.chat?.discord !== undefined);
-        if (discordAgents.length === 0) {
-            logger.debug("No agents with Discord configured");
-            this.initialized = true;
-            return;
-        }
-        logger.debug(`Initializing Discord connectors for ${discordAgents.length} agent(s)`);
-        for (const agent of discordAgents) {
-            try {
-                const discordConfig = agent.chat.discord;
-                if (!discordConfig)
-                    continue;
-                // Get bot token from environment variable
-                const botToken = process.env[discordConfig.bot_token_env];
-                if (!botToken) {
-                    logger.warn(`Discord bot token not found in environment variable '${discordConfig.bot_token_env}' for agent '${agent.name}'`);
-                    continue;
-                }
-                // Create logger adapter for this agent
-                const createAgentLogger = (prefix) => ({
-                    debug: (msg, data) => logger.debug(`${prefix} ${msg}${data ? ` ${JSON.stringify(data)}` : ""}`),
-                    info: (msg, data) => logger.info(`${prefix} ${msg}${data ? ` ${JSON.stringify(data)}` : ""}`),
-                    warn: (msg, data) => logger.warn(`${prefix} ${msg}${data ? ` ${JSON.stringify(data)}` : ""}`),
-                    error: (msg, data) => logger.error(`${prefix} ${msg}${data ? ` ${JSON.stringify(data)}` : ""}`),
-                });
-                // Create session manager for this agent
-                const sessionManager = new SessionManager({
-                    agentName: agent.name,
-                    stateDir,
-                    sessionExpiryHours: discordConfig.session_expiry_hours,
-                    logger: createAgentLogger(`[discord:${agent.name}:session]`),
-                });
-                // Create the connector
-                // Note: FleetManager is passed via ctx.getEmitter() which returns the FleetManager instance
-                const connector = new DiscordConnector({
-                    agentConfig: agent,
-                    discordConfig,
-                    botToken,
-                    // The context's getEmitter() returns the FleetManager instance (which extends EventEmitter)
-                    fleetManager: this.ctx.getEmitter(),
-                    sessionManager,
-                    stateDir,
-                    logger: createAgentLogger(`[discord:${agent.name}]`),
-                });
-                this.connectors.set(agent.name, connector);
-                logger.debug(`Created Discord connector for agent '${agent.name}'`);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error(`Failed to create Discord connector for agent '${agent.name}': ${errorMessage}`);
-                // Continue with other agents - don't fail the whole initialization
-            }
-        }
-        this.initialized = true;
-        logger.debug(`Discord manager initialized with ${this.connectors.size} connector(s)`);
-    }
-    /**
-     * Connect all Discord connectors
-     *
-     * Connects each connector to the Discord gateway and subscribes to events.
-     * Errors are logged but don't stop other connectors from connecting.
-     */
-    async start() {
-        const logger = this.ctx.getLogger();
-        if (this.connectors.size === 0) {
-            logger.debug("No Discord connectors to start");
-            return;
-        }
-        logger.debug(`Starting ${this.connectors.size} Discord connector(s)...`);
-        const connectPromises = [];
-        for (const [agentName, connector] of this.connectors) {
-            // Subscribe to connector events before connecting
-            connector.on("message", (event) => {
-                this.handleMessage(agentName, event).catch((error) => {
-                    this.handleError(agentName, error);
-                });
-            });
-            connector.on("error", (event) => {
-                this.handleError(agentName, event.error);
-            });
-            connectPromises.push(connector.connect().catch((error) => {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error(`Failed to connect Discord for agent '${agentName}': ${errorMessage}`);
-                // Don't re-throw - we want to continue connecting other agents
-            }));
-        }
-        await Promise.all(connectPromises);
-        const connectedCount = Array.from(this.connectors.values()).filter((c) => c.isConnected()).length;
-        logger.info(`Discord connectors started: ${connectedCount}/${this.connectors.size} connected`);
-    }
-    /**
-     * Disconnect all Discord connectors gracefully
-     *
-     * Sessions are automatically persisted to disk on every update,
-     * so they survive bot restarts. This method logs session state
-     * before disconnecting for monitoring purposes.
-     *
-     * Errors are logged but don't prevent other connectors from disconnecting.
-     */
-    async stop() {
-        const logger = this.ctx.getLogger();
-        if (this.connectors.size === 0) {
-            logger.debug("No Discord connectors to stop");
-            return;
-        }
-        logger.debug(`Stopping ${this.connectors.size} Discord connector(s)...`);
-        // Log session state before shutdown (sessions are already persisted to disk)
-        for (const [agentName, connector] of this.connectors) {
-            try {
-                const activeSessionCount = await connector.sessionManager.getActiveSessionCount();
-                if (activeSessionCount > 0) {
-                    logger.debug(`Preserving ${activeSessionCount} active session(s) for agent '${agentName}'`);
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.warn(`Failed to get session count for agent '${agentName}': ${errorMessage}`);
-                // Continue with shutdown - this is just informational logging
-            }
-        }
-        const disconnectPromises = [];
-        for (const [agentName, connector] of this.connectors) {
-            disconnectPromises.push(connector.disconnect().catch((error) => {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error(`Error disconnecting Discord for agent '${agentName}': ${errorMessage}`);
-                // Don't re-throw - graceful shutdown should continue
-            }));
-        }
-        await Promise.all(disconnectPromises);
-        logger.debug("All Discord connectors stopped");
-    }
-    /**
-     * Get a connector for a specific agent
-     *
-     * @param agentName - Name of the agent
-     * @returns The DiscordConnector instance, or undefined if not found
-     */
-    getConnector(agentName) {
-        return this.connectors.get(agentName);
-    }
-    /**
-     * Get all connector names
-     *
-     * @returns Array of agent names that have Discord connectors
-     */
-    getConnectorNames() {
-        return Array.from(this.connectors.keys());
-    }
-    /**
-     * Get the number of active connectors
-     *
-     * @returns Number of connectors that are currently connected
-     */
-    getConnectedCount() {
-        return Array.from(this.connectors.values()).filter((c) => c.isConnected()).length;
-    }
-    /**
-     * Check if a specific agent has a Discord connector
-     *
-     * @param agentName - Name of the agent
-     * @returns true if the agent has a Discord connector
-     */
-    hasConnector(agentName) {
-        return this.connectors.has(agentName);
-    }
-    // ===========================================================================
-    // Message Handling Pipeline
-    // ===========================================================================
-    /**
-     * Handle an incoming Discord message
-     *
-     * This method:
-     * 1. Gets or creates a session for the channel
-     * 2. Builds job context from the message
-     * 3. Executes the job via trigger
-     * 4. Sends the response back to Discord
-     *
-     * @param agentName - Name of the agent handling the message
-     * @param event - The Discord message event
-     */
-    async handleMessage(agentName, event) {
-        const logger = this.ctx.getLogger();
-        const emitter = this.ctx.getEmitter();
-        logger.info(`Discord message for agent '${agentName}': ${event.prompt.substring(0, 50)}...`);
-        // Get the agent configuration
-        const config = this.ctx.getConfig();
-        const agent = config?.agents.find((a) => a.name === agentName);
-        if (!agent) {
-            logger.error(`Agent '${agentName}' not found in configuration`);
-            try {
-                await event.reply("Sorry, I'm not properly configured. Please contact an administrator.");
-            }
-            catch (replyError) {
-                logger.error(`Failed to send error reply: ${replyError.message}`);
-            }
-            return;
-        }
-        // Get output configuration (with defaults)
-        const outputConfig = agent.chat?.discord?.output ?? {
-            tool_results: true,
-            tool_result_max_length: 900,
-            system_status: true,
-            result_summary: false,
-            errors: true,
-        };
-        // Get existing session for this channel (for conversation continuity)
-        const connector = this.connectors.get(agentName);
-        let existingSessionId;
-        if (connector) {
-            try {
-                const existingSession = await connector.sessionManager.getSession(event.metadata.channelId);
-                if (existingSession) {
-                    existingSessionId = existingSession.sessionId;
-                    logger.debug(`Resuming session for channel ${event.metadata.channelId}: ${existingSessionId}`);
-                }
-                else {
-                    logger.debug(`No existing session for channel ${event.metadata.channelId}, starting new conversation`);
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.warn(`Failed to get session: ${errorMessage}`);
-                // Continue processing - session failure shouldn't block message handling
-            }
-        }
-        // Create streaming responder for incremental message delivery
-        // StreamingResponder only sends text, so narrow the reply type
-        const streamer = new StreamingResponder({
-            reply: (content) => event.reply(content),
-            splitResponse: (text) => this.splitResponse(text),
-            logger,
-            agentName,
-        });
-        // Start typing indicator while processing
-        const stopTyping = event.startTyping();
-        // Track if we've stopped typing to avoid multiple calls
-        let typingStopped = false;
-        try {
-            // Import FleetManager dynamically to avoid circular dependency
-            // The context's getEmitter() returns the FleetManager instance
-            const fleetManager = emitter;
-            // Track pending tool_use blocks so we can pair them with results
-            const pendingToolUses = new Map();
-            let embedsSent = 0;
-            // Execute job via FleetManager.trigger()
-            // Pass resume option for conversation continuity
-            // The onMessage callback streams output incrementally to Discord
-            const result = await fleetManager.trigger(agentName, undefined, {
-                prompt: event.prompt,
-                resume: existingSessionId,
-                onMessage: async (message) => {
-                    // Extract text content from assistant messages and stream to Discord
-                    if (message.type === "assistant") {
-                        const content = this.extractMessageContent(message);
-                        if (content) {
-                            // Each assistant message is a complete turn - send immediately
-                            await streamer.addMessageAndSend(content);
-                        }
-                        // Track tool_use blocks for pairing with results later
-                        const toolUseBlocks = this.extractToolUseBlocks(message);
-                        for (const block of toolUseBlocks) {
-                            if (block.id) {
-                                pendingToolUses.set(block.id, {
-                                    name: block.name,
-                                    input: block.input,
-                                    startTime: Date.now(),
-                                });
-                            }
-                        }
-                    }
-                    // Build and send embeds for tool results
-                    if (message.type === "user" && outputConfig.tool_results) {
-                        const toolResults = this.extractToolResults(message);
-                        for (const toolResult of toolResults) {
-                            // Look up the matching tool_use for name, input, and timing
-                            const toolUse = toolResult.toolUseId
-                                ? pendingToolUses.get(toolResult.toolUseId)
-                                : undefined;
-                            if (toolResult.toolUseId) {
-                                pendingToolUses.delete(toolResult.toolUseId);
-                            }
-                            const embed = this.buildToolEmbed(toolUse ?? null, toolResult, outputConfig.tool_result_max_length);
-                            // Flush any buffered text before sending embed to preserve ordering
-                            await streamer.flush();
-                            await event.reply({ embeds: [embed] });
-                            embedsSent++;
-                        }
-                    }
-                    // Show system status messages (e.g., "compacting context...")
-                    if (message.type === "system" && outputConfig.system_status) {
-                        if (message.subtype === "status" && message.status) {
-                            const statusText = message.status === "compacting"
-                                ? "Compacting context..."
-                                : `Status: ${message.status}`;
-                            await streamer.flush();
-                            await event.reply({
-                                embeds: [{
-                                        title: "\u2699\uFE0F System",
-                                        description: statusText,
-                                        color: DiscordManager.EMBED_COLOR_SYSTEM,
-                                    }],
-                            });
-                            embedsSent++;
-                        }
-                    }
-                    // Show result summary embed (cost, tokens, turns)
-                    if (message.type === "result" && outputConfig.result_summary) {
-                        const fields = [];
-                        if (message.duration_ms !== undefined) {
-                            fields.push({
-                                name: "Duration",
-                                value: DiscordManager.formatDuration(message.duration_ms),
-                                inline: true,
-                            });
-                        }
-                        if (message.num_turns !== undefined) {
-                            fields.push({
-                                name: "Turns",
-                                value: String(message.num_turns),
-                                inline: true,
-                            });
-                        }
-                        if (message.total_cost_usd !== undefined) {
-                            fields.push({
-                                name: "Cost",
-                                value: `$${message.total_cost_usd.toFixed(4)}`,
-                                inline: true,
-                            });
-                        }
-                        if (message.usage) {
-                            const inputTokens = message.usage.input_tokens ?? 0;
-                            const outputTokens = message.usage.output_tokens ?? 0;
-                            fields.push({
-                                name: "Tokens",
-                                value: `${inputTokens.toLocaleString()} in / ${outputTokens.toLocaleString()} out`,
-                                inline: true,
-                            });
-                        }
-                        const isError = message.is_error === true;
-                        await streamer.flush();
-                        await event.reply({
-                            embeds: [{
-                                    title: isError ? "\u274C Task Failed" : "\u2705 Task Complete",
-                                    color: isError ? DiscordManager.EMBED_COLOR_ERROR : DiscordManager.EMBED_COLOR_SUCCESS,
-                                    fields,
-                                }],
-                        });
-                        embedsSent++;
-                    }
-                    // Show SDK error messages
-                    if (message.type === "error" && outputConfig.errors) {
-                        const errorText = typeof message.content === "string"
-                            ? message.content
-                            : "An unknown error occurred";
-                        await streamer.flush();
-                        await event.reply({
-                            embeds: [{
-                                    title: "\u274C Error",
-                                    description: errorText.length > 4000 ? errorText.substring(0, 4000) + "..." : errorText,
-                                    color: DiscordManager.EMBED_COLOR_ERROR,
-                                }],
-                        });
-                        embedsSent++;
-                    }
-                },
-            });
-            // Stop typing indicator immediately after SDK execution completes
-            // This prevents the interval from firing during flush/session storage
-            if (!typingStopped) {
-                stopTyping();
-                typingStopped = true;
-            }
-            // Flush any remaining buffered content
-            await streamer.flush();
-            logger.debug(`Discord job completed: ${result.jobId} for agent '${agentName}'${result.sessionId ? ` (session: ${result.sessionId})` : ""}`);
-            // If no messages were sent (text or embeds), send an appropriate fallback
-            if (!streamer.hasSentMessages() && embedsSent === 0) {
-                if (result.success) {
-                    await event.reply("I've completed the task, but I don't have a specific response to share.");
-                }
-                else {
-                    // Job failed without streaming any messages - send error details
-                    const errorMessage = result.errorDetails?.message ?? result.error?.message ?? "An unknown error occurred";
-                    await event.reply(`❌ **Error:** ${errorMessage}\n\nThe task could not be completed. Please check the logs for more details.`);
-                }
-                // Stop typing after sending fallback message (if not already stopped)
-                if (!typingStopped) {
-                    stopTyping();
-                    typingStopped = true;
-                }
-            }
-            // Store the SDK session ID for future conversation continuity
-            // Only store if the job succeeded - failed jobs may return invalid session IDs
-            if (connector && result.sessionId && result.success) {
-                try {
-                    await connector.sessionManager.setSession(event.metadata.channelId, result.sessionId);
-                    logger.debug(`Stored session ${result.sessionId} for channel ${event.metadata.channelId}`);
-                }
-                catch (sessionError) {
-                    const errorMessage = sessionError instanceof Error ? sessionError.message : String(sessionError);
-                    logger.warn(`Failed to store session: ${errorMessage}`);
-                    // Don't fail the message handling for session storage failure
-                }
-            }
-            else if (connector && result.sessionId && !result.success) {
-                logger.debug(`Not storing session ${result.sessionId} for channel ${event.metadata.channelId} - job failed`);
-            }
-            // Emit event for tracking
-            emitter.emit("discord:message:handled", {
-                agentName,
-                channelId: event.metadata.channelId,
-                messageId: event.metadata.messageId,
-                jobId: result.jobId,
-                timestamp: new Date().toISOString(),
-            });
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            logger.error(`Discord message handling failed for agent '${agentName}': ${err.message}`);
-            // Send user-friendly error message using the formatted error method
-            try {
-                await event.reply(this.formatErrorMessage(err));
-            }
-            catch (replyError) {
-                logger.error(`Failed to send error reply: ${replyError.message}`);
-            }
-            // Emit error event for tracking
-            emitter.emit("discord:message:error", {
-                agentName,
-                channelId: event.metadata.channelId,
-                messageId: event.metadata.messageId,
-                error: err.message,
-                timestamp: new Date().toISOString(),
-            });
-        }
-        finally {
-            // Safety net: stop typing indicator if not already stopped
-            // (Should already be stopped after sending messages, but this ensures cleanup on errors)
-            if (!typingStopped) {
-                stopTyping();
-            }
-        }
-    }
-    /**
-     * Extract text content from an SDK message
-     *
-     * Handles various message formats from the Claude Agent SDK
-     */
-    extractMessageContent(message) {
-        // Check for direct content
-        if (typeof message.content === "string" && message.content) {
-            return message.content;
-        }
-        // Check for nested message content (SDK structure)
-        const apiMessage = message.message;
-        const content = apiMessage?.content;
-        if (!content)
-            return undefined;
-        // If it's a string, return directly
-        if (typeof content === "string") {
-            return content;
-        }
-        // If it's an array of content blocks, extract text
-        if (Array.isArray(content)) {
-            const textParts = [];
-            for (const block of content) {
-                if (block && typeof block === "object" && "type" in block) {
-                    if (block.type === "text" && "text" in block && typeof block.text === "string") {
-                        textParts.push(block.text);
-                    }
-                }
-            }
-            return textParts.length > 0 ? textParts.join("") : undefined;
-        }
-        return undefined;
-    }
-    // =============================================================================
-    // Tool Embed Support
-    // =============================================================================
-    /** Maximum characters for tool output in Discord embed fields */
-    static TOOL_OUTPUT_MAX_CHARS = 900;
-    /** Embed colors */
-    static EMBED_COLOR_DEFAULT = 0x5865f2; // Discord blurple
-    static EMBED_COLOR_ERROR = 0xef4444; // Red
-    static EMBED_COLOR_SYSTEM = 0x95a5a6; // Gray
-    static EMBED_COLOR_SUCCESS = 0x57f287; // Green
-    /** Tool title emojis */
-    static TOOL_EMOJIS = {
-        Bash: "\u{1F4BB}", // laptop
-        bash: "\u{1F4BB}",
-        Read: "\u{1F4C4}", // page
-        Write: "\u{270F}\u{FE0F}", // pencil
-        Edit: "\u{270F}\u{FE0F}",
-        Glob: "\u{1F50D}", // magnifying glass
-        Grep: "\u{1F50D}",
-        WebFetch: "\u{1F310}", // globe
-        WebSearch: "\u{1F310}",
-    };
-    /**
-     * Extract tool_use blocks from an assistant message's content blocks
-     *
-     * Returns id, name, and input for each tool_use block so we can
-     * track pending calls and pair them with results.
-     */
-    extractToolUseBlocks(message) {
-        const apiMessage = message.message;
-        const content = apiMessage?.content;
-        if (!Array.isArray(content))
-            return [];
-        const blocks = [];
-        for (const block of content) {
-            if (block &&
-                typeof block === "object" &&
-                "type" in block &&
-                block.type === "tool_use" &&
-                "name" in block &&
-                typeof block.name === "string") {
-                blocks.push({
-                    id: "id" in block && typeof block.id === "string" ? block.id : undefined,
-                    name: block.name,
-                    input: "input" in block ? block.input : undefined,
-                });
-            }
-        }
-        return blocks;
-    }
-    /**
-     * Get a human-readable summary of tool input
-     */
-    getToolInputSummary(name, input) {
-        const inputObj = input;
-        if (name === "Bash" || name === "bash") {
-            const command = inputObj?.command;
-            if (typeof command === "string" && command.length > 0) {
-                return command.length > 200 ? command.substring(0, 200) + "..." : command;
-            }
-        }
-        if (name === "Read" || name === "Write" || name === "Edit") {
-            const path = inputObj?.file_path ?? inputObj?.path;
-            if (typeof path === "string")
-                return path;
-        }
-        if (name === "Glob" || name === "Grep") {
-            const pattern = inputObj?.pattern;
-            if (typeof pattern === "string")
-                return pattern;
-        }
-        if (name === "WebFetch" || name === "WebSearch") {
-            const url = inputObj?.url;
-            const query = inputObj?.query;
-            if (typeof url === "string")
-                return url;
-            if (typeof query === "string")
-                return query;
-        }
-        return undefined;
-    }
-    /**
-     * Extract tool results from a user message
-     *
-     * Returns output, error status, and the tool_use_id for matching
-     * to the pending tool_use that produced this result.
-     */
-    extractToolResults(message) {
-        const results = [];
-        // Check for top-level tool_use_result (direct SDK format)
-        if (message.tool_use_result !== undefined) {
-            const extracted = this.extractToolResultContent(message.tool_use_result);
-            if (extracted) {
-                results.push(extracted);
-            }
-            return results;
-        }
-        // Check for content blocks in nested message
-        const apiMessage = message.message;
-        const content = apiMessage?.content;
-        if (!Array.isArray(content))
-            return results;
-        for (const block of content) {
-            if (!block || typeof block !== "object" || !("type" in block))
-                continue;
-            if (block.type === "tool_result") {
-                const toolResultBlock = block;
-                const isError = toolResultBlock.is_error === true;
-                const toolUseId = typeof toolResultBlock.tool_use_id === "string"
-                    ? toolResultBlock.tool_use_id
-                    : undefined;
-                // Content can be a string or an array of content blocks
-                const blockContent = toolResultBlock.content;
-                if (typeof blockContent === "string" && blockContent.length > 0) {
-                    results.push({ output: blockContent, isError, toolUseId });
-                }
-                else if (Array.isArray(blockContent)) {
-                    const textParts = [];
-                    for (const part of blockContent) {
-                        if (part &&
-                            typeof part === "object" &&
-                            "type" in part &&
-                            part.type === "text" &&
-                            "text" in part &&
-                            typeof part.text === "string") {
-                            textParts.push(part.text);
-                        }
-                    }
-                    if (textParts.length > 0) {
-                        results.push({ output: textParts.join("\n"), isError, toolUseId });
-                    }
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Extract content from a top-level tool_use_result value
-     */
-    extractToolResultContent(result) {
-        if (typeof result === "string" && result.length > 0) {
-            return { output: result, isError: false };
-        }
-        if (result && typeof result === "object") {
-            const obj = result;
-            // Check for content field
-            if (typeof obj.content === "string" && obj.content.length > 0) {
-                return {
-                    output: obj.content,
-                    isError: obj.is_error === true,
-                    toolUseId: typeof obj.tool_use_id === "string" ? obj.tool_use_id : undefined,
-                };
-            }
-            // Check for content blocks array
-            if (Array.isArray(obj.content)) {
-                const textParts = [];
-                for (const block of obj.content) {
-                    if (block &&
-                        typeof block === "object" &&
-                        "type" in block &&
-                        block.type === "text" &&
-                        "text" in block &&
-                        typeof block.text === "string") {
-                        textParts.push(block.text);
-                    }
-                }
-                if (textParts.length > 0) {
-                    return {
-                        output: textParts.join("\n"),
-                        isError: obj.is_error === true,
-                        toolUseId: typeof obj.tool_use_id === "string" ? obj.tool_use_id : undefined,
-                    };
-                }
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Format duration in milliseconds to a human-readable string
-     */
-    static formatDuration(ms) {
-        if (ms < 1000)
-            return `${ms}ms`;
-        const seconds = Math.floor(ms / 1000);
-        if (seconds < 60)
-            return `${seconds}s`;
-        const minutes = Math.floor(seconds / 60);
-        const remainingSeconds = seconds % 60;
-        return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
-    }
-    /**
-     * Build a Discord embed for a tool call result
-     *
-     * Combines the tool_use info (name, input) with the tool_result
-     * (output, error status) into a compact Discord embed.
-     *
-     * @param toolUse - The tool_use block info (name, input, startTime)
-     * @param toolResult - The tool result (output, isError)
-     * @param maxOutputChars - Maximum characters for output (defaults to TOOL_OUTPUT_MAX_CHARS)
-     */
-    buildToolEmbed(toolUse, toolResult, maxOutputChars) {
-        const toolName = toolUse?.name ?? "Tool";
-        const emoji = DiscordManager.TOOL_EMOJIS[toolName] ?? "\u{1F527}"; // wrench fallback
-        const isError = toolResult.isError;
-        // Build description from input summary
-        const inputSummary = toolUse ? this.getToolInputSummary(toolUse.name, toolUse.input) : undefined;
-        let description;
-        if (inputSummary) {
-            if (toolName === "Bash" || toolName === "bash") {
-                description = `\`> ${inputSummary}\``;
-            }
-            else {
-                description = `\`${inputSummary}\``;
-            }
-        }
-        // Build inline fields
-        const fields = [];
-        if (toolUse) {
-            const durationMs = Date.now() - toolUse.startTime;
-            fields.push({
-                name: "Duration",
-                value: DiscordManager.formatDuration(durationMs),
-                inline: true,
-            });
-        }
-        const outputLength = toolResult.output.length;
-        fields.push({
-            name: "Output",
-            value: outputLength >= 1000
-                ? `${(outputLength / 1000).toFixed(1)}k chars`
-                : `${outputLength} chars`,
-            inline: true,
-        });
-        // Add truncated output as a field if non-empty
-        const trimmedOutput = toolResult.output.trim();
-        if (trimmedOutput.length > 0) {
-            const maxChars = maxOutputChars ?? DiscordManager.TOOL_OUTPUT_MAX_CHARS;
-            let outputText = trimmedOutput;
-            if (outputText.length > maxChars) {
-                outputText = outputText.substring(0, maxChars) + `\n... (${outputLength.toLocaleString()} chars total)`;
-            }
-            fields.push({
-                name: isError ? "Error" : "Result",
-                value: `\`\`\`\n${outputText}\n\`\`\``,
-                inline: false,
-            });
-        }
-        return {
-            title: `${emoji} ${toolName}`,
-            description,
-            color: isError ? DiscordManager.EMBED_COLOR_ERROR : DiscordManager.EMBED_COLOR_DEFAULT,
-            fields,
-        };
-    }
-    /**
-     * Handle errors from Discord connectors
-     *
-     * Logs errors without crashing the connector
-     *
-     * @param agentName - Name of the agent that encountered the error
-     * @param error - The error that occurred
-     */
-    handleError(agentName, error) {
-        const logger = this.ctx.getLogger();
-        const emitter = this.ctx.getEmitter();
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error(`Discord connector error for agent '${agentName}': ${errorMessage}`);
-        // Emit error event for monitoring
-        emitter.emit("discord:error", {
-            agentName,
-            error: errorMessage,
-            timestamp: new Date().toISOString(),
-        });
-    }
-    // ===========================================================================
-    // Response Formatting and Splitting
-    // ===========================================================================
-    /** Discord's maximum message length */
-    static MAX_MESSAGE_LENGTH = 2000;
-    /**
-     * Format an error message for Discord display
-     *
-     * Creates a user-friendly error message with guidance on how to proceed.
-     *
-     * @param error - The error that occurred
-     * @returns Formatted error message string
-     */
-    formatErrorMessage(error) {
-        return `❌ **Error**: ${error.message}\n\nPlease try again or use \`/reset\` to start a new session.`;
-    }
-    /**
-     * Split a response into chunks that fit Discord's 2000 character limit
-     *
-     * This method intelligently splits text:
-     * - Preserves code blocks when possible (closing and reopening across chunks)
-     * - Splits at natural boundaries (newlines, then spaces)
-     * - Never splits mid-word
-     *
-     * @param text - The text to split
-     * @returns Array of text chunks, each under 2000 characters
-     */
-    splitResponse(text) {
-        const MAX_LENGTH = DiscordManager.MAX_MESSAGE_LENGTH;
-        // If text fits in one message, return as-is
-        if (text.length <= MAX_LENGTH) {
-            return [text];
-        }
-        const chunks = [];
-        let remaining = text;
-        while (remaining.length > 0) {
-            if (remaining.length <= MAX_LENGTH) {
-                chunks.push(remaining);
-                break;
-            }
-            // Find the best split point
-            const { chunk, rest } = this.findSplitPoint(remaining, MAX_LENGTH);
-            chunks.push(chunk);
-            remaining = rest;
-        }
-        return chunks;
-    }
-    /**
-     * Find the best point to split text, preserving code blocks
-     *
-     * @param text - Text to split
-     * @param maxLength - Maximum chunk length
-     * @returns Object with the chunk and remaining text
-     */
-    findSplitPoint(text, maxLength) {
-        // Check if we're inside a code block at the split point
-        const codeBlockState = this.analyzeCodeBlocks(text.substring(0, maxLength));
-        // If inside a code block, we need to close it and reopen in the next chunk
-        if (codeBlockState.insideBlock) {
-            // Find a good split point before maxLength
-            const splitIndex = this.findNaturalBreak(text, maxLength);
-            const chunkText = text.substring(0, splitIndex);
-            // Re-analyze the actual chunk
-            const actualState = this.analyzeCodeBlocks(chunkText);
-            if (actualState.insideBlock) {
-                // Close the code block in this chunk
-                const closedChunk = chunkText + "\n```";
-                // Reopen with the same language in the next chunk
-                const continuation = "```" + (actualState.language || "") + "\n" + text.substring(splitIndex);
-                return { chunk: closedChunk, rest: continuation };
-            }
-            return {
-                chunk: chunkText,
-                rest: text.substring(splitIndex),
-            };
-        }
-        // Not inside a code block - find natural break point
-        const splitIndex = this.findNaturalBreak(text, maxLength);
-        return {
-            chunk: text.substring(0, splitIndex),
-            rest: text.substring(splitIndex),
-        };
-    }
-    /**
-     * Analyze text to determine if it ends inside a code block
-     *
-     * @param text - Text to analyze
-     * @returns Object indicating if inside a block and the language if so
-     */
-    analyzeCodeBlocks(text) {
-        // Find all code block markers (```)
-        const codeBlockRegex = /```(\w*)?/g;
-        let match;
-        let insideBlock = false;
-        let language = null;
-        while ((match = codeBlockRegex.exec(text)) !== null) {
-            if (insideBlock) {
-                // This closes a block
-                insideBlock = false;
-                language = null;
-            }
-            else {
-                // This opens a block
-                insideBlock = true;
-                language = match[1] || null;
-            }
-        }
-        return { insideBlock, language };
-    }
-    /**
-     * Find a natural break point in text (newline or space)
-     *
-     * Prefers breaking at:
-     * 1. Double newlines (paragraph breaks)
-     * 2. Single newlines
-     * 3. Spaces
-     *
-     * @param text - Text to search
-     * @param maxLength - Maximum position to search
-     * @returns Index of the best split point
-     */
-    findNaturalBreak(text, maxLength) {
-        // Don't search beyond the text length
-        const searchEnd = Math.min(maxLength, text.length);
-        // First, try to find a double newline (paragraph break)
-        const doubleNewline = text.lastIndexOf("\n\n", searchEnd);
-        if (doubleNewline > 0 && doubleNewline > searchEnd - 500) {
-            // Found a paragraph break within the last 500 chars
-            return doubleNewline + 2; // Include the newlines
-        }
-        // Try to find a single newline
-        const singleNewline = text.lastIndexOf("\n", searchEnd);
-        if (singleNewline > 0 && singleNewline > searchEnd - 200) {
-            // Found a newline within the last 200 chars
-            return singleNewline + 1; // Include the newline
-        }
-        // Try to find a space (avoid splitting mid-word)
-        const space = text.lastIndexOf(" ", searchEnd);
-        if (space > 0 && space > searchEnd - 100) {
-            // Found a space within the last 100 chars
-            return space + 1; // Include the space
-        }
-        // Last resort: hard cut at maxLength
-        return searchEnd;
-    }
-    /**
-     * Send a response to Discord, splitting if necessary
-     *
-     * @param reply - The reply function from the message event
-     * @param content - The content to send
-     */
-    async sendResponse(reply, content) {
-        const chunks = this.splitResponse(content);
-        for (const chunk of chunks) {
-            await reply(chunk);
-        }
-    }
-}
-//# sourceMappingURL=discord-manager.js.map