@poncho-ai/messaging 0.7.6 → 0.7.8

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/messaging@0.7.6 build /home/runner/work/poncho-ai/poncho-ai/packages/messaging
+> @poncho-ai/messaging@0.7.8 build /home/runner/work/poncho-ai/poncho-ai/packages/messaging
 > tsup src/index.ts --format esm --dts
 
 CLI Building entry: src/index.ts
@@ -7,8 +7,8 @@
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist/index.js 51.09 KB
-ESM ⚡️ Build success in 102ms
+ESM dist/index.js 51.91 KB
+ESM ⚡️ Build success in 49ms
 DTS Build start
-DTS ⚡️ Build success in 4825ms
-DTS dist/index.d.ts 11.24 KB
+DTS ⚡️ Build success in 5402ms
+DTS dist/index.d.ts 11.66 KB

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @poncho-ai/messaging
 
+## 0.7.8
+
+### Patch Changes
+
+- [`30026c5`](https://github.com/cesr/poncho-ai/commit/30026c5eba3f714bb80c2402c5e8f32c6fd38d87) Thanks [@cesr](https://github.com/cesr)! - Fix Telegram conversation instability on serverless: use stable platformThreadId instead of in-memory session counter.
+
+## 0.7.7
+
+### Patch Changes
+
+- [#61](https://github.com/cesr/poncho-ai/pull/61) [`0a51abe`](https://github.com/cesr/poncho-ai/commit/0a51abec12191397fd36ab1fd4feca7460489e33) Thanks [@cesr](https://github.com/cesr)! - Fix /new command on Telegram in serverless environments: persist conversation reset to the store so it survives cold starts.
+
 ## 0.7.6
 
 ### Patch Changes

package/dist/index.d.ts

@@ -26,6 +26,7 @@ interface IncomingMessage {
     raw: unknown;
 }
 type IncomingMessageHandler = (message: IncomingMessage) => Promise<void>;
+type ResetHandler = (platform: string, threadRef: ThreadRef) => Promise<void>;
 type RouteHandler = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
 type RouteRegistrar = (method: "GET" | "POST", path: string, handler: RouteHandler) => void;
 interface MessagingAdapter {
@@ -43,6 +44,8 @@ interface MessagingAdapter {
     initialize(): Promise<void>;
     /** Set the handler that processes incoming messages. */
     onMessage(handler: IncomingMessageHandler): void;
+    /** Set the handler called when a user resets the conversation (e.g. /new). */
+    onReset?(handler: ResetHandler): void;
     /** Post a reply back to the originating thread. */
     sendReply(threadRef: ThreadRef, content: string, options?: {
         files?: FileAttachment[];
@@ -89,6 +92,11 @@ interface AgentRunner {
         steps?: number;
         maxSteps?: number;
     }>;
+    /**
+     * Reset a conversation by clearing its messages, making the next
+     * interaction start fresh while keeping the same conversation ID.
+     */
+    resetConversation?(conversationId: string): Promise<void>;
 }
 interface AgentBridgeOptions {
     adapter: MessagingAdapter;
@@ -223,13 +231,14 @@ declare class TelegramAdapter implements MessagingAdapter {
     private readonly webhookSecretEnv;
     private readonly allowedUserIds;
     private handler;
+    private resetHandler;
     private approvalDecisionHandler;
-    private readonly sessionCounters;
     private readonly approvalMessageIds;
     private lastUpdateId;
     constructor(options?: TelegramAdapterOptions);
     initialize(): Promise<void>;
     onMessage(handler: IncomingMessageHandler): void;
+    onReset(handler: ResetHandler): void;
     registerRoutes(router: RouteRegistrar): void;
     sendReply(threadRef: ThreadRef, content: string, options?: {
         files?: FileAttachment[];
@@ -242,7 +251,6 @@ declare class TelegramAdapter implements MessagingAdapter {
     updateApprovalMessage(approvalId: string, decision: "approved" | "denied", tool: string): Promise<void>;
     private handleRequest;
     private handleCallbackQuery;
-    private sessionKey;
     private extractFiles;
 }
 

package/dist/index.js

@@ -30,6 +30,12 @@ var AgentBridge = class {
       this.waitUntil(processing);
       return processing;
     });
+    if (this.adapter.onReset && this.runner.resetConversation) {
+      this.adapter.onReset(async (platform, threadRef) => {
+        const conversationId = conversationIdFromThread(platform, threadRef);
+        await this.runner.resetConversation(conversationId);
+      });
+    }
     await this.adapter.initialize();
   }
   async handleMessage(message) {
@@ -1186,6 +1192,12 @@ var stripMention2 = (text, entities, botUsername, botId) => {
 // src/adapters/telegram/index.ts
 var TYPING_INTERVAL_MS = 4e3;
 var NEW_COMMAND_RE = /^\/new(?:@(\S+))?$/i;
+var parseMessageThreadId = (platformThreadId, chatId) => {
+  const parts = platformThreadId.split(":");
+  if (parts.length !== 3 || parts[0] !== chatId) return void 0;
+  const threadId = Number(parts[1]);
+  return Number.isInteger(threadId) ? threadId : void 0;
+};
 var collectBody3 = (req) => new Promise((resolve, reject) => {
   const chunks = [];
   req.on("data", (chunk) => chunks.push(chunk));
@@ -1204,8 +1216,8 @@ var TelegramAdapter = class {
   webhookSecretEnv;
   allowedUserIds;
   handler;
+  resetHandler;
   approvalDecisionHandler;
-  sessionCounters = /* @__PURE__ */ new Map();
   approvalMessageIds = /* @__PURE__ */ new Map();
   lastUpdateId = 0;
   constructor(options = {}) {
@@ -1231,6 +1243,9 @@ var TelegramAdapter = class {
   onMessage(handler) {
     this.handler = handler;
   }
+  onReset(handler) {
+    this.resetHandler = handler;
+  }
   registerRoutes(router) {
     router(
       "POST",
@@ -1241,11 +1256,16 @@ var TelegramAdapter = class {
   async sendReply(threadRef, content, options) {
     const chatId = threadRef.channelId;
     const replyTo = threadRef.messageId ? Number(threadRef.messageId) : void 0;
+    const messageThreadId = parseMessageThreadId(
+      threadRef.platformThreadId,
+      chatId
+    );
     if (content) {
       const chunks = splitMessage2(content);
       for (const chunk of chunks) {
         await sendMessage(this.botToken, chatId, chunk, {
-          reply_to_message_id: replyTo
+          reply_to_message_id: replyTo,
+          message_thread_id: messageThreadId
         });
       }
     }
@@ -1254,11 +1274,13 @@ var TelegramAdapter = class {
         if (file.mediaType.startsWith("image/")) {
           await sendPhoto(this.botToken, chatId, file.data, {
             reply_to_message_id: replyTo,
+            message_thread_id: messageThreadId,
             filename: file.filename
           });
         } else {
           await sendDocument(this.botToken, chatId, file.data, {
             reply_to_message_id: replyTo,
+            message_thread_id: messageThreadId,
             filename: file.filename,
             mediaType: file.mediaType
           });
@@ -1413,11 +1435,20 @@ ${inputSummary}` : "(no input)"
         res.end();
         return;
       }
-      const key2 = this.sessionKey(message);
-      const current = this.sessionCounters.get(key2) ?? 0;
-      this.sessionCounters.set(key2, current + 1);
       res.writeHead(200);
       res.end();
+      if (this.resetHandler) {
+        const topicId2 = message.message_thread_id;
+        const threadId = topicId2 ? `${chatId}:${topicId2}:0` : `${chatId}:0`;
+        try {
+          await this.resetHandler("telegram", {
+            channelId: chatId,
+            platformThreadId: threadId
+          });
+        } catch (err) {
+          console.error("[telegram-adapter] reset handler error:", err instanceof Error ? err.message : err);
+        }
+      }
       await sendMessage(
         this.botToken,
         chatId,
@@ -1446,10 +1477,8 @@ ${inputSummary}` : "(no input)"
     res.end();
     if (!this.handler) return;
     const files = await this.extractFiles(message);
-    const key = this.sessionKey(message);
-    const session = this.sessionCounters.get(key) ?? 0;
     const topicId = message.message_thread_id;
-    const platformThreadId = topicId ? `${chatId}:${topicId}:${session}` : `${chatId}:${session}`;
+    const platformThreadId = topicId ? `${chatId}:${topicId}:0` : `${chatId}:0`;
     const userId = String(message.from?.id ?? "unknown");
     const userName = [message.from?.first_name, message.from?.last_name].filter(Boolean).join(" ") || void 0;
     const ponchoMessage = {
@@ -1505,10 +1534,6 @@ ${inputSummary}` : "(no input)"
   // -----------------------------------------------------------------------
   // Helpers
   // -----------------------------------------------------------------------
-  sessionKey(message) {
-    const chatId = String(message.chat.id);
-    return message.message_thread_id ? `${chatId}:${message.message_thread_id}` : chatId;
-  }
   async extractFiles(message) {
     const files = [];
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/messaging",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Messaging platform adapters for Poncho agents (Slack, Telegram, etc.)",
   "repository": {
     "type": "git",

package/src/adapters/telegram/index.ts

@@ -4,6 +4,7 @@ import type {
   IncomingMessage as PonchoIncomingMessage,
   IncomingMessageHandler,
   MessagingAdapter,
+  ResetHandler,
   RouteRegistrar,
   ThreadRef,
 } from "../../types.js";
@@ -30,6 +31,19 @@ import {
 const TYPING_INTERVAL_MS = 4_000;
 const NEW_COMMAND_RE = /^\/new(?:@(\S+))?$/i;
 
+const parseMessageThreadId = (
+  platformThreadId: string,
+  chatId: string,
+): number | undefined => {
+  const parts = platformThreadId.split(":");
+  // Telegram thread format:
+  // - non-topic chats: `${chatId}:${session}`
+  // - forum topics: `${chatId}:${message_thread_id}:${session}`
+  if (parts.length !== 3 || parts[0] !== chatId) return undefined;
+  const threadId = Number(parts[1]);
+  return Number.isInteger(threadId) ? threadId : undefined;
+};
+
 export interface TelegramApprovalInfo {
   approvalId: string;
   tool: string;
@@ -69,8 +83,8 @@ export class TelegramAdapter implements MessagingAdapter {
   private readonly webhookSecretEnv: string;
   private readonly allowedUserIds: number[] | undefined;
   private handler: IncomingMessageHandler | undefined;
+  private resetHandler: ResetHandler | undefined;
   private approvalDecisionHandler: TelegramApprovalDecisionHandler | undefined;
-  private readonly sessionCounters = new Map<string, number>();
   private readonly approvalMessageIds = new Map<string, { chatId: string; messageId: number }>();
   private lastUpdateId = 0;
 
@@ -107,6 +121,10 @@ export class TelegramAdapter implements MessagingAdapter {
     this.handler = handler;
   }
 
+  onReset(handler: ResetHandler): void {
+    this.resetHandler = handler;
+  }
+
   registerRoutes(router: RouteRegistrar): void {
     router("POST", "/api/messaging/telegram", (req, res) =>
       this.handleRequest(req, res),
@@ -122,12 +140,17 @@ export class TelegramAdapter implements MessagingAdapter {
     const replyTo = threadRef.messageId
       ? Number(threadRef.messageId)
       : undefined;
+    const messageThreadId = parseMessageThreadId(
+      threadRef.platformThreadId,
+      chatId,
+    );
 
     if (content) {
       const chunks = splitMessage(content);
       for (const chunk of chunks) {
         await sendMessage(this.botToken, chatId, chunk, {
           reply_to_message_id: replyTo,
+          message_thread_id: messageThreadId,
         });
       }
     }
@@ -137,11 +160,13 @@ export class TelegramAdapter implements MessagingAdapter {
         if (file.mediaType.startsWith("image/")) {
           await sendPhoto(this.botToken, chatId, file.data, {
             reply_to_message_id: replyTo,
+            message_thread_id: messageThreadId,
             filename: file.filename,
           });
         } else {
           await sendDocument(this.botToken, chatId, file.data, {
             reply_to_message_id: replyTo,
+            message_thread_id: messageThreadId,
             filename: file.filename,
             mediaType: file.mediaType,
           });
@@ -348,13 +373,25 @@ export class TelegramAdapter implements MessagingAdapter {
         return;
       }
 
-      const key = this.sessionKey(message);
-      const current = this.sessionCounters.get(key) ?? 0;
-      this.sessionCounters.set(key, current + 1);
-
       res.writeHead(200);
       res.end();
 
+      // Clear conversation in the store so the next message starts fresh.
+      if (this.resetHandler) {
+        const topicId = message.message_thread_id;
+        const threadId = topicId
+          ? `${chatId}:${topicId}:0`
+          : `${chatId}:0`;
+        try {
+          await this.resetHandler("telegram", {
+            channelId: chatId,
+            platformThreadId: threadId,
+          });
+        } catch (err) {
+          console.error("[telegram-adapter] reset handler error:", err instanceof Error ? err.message : err);
+        }
+      }
+
       await sendMessage(
         this.botToken,
         chatId,
@@ -396,12 +433,12 @@ export class TelegramAdapter implements MessagingAdapter {
     const files = await this.extractFiles(message);
 
     // -- Build thread ref -------------------------------------------------
-    const key = this.sessionKey(message);
-    const session = this.sessionCounters.get(key) ?? 0;
+    // Always use a fixed session component so the conversationId is stable
+    // across serverless cold starts. /new resets via the store instead.
     const topicId = message.message_thread_id;
     const platformThreadId = topicId
-      ? `${chatId}:${topicId}:${session}`
-      : `${chatId}:${session}`;
+      ? `${chatId}:${topicId}:0`
+      : `${chatId}:0`;
 
     const userId = String(message.from?.id ?? "unknown");
     const userName =
@@ -476,13 +513,6 @@ export class TelegramAdapter implements MessagingAdapter {
   // Helpers
   // -----------------------------------------------------------------------
 
-  private sessionKey(message: TelegramMessage): string {
-    const chatId = String(message.chat.id);
-    return message.message_thread_id
-      ? `${chatId}:${message.message_thread_id}`
-      : chatId;
-  }
-
   private async extractFiles(
     message: TelegramMessage,
   ): Promise<FileAttachment[]> {

package/src/bridge.ts

@@ -50,6 +50,14 @@ export class AgentBridge {
       this.waitUntil(processing);
       return processing;
     });
+
+    if (this.adapter.onReset && this.runner.resetConversation) {
+      this.adapter.onReset(async (platform, threadRef) => {
+        const conversationId = conversationIdFromThread(platform, threadRef);
+        await this.runner.resetConversation!(conversationId);
+      });
+    }
+
     await this.adapter.initialize();
   }
 

package/src/types.ts

@@ -33,6 +33,11 @@ export type IncomingMessageHandler = (
   message: IncomingMessage,
 ) => Promise<void>;
 
+export type ResetHandler = (
+  platform: string,
+  threadRef: ThreadRef,
+) => Promise<void>;
+
 // ---------------------------------------------------------------------------
 // Route registration (adapter ↔ HTTP server contract)
 // ---------------------------------------------------------------------------
@@ -73,6 +78,9 @@ export interface MessagingAdapter {
   /** Set the handler that processes incoming messages. */
   onMessage(handler: IncomingMessageHandler): void;
 
+  /** Set the handler called when a user resets the conversation (e.g. /new). */
+  onReset?(handler: ResetHandler): void;
+
   /** Post a reply back to the originating thread. */
   sendReply(
     threadRef: ThreadRef,
@@ -133,6 +141,12 @@ export interface AgentRunner {
     steps?: number;
     maxSteps?: number;
   }>;
+
+  /**
+   * Reset a conversation by clearing its messages, making the next
+   * interaction start fresh while keeping the same conversation ID.
+   */
+  resetConversation?(conversationId: string): Promise<void>;
 }
 
 // ---------------------------------------------------------------------------