opc-agent 4.0.8 → 4.0.10

package/dist/channels/telegram.d.ts

@@ -1,3 +1,4 @@
+import type { Message } from '../core/types';
 import { BaseChannel } from './index';
 /**
  * Telegram channel — supports both long-polling and webhook modes.
@@ -35,6 +36,10 @@ export declare class TelegramChannel extends BaseChannel {
     private startWebhook;
     private stopWebhook;
     private processUpdate;
+    private streamResponse;
+    private streamHandler?;
+    setStreamHandler(handler: (msg: Message) => AsyncIterable<string>): void;
+    sendMarkdown(chatId: number | string, text: string, replyTo?: number): Promise<any>;
     sendMessage(chatId: number | string, text: string): Promise<void>;
     private apiCall;
     private splitText;

package/dist/channels/telegram.js

@@ -152,12 +152,21 @@ class TelegramChannel extends index_1.BaseChannel {
     // ─── Shared ──────────────────────────────────────────────
     async processUpdate(update) {
         const message = update.message || update.edited_message;
-        if (!message?.text || !this.handler)
+        if (!message || !this.handler)
+            return;
+        // Handle /start command
+        if (message.text === '/start') {
+            await this.sendMarkdown(message.chat.id, '👋 Hello! I\'m ready to help. Send me a message to get started.');
+            return;
+        }
+        // Handle text, photo captions, document captions
+        const text = message.text || message.caption;
+        if (!text)
             return;
         const msg = {
             id: `tg_${message.message_id}`,
             role: 'user',
-            content: message.text,
+            content: text,
             timestamp: message.date * 1000,
             metadata: {
                 sessionId: `tg_${message.chat.id}`,
@@ -167,31 +176,132 @@ class TelegramChannel extends index_1.BaseChannel {
                 firstName: message.from?.first_name,
                 platform: 'telegram',
                 chatType: message.chat.type,
+                replyToMessageId: message.message_id,
             },
         };
-        // Show typing indicator while processing
+        // Show typing indicator
         await this.apiCall('sendChatAction', { chat_id: message.chat.id, action: 'typing' });
         const typingInterval = setInterval(() => {
             this.apiCall('sendChatAction', { chat_id: message.chat.id, action: 'typing' }).catch(() => { });
         }, 4000);
         try {
-            const response = await this.handler(msg);
-            await this.sendMessage(message.chat.id, response.content);
+            // Try streaming if provider supports it
+            if (this.streamHandler) {
+                await this.streamResponse(message.chat.id, msg, message.message_id);
+            }
+            else {
+                const response = await this.handler(msg);
+                await this.sendMarkdown(message.chat.id, response.content, message.message_id);
+            }
+        }
+        catch (err) {
+            console.error('[TelegramChannel] Error processing message:', err);
+            await this.sendMarkdown(message.chat.id, '⚠️ Sorry, something went wrong. Please try again.');
         }
         finally {
             clearInterval(typingInterval);
         }
     }
-    async sendMessage(chatId, text) {
-        // Telegram max message length is 4096
+    async streamResponse(chatId, msg, replyTo) {
+        if (!this.streamHandler)
+            return;
+        let sentMessageId = null;
+        let fullText = '';
+        let lastEditTime = 0;
+        const EDIT_INTERVAL = 1000; // Edit at most once per second
+        let pendingEdit = false;
+        const doEdit = async () => {
+            if (!sentMessageId || !fullText)
+                return;
+            pendingEdit = false;
+            try {
+                await this.apiCall('editMessageText', {
+                    chat_id: chatId,
+                    message_id: sentMessageId,
+                    text: fullText,
+                    parse_mode: 'Markdown',
+                });
+                lastEditTime = Date.now();
+            }
+            catch (err) {
+                // If Markdown fails, try plain text
+                if (err?.message?.includes('parse') || err?.message?.includes('entities')) {
+                    try {
+                        await this.apiCall('editMessageText', {
+                            chat_id: chatId,
+                            message_id: sentMessageId,
+                            text: fullText,
+                        });
+                    }
+                    catch { }
+                }
+            }
+        };
+        try {
+            for await (const chunk of this.streamHandler(msg)) {
+                fullText += chunk;
+                if (!sentMessageId) {
+                    // Send first message
+                    const result = await this.sendMarkdown(chatId, fullText, replyTo);
+                    sentMessageId = result?.message_id;
+                    lastEditTime = Date.now();
+                }
+                else {
+                    const now = Date.now();
+                    if (now - lastEditTime >= EDIT_INTERVAL) {
+                        await doEdit();
+                    }
+                    else if (!pendingEdit) {
+                        pendingEdit = true;
+                    }
+                }
+            }
+            // Final edit with complete text
+            if (sentMessageId && fullText) {
+                await doEdit();
+            }
+        }
+        catch (err) {
+            // If streaming fails, send what we have
+            if (!sentMessageId && fullText) {
+                await this.sendMarkdown(chatId, fullText, replyTo);
+            }
+            throw err;
+        }
+    }
+    // Stream handler — set by runtime when provider supports streaming
+    streamHandler;
+    setStreamHandler(handler) {
+        this.streamHandler = handler;
+    }
+    async sendMarkdown(chatId, text, replyTo) {
         const chunks = this.splitText(text, 4096);
+        let lastResult = null;
         for (const chunk of chunks) {
-            await this.apiCall('sendMessage', {
-                chat_id: chatId,
-                text: chunk,
-                parse_mode: 'Markdown',
-            });
+            try {
+                lastResult = await this.apiCall('sendMessage', {
+                    chat_id: chatId,
+                    text: chunk,
+                    parse_mode: 'Markdown',
+                    ...(replyTo ? { reply_to_message_id: replyTo } : {}),
+                });
+                // Only reply to first chunk
+                replyTo = undefined;
+            }
+            catch (err) {
+                // Markdown parse failed — send as plain text
+                lastResult = await this.apiCall('sendMessage', {
+                    chat_id: chatId,
+                    text: chunk,
+                    ...(replyTo ? { reply_to_message_id: replyTo } : {}),
+                });
+                replyTo = undefined;
+            }
         }
+        return lastResult?.result;
+    }
+    async sendMessage(chatId, text) {
+        await this.sendMarkdown(chatId, text);
     }
     async apiCall(method, body) {
         const url = `https://api.telegram.org/bot${this.token}/${method}`;

package/dist/core/runtime.js

@@ -165,10 +165,21 @@ class AgentRuntime {
                 this.logger.info('Bound web channel', { port });
             }
             else if (ch.type === 'telegram') {
-                this.agent.bindChannel(new telegram_1.TelegramChannel({
+                const tgChannel = new telegram_1.TelegramChannel({
                     token: ch.config?.token,
                     port: ch.port,
-                }));
+                });
+                // Wire up streaming for real-time message editing
+                const agentRef = this.agent;
+                tgChannel.setStreamHandler(async function* (msg) {
+                    const history = [msg];
+                    const provider = agentRef.provider;
+                    const systemPrompt = agentRef.getSystemPrompt();
+                    for await (const chunk of provider.chatStream(history, systemPrompt)) {
+                        yield chunk;
+                    }
+                });
+                this.agent.bindChannel(tgChannel);
                 this.logger.info('Bound telegram channel');
             }
             else if (ch.type === 'websocket') {

package/dist/providers/index.js

@@ -406,9 +406,65 @@ class ClaudeCLIProvider {
         }
     }
     async *chatStream(messages, systemPrompt) {
-        // Claude CLI --print doesn't support streaming well, so we do single-shot
-        const result = await this.chat(messages, systemPrompt);
-        yield result;
+        // Build prompt same as chat()
+        const parts = [];
+        if (systemPrompt) {
+            parts.push(`[System]: ${systemPrompt}`);
+        }
+        for (const m of messages) {
+            const role = m.role === 'user' ? 'Human' : 'Assistant';
+            parts.push(`${role}: ${m.content}`);
+        }
+        const prompt = parts.join('\n\n');
+        const args = ['-p', '--output-format', 'text'];
+        if (this.model) {
+            args.push('--model', this.model);
+        }
+        // Write system prompt to temp file if needed
+        let tmpFile;
+        if (systemPrompt) {
+            const { writeFileSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+            const { join } = await Promise.resolve().then(() => __importStar(require('path')));
+            const { tmpdir } = await Promise.resolve().then(() => __importStar(require('os')));
+            tmpFile = join(tmpdir(), `opc-claude-stream-${Date.now()}.txt`);
+            writeFileSync(tmpFile, systemPrompt);
+            args.push('--system-prompt-file', tmpFile);
+        }
+        const lastMsg = messages[messages.length - 1];
+        args.push(lastMsg?.content ?? prompt);
+        const { spawn } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        try {
+            const proc = spawn('claude', args, {
+                env: { ...process.env },
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            proc.stdin.end();
+            // Yield chunks as they arrive from stdout
+            const readable = proc.stdout;
+            for await (const chunk of readable) {
+                yield chunk.toString();
+            }
+            // Wait for process to finish
+            await new Promise((resolve, reject) => {
+                proc.on('close', (code) => {
+                    if (code !== 0 && code !== null) {
+                        // Already yielded content, just log
+                        console.warn(`[ClaudeCLI] Process exited with code ${code}`);
+                    }
+                    resolve();
+                });
+                proc.on('error', reject);
+            });
+        }
+        finally {
+            if (tmpFile) {
+                try {
+                    const { unlinkSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+                    unlinkSync(tmpFile);
+                }
+                catch { }
+            }
+        }
     }
 }
 function createProvider(name = 'openai', model, baseUrl, apiKey) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "4.0.8",
+  "version": "4.0.10",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/channels/telegram.ts

@@ -1,4 +1,5 @@
 import type { Message } from '../core/types';
+import type { LLMProvider } from '../providers/index';
 import { BaseChannel } from './index';
 
 /**
@@ -152,12 +153,22 @@ export class TelegramChannel extends BaseChannel {
 
   private async processUpdate(update: any): Promise<void> {
     const message = update.message || update.edited_message;
-    if (!message?.text || !this.handler) return;
+    if (!message || !this.handler) return;
+
+    // Handle /start command
+    if (message.text === '/start') {
+      await this.sendMarkdown(message.chat.id, '👋 Hello! I\'m ready to help. Send me a message to get started.');
+      return;
+    }
+
+    // Handle text, photo captions, document captions
+    const text = message.text || message.caption;
+    if (!text) return;
 
     const msg: Message = {
       id: `tg_${message.message_id}`,
       role: 'user',
-      content: message.text,
+      content: text,
       timestamp: message.date * 1000,
       metadata: {
         sessionId: `tg_${message.chat.id}`,
@@ -167,33 +178,133 @@ export class TelegramChannel extends BaseChannel {
         firstName: message.from?.first_name,
         platform: 'telegram',
         chatType: message.chat.type,
+        replyToMessageId: message.message_id,
       },
     };
 
-    // Show typing indicator while processing
+    // Show typing indicator
     await this.apiCall('sendChatAction', { chat_id: message.chat.id, action: 'typing' });
     const typingInterval = setInterval(() => {
       this.apiCall('sendChatAction', { chat_id: message.chat.id, action: 'typing' }).catch(() => {});
     }, 4000);
 
     try {
-      const response = await this.handler(msg);
-      await this.sendMessage(message.chat.id, response.content);
+      // Try streaming if provider supports it
+      if (this.streamHandler) {
+        await this.streamResponse(message.chat.id, msg, message.message_id);
+      } else {
+        const response = await this.handler(msg);
+        await this.sendMarkdown(message.chat.id, response.content, message.message_id);
+      }
+    } catch (err) {
+      console.error('[TelegramChannel] Error processing message:', err);
+      await this.sendMarkdown(message.chat.id, '⚠️ Sorry, something went wrong. Please try again.');
     } finally {
       clearInterval(typingInterval);
     }
   }
 
-  async sendMessage(chatId: number | string, text: string): Promise<void> {
-    // Telegram max message length is 4096
+  private async streamResponse(chatId: number | string, msg: Message, replyTo?: number): Promise<void> {
+    if (!this.streamHandler) return;
+
+    let sentMessageId: number | null = null;
+    let fullText = '';
+    let lastEditTime = 0;
+    const EDIT_INTERVAL = 1000; // Edit at most once per second
+    let pendingEdit = false;
+
+    const doEdit = async () => {
+      if (!sentMessageId || !fullText) return;
+      pendingEdit = false;
+      try {
+        await this.apiCall('editMessageText', {
+          chat_id: chatId,
+          message_id: sentMessageId,
+          text: fullText,
+          parse_mode: 'Markdown',
+        });
+        lastEditTime = Date.now();
+      } catch (err: any) {
+        // If Markdown fails, try plain text
+        if (err?.message?.includes('parse') || err?.message?.includes('entities')) {
+          try {
+            await this.apiCall('editMessageText', {
+              chat_id: chatId,
+              message_id: sentMessageId,
+              text: fullText,
+            });
+          } catch {}
+        }
+      }
+    };
+
+    try {
+      for await (const chunk of this.streamHandler(msg)) {
+        fullText += chunk;
+
+        if (!sentMessageId) {
+          // Send first message
+          const result = await this.sendMarkdown(chatId, fullText, replyTo);
+          sentMessageId = result?.message_id;
+          lastEditTime = Date.now();
+        } else {
+          const now = Date.now();
+          if (now - lastEditTime >= EDIT_INTERVAL) {
+            await doEdit();
+          } else if (!pendingEdit) {
+            pendingEdit = true;
+          }
+        }
+      }
+
+      // Final edit with complete text
+      if (sentMessageId && fullText) {
+        await doEdit();
+      }
+    } catch (err) {
+      // If streaming fails, send what we have
+      if (!sentMessageId && fullText) {
+        await this.sendMarkdown(chatId, fullText, replyTo);
+      }
+      throw err;
+    }
+  }
+
+  // Stream handler — set by runtime when provider supports streaming
+  private streamHandler?: (msg: Message) => AsyncIterable<string>;
+
+  setStreamHandler(handler: (msg: Message) => AsyncIterable<string>): void {
+    this.streamHandler = handler;
+  }
+
+  async sendMarkdown(chatId: number | string, text: string, replyTo?: number): Promise<any> {
     const chunks = this.splitText(text, 4096);
+    let lastResult: any = null;
     for (const chunk of chunks) {
-      await this.apiCall('sendMessage', {
-        chat_id: chatId,
-        text: chunk,
-        parse_mode: 'Markdown',
-      });
+      try {
+        lastResult = await this.apiCall('sendMessage', {
+          chat_id: chatId,
+          text: chunk,
+          parse_mode: 'Markdown',
+          ...(replyTo ? { reply_to_message_id: replyTo } : {}),
+        });
+        // Only reply to first chunk
+        replyTo = undefined;
+      } catch (err: any) {
+        // Markdown parse failed — send as plain text
+        lastResult = await this.apiCall('sendMessage', {
+          chat_id: chatId,
+          text: chunk,
+          ...(replyTo ? { reply_to_message_id: replyTo } : {}),
+        });
+        replyTo = undefined;
+      }
     }
+    return lastResult?.result;
+  }
+
+  async sendMessage(chatId: number | string, text: string): Promise<void> {
+    await this.sendMarkdown(chatId, text);
   }
 
   private async apiCall(method: string, body?: Record<string, unknown>): Promise<any> {

package/src/core/runtime.ts

@@ -136,10 +136,21 @@ export class AgentRuntime {
         this.agent.bindChannel(webChannel);
         this.logger.info('Bound web channel', { port });
       } else if (ch.type === 'telegram') {
-        this.agent.bindChannel(new TelegramChannel({
+        const tgChannel = new TelegramChannel({
           token: ch.config?.token as string,
           port: ch.port,
-        }));
+        });
+        // Wire up streaming for real-time message editing
+        const agentRef = this.agent;
+        tgChannel.setStreamHandler(async function* (msg) {
+          const history = [msg];
+          const provider = agentRef.provider;
+          const systemPrompt = agentRef.getSystemPrompt();
+          for await (const chunk of provider.chatStream(history, systemPrompt)) {
+            yield chunk;
+          }
+        });
+        this.agent.bindChannel(tgChannel);
         this.logger.info('Bound telegram channel');
       } else if (ch.type === 'websocket') {
         this.agent.bindChannel(new WebSocketChannel(ch.port ?? 3002));

package/src/providers/index.ts

@@ -410,9 +410,67 @@ class ClaudeCLIProvider implements LLMProvider {
   }
 
   async *chatStream(messages: Message[], systemPrompt?: string): AsyncIterable<string> {
-    // Claude CLI --print doesn't support streaming well, so we do single-shot
-    const result = await this.chat(messages, systemPrompt);
-    yield result;
+    // Build prompt same as chat()
+    const parts: string[] = [];
+    if (systemPrompt) {
+      parts.push(`[System]: ${systemPrompt}`);
+    }
+    for (const m of messages) {
+      const role = m.role === 'user' ? 'Human' : 'Assistant';
+      parts.push(`${role}: ${m.content}`);
+    }
+    const prompt = parts.join('\n\n');
+
+    const args = ['-p', '--output-format', 'text'];
+    if (this.model) {
+      args.push('--model', this.model);
+    }
+
+    // Write system prompt to temp file if needed
+    let tmpFile: string | undefined;
+    if (systemPrompt) {
+      const { writeFileSync } = await import('fs');
+      const { join } = await import('path');
+      const { tmpdir } = await import('os');
+      tmpFile = join(tmpdir(), `opc-claude-stream-${Date.now()}.txt`);
+      writeFileSync(tmpFile, systemPrompt);
+      args.push('--system-prompt-file', tmpFile);
+    }
+
+    const lastMsg = messages[messages.length - 1];
+    args.push(lastMsg?.content ?? prompt);
+
+    const { spawn } = await import('child_process');
+
+    try {
+      const proc = spawn('claude', args, {
+        env: { ...process.env },
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      proc.stdin.end();
+
+      // Yield chunks as they arrive from stdout
+      const readable = proc.stdout;
+      for await (const chunk of readable) {
+        yield (chunk as Buffer).toString();
+      }
+
+      // Wait for process to finish
+      await new Promise<void>((resolve, reject) => {
+        proc.on('close', (code) => {
+          if (code !== 0 && code !== null) {
+            // Already yielded content, just log
+            console.warn(`[ClaudeCLI] Process exited with code ${code}`);
+          }
+          resolve();
+        });
+        proc.on('error', reject);
+      });
+    } finally {
+      if (tmpFile) {
+        try { const { unlinkSync } = await import('fs'); unlinkSync(tmpFile); } catch {}
+      }
+    }
   }
 }