opencode-gateway 0.3.1 → 0.3.2

package/dist/delivery/text.d.ts

@@ -7,11 +7,15 @@ export type TextDeliverySession = {
     preview(text: string): Promise<void>;
     finish(finalText: string | null): Promise<boolean>;
 };
+export type TextDeliveryOptions = {
+    progressiveRefreshIntervalMs?: number;
+};
 export declare class GatewayTextDelivery {
     private readonly transport;
     private readonly store;
     private readonly telegramSupport;
-    constructor(transport: GatewayTransportHost, store: SqliteStore, telegramSupport: TelegramProgressiveSupport);
+    private readonly options;
+    constructor(transport: GatewayTransportHost, store: SqliteStore, telegramSupport: TelegramProgressiveSupport, options?: TextDeliveryOptions);
     open(target: BindingDeliveryTarget, preference: DeliveryModePreference): Promise<TextDeliverySession>;
     openMany(targets: BindingDeliveryTarget[], preference: DeliveryModePreference): Promise<TextDeliverySession[]>;
     sendTest(target: BindingDeliveryTarget, text: string, preference: DeliveryModePreference): Promise<{

package/dist/index.js

@@ -17219,14 +17219,18 @@ function createDraftId() {
 }
 
 // src/delivery/text.ts
+var DEFAULT_PROGRESSIVE_REFRESH_INTERVAL_MS = 3000;
+
 class GatewayTextDelivery {
   transport;
   store;
   telegramSupport;
-  constructor(transport, store, telegramSupport) {
+  options;
+  constructor(transport, store, telegramSupport, options = {}) {
     this.transport = transport;
     this.store = store;
     this.telegramSupport = telegramSupport;
+    this.options = options;
   }
   async open(target, preference) {
     const [session] = await this.openMany([target], preference);
@@ -17240,7 +17244,7 @@ class GatewayTextDelivery {
     const sessions = await Promise.all(uniqueTargets.map(async (target) => {
       const mode = await this.telegramSupport.resolveMode(target, preference);
       if (mode === "progressive") {
-        const session = new ProgressiveTextDeliverySession(target, this.transport, this.telegramSupport, this.store);
+        const session = new ProgressiveTextDeliverySession(target, this.transport, this.telegramSupport, this.store, this.options.progressiveRefreshIntervalMs ?? DEFAULT_PROGRESSIVE_REFRESH_INTERVAL_MS);
         session.start();
         return session;
       }
@@ -17320,37 +17324,86 @@ class ProgressiveTextDeliverySession {
   transport;
   telegramSupport;
   store;
+  refreshIntervalMs;
   mode = "progressive";
   previewFailed = false;
   previewDelivered = false;
-  closed = false;
+  acceptingPreviews = true;
+  finished = false;
+  latestPreviewText = null;
   pendingPreviewCount = 0;
   pendingPreview = Promise.resolve();
+  keepaliveTimer = null;
   draftId = createDraftId();
-  constructor(target, transport, telegramSupport, store) {
+  constructor(target, transport, telegramSupport, store, refreshIntervalMs) {
     this.target = target;
     this.transport = transport;
     this.telegramSupport = telegramSupport;
     this.store = store;
+    this.refreshIntervalMs = refreshIntervalMs;
   }
   start() {
     this.telegramSupport.startTyping(this.target);
   }
   async preview(text) {
-    if (this.previewFailed || this.closed || text.trim().length === 0) {
+    if (this.previewFailed || !this.acceptingPreviews || this.finished || text.trim().length === 0) {
       return;
     }
+    this.latestPreviewText = text;
+    await this.enqueueDraftSend(() => this.latestPreviewText, true);
+    if (!this.previewFailed && this.previewDelivered) {
+      this.ensureKeepalive();
+    }
+  }
+  async finish(finalText) {
+    this.acceptingPreviews = false;
+    this.stopKeepalive();
+    await this.awaitPendingPreview();
+    const normalizedFinalText = finalText?.trim() ?? "";
+    if (normalizedFinalText.length === 0) {
+      this.finished = true;
+      return false;
+    }
+    if (!this.previewDelivered && !this.previewFailed) {
+      recordTelegramStreamFallback(this.store, "preview_not_established", Date.now());
+    }
+    if (this.previewDelivered && !this.previewFailed && this.latestPreviewText !== normalizedFinalText) {
+      this.latestPreviewText = normalizedFinalText;
+      await this.enqueueDraftSend(() => this.latestPreviewText, false);
+    }
+    try {
+      const ack = await this.transport.sendMessage({
+        deliveryTarget: this.target,
+        body: normalizedFinalText
+      });
+      if (ack.errorMessage !== null) {
+        throw new Error(ack.errorMessage);
+      }
+      return true;
+    } finally {
+      this.finished = true;
+      this.stopKeepalive();
+    }
+  }
+  async enqueueDraftSend(getText, recordEmit) {
     const runPreview = async () => {
       try {
-        if (this.previewFailed || this.closed) {
+        if (this.finished || this.previewFailed) {
+          return;
+        }
+        const text = getText();
+        if (text === null || text.trim().length === 0) {
           return;
         }
         try {
-          recordTelegramPreviewEmit(this.store, Date.now());
+          if (recordEmit) {
+            recordTelegramPreviewEmit(this.store, Date.now());
+          }
           await this.telegramSupport.sendDraft(this.target, this.draftId, text);
           this.previewDelivered = true;
         } catch {
           this.previewFailed = true;
+          this.stopKeepalive();
         }
       } finally {
         this.pendingPreviewCount = Math.max(0, this.pendingPreviewCount - 1);
@@ -17360,25 +17413,37 @@ class ProgressiveTextDeliverySession {
     this.pendingPreview = this.pendingPreview.then(runPreview, runPreview);
     await this.pendingPreview;
   }
-  async finish(finalText) {
-    this.closed = true;
+  async awaitPendingPreview() {
     if (this.pendingPreviewCount > 0) {
       await this.pendingPreview;
     }
-    if (finalText === null || finalText.trim().length === 0) {
-      return false;
-    }
-    if (!this.previewDelivered && !this.previewFailed) {
-      recordTelegramStreamFallback(this.store, "preview_not_established", Date.now());
+  }
+  ensureKeepalive() {
+    if (!this.shouldKeepalive() || this.keepaliveTimer !== null) {
+      return;
     }
-    const ack = await this.transport.sendMessage({
-      deliveryTarget: this.target,
-      body: finalText
-    });
-    if (ack.errorMessage !== null) {
-      throw new Error(ack.errorMessage);
+    this.keepaliveTimer = setTimeout(() => {
+      this.keepaliveTimer = null;
+      if (!this.shouldKeepalive()) {
+        return;
+      }
+      this.telegramSupport.startTyping(this.target);
+      this.enqueueDraftSend(() => this.latestPreviewText, false).finally(() => {
+        if (this.shouldKeepalive()) {
+          this.ensureKeepalive();
+        }
+      });
+    }, this.refreshIntervalMs);
+  }
+  stopKeepalive() {
+    if (this.keepaliveTimer === null) {
+      return;
     }
-    return true;
+    clearTimeout(this.keepaliveTimer);
+    this.keepaliveTimer = null;
+  }
+  shouldKeepalive() {
+    return this.acceptingPreviews && !this.finished && !this.previewFailed && this.previewDelivered && this.latestPreviewText !== null;
   }
 }
 function dedupeTargets(targets) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gateway",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Gateway plugin for OpenCode",
   "license": "MIT",
   "type": "module",