@ebowwa/glm-daemon 0.4.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/glm-daemon",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Autonomous GLM 4.7 daemon with hooks, tools, teammates, and communication channels (Telegram, Discord)",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,18 +54,17 @@
   },
   "dependencies": {
     "@ebowwa/ai": "^0.1.2",
+    "@ebowwa/channel-telegram": "^1.13.0",
     "@ebowwa/channel-types": "^0.1.1",
     "@ebowwa/codespaces-types": "^1.4.0",
     "@ebowwa/structured-prompts": "^0.3.2",
     "@ebowwa/teammates": "^0.1.2",
     "discord.js": "^14.16.3",
-    "node-telegram-bot-api": "^0.66.0",
     "zod": "^4.3.5"
   },
   "devDependencies": {
     "@types/bun": "catalog:dev",
     "@types/node": "catalog:dev",
-    "@types/node-telegram-bot-api": "^0.64.13",
     "typescript": "catalog:",
     "bun-types": "catalog:dev"
   },

package/src/channels/base.ts

@@ -20,7 +20,8 @@ import {
   RICH_CAPABILITIES,
 } from "@ebowwa/channel-types";
 import { GLMClient } from "@ebowwa/ai";
-import { GLMDaemon, type GLMDaemonConfig } from "@ebowwa/glm-daemon";
+import { GLMDaemon, type GLMDaemonConfig } from "../daemon.js";
+import { BUILTIN_TOOLS, toGLMFormat, executeBuiltinTool } from "../builtin-tools.js";
 
 // ============================================================
 // CHANNEL CONFIG (extends base config from channel-types)
@@ -331,7 +332,7 @@ export abstract class BaseChannel implements ChannelConnector {
   // ============================================================
 
   /**
-   * Handle chat messages locally with GLM
+   * Handle chat messages locally with GLM + tools
    */
   protected async handleChat(content: string, context: MessageContext): Promise<RouteResult> {
     const start = Date.now();
@@ -340,20 +341,28 @@ export abstract class BaseChannel implements ChannelConnector {
       const history = this.conversationHistory.get(context.userId) || [];
 
       // Build system prompt with context
-      const systemPrompt = `You are a helpful AI assistant. You have access to conversation history and user context.
+      const systemPrompt = `You are a helpful AI assistant with tool access. You have access to conversation history and user context.
 
 User: ${context.userName || context.userId}
 Time: ${context.timestamp.toISOString()}
+Working Directory: ${this.config.daemonWorkdir || process.cwd()}
 
-Be concise, helpful, and friendly. If the user asks about your capabilities, explain that you can:
-- Answer questions and have conversations
-- Handle coding tasks by delegating to a specialized daemon
-- Check status of ongoing work
+You have access to tools for:
+- File operations (read_file, write_file, edit_file, list_dir)
+- Shell commands (run_command) - use for git, system info, etc.
+- Git operations (git_status)
+- System info (system_info)
 
-For complex coding tasks, suggest the user phrase it as a task request.`;
+USE TOOLS when the user asks you to do something (not just chat). Examples:
+- "list files" → use list_dir
+- "read package.json" → use read_file
+- "what's the git status" → use git_status
+- "run npm test" → use run_command
+
+Always use tools when appropriate. Be helpful and execute tasks.`;
 
       // Build messages array with system prompt and history
-      const messages: Array<{ role: "system" | "user" | "assistant"; content: string }> = [
+      const messages: Array<{ role: "system" | "user" | "assistant"; content: string; tool_calls?: unknown[]; tool_call_id?: string }> = [
         { role: "system", content: systemPrompt },
         ...history.slice(-10).map(msg => ({
           role: msg.role as "user" | "assistant",
@@ -362,22 +371,73 @@ For complex coding tasks, suggest the user phrase it as a task request.`;
         { role: "user", content }
       ];
 
-      const response = await this.glmClient.chatCompletion(messages, {
+      // Get tools in GLM format
+      const tools = toGLMFormat(BUILTIN_TOOLS);
+
+      // First call with tools
+      let response = await this.glmClient.chatCompletion(messages, {
         temperature: 0.7,
-        maxTokens: 4096
+        maxTokens: 4096,
+        tools
       });
 
-      // Extract response text from chat completion response
-      const responseText = response.choices?.[0]?.message?.content || String(response);
+      // Handle tool calls in a loop (max 5 iterations to prevent infinite loops)
+      let iterations = 0;
+      const maxIterations = 5;
+      let responseMessage = response.choices?.[0]?.message;
+
+      while (responseMessage?.tool_calls && iterations < maxIterations) {
+        iterations++;
+        console.log(`[${this.constructor.name}] Tool call iteration ${iterations}`);
+
+        // Add assistant message with tool calls to history
+        messages.push({
+          role: "assistant",
+          content: responseMessage.content || "",
+          tool_calls: responseMessage.tool_calls
+        });
+
+        // Execute each tool call
+        for (const toolCall of responseMessage.tool_calls as Array<{ id: string; function: { name: string; arguments: string } }>) {
+          const toolName = toolCall.function.name;
+          const toolArgs = JSON.parse(toolCall.function.arguments);
+
+          console.log(`[${this.constructor.name}] Executing tool: ${toolName}(${JSON.stringify(toolArgs).slice(0, 100)})`);
+
+          // Execute the tool
+          const toolResult = await executeBuiltinTool(toolName, toolArgs);
+
+          console.log(`[${this.constructor.name}] Tool result: ${toolResult.slice(0, 100)}...`);
+
+          // Add tool result to messages
+          messages.push({
+            role: "tool",
+            content: toolResult,
+            tool_call_id: toolCall.id
+          } as any);
+        }
+
+        // Get next response (without tools to get final answer)
+        response = await this.glmClient.chatCompletion(messages, {
+          temperature: 0.7,
+          maxTokens: 4096,
+          tools
+        });
+        responseMessage = response.choices?.[0]?.message;
+      }
+
+      // Extract final response text
+      const responseText = responseMessage?.content || "No response generated.";
 
       this.addToHistory(context.userId, { role: "assistant", content: responseText });
 
       return {
         source: "butler",
         response: responseText,
-        metadata: { executionTime: Date.now() - start },
+        metadata: { executionTime: Date.now() - start, toolIterations: iterations },
       };
     } catch (error) {
+      console.error(`[${this.constructor.name}] handleChat error:`, error);
       return {
         source: "error",
         response: `Sorry, I encountered an error: ${error instanceof Error ? error.message : String(error)}`,

package/src/channels/telegram.ts

@@ -1,27 +1,21 @@
 /**
- * Telegram Channel Adapter
+ * Telegram Channel for GLM Daemon
  *
- * Implements ChannelConnector from @ebowwa/channel-types.
- * Telegram bot using node-telegram-bot-api.
+ * Wraps @ebowwa/channel-telegram (pure protocol adapter)
+ * with GLM Daemon intelligence (GLM client, daemon delegation, routing).
  */
 
-import TelegramBot from "node-telegram-bot-api";
 import {
   type ChannelId,
-  type ChannelMessage,
-  type ChannelResponse,
   type ChannelCapabilities,
-  type MessageSender,
-  type MessageContext,
-  createChannelId,
-  RICH_CAPABILITIES,
 } from "@ebowwa/channel-types";
+import {
+  TelegramChannel as TelegramProtocolAdapter,
+  type TelegramConfig as ProtocolConfig,
+} from "@ebowwa/channel-telegram";
 import {
   BaseChannel,
   type GLMChannelConfig,
-  type BaseChannelConfig,
-  type MessageContext as InternalMessageContext,
-  type RouteResult,
 } from "./base.js";
 
 // ============================================================
@@ -44,7 +38,7 @@ export interface TelegramChannelConfig extends GLMChannelConfig {
 export type { TelegramChannelConfig as TelegramConfig };
 
 // ============================================================
-// TELEGRAM CHANNEL
+// TELEGRAM CHANNEL (Wraps @ebowwa/channel-telegram)
 // ============================================================
 
 export class TelegramChannel extends BaseChannel {
@@ -56,7 +50,7 @@ export class TelegramChannel extends BaseChannel {
       media: true,
       replies: true,
       threads: false,
-      reactions: true,  // Now supported via message_reaction
+      reactions: true,
       editing: true,
       streaming: false,
     },
@@ -70,20 +64,26 @@ export class TelegramChannel extends BaseChannel {
     },
   };
 
-  private bot: TelegramBot;
-  private token: string;
-  private testChatId?: string;
-  private allowedUsers?: number[];
-  private allowedChats?: number[];
+  private protocolAdapter: TelegramProtocolAdapter;
+  private telegramConfig: {
+    botToken: string;
+    testChatId?: string;
+    allowedUsers?: number[];
+    allowedChats?: number[];
+  };
 
   constructor(config: TelegramChannelConfig) {
     super(config);
-    this.token = config.botToken;
-    this.testChatId = config.testChatId;
-    this.allowedUsers = config.allowedUsers;
-    this.allowedChats = config.allowedChats;
+
+    this.telegramConfig = {
+      botToken: config.botToken,
+      testChatId: config.testChatId,
+      allowedUsers: config.allowedUsers,
+      allowedChats: config.allowedChats,
+    };
+
     this.id = this.createId();
-    this.bot = new TelegramBot(this.token, { polling: false }); // Don't start polling yet
+    this.protocolAdapter = new TelegramProtocolAdapter(this.telegramConfig);
   }
 
   // ============================================================
@@ -91,339 +91,77 @@ export class TelegramChannel extends BaseChannel {
   // ============================================================
 
   /**
-   * Send response to Telegram
+   * Send response to Telegram via protocol adapter
    */
-  async send(response: ChannelResponse): Promise<void> {
-    const chatId = this.extractChatId(response.replyTo);
-    if (!chatId) {
-      console.error("[Telegram] Cannot send: no chat ID in response");
-      return;
-    }
-
-    await this.sendResponse(chatId, response.content.text);
+  async send(response: Parameters<TelegramProtocolAdapter['send']>[0]): Promise<void> {
+    await this.protocolAdapter.send(response);
   }
 
   // ============================================================
-  // Platform-Specific Implementation
+  // Platform-Specific Implementation (BaseChannel abstract methods)
   // ============================================================
 
   /**
-   * Start Telegram bot
+   * Start Telegram bot via protocol adapter
    */
   protected async startPlatform(): Promise<void> {
-    console.log("[Telegram] Starting bot...");
-
-    // Start polling with all required update types
-    this.bot = new TelegramBot(this.token, {
-      polling: {
-        interval: 300,
-        autoStart: true,
-        params: {
-          allowed_updates: ['message', 'edited_message', 'message_reaction', 'callback_query']
-        }
-      }
-    });
-
-    // Handle /start command
-    this.bot.onText(/\/start/, async (msg: TelegramBot.Message) => {
-      const chatId = msg.chat.id;
-      await this.bot.sendMessage(
-        chatId,
-        "👋 Hello! I'm the GLM Daemon Telegram Bot.\n\n" +
-          "I can help you with:\n" +
-          "- Chat and questions (handled locally)\n" +
-          "- Coding tasks and features (delegated to daemon)\n\n" +
-          "Just send me a message!"
-      );
-    });
-
-    // Handle all text messages (with reply context)
-    this.bot.on("message", async (msg: TelegramBot.Message) => {
-      if (!msg.text) return;
-      if (msg.text.startsWith("/")) return;
-
-      const chatId = msg.chat.id;
-      const userId = msg.from?.id;
-
-      // Check allowlist
-      if (!this.isAllowed(userId, chatId)) {
-        console.log(`[Telegram] Blocked message from unauthorized user/chat: ${userId}/${chatId}`);
-        return;
-      }
-
-      const userName = msg.from?.first_name || msg.from?.username || "User";
-
-      // Check if this is a reply
-      const replyContext = msg.reply_to_message ? {
-        originalText: msg.reply_to_message.text,
-        originalFrom: msg.reply_to_message.from?.first_name || 'User',
-        originalMessageId: msg.reply_to_message.message_id
-      } : null;
-
-      if (replyContext) {
-        console.log(`[Telegram] ${userName} (replying to ${replyContext.originalFrom}): ${msg.text}`);
-      } else {
-        console.log(`[Telegram] ${userName}: ${msg.text}`);
-      }
-
-      // Build message with reply context
-      let messageText = msg.text;
-      if (replyContext?.originalText) {
-        messageText = `[Replying to ${replyContext.originalFrom}: "${replyContext.originalText.slice(0, 100)}"]\n\n${msg.text}`;
-      }
-
-      // Show typing indicator
-      await this.bot.sendChatAction(chatId, "typing");
-
-      try {
-        // Create normalized ChannelMessage
-        const message = this.createChannelMessage(msg);
-        if (replyContext) {
-          message.text = messageText; // Override with context
-        }
-
-        // Route through base channel
-        const response = await this.routeChannelMessage(message);
-
-        // Send response - thread to original if reply
-        if (replyContext) {
-          await this.bot.sendMessage(chatId, response.content.text, {
-            reply_to_message_id: msg.message_id,
-            parse_mode: "Markdown"
-          });
-        } else {
-          await this.send(response);
-        }
-      } catch (error) {
-        console.error("[Telegram] Error handling message:", error);
-        await this.bot.sendMessage(
-          chatId,
-          `Sorry, I encountered an error: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    });
-
-    // Handle message edits
-    this.bot.on("edited_message", async (msg: TelegramBot.Message) => {
-      if (!msg.text) return;
-
-      const chatId = msg.chat.id;
-      const userId = msg.from?.id;
-      const userName = msg.from?.first_name || "User";
-
-      if (!this.isAllowed(userId, chatId)) return;
-
-      console.log(`[Telegram] EDIT ${userName}: ${msg.text.slice(0, 50)}...`);
-
-      // Notify about edit and re-process
-      await this.bot.sendChatAction(chatId, "typing");
-
-      try {
-        const message = this.createChannelMessage(msg);
-        message.text = `[User edited their message to: "${msg.text}"]`;
+    console.log("[TelegramChannel] Starting via protocol adapter...");
 
-        const response = await this.routeChannelMessage(message);
-        await this.bot.sendMessage(chatId, `📝 *Edit noted:*\n\n${response.content.text}`, {
-          parse_mode: "Markdown"
-        });
-      } catch (error) {
-        console.error("[Telegram] Error handling edit:", error);
-      }
+    // Connect protocol adapter to our routing logic
+    this.protocolAdapter.onMessage(async (message) => {
+      // Route through BaseChannel's routing logic (GLM + daemon)
+      return this.routeChannelMessage(message);
     });
 
-    // Handle reactions (likes/emojis) - Telegram Bot API 5.0+
-    // Type definitions may not include this yet
-    (this.bot as any).on("message_reaction", async (reaction: {
-      chat: { id: number };
-      message_id: number;
-      user: { id: number; first_name?: string };
-      old_reaction: Array<{ type: string; emoji?: string }>;
-      new_reaction: Array<{ type: string; emoji?: string }>;
-    }) => {
-      const chatId = reaction.chat.id;
-      const userName = reaction.user.first_name || "User";
-
-      const newEmojis = reaction.new_reaction
-        .filter(r => r.type === 'emoji' && r.emoji)
-        .map(r => r.emoji!);
-
-      const oldEmojis = reaction.old_reaction
-        .filter(r => r.type === 'emoji' && r.emoji)
-        .map(r => r.emoji!);
-
-      const added = newEmojis.filter(e => !oldEmojis.includes(e));
-      const removed = oldEmojis.filter(e => !newEmojis.includes(e));
-
-      console.log(`[Telegram] REACTION by ${userName}: +${added.join(',')} -${removed.join(',')} on msg ${reaction.message_id}`);
-
-      // Respond to negative feedback
-      if (added.includes('👎')) {
-        await this.bot.sendMessage(chatId, `Thanks for the feedback, ${userName}. I'll try to do better!`);
-      }
-    });
-
-    // Handle callback queries (inline button reactions)
-    this.bot.on("callback_query", async (query: TelegramBot.CallbackQuery) => {
-      const chatId = query.message?.chat.id;
-      const data = query.data;
-      const userName = query.from.first_name || "User";
-
-      if (!chatId || !data) {
-        await this.bot.answerCallbackQuery(query.id);
-        return;
-      }
-
-      console.log(`[Telegram] CALLBACK ${userName}: ${data}`);
-
-      const [action, value] = data.split(':');
-
-      switch (action) {
-        case 'react': {
-          const count = parseInt(value) || 0;
-          const newCount = count + 1;
-          await this.bot.editMessageReplyMarkup(
-            { inline_keyboard: [[
-              { text: `👍 ${newCount}`, callback_data: `react:${newCount}` }
-            ]]},
-            { chat_id: chatId, message_id: query.message?.message_id }
-          );
-          break;
-        }
-        case 'approve':
-          await this.bot.sendMessage(chatId, `✅ Approved by ${userName}`);
-          break;
-        case 'reject':
-          await this.bot.sendMessage(chatId, `❌ Rejected by ${userName}`);
-          break;
-        case 'cancel':
-          await this.bot.sendMessage(chatId, `🛑 Task cancelled by ${userName}`);
-          break;
-      }
-
-      await this.bot.answerCallbackQuery(query.id);
-    });
-
-    // Handle polling errors
-    this.bot.on("polling_error", (error: Error) => {
-      console.error("[Telegram] Polling error:", error);
-    });
-
-    console.log("[Telegram] Bot is running!");
-
-    // Send test message if chat ID provided
-    if (this.testChatId) {
-      await this.sendTestMessage(Number(this.testChatId));
-    }
+    await this.protocolAdapter.start();
+    console.log("[TelegramChannel] Protocol adapter started");
   }
 
   /**
-   * Stop Telegram bot
+   * Stop Telegram bot via protocol adapter
    */
   protected async stopPlatform(): Promise<void> {
-    console.log("[Telegram] Stopping bot...");
-    await this.bot.stopPolling();
+    console.log("[TelegramChannel] Stopping protocol adapter...");
+    await this.protocolAdapter.stop();
   }
 
   // ============================================================
-  // Telegram-Specific Helpers
+  // Telegram-Specific Helpers (delegated to protocol adapter)
   // ============================================================
 
   /**
-   * Create normalized ChannelMessage from Telegram message
+   * Get underlying bot instance for advanced operations
    */
-  private createChannelMessage(msg: TelegramBot.Message): ChannelMessage {
-    const sender: MessageSender = {
-      id: msg.from?.id?.toString() || msg.chat.id.toString(),
-      username: msg.from?.username,
-      displayName: msg.from?.first_name || msg.from?.username,
-      isBot: msg.from?.is_bot || false,
-    };
-
-    const context: MessageContext = {
-      isDM: msg.chat.type === "private",
-      groupName: msg.chat.type !== "private" ? msg.chat.title : undefined,
-    };
-
-    return {
-      messageId: msg.message_id.toString(),
-      channelId: this.id,
-      timestamp: new Date(msg.date * 1000),
-      sender,
-      text: msg.text || "",
-      context,
-      replyTo: msg.reply_to_message
-        ? {
-            messageId: msg.reply_to_message.message_id.toString(),
-            channelId: this.id,
-          }
-        : undefined,
-    };
+  getBot() {
+    return this.protocolAdapter.getBot();
   }
 
   /**
-   * Check if user/chat is allowed
+   * Send a simple message
    */
-  private isAllowed(userId?: number, chatId?: number): boolean {
-    // No allowlist configured = allow all
-    if (!this.allowedUsers?.length && !this.allowedChats?.length) {
-      return true;
-    }
-
-    // Check user allowlist
-    if (this.allowedUsers?.length && userId) {
-      if (this.allowedUsers.includes(userId)) return true;
-    }
-
-    // Check chat allowlist
-    if (this.allowedChats?.length && chatId) {
-      if (this.allowedChats.includes(chatId)) return true;
-    }
-
-    return false;
+  async sendMessage(chatId: number, text: string) {
+    await this.protocolAdapter.sendMessage(chatId, text);
   }
 
   /**
-   * Extract chat ID from MessageRef
+   * Start typing indicator
    */
-  private extractChatId(replyTo: { messageId: string; channelId: ChannelId }): number | null {
-    // Chat ID is stored in channelId.accountId for Telegram
-    const accountId = replyTo.channelId.accountId;
-    // Try to parse as number, fallback to null
-    const parsed = parseInt(accountId, 10);
-    return isNaN(parsed) ? null : parsed;
+  startTypingIndicator(chatId: number) {
+    this.protocolAdapter.startTypingIndicator(chatId);
   }
 
   /**
-   * Send response, handling chunking for long messages
+   * Stop typing indicator
    */
-  private async sendResponse(chatId: number, response: string): Promise<void> {
-    const maxLength = 4096; // Telegram message limit
-
-    if (response.length > maxLength) {
-      const chunks = response.match(/[\s\S]{1,4000}/g) || [];
-      for (const chunk of chunks) {
-        await this.bot.sendMessage(chatId, chunk, { parse_mode: "Markdown" });
-      }
-    } else {
-      await this.bot.sendMessage(chatId, response, { parse_mode: "Markdown" });
-    }
+  stopTypingIndicator(chatId: number) {
+    this.protocolAdapter.stopTypingIndicator(chatId);
   }
 
   /**
-   * Send test message
+   * Check if user/chat is allowed
    */
-  async sendTestMessage(chatId: number): Promise<void> {
-    await this.bot.sendMessage(
-      chatId,
-      "✅ GLM Daemon Telegram Bot is NOW ONLINE!\n\n" +
-        "🎉 The bot is working correctly!\n\n" +
-        "Commands:\n" +
-        "/start - Show welcome message\n" +
-        'Any message - Chat or task\n' +
-        '"status" - Check daemon status\n\n' +
-        "I'll route your messages appropriately!"
-    );
-    console.log(`[Telegram] Test message sent to chat ${chatId}`);
+  isAllowed(userId?: number, chatId?: number): boolean {
+    return this.protocolAdapter.isAllowed(userId, chatId);
   }
 }