@poncho-ai/messaging 0.7.6 → 0.7.7

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.7 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 52.41 KB
+ESM ⚡️ Build success in 89ms
 DTS Build start
-DTS ⚡️ Build success in 4825ms
-DTS dist/index.d.ts 11.24 KB
+DTS ⚡️ Build success in 5653ms
+DTS dist/index.d.ts 11.72 KB

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @poncho-ai/messaging
 
+## 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,6 +231,7 @@ declare class TelegramAdapter implements MessagingAdapter {
     private readonly webhookSecretEnv;
     private readonly allowedUserIds;
     private handler;
+    private resetHandler;
     private approvalDecisionHandler;
     private readonly sessionCounters;
     private readonly approvalMessageIds;
@@ -230,6 +239,7 @@ declare class TelegramAdapter implements MessagingAdapter {
     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[];

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,6 +1216,7 @@ var TelegramAdapter = class {
   webhookSecretEnv;
   allowedUserIds;
   handler;
+  resetHandler;
   approvalDecisionHandler;
   sessionCounters = /* @__PURE__ */ new Map();
   approvalMessageIds = /* @__PURE__ */ new Map();
@@ -1231,6 +1244,9 @@ var TelegramAdapter = class {
   onMessage(handler) {
     this.handler = handler;
   }
+  onReset(handler) {
+    this.resetHandler = handler;
+  }
   registerRoutes(router) {
     router(
       "POST",
@@ -1241,11 +1257,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 +1275,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
           });
@@ -1418,6 +1441,18 @@ ${inputSummary}` : "(no input)"
       this.sessionCounters.set(key2, current + 1);
       res.writeHead(200);
       res.end();
+      if (this.resetHandler) {
+        const topicId2 = message.message_thread_id;
+        const prevThreadId = topicId2 ? `${chatId}:${topicId2}:${current}` : `${chatId}:${current}`;
+        try {
+          await this.resetHandler("telegram", {
+            channelId: chatId,
+            platformThreadId: prevThreadId
+          });
+        } catch (err) {
+          console.error("[telegram-adapter] reset handler error:", err instanceof Error ? err.message : err);
+        }
+      }
       await sendMessage(
         this.botToken,
         chatId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/messaging",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "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,6 +83,7 @@ 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 }>();
@@ -107,6 +122,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 +141,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 +161,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,
           });
@@ -355,6 +381,24 @@ export class TelegramAdapter implements MessagingAdapter {
       res.writeHead(200);
       res.end();
 
+      // Persist the reset so it survives serverless cold starts.
+      // The in-memory counter handles long-running processes; the bridge
+      // clears messages in the conversation store for serverless.
+      if (this.resetHandler) {
+        const topicId = message.message_thread_id;
+        const prevThreadId = topicId
+          ? `${chatId}:${topicId}:${current}`
+          : `${chatId}:${current}`;
+        try {
+          await this.resetHandler("telegram", {
+            channelId: chatId,
+            platformThreadId: prevThreadId,
+          });
+        } catch (err) {
+          console.error("[telegram-adapter] reset handler error:", err instanceof Error ? err.message : err);
+        }
+      }
+
       await sendMessage(
         this.botToken,
         chatId,

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>;
 }
 
 // ---------------------------------------------------------------------------