@fortressllm/sybil 0.0.3

package/src/tools/telegram-file-tools.ts

@@ -0,0 +1,320 @@
+// telegram-file-tools.ts - Tools for agents to send files to Telegram
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { bot } from "../utils/telegram.js";
+import * as fs from "fs/promises";
+import * as path from "path";
+
+/**
+ * Tool: Send a file to Telegram
+ * This tool allows agents to send files back to the user via Telegram
+ */
+export const sendTelegramFileTool = createTool({
+  id: "send-telegram-file",
+  description: "Send a file to the user via Telegram. Use this to share documents, images, code files, or any other files with the user. Supports both absolute paths and relative paths from the workspace directory.",
+  inputSchema: z.object({
+    filePath: z.string().describe("Path to the file to send (absolute or relative to workspace). Examples: 'report.pdf', '/absolute/path/to/file.txt', 'subdir/data.json'"),
+    caption: z.string().optional().describe("Optional caption/description for the file"),
+    filename: z.string().optional().describe("Optional custom filename (defaults to original filename)"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    message: z.string(),
+    filePath: z.string(),
+    fileSize: z.number().optional().describe("Size of the file in bytes"),
+  }),
+  execute: async (inputData, context) => {
+    const { filePath: inputPath, caption, filename } = inputData;
+    
+    // Get chatId from request context (set by Telegram handler)
+    const chatId = context?.requestContext?.get("telegramChatId") as number | undefined;
+    
+    if (!chatId) {
+      return {
+        success: false,
+        message: "No Telegram chat context available. This tool can only be used when processing Telegram messages.",
+        filePath: inputPath,
+      };
+    }
+
+    try {
+      // Resolve file path - handle both absolute and relative paths
+      let resolvedPath: string;
+      if (path.isAbsolute(inputPath)) {
+        resolvedPath = inputPath;
+      } else {
+        // Relative path - resolve against workspace directory
+        const workspaceDir = process.env.WORKSPACE_DIR || "./workspace";
+        resolvedPath = path.join(workspaceDir, inputPath);
+      }
+
+      // Verify file exists
+      let stats;
+      try {
+        stats = await fs.stat(resolvedPath);
+      } catch {
+        return {
+          success: false,
+          message: `File not found: "${inputPath}". Use the listFiles tool to see available files in the workspace.`,
+          filePath: inputPath,
+        };
+      }
+      
+      if (!stats.isFile()) {
+        return {
+          success: false,
+          message: `Path is not a file: "${inputPath}"`,
+          filePath: inputPath,
+        };
+      }
+
+      // Check file size (Telegram limit is 20MB for bots)
+      const maxSize = 20 * 1024 * 1024; // 20MB
+      if (stats.size > maxSize) {
+        return {
+          success: false,
+          message: `File "${path.basename(resolvedPath)}" is too large (${(stats.size / 1024 / 1024).toFixed(2)} MB). Maximum size is 20 MB.`,
+          filePath: inputPath,
+          fileSize: stats.size,
+        };
+      }
+
+      // Read file content
+      const fileContent = await fs.readFile(resolvedPath);
+      const fileName = filename || path.basename(resolvedPath);
+      
+      // Determine file type based on extension
+      const ext = path.extname(resolvedPath).toLowerCase();
+      const isImage = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp'].includes(ext);
+      const isVideo = ['.mp4', '.avi', '.mov', '.mkv', '.webm'].includes(ext);
+      const isAudio = ['.mp3', '.ogg', '.wav', '.m4a', '.flac'].includes(ext);
+
+      // File options for custom filename
+      const fileOptions = {
+        filename: fileName,
+        contentType: undefined as string | undefined,
+      };
+
+      // Send file based on type
+      if (isImage) {
+        fileOptions.contentType = `image/${ext.replace('.', '')}`;
+        await bot.sendPhoto(chatId, fileContent, {
+          caption: caption || undefined,
+        }, fileOptions);
+      } else if (isVideo) {
+        fileOptions.contentType = `video/${ext.replace('.', '')}`;
+        await bot.sendVideo(chatId, fileContent, {
+          caption: caption || undefined,
+        }, fileOptions);
+      } else if (isAudio) {
+        fileOptions.contentType = `audio/${ext.replace('.', '')}`;
+        await bot.sendAudio(chatId, fileContent, {
+          caption: caption || undefined,
+        }, fileOptions);
+      } else {
+        // Send as document for other file types
+        await bot.sendDocument(chatId, fileContent, {
+          caption: caption || undefined,
+        }, fileOptions);
+      }
+
+      return {
+        success: true,
+        message: `File sent successfully to Telegram: ${fileName} (${(stats.size / 1024).toFixed(2)} KB)`,
+        filePath: inputPath,
+        fileSize: stats.size,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: `Failed to send file: ${error.message}`,
+        filePath: inputPath,
+      };
+    }
+  },
+});
+
+/**
+ * Tool: Send a text message to Telegram
+ * This tool allows agents to send additional text messages
+ */
+export const sendTelegramMessageTool = createTool({
+  id: "send-telegram-message",
+  description: "Send a text message to the user via Telegram. Use this for status updates, summaries, or additional information.",
+  inputSchema: z.object({
+    message: z.string().describe("The message text to send (supports Markdown)"),
+    parseMode: z.enum(["Markdown", "HTML", "none"]).optional().describe("Parse mode for the message (default: Markdown)"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    message: z.string(),
+  }),
+  execute: async (inputData, context) => {
+    const { message, parseMode = "Markdown" } = inputData;
+    
+    // Get chatId from request context (set by Telegram handler)
+    const chatId = context?.requestContext?.get("telegramChatId") as number | undefined;
+    
+    if (!chatId) {
+      return {
+        success: false,
+        message: "No Telegram chat context available. This tool can only be used when processing Telegram messages.",
+      };
+    }
+
+    try {
+      await bot.sendMessage(chatId, message, {
+        parse_mode: parseMode === "none" ? undefined : parseMode,
+      });
+
+      return {
+        success: true,
+        message: "Message sent successfully to Telegram",
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: `Failed to send message: ${error.message}`,
+      };
+    }
+  },
+});
+
+/**
+ * Tool: Send multiple files as a media group to Telegram
+ * Useful for sending related files together
+ */
+export const sendTelegramMediaGroupTool = createTool({
+  id: "send-telegram-media-group",
+  description: "Send multiple photos/videos as an album to Telegram. All files will be grouped together in a single message. Supports both absolute and relative paths from the workspace directory.",
+  inputSchema: z.object({
+    filePaths: z.array(z.string()).describe("Array of file paths to send (images or videos). Supports relative paths from workspace."),
+    caption: z.string().optional().describe("Optional caption for the media group"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    message: z.string(),
+    sentCount: z.number(),
+    skippedCount: z.number().optional().describe("Number of files skipped (non-media or not found)"),
+  }),
+  execute: async (inputData, context) => {
+    const { filePaths, caption } = inputData;
+    
+    // Get chatId from request context (set by Telegram handler)
+    const chatId = context?.requestContext?.get("telegramChatId") as number | undefined;
+    
+    if (!chatId) {
+      return {
+        success: false,
+        message: "No Telegram chat context available. This tool can only be used when processing Telegram messages.",
+        sentCount: 0,
+        skippedCount: 0,
+      };
+    }
+
+    if (filePaths.length === 0) {
+      return {
+        success: false,
+        message: "No files provided",
+        sentCount: 0,
+        skippedCount: 0,
+      };
+    }
+
+    try {
+      const media: any[] = [];
+      let skippedCount = 0;
+      const maxSize = 20 * 1024 * 1024; // 20MB per file
+      
+      for (let i = 0; i < filePaths.length; i++) {
+        const inputPath = filePaths[i];
+        
+        // Resolve file path
+        let resolvedPath: string;
+        if (path.isAbsolute(inputPath)) {
+          resolvedPath = inputPath;
+        } else {
+          const workspaceDir = process.env.WORKSPACE_DIR || "./workspace";
+          resolvedPath = path.join(workspaceDir, inputPath);
+        }
+        
+        // Check if file exists
+        let stats;
+        try {
+          stats = await fs.stat(resolvedPath);
+        } catch {
+          skippedCount++;
+          continue; // Skip files that don't exist
+        }
+        
+        if (!stats.isFile()) {
+          skippedCount++;
+          continue; // Skip directories
+        }
+        
+        // Check size limit
+        if (stats.size > maxSize) {
+          skippedCount++;
+          continue; // Skip files that are too large
+        }
+        
+        const ext = path.extname(resolvedPath).toLowerCase();
+        const isImage = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp'].includes(ext);
+        const isVideo = ['.mp4', '.avi', '.mov', '.mkv', '.webm'].includes(ext);
+        
+        if (!isImage && !isVideo) {
+          skippedCount++;
+          continue; // Skip non-media files
+        }
+
+        const fileContent = await fs.readFile(resolvedPath);
+        const mediaItem: any = {
+          type: isImage ? 'photo' : 'video',
+          media: fileContent,
+        };
+        
+        // Add caption only to the first item
+        if (i === 0 && caption) {
+          mediaItem.caption = caption;
+          mediaItem.parse_mode = 'Markdown';
+        }
+        
+        media.push(mediaItem);
+      }
+
+      if (media.length === 0) {
+        return {
+          success: false,
+          message: "No valid media files found (only images and videos are supported for media groups). Some files may not exist or be too large.",
+          sentCount: 0,
+          skippedCount,
+        };
+      }
+
+      await bot.sendMediaGroup(chatId, media);
+
+      return {
+        success: true,
+        message: `Media group sent successfully with ${media.length} items${skippedCount > 0 ? ` (${skippedCount} files skipped)` : ''}`,
+        sentCount: media.length,
+        skippedCount,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: `Failed to send media group: ${error.message}`,
+        sentCount: 0,
+        skippedCount: 0,
+      };
+    }
+  },
+});
+
+// Export all Telegram tools
+export const telegramTools = {
+  sendTelegramFile: sendTelegramFileTool,
+  sendTelegramMessage: sendTelegramMessageTool,
+  sendTelegramMediaGroup: sendTelegramMediaGroupTool,
+};
+
+export default telegramTools;

package/src/tools/tool-registry.ts

@@ -0,0 +1,233 @@
+/**
+ * Tool Registry for Dynamic Tool Discovery
+ * 
+ * This module exports all available tools for use with ToolSearchProcessor
+ * enabling dynamic tool loading based on user requests.
+ */
+
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import axios from "axios";
+import * as cheerio from "cheerio";
+
+// Import existing tools from other files
+import {
+  fetchWebContentTool,
+  searchWebTool,
+  extractStructuredDataTool,
+  deepResearchTool
+} from "./web-tools.js";
+
+import {
+  getWhatsAppStatusTool,
+  initializeWhatsAppTool,
+  sendWhatsAppMessageTool,
+  getWhatsAppChatsTool,
+  getWhatsAppMessagesTool,
+  getWhatsAppContactTool,
+  getAllWhatsAppContactsTool,
+  getMyWhatsAppInfoTool,
+  broadcastWhatsAppMessageTool,
+} from "./whatsapp-tools.js";
+
+import {
+  configureAutoReplyTool,
+  approvePendingReplyTool,
+} from "./whatsapp-autoreply-tools.js";
+
+// Import extended tools that are actually available
+import {
+  readFileTool,
+  writeFileTool,
+  listDirectoryTool,
+  executeCodeTool,
+  createCalendarEventTool,
+  listCalendarEventsTool,
+  sendEmailTool,
+  queryDatabaseTool,
+  postToTwitterTool,
+  getAnalyticsReportTool,
+} from "./extended-tools.js";
+
+// Import dynamic tool generation tools
+import {
+  generateToolTool,
+  listGeneratedToolsTool,
+  deleteGeneratedToolTool,
+} from "./dynamic/tool-generator.js";
+
+// Import dynamic skill generation tools
+import {
+  generateSkillTool,
+  learnSkillFromFeedbackTool,
+  listSkillsTool,
+  activateSkillTool,
+  analyzeForSkillOpportunityTool,
+} from "../skills/dynamic/skill-generator.js";
+
+import { dynamicToolRegistry } from "./dynamic/registry.js";
+
+/**
+ * All available tools for dynamic discovery
+ * Total: 33 tools across multiple domains (25 static + 3 dynamic tool generation + 5 dynamic skill generation)
+ */
+export const allTools = {
+  // Web tools (4)
+  fetchWebContent: fetchWebContentTool,
+  searchWeb: searchWebTool,
+  extractStructuredData: extractStructuredDataTool,
+  deepResearch: deepResearchTool,
+
+  // WhatsApp tools (11)
+  getWhatsAppStatus: getWhatsAppStatusTool,
+  initializeWhatsApp: initializeWhatsAppTool,
+  sendWhatsAppMessage: sendWhatsAppMessageTool,
+  getWhatsAppChats: getWhatsAppChatsTool,
+  getWhatsAppMessages: getWhatsAppMessagesTool,
+  getWhatsAppContact: getWhatsAppContactTool,
+  getAllWhatsAppContacts: getAllWhatsAppContactsTool,
+  getMyWhatsAppInfo: getMyWhatsAppInfoTool,
+  broadcastWhatsAppMessage: broadcastWhatsAppMessageTool,
+  configureAutoReply: configureAutoReplyTool,
+  approvePendingReply: approvePendingReplyTool,
+
+  // Filesystem tools (3)
+  readFile: readFileTool,
+  writeFile: writeFileTool,
+  listDirectory: listDirectoryTool,
+
+  // Code execution (1)
+  executeCode: executeCodeTool,
+
+  // Calendar tools (2)
+  createCalendarEvent: createCalendarEventTool,
+  listCalendarEvents: listCalendarEventsTool,
+
+  // Email (1)
+  sendEmail: sendEmailTool,
+
+  // Database (1)
+  queryDatabase: queryDatabaseTool,
+
+  // Social media (1)
+  postToTwitter: postToTwitterTool,
+
+  // Analytics (1)
+  getAnalyticsReport: getAnalyticsReportTool,
+
+  // Dynamic tool generation (3)
+  generateTool: generateToolTool,
+  listGeneratedTools: listGeneratedToolsTool,
+  deleteGeneratedTool: deleteGeneratedToolTool,
+
+  // Dynamic skill generation (5)
+  generateSkill: generateSkillTool,
+  learnSkillFromFeedback: learnSkillFromFeedbackTool,
+  listSkills: listSkillsTool,
+  activateSkill: activateSkillTool,
+  analyzeForSkillOpportunity: analyzeForSkillOpportunityTool,
+};
+
+/**
+ * Tool count for reference
+ */
+export const toolCount = Object.keys(allTools).length;
+
+/**
+ * Tool categories for organization
+ */
+export const toolCategories = {
+  web: ["fetchWebContent", "searchWeb", "extractStructuredData", "deepResearch"],
+  whatsapp: ["getWhatsAppStatus", "initializeWhatsApp", "sendWhatsAppMessage", "getWhatsAppChats", "getWhatsAppMessages", "getWhatsAppContact", "getMyWhatsAppInfo", "broadcastWhatsAppMessage", "configureAutoReply", "approvePendingReply"],
+  filesystem: ["readFile", "writeFile", "listDirectory"],
+  code: ["executeCode"],
+  calendar: ["createCalendarEvent", "listCalendarEvents"],
+  email: ["sendEmail"],
+  database: ["queryDatabase"],
+  social: ["postToTwitter"],
+  analytics: ["getAnalyticsReport"],
+  dynamic: [
+    "generateTool",
+    "listGeneratedTools",
+    "deleteGeneratedTool",
+    "generateSkill",
+    "learnSkillFromFeedback",
+    "listSkills",
+    "activateSkill",
+    "analyzeForSkillOpportunity",
+  ],
+};
+
+/**
+ * Get tools by category
+ */
+export function getToolsByCategory(category: keyof typeof toolCategories): string[] {
+  return toolCategories[category] || [];
+}
+
+/**
+ * Get tool descriptions for search indexing
+ * This is used by ToolSearchProcessor for semantic matching
+ */
+export const toolDescriptions: Record<string, string> = {
+  // Web tools
+  fetchWebContent: "Fetch and extract content from web pages. Read articles, documentation, or any web content.",
+  searchWeb: "Search the web for information. Use DuckDuckGo to find current information.",
+  extractStructuredData: "Extract structured data from web pages using CSS selectors. Scrape specific elements.",
+  deepResearch: "Perform comprehensive research on topics. Search, read, and synthesize information.",
+
+  // WhatsApp tools
+  getWhatsAppStatus: "Check WhatsApp connection status. Verify if WhatsApp is ready.",
+  initializeWhatsApp: "Initialize WhatsApp Web connection. Scan QR code to connect.",
+  sendWhatsAppMessage: "Send WhatsApp messages to contacts. Use international phone format.",
+  getWhatsAppChats: "List WhatsApp conversations. View recent chats.",
+  getWhatsAppMessages: "Retrieve WhatsApp message history. View conversation messages.",
+  getWhatsAppContact: "Get WhatsApp contact information. View contact details.",
+  getMyWhatsAppInfo: "Get my WhatsApp profile information. View my account details.",
+  broadcastWhatsAppMessage: "Broadcast WhatsApp message to multiple contacts. Send bulk messages.",
+  configureAutoReply: "Configure WhatsApp auto-reply settings. Enable/disable auto-replies.",
+  approvePendingReply: "Approve pending WhatsApp auto-replies. Review and send pending messages.",
+
+  // Filesystem tools
+  readFile: "Read file contents from the filesystem. Open and view files.",
+  writeFile: "Write content to files. Create or update files.",
+  listDirectory: "List files and directories. Explore folder contents.",
+
+  // Code execution
+  executeCode: "Execute code in sandboxed environment. Run JavaScript, Python, or shell scripts.",
+
+  // Calendar tools
+  createCalendarEvent: "Create calendar events and meetings. Schedule appointments.",
+  listCalendarEvents: "List upcoming calendar events. View schedule.",
+
+  // Email
+  sendEmail: "Send emails. Send notifications and communications.",
+
+  // Database
+  queryDatabase: "Query databases using SQL. Retrieve data.",
+
+  // Social media
+  postToTwitter: "Post tweets to Twitter. Share updates on social media.",
+
+  // Analytics
+  getAnalyticsReport: "Get analytics and reports. View website traffic and metrics.",
+
+  // Dynamic tool generation (3)
+  generateTool: "Generate new custom tools based on requirements. Create tools dynamically from natural language descriptions.",
+  listGeneratedTools: "List all dynamically generated tools. View custom tools created by the agent.",
+  deleteGeneratedTool: "Delete a dynamically generated tool. Remove custom tools when no longer needed.",
+
+  // Dynamic skill generation (5)
+  generateSkill: "Create a new skill that teaches the agent how to handle specific tasks. Skills guide behavior in particular domains.",
+  learnSkillFromFeedback: "Learn or update a skill based on user feedback. Extract patterns from what worked well.",
+  listSkills: "List all available skills that can be activated. Skills enhance agent capabilities.",
+  activateSkill: "Activate a skill for use in the current conversation. Skills provide specialized instructions.",
+  analyzeForSkillOpportunity: "Analyze interactions to identify opportunities for new skills. Find gaps in capabilities.",
+};
+
+/**
+ * Export dynamic tool registry for runtime tool loading
+ */
+export { dynamicToolRegistry };
+
+export default allTools;