dexto 1.3.0 → 1.5.0

package/dist/cli/commands/interactive-commands/model/model-commands.js

@@ -1,190 +0,0 @@
-/**
- * Model Management Commands
- *
- * This module contains all model-related CLI commands extracted from the monolithic commands.ts.
- * These commands provide functionality for managing AI models including listing supported models,
- * switching between different models, and displaying current model configuration.
- *
- * Commands:
- * - list: List all supported providers and models with capabilities
- * - current: Show current model configuration details
- * - switch: Switch to a different AI model (provider auto-detected)
- * - help: Show detailed help for model commands
- */
-import chalk from 'chalk';
-import { DextoRuntimeError, DextoValidationError } from '@dexto/core';
-import { CommandOutputHelper } from '../utils/command-output.js';
-/**
- * Model management command definition
- * Note: In interactive CLI, /model shows the interactive selector
- * Subcommands available for debugging/advanced use, but not emphasized
- */
-export const modelCommands = {
-    name: 'model',
-    description: 'Switch AI model (interactive selector)',
-    usage: '/model',
-    category: 'General',
-    aliases: ['m'],
-    subcommands: [
-        {
-            name: 'list',
-            description: 'List all supported providers and models',
-            usage: '/model list',
-            handler: async (_args, agent) => {
-                try {
-                    console.log(chalk.bold.blue('\n🤖 Supported Models and Providers:\n'));
-                    const providers = agent.getSupportedProviders();
-                    const allModels = agent.getSupportedModels();
-                    for (const provider of providers) {
-                        const models = allModels[provider];
-                        console.log(chalk.bold.yellow(`${provider.toUpperCase()}:`));
-                        console.log(chalk.cyan('  Models:'));
-                        for (const model of models) {
-                            const tokenLimit = ` (${model.maxInputTokens.toLocaleString()} tokens)`;
-                            const defaultLabel = model.isDefault ? chalk.green(' [DEFAULT]') : '';
-                            console.log(`    ${chalk.cyan(model.name)}${tokenLimit}${defaultLabel}`);
-                        }
-                        console.log();
-                    }
-                    console.log(chalk.dim('💡 Use /model switch <model> to switch models'));
-                    console.log(chalk.dim('💡 Default models are marked with [DEFAULT]'));
-                    console.log(chalk.dim('💡 Token limits show maximum input context size\n'));
-                    return CommandOutputHelper.noOutput(); // List is displayed above
-                }
-                catch (error) {
-                    return CommandOutputHelper.error(error, 'Failed to list models');
-                }
-            },
-        },
-        {
-            name: 'current',
-            description: 'Show current model configuration',
-            usage: '/model current',
-            handler: async (args, agent) => {
-                try {
-                    const config = agent.getEffectiveConfig();
-                    console.log(chalk.blue('\n🤖 Current Model Configuration:\n'));
-                    console.log(`  Provider: ${chalk.cyan(config.llm.provider)}`);
-                    console.log(`  Model: ${chalk.cyan(config.llm.model)}`);
-                    console.log(`  Router: ${chalk.cyan(config.llm.router)}`);
-                    if (config.llm.maxIterations) {
-                        console.log(`  Max Iterations: ${chalk.cyan(config.llm.maxIterations.toString())}`);
-                    }
-                    if (config.llm.maxInputTokens) {
-                        console.log(`  Max Input Tokens: ${chalk.cyan(config.llm.maxInputTokens.toString())}`);
-                    }
-                    console.log();
-                    return CommandOutputHelper.noOutput(); // Config is displayed above
-                }
-                catch (error) {
-                    return CommandOutputHelper.error(error, 'Failed to get model info');
-                }
-            },
-        },
-        {
-            name: 'switch',
-            description: 'Switch to a different model',
-            usage: '/model switch <model>',
-            handler: async (args, agent) => {
-                const validationError = CommandOutputHelper.validateRequiredArg(args, 0, 'Model name', '/model switch <model>');
-                if (validationError)
-                    return validationError;
-                const model = args[0] || '';
-                try {
-                    // Infer provider from model name
-                    const provider = agent.inferProviderFromModel(model);
-                    if (!provider) {
-                        return CommandOutputHelper.error(new Error(`Unknown model: ${model}\n💡 Use /model list to see available models`));
-                    }
-                    console.log(chalk.yellow(`🔄 Switching to ${model} (${provider})...`));
-                    const llmConfig = { model, provider };
-                    await agent.switchLLM(llmConfig);
-                    return CommandOutputHelper.success(`✅ Successfully switched to ${model} (${provider})`);
-                }
-                catch (error) {
-                    if (error instanceof DextoRuntimeError) {
-                        const errorLines = [
-                            `Failed to switch model:\n   ${error.message}\n   Code: ${error.code}`,
-                        ];
-                        if (error.recovery) {
-                            const recoverySteps = Array.isArray(error.recovery)
-                                ? error.recovery
-                                : [error.recovery];
-                            errorLines.push(...recoverySteps.map((step) => `💡 ${step}`));
-                        }
-                        console.log(chalk.red(errorLines.join('\n')));
-                        return CommandOutputHelper.error(new Error(errorLines.join('\n')));
-                    }
-                    else if (error instanceof DextoValidationError) {
-                        const errors = error.errors.map((e) => `   - ${e.message}`).join('\n');
-                        return CommandOutputHelper.error(new Error(`Validation failed:\n${errors}`));
-                    }
-                    return CommandOutputHelper.error(error, 'Failed to switch model');
-                }
-            },
-        },
-        {
-            name: 'help',
-            description: 'Show detailed help for model commands',
-            usage: '/model help',
-            handler: async (_args, _agent) => {
-                const helpText = [
-                    '\n🤖 Model Management Commands:\n',
-                    'Available subcommands:',
-                    '  /model list - List all supported providers, models, and capabilities',
-                    '  /model current - Display currently active model and configuration',
-                    '  /model switch <model> - Switch to a different AI model (provider auto-detected)',
-                    '    Examples:',
-                    '      /model switch gpt-5',
-                    '      /model switch claude-sonnet-4-5-20250929',
-                    '      /model switch gemini-2.5-pro',
-                    '  /model help - Show this help message',
-                    '\n💡 Switching models allows you to use different AI capabilities',
-                    '💡 Model changes apply to the current session immediately',
-                    '💡 Available providers: openai, anthropic, gemini',
-                    '💡 You can also press Ctrl+M for interactive model selector\n',
-                ].join('\n');
-                console.log(chalk.bold.blue('\n🤖 Model Management Commands:\n'));
-                console.log(chalk.cyan('Available subcommands:'));
-                console.log(`  ${chalk.yellow('/model list')} - List all supported providers, models, and capabilities`);
-                console.log(`  ${chalk.yellow('/model current')} - Display currently active model and configuration`);
-                console.log(`  ${chalk.yellow('/model switch')} ${chalk.blue('<model>')} - Switch to a different AI model (provider auto-detected)`);
-                console.log(`        Examples:`);
-                console.log(`          ${chalk.dim('/model switch gpt-5')}`);
-                console.log(`          ${chalk.dim('/model switch claude-sonnet-4-5-20250929')}`);
-                console.log(`          ${chalk.dim('/model switch gemini-2.5-pro')}`);
-                console.log(`  ${chalk.yellow('/model help')} - Show this help message`);
-                console.log(chalk.dim('\n💡 Switching models allows you to use different AI capabilities'));
-                console.log(chalk.dim('💡 Model changes apply to the current session immediately'));
-                console.log(chalk.dim('💡 Available providers: openai, anthropic, gemini'));
-                console.log(chalk.dim('💡 You can also press Ctrl+M for interactive model selector\n'));
-                return helpText;
-            },
-        },
-    ],
-    handler: async (args, agent) => {
-        // Default to showing help about interactive selector if no subcommand
-        if (args.length === 0) {
-            const helpText = [
-                '🤖 Model Selection',
-                '\nIn interactive mode: Press Ctrl+M or type /model to show the model selector',
-                '\nAdvanced subcommands (optional):',
-                '  /model list    - List all available models',
-                '  /model current - Show current model',
-                '  /model switch <model> - Switch to specific model\n',
-            ].join('\n');
-            console.log(chalk.blue(helpText));
-            return helpText;
-        }
-        const subcommand = args[0];
-        const subArgs = args.slice(1);
-        // Find matching subcommand
-        const subcmd = modelCommands.subcommands?.find((s) => s.name === subcommand);
-        if (subcmd) {
-            return subcmd.handler(subArgs, agent);
-        }
-        const errorMsg = `❌ Unknown model subcommand: ${subcommand}\nUse /model for interactive selector or /model list to see all models`;
-        console.log(chalk.red(errorMsg));
-        return errorMsg;
-    },
-};

package/dist/cli/ink-cli/components/MultiLineTextInput.d.ts

@@ -1,26 +0,0 @@
-/**
- * Multi-line text input component
- *
- * Keyboard behavior (standard terminal-like):
- * - Typing: Characters appear at cursor position
- * - Backspace: Delete character before cursor
- * - Left/Right: Move cursor horizontally
- * - Up/Down: Navigate history (single line) or move between lines (multi-line)
- * - Enter: Submit
- * - Shift+Enter: Add newline
- * - Ctrl+A: Move to start of line
- * - Ctrl+E: Move to end of line
- */
-interface MultiLineTextInputProps {
-    value: string;
-    onChange: (value: string) => void;
-    onSubmit: (value: string) => void;
-    placeholder?: string | undefined;
-    isDisabled?: boolean | undefined;
-    history?: string[] | undefined;
-    historyIndex?: number | undefined;
-    onHistoryNavigate?: ((direction: 'up' | 'down') => void) | undefined;
-}
-export declare function MultiLineTextInput({ value, onChange, onSubmit, placeholder, isDisabled, history, historyIndex, onHistoryNavigate, }: MultiLineTextInputProps): import("react/jsx-runtime").JSX.Element;
-export {};
-//# sourceMappingURL=MultiLineTextInput.d.ts.map

package/dist/cli/ink-cli/components/MultiLineTextInput.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MultiLineTextInput.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/components/MultiLineTextInput.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,UAAU,uBAAuB;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAEjC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC/B,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,iBAAiB,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CACxE;AAED,wBAAgB,kBAAkB,CAAC,EAC/B,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,UAAkB,EAClB,OAAY,EACZ,YAAiB,EACjB,iBAAiB,GACpB,EAAE,uBAAuB,2CA2RzB"}

package/dist/cli/ink-cli/components/MultiLineTextInput.js

@@ -1,220 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * Multi-line text input component
- *
- * Keyboard behavior (standard terminal-like):
- * - Typing: Characters appear at cursor position
- * - Backspace: Delete character before cursor
- * - Left/Right: Move cursor horizontally
- * - Up/Down: Navigate history (single line) or move between lines (multi-line)
- * - Enter: Submit
- * - Shift+Enter: Add newline
- * - Ctrl+A: Move to start of line
- * - Ctrl+E: Move to end of line
- */
-import { useState, useEffect, useCallback } from 'react';
-import { Box, Text, useInput, useStdout } from 'ink';
-export function MultiLineTextInput({ value, onChange, onSubmit, placeholder, isDisabled = false, history = [], historyIndex = -1, onHistoryNavigate, }) {
-    const [cursorPos, setCursorPos] = useState(value.length);
-    const { stdout } = useStdout();
-    const terminalWidth = stdout?.columns || 80;
-    // Keep cursor valid when value changes externally (e.g., from history navigation)
-    // Only adjust if cursor would be past end of value, to avoid jumping during typing
-    useEffect(() => {
-        if (cursorPos > value.length) {
-            setCursorPos(value.length);
-        }
-    }, [value, cursorPos]);
-    // Calculate line info for cursor positioning
-    const getLineInfo = useCallback((pos) => {
-        const lines = value.split('\n');
-        let charCount = 0;
-        let lineIndex = 0;
-        let colIndex = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const lineLength = lines[i].length;
-            if (charCount + lineLength >= pos || i === lines.length - 1) {
-                lineIndex = i;
-                colIndex = pos - charCount;
-                break;
-            }
-            charCount += lineLength + 1; // +1 for newline
-        }
-        return { lines, lineIndex, colIndex, charCount };
-    }, [value]);
-    // Get position at start of a line
-    const getLineStart = useCallback((lineIndex) => {
-        const lines = value.split('\n');
-        let pos = 0;
-        for (let i = 0; i < lineIndex && i < lines.length; i++) {
-            pos += lines[i].length + 1;
-        }
-        return pos;
-    }, [value]);
-    useInput((input, key) => {
-        if (isDisabled)
-            return;
-        const lines = value.split('\n');
-        const isMultiLine = lines.length > 1;
-        const { lineIndex, colIndex } = getLineInfo(cursorPos);
-        // Newline detection based on actual terminal behavior:
-        // - Ctrl+J sends \n (0x0a) with NO ctrl flag (Enter sends \r with key.return)
-        // - Shift+Enter sends backslash + \r (0x5c 0x0d) on many terminals
-        // - Alt+Enter may set key.meta with key.return
-        const isCtrlJ = input === '\n'; // Ctrl+J sends 0x0a, regular Enter sends 0x0d
-        const isShiftEnter = input === '\\\r' ||
-            (key.return && key.shift) ||
-            input === '\x1b[13;2u' ||
-            input === '\x1bOM';
-        const wantsNewline = isCtrlJ || isShiftEnter || (key.return && key.meta);
-        if (wantsNewline) {
-            const newValue = value.slice(0, cursorPos) + '\n' + value.slice(cursorPos);
-            onChange(newValue);
-            setCursorPos(cursorPos + 1);
-            return;
-        }
-        // Enter = submit
-        if (key.return) {
-            if (value.trim()) {
-                onSubmit(value);
-            }
-            return;
-        }
-        // Backspace - delete character before cursor
-        const isBackspace = key.backspace || input === '\x7f' || input === '\x08';
-        if (isBackspace) {
-            if (cursorPos > 0) {
-                const newValue = value.slice(0, cursorPos - 1) + value.slice(cursorPos);
-                onChange(newValue);
-                setCursorPos(cursorPos - 1);
-            }
-            return;
-        }
-        // Delete - delete character at cursor (forward delete)
-        if (key.delete) {
-            if (cursorPos < value.length) {
-                const newValue = value.slice(0, cursorPos) + value.slice(cursorPos + 1);
-                onChange(newValue);
-            }
-            return;
-        }
-        // Left arrow
-        if (key.leftArrow) {
-            setCursorPos(Math.max(0, cursorPos - 1));
-            return;
-        }
-        // Right arrow
-        if (key.rightArrow) {
-            setCursorPos(Math.min(value.length, cursorPos + 1));
-            return;
-        }
-        // Up arrow
-        if (key.upArrow) {
-            if (isMultiLine && lineIndex > 0) {
-                const prevLineStart = getLineStart(lineIndex - 1);
-                const prevLineLength = lines[lineIndex - 1].length;
-                const newCol = Math.min(colIndex, prevLineLength);
-                setCursorPos(prevLineStart + newCol);
-            }
-            else if (onHistoryNavigate && history.length > 0) {
-                onHistoryNavigate('up');
-            }
-            return;
-        }
-        // Down arrow
-        if (key.downArrow) {
-            if (isMultiLine && lineIndex < lines.length - 1) {
-                const nextLineStart = getLineStart(lineIndex + 1);
-                const nextLineLength = lines[lineIndex + 1].length;
-                const newCol = Math.min(colIndex, nextLineLength);
-                setCursorPos(nextLineStart + newCol);
-            }
-            else if (onHistoryNavigate && historyIndex >= 0) {
-                onHistoryNavigate('down');
-            }
-            return;
-        }
-        // Ctrl+A - start of line
-        if (key.ctrl && input === 'a') {
-            setCursorPos(getLineStart(lineIndex));
-            return;
-        }
-        // Ctrl+E - end of line
-        if (key.ctrl && input === 'e') {
-            const lineStart = getLineStart(lineIndex);
-            setCursorPos(lineStart + lines[lineIndex].length);
-            return;
-        }
-        // Ctrl+K - delete to end of line
-        if (key.ctrl && input === 'k') {
-            const lineStart = getLineStart(lineIndex);
-            const lineEnd = lineStart + lines[lineIndex].length;
-            if (cursorPos < lineEnd) {
-                onChange(value.slice(0, cursorPos) + value.slice(lineEnd));
-            }
-            else if (cursorPos < value.length) {
-                onChange(value.slice(0, cursorPos) + value.slice(cursorPos + 1));
-            }
-            return;
-        }
-        // Ctrl+U - delete to start of line
-        if (key.ctrl && input === 'u') {
-            const lineStart = getLineStart(lineIndex);
-            if (cursorPos > lineStart) {
-                onChange(value.slice(0, lineStart) + value.slice(cursorPos));
-                setCursorPos(lineStart);
-            }
-            return;
-        }
-        // Ctrl+W - delete word
-        if (key.ctrl && input === 'w') {
-            if (cursorPos > 0) {
-                let wordStart = cursorPos - 1;
-                while (wordStart > 0 && value[wordStart] === ' ')
-                    wordStart--;
-                while (wordStart > 0 &&
-                    value[wordStart - 1] !== ' ' &&
-                    value[wordStart - 1] !== '\n')
-                    wordStart--;
-                onChange(value.slice(0, wordStart) + value.slice(cursorPos));
-                setCursorPos(wordStart);
-            }
-            return;
-        }
-        // Regular character input
-        if (input && !key.ctrl && !key.meta) {
-            const newValue = value.slice(0, cursorPos) + input + value.slice(cursorPos);
-            onChange(newValue);
-            setCursorPos(cursorPos + input.length);
-        }
-    }, { isActive: !isDisabled });
-    // Helper to pad line to full terminal width
-    const padLine = (content) => {
-        const visibleLength = content.length;
-        const padding = Math.max(0, terminalWidth - visibleLength);
-        return content + ' '.repeat(padding);
-    };
-    // Empty state
-    if (!value) {
-        const emptyContent = '❯  ' + (placeholder || '');
-        return (_jsx(Box, { width: terminalWidth, children: _jsxs(Text, { backgroundColor: "#222", children: [_jsx(Text, { color: "green", bold: true, children: '❯ ' }), _jsx(Text, { inverse: true, children: " " }), placeholder && _jsx(Text, { dimColor: true, children: placeholder }), _jsx(Text, { children: ' '.repeat(Math.max(0, terminalWidth - 3 - (placeholder?.length || 0))) })] }) }));
-    }
-    // Render lines
-    const lines = value.split('\n');
-    const { lineIndex: cursorLine, colIndex: cursorCol } = getLineInfo(cursorPos);
-    return (_jsx(Box, { flexDirection: "column", width: terminalWidth, children: lines.map((line, idx) => {
-            const prefix = idx === 0 ? '❯ ' : '  ';
-            const isCursorLine = idx === cursorLine;
-            const contentLength = prefix.length + line.length + 1; // +1 for cursor space
-            const padding = ' '.repeat(Math.max(0, terminalWidth - contentLength));
-            if (!isCursorLine) {
-                return (_jsx(Box, { width: terminalWidth, children: _jsxs(Text, { backgroundColor: "#222", children: [_jsx(Text, { color: "green", bold: idx === 0, children: prefix }), _jsx(Text, { children: line }), _jsx(Text, { children: ' '.repeat(Math.max(0, terminalWidth - prefix.length - line.length)) })] }) }, idx));
-            }
-            // Cursor line
-            const before = line.slice(0, cursorCol);
-            const atCursor = line.charAt(cursorCol) || ' ';
-            const after = line.slice(cursorCol + 1);
-            const cursorContentLength = prefix.length + before.length + 1 + after.length;
-            return (_jsx(Box, { width: terminalWidth, children: _jsxs(Text, { backgroundColor: "#222", children: [_jsx(Text, { color: "green", bold: idx === 0, children: prefix }), _jsx(Text, { children: before }), _jsx(Text, { inverse: true, children: atCursor }), _jsx(Text, { children: after }), _jsx(Text, { children: ' '.repeat(Math.max(0, terminalWidth - cursorContentLength)) })] }) }, idx));
-        }) }));
-}

package/dist/discord/bot.d.ts

@@ -1,4 +0,0 @@
-import { Client } from 'discord.js';
-import { DextoAgent } from '@dexto/core';
-export declare function startDiscordBot(agent: DextoAgent): Client<boolean>;
-//# sourceMappingURL=bot.d.ts.map

package/dist/discord/bot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bot.d.ts","sourceRoot":"","sources":["../../src/discord/bot.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAA+B,MAAM,YAAY,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAgFzC,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,mBA+IhD"}

package/dist/discord/bot.js

@@ -1,193 +0,0 @@
-import dotenv from 'dotenv';
-import { Client, GatewayIntentBits, Partials } from 'discord.js';
-import https from 'https';
-import http from 'http'; // ADDED for http support
-// Load environment variables
-dotenv.config();
-const token = process.env.DISCORD_BOT_TOKEN;
-// User-based cooldown system for Discord interactions
-const userCooldowns = new Map();
-const RATE_LIMIT_ENABLED = process.env.DISCORD_RATE_LIMIT_ENABLED?.toLowerCase() !== 'false'; // default-on
-let COOLDOWN_SECONDS = Number(process.env.DISCORD_RATE_LIMIT_SECONDS ?? 5);
-if (Number.isNaN(COOLDOWN_SECONDS) || COOLDOWN_SECONDS < 0) {
-    console.error('DISCORD_RATE_LIMIT_SECONDS must be a non-negative number. Defaulting to 5 seconds.');
-    COOLDOWN_SECONDS = 5; // Default to a safe value
-}
-// Helper to download a file URL and convert it to base64
-async function downloadFileAsBase64(fileUrl) {
-    return new Promise((resolve, reject) => {
-        const protocol = fileUrl.startsWith('https:') ? https : http; // Determine protocol
-        const MAX_BYTES = 5 * 1024 * 1024; // 5 MB hard cap
-        let downloadedBytes = 0;
-        const req = protocol.get(fileUrl, (res) => {
-            // Store the request object
-            if (res.statusCode && res.statusCode >= 400) {
-                // Clean up response stream
-                res.resume();
-                return reject(new Error(`Failed to download file: ${res.statusCode} ${res.statusMessage}`));
-            }
-            const chunks = [];
-            res.on('data', (chunk) => {
-                downloadedBytes += chunk.length;
-                if (downloadedBytes > MAX_BYTES) {
-                    // Clean up response stream before destroying request
-                    res.resume();
-                    req.destroy(new Error('Attachment exceeds 5 MB limit')); // Destroy the request
-                    // No explicit reject here, as 'error' on req should handle it or timeout will occur
-                    return;
-                }
-                chunks.push(chunk);
-            });
-            res.on('end', () => {
-                if (req.destroyed)
-                    return; // If request was destroyed due to size limit, do nothing
-                const buffer = Buffer.concat(chunks);
-                const contentType = res.headers['content-type'] || 'application/octet-stream';
-                resolve({ base64: buffer.toString('base64'), mimeType: contentType });
-            });
-            // Handle errors on the response stream itself (e.g., premature close)
-            res.on('error', (err) => {
-                if (!req.destroyed) {
-                    // Avoid double-rejection if req.destroy() already called this
-                    reject(err);
-                }
-            });
-        });
-        // Handle errors on the request object (e.g., socket hang up, DNS resolution error, or from req.destroy())
-        req.on('error', (err) => {
-            reject(err);
-        });
-        // Optional: Add a timeout for the request
-        req.setTimeout(30000, () => {
-            // 30 seconds timeout
-            if (!req.destroyed) {
-                req.destroy(new Error('File download timed out'));
-            }
-        });
-    });
-}
-// Insert initDiscordBot to wire up a Discord client given pre-initialized services
-export function startDiscordBot(agent) {
-    if (!token) {
-        throw new Error('DISCORD_BOT_TOKEN is not set');
-    }
-    const agentEventBus = agent.agentEventBus;
-    // Helper to get or create session for a Discord user
-    // Each Discord user gets their own persistent session
-    function getDiscordSessionId(userId) {
-        return `discord-${userId}`;
-    }
-    // Create Discord client
-    const client = new Client({
-        intents: [
-            GatewayIntentBits.Guilds,
-            GatewayIntentBits.GuildMessages,
-            GatewayIntentBits.MessageContent,
-            GatewayIntentBits.DirectMessages,
-        ],
-        partials: [Partials.Channel],
-    });
-    client.once('ready', () => {
-        console.log(`Discord bot logged in as ${client.user?.tag || 'Unknown'}`);
-    });
-    client.on('messageCreate', async (message) => {
-        // Ignore bots
-        if (message.author.bot)
-            return;
-        if (RATE_LIMIT_ENABLED && COOLDOWN_SECONDS > 0) {
-            // Only apply cooldown if enabled and seconds > 0
-            const now = Date.now();
-            const cooldownEnd = userCooldowns.get(message.author.id) || 0;
-            if (now < cooldownEnd) {
-                const timeLeft = (cooldownEnd - now) / 1000;
-                try {
-                    await message.reply(`Please wait ${timeLeft.toFixed(1)} more seconds before using this command again.`);
-                }
-                catch (replyError) {
-                    console.error('Error sending cooldown message:', replyError);
-                }
-                return;
-            }
-        }
-        let userText = message.content;
-        let imageDataInput;
-        // Handle attachments (images)
-        if (message.attachments.size > 0) {
-            const attachment = message.attachments.first();
-            if (attachment && attachment.url) {
-                const { base64, mimeType } = await downloadFileAsBase64(attachment.url);
-                imageDataInput = { image: base64, mimeType };
-                userText = message.content || '';
-            }
-        }
-        // Only respond to !ask prefix or DMs
-        if (!message.guild || (userText && userText.startsWith('!ask '))) {
-            if (userText && userText.startsWith('!ask ')) {
-                userText = userText.substring(5).trim();
-            }
-            if (!userText)
-                return;
-            // Subscribe for toolCall events
-            const toolCallHandler = (payload) => {
-                message.channel
-                    .send(`🔧 Calling tool **${payload.toolName}** with args: ${JSON.stringify(payload.args)}`)
-                    .catch((error) => {
-                    console.error(`Failed to send tool call notification for ${payload.toolName} to channel ${message.channel.id}:`, error);
-                });
-            };
-            agentEventBus.on('llm:tool-call', toolCallHandler);
-            try {
-                const sessionId = getDiscordSessionId(message.author.id);
-                await message.channel.sendTyping();
-                const responseText = await agent.run(userText, imageDataInput, undefined, sessionId);
-                // Handle Discord's 2000 character limit
-                const MAX_LENGTH = 1900; // Leave some buffer
-                if (responseText && responseText.length <= MAX_LENGTH) {
-                    await message.reply(responseText);
-                }
-                else if (responseText) {
-                    // Split into chunks and send multiple messages
-                    let remaining = responseText;
-                    let isFirst = true;
-                    while (remaining && remaining.length > 0) {
-                        const chunk = remaining.substring(0, MAX_LENGTH);
-                        remaining = remaining.substring(MAX_LENGTH);
-                        if (isFirst) {
-                            await message.reply(chunk);
-                            isFirst = false;
-                        }
-                        else {
-                            // For subsequent chunks, use message.channel.send to avoid a chain of replies
-                            // and to ensure messages are sent in order.
-                            // Adding a small delay can also help with ordering and rate limits.
-                            await new Promise((resolve) => setTimeout(resolve, 250)); // 250ms delay
-                            await message.channel.send(chunk);
-                        }
-                    }
-                }
-                else {
-                    await message.reply('I received your message but could not generate a response.');
-                }
-            }
-            catch (error) {
-                console.error('Error handling Discord message', error);
-                try {
-                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                    await message.reply(`Error: ${errorMessage}`);
-                }
-                catch (replyError) {
-                    console.error('Error sending error reply:', replyError);
-                }
-            }
-            finally {
-                agentEventBus.off('llm:tool-call', toolCallHandler);
-                // Set cooldown for the user after processing
-                if (RATE_LIMIT_ENABLED && COOLDOWN_SECONDS > 0) {
-                    userCooldowns.set(message.author.id, Date.now() + COOLDOWN_SECONDS * 1000);
-                }
-            }
-        }
-    });
-    client.login(token);
-    return client;
-}

package/dist/telegram/bot.d.ts

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-import { Bot } from 'grammy';
-import { DextoAgent } from '@dexto/core';
-export declare function startTelegramBot(agent: DextoAgent): Bot<import("grammy").Context, import("grammy").Api<import("grammy").RawApi>>;
-//# sourceMappingURL=bot.d.ts.map

package/dist/telegram/bot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bot.d.ts","sourceRoot":"","sources":["../../src/telegram/bot.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,GAAG,EAAkB,MAAM,QAAQ,CAAC;AAE7C,OAAO,EAAE,UAAU,EAAU,MAAM,aAAa,CAAC;AAyCjD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,gFAyOjD"}