omnius 1.0.657 → 1.0.659

package/dist/index.js

@@ -779939,6 +779939,438 @@ var init_telegram_vision_router = __esm({
   }
 });
 
+// packages/cli/src/tui/telegram-api-governor.ts
+function positiveInteger3(value2, fallback) {
+  return Number.isFinite(value2) && value2 > 0 ? Math.max(1, Math.floor(value2)) : fallback;
+}
+function nonNegativeInteger(value2, fallback) {
+  return Number.isFinite(value2) && value2 >= 0 ? Math.max(0, Math.floor(value2)) : fallback;
+}
+function parseArrayLength(value2) {
+  if (Array.isArray(value2)) return value2.length;
+  if (typeof value2 !== "string") return void 0;
+  try {
+    const parsed = JSON.parse(value2);
+    return Array.isArray(parsed) ? parsed.length : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function telegramDeliveryMessageCost(method, body) {
+  if (!TELEGRAM_DELIVERY_METHODS.has(method)) return 0;
+  if (method === "sendMediaGroup") {
+    return Math.max(1, parseArrayLength(body?.["media"]) ?? 1);
+  }
+  if (method === "copyMessages" || method === "forwardMessages") {
+    return Math.max(1, parseArrayLength(body?.["message_ids"]) ?? 1);
+  }
+  return 1;
+}
+function telegramFloodWaitSeconds(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) {
+    return void 0;
+  }
+  const response = value2;
+  if (Number(response["error_code"]) !== 429) return void 0;
+  const parameters = response["parameters"];
+  if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) {
+    return void 0;
+  }
+  const seconds = Number(
+    parameters["retry_after"]
+  );
+  return Number.isFinite(seconds) && seconds > 0 ? seconds : void 0;
+}
+function inferredGroupChat(chatId, chatType) {
+  if (chatType) return chatType !== "private";
+  if (typeof chatId === "number") return chatId < 0;
+  return typeof chatId === "string" && /^-\d+$/.test(chatId) && Number(chatId) < 0;
+}
+function abortError(reason) {
+  if (reason instanceof Error) return reason;
+  const error = new Error(
+    typeof reason === "string" && reason ? reason : "Telegram request aborted"
+  );
+  error.name = "AbortError";
+  return error;
+}
+var TELEGRAM_DELIVERY_METHODS, TelegramApiGovernor;
+var init_telegram_api_governor = __esm({
+  "packages/cli/src/tui/telegram-api-governor.ts"() {
+    TELEGRAM_DELIVERY_METHODS = /* @__PURE__ */ new Set([
+      "copyMessage",
+      "copyMessages",
+      "forwardMessage",
+      "forwardMessages",
+      "sendAnimation",
+      "sendAudio",
+      "sendChecklist",
+      "sendContact",
+      "sendDice",
+      "sendDocument",
+      "sendGame",
+      "sendInvoice",
+      "sendLivePhoto",
+      "sendLocation",
+      "sendMediaGroup",
+      "sendMessage",
+      "sendMessageDraft",
+      "sendPaidMedia",
+      "sendPhoto",
+      "sendPoll",
+      "sendSticker",
+      "sendVenue",
+      "sendVideo",
+      "sendVideoNote",
+      "sendVoice"
+    ]);
+    TelegramApiGovernor = class {
+      globalRequestsPerSecond;
+      globalMessagesPerSecond;
+      perChatMessageIntervalMs;
+      groupMessagesPerMinute;
+      maxConcurrentRequests;
+      maxQueuedRequests;
+      now;
+      lanes = /* @__PURE__ */ new Map();
+      laneOrder = [];
+      nextLaneIndex = 0;
+      nextRequestId = 1;
+      queuedCount = 0;
+      activeCount = 0;
+      timer = null;
+      stoppedReason = null;
+      globalCooldownUntilMs = 0;
+      chatCooldownUntilMs = /* @__PURE__ */ new Map();
+      globalRequestStarts = [];
+      globalMessageStarts = [];
+      groupMessageStarts = /* @__PURE__ */ new Map();
+      nextChatMessageAtMs = /* @__PURE__ */ new Map();
+      constructor(options2 = {}) {
+        this.globalRequestsPerSecond = positiveInteger3(
+          options2.globalRequestsPerSecond,
+          28
+        );
+        this.globalMessagesPerSecond = positiveInteger3(
+          options2.globalMessagesPerSecond,
+          28
+        );
+        this.perChatMessageIntervalMs = nonNegativeInteger(
+          options2.perChatMessageIntervalMs,
+          1050
+        );
+        this.groupMessagesPerMinute = positiveInteger3(
+          options2.groupMessagesPerMinute,
+          20
+        );
+        this.maxConcurrentRequests = positiveInteger3(
+          options2.maxConcurrentRequests,
+          8
+        );
+        this.maxQueuedRequests = positiveInteger3(options2.maxQueuedRequests, 2048);
+        this.now = options2.now ?? Date.now;
+      }
+      run(request) {
+        if (this.stoppedReason) return Promise.reject(this.stoppedReason);
+        if (request.signal?.aborted) {
+          return Promise.reject(abortError(request.signal.reason));
+        }
+        if (request.method === "getUpdates") return request.execute();
+        if (this.queuedCount >= this.maxQueuedRequests) {
+          return Promise.reject(
+            new Error(
+              `Telegram API governor queue is full (${this.maxQueuedRequests} requests)`
+            )
+          );
+        }
+        const chatKey = request.chatId === void 0 ? void 0 : String(request.chatId);
+        const laneKey = chatKey === void 0 ? "control" : `chat:${chatKey}`;
+        const messageCost = telegramDeliveryMessageCost(
+          request.method,
+          request.body
+        );
+        return new Promise((resolve92, reject) => {
+          const pending2 = {
+            ...request,
+            id: this.nextRequestId++,
+            laneKey,
+            messageCost,
+            notBeforeMs: 0,
+            resolve: resolve92,
+            reject,
+            queued: false,
+            settled: false
+          };
+          if (request.signal) {
+            pending2.abortListener = () => {
+              if (pending2.settled) return;
+              pending2.settled = true;
+              if (pending2.queued) {
+                pending2.queued = false;
+                this.queuedCount = Math.max(0, this.queuedCount - 1);
+              }
+              reject(abortError(request.signal?.reason));
+              this.pump();
+            };
+            request.signal.addEventListener("abort", pending2.abortListener, {
+              once: true
+            });
+          }
+          this.enqueue(pending2);
+          this.pump();
+        });
+      }
+      stop(reason = "Telegram API governor stopped") {
+        if (this.stoppedReason) return;
+        this.stoppedReason = new Error(reason);
+        if (this.timer) clearTimeout(this.timer);
+        this.timer = null;
+        for (const queue of this.lanes.values()) {
+          for (const pending2 of queue) {
+            if (pending2.settled) continue;
+            pending2.settled = true;
+            pending2.signal?.removeEventListener(
+              "abort",
+              pending2.abortListener ?? (() => {
+              })
+            );
+            pending2.reject(this.stoppedReason);
+          }
+        }
+        this.lanes.clear();
+        this.laneOrder = [];
+        this.queuedCount = 0;
+      }
+      snapshot() {
+        return {
+          active: this.activeCount,
+          queued: this.queuedCount,
+          lanes: this.lanes.size,
+          globalCooldownUntilMs: this.globalCooldownUntilMs,
+          chatCooldowns: Object.fromEntries(this.chatCooldownUntilMs)
+        };
+      }
+      enqueue(pending2, front = false) {
+        let queue = this.lanes.get(pending2.laneKey);
+        if (!queue) {
+          queue = [];
+          this.lanes.set(pending2.laneKey, queue);
+          this.laneOrder.push(pending2.laneKey);
+        }
+        if (pending2.coalesceKey) {
+          const replacedIndex = queue.findIndex(
+            (item) => !item.settled && item.coalesceKey === pending2.coalesceKey
+          );
+          if (replacedIndex >= 0) {
+            const replaced = queue.splice(replacedIndex, 1)[0];
+            replaced.queued = false;
+            replaced.settled = true;
+            this.queuedCount = Math.max(0, this.queuedCount - 1);
+            if (replaced.abortListener) {
+              replaced.signal?.removeEventListener("abort", replaced.abortListener);
+            }
+            if (replaced.supersededValue) {
+              replaced.resolve(replaced.supersededValue());
+            } else {
+              replaced.reject(new Error("Telegram API request was superseded"));
+            }
+          }
+        }
+        if (front) queue.unshift(pending2);
+        else queue.push(pending2);
+        pending2.queued = true;
+        this.queuedCount += 1;
+      }
+      removeEmptyLane(laneKey) {
+        const queue = this.lanes.get(laneKey);
+        if (queue?.some((item) => !item.settled)) return;
+        this.lanes.delete(laneKey);
+        const index = this.laneOrder.indexOf(laneKey);
+        if (index < 0) return;
+        this.laneOrder.splice(index, 1);
+        if (this.laneOrder.length === 0) this.nextLaneIndex = 0;
+        else if (index < this.nextLaneIndex) this.nextLaneIndex -= 1;
+        this.nextLaneIndex %= Math.max(1, this.laneOrder.length);
+      }
+      pruneHistory(history, cutoff) {
+        let remove = 0;
+        while (remove < history.length && history[remove] <= cutoff) remove += 1;
+        if (remove > 0) history.splice(0, remove);
+      }
+      windowReadyAt(history, now2, windowMs, limit2, cost) {
+        this.pruneHistory(history, now2 - windowMs);
+        const needed = history.length + cost - limit2;
+        if (needed <= 0) return now2;
+        return history[Math.min(history.length - 1, needed - 1)] + windowMs + 1;
+      }
+      requestReadyAt(pending2, now2) {
+        let readyAt = Math.max(pending2.notBeforeMs, this.globalCooldownUntilMs);
+        const chatKey = pending2.chatId === void 0 ? void 0 : String(pending2.chatId);
+        if (chatKey !== void 0) {
+          const cooldownUntil = this.chatCooldownUntilMs.get(chatKey) ?? 0;
+          if (cooldownUntil <= now2) this.chatCooldownUntilMs.delete(chatKey);
+          readyAt = Math.max(readyAt, cooldownUntil);
+        }
+        readyAt = Math.max(
+          readyAt,
+          this.windowReadyAt(
+            this.globalRequestStarts,
+            now2,
+            1e3,
+            this.globalRequestsPerSecond,
+            1
+          )
+        );
+        if (pending2.messageCost <= 0) return readyAt;
+        readyAt = Math.max(
+          readyAt,
+          this.windowReadyAt(
+            this.globalMessageStarts,
+            now2,
+            1e3,
+            this.globalMessagesPerSecond,
+            pending2.messageCost
+          )
+        );
+        if (chatKey !== void 0) {
+          const nextChatAt = this.nextChatMessageAtMs.get(chatKey) ?? 0;
+          if (nextChatAt <= now2) this.nextChatMessageAtMs.delete(chatKey);
+          readyAt = Math.max(readyAt, nextChatAt);
+          if (inferredGroupChat(pending2.chatId, pending2.chatType)) {
+            const groupHistory = this.groupMessageStarts.get(chatKey) ?? [];
+            const groupReadyAt = this.windowReadyAt(
+              groupHistory,
+              now2,
+              6e4,
+              this.groupMessagesPerMinute,
+              pending2.messageCost
+            );
+            if (groupHistory.length > 0) {
+              this.groupMessageStarts.set(chatKey, groupHistory);
+            } else {
+              this.groupMessageStarts.delete(chatKey);
+            }
+            readyAt = Math.max(readyAt, groupReadyAt);
+          }
+        }
+        return readyAt;
+      }
+      reserve(pending2, now2) {
+        this.globalRequestStarts.push(now2);
+        if (pending2.messageCost <= 0) return;
+        for (let index = 0; index < pending2.messageCost; index++) {
+          this.globalMessageStarts.push(now2);
+        }
+        if (pending2.chatId === void 0) return;
+        const chatKey = String(pending2.chatId);
+        this.nextChatMessageAtMs.set(chatKey, now2 + this.perChatMessageIntervalMs);
+        if (!inferredGroupChat(pending2.chatId, pending2.chatType)) return;
+        const groupHistory = this.groupMessageStarts.get(chatKey) ?? [];
+        for (let index = 0; index < pending2.messageCost; index++) {
+          groupHistory.push(now2);
+        }
+        this.groupMessageStarts.set(chatKey, groupHistory);
+      }
+      nextReadyRequest(now2) {
+        if (this.laneOrder.length === 0) return {};
+        let nextWakeMs = Number.POSITIVE_INFINITY;
+        const laneCount = this.laneOrder.length;
+        for (let offset = 0; offset < laneCount; offset++) {
+          const index = (this.nextLaneIndex + offset) % laneCount;
+          const laneKey = this.laneOrder[index];
+          const queue = this.lanes.get(laneKey);
+          while (queue?.[0]?.settled) queue.shift();
+          const pending2 = queue?.[0];
+          if (!pending2) {
+            this.removeEmptyLane(laneKey);
+            return this.nextReadyRequest(now2);
+          }
+          const readyAt = this.requestReadyAt(pending2, now2);
+          nextWakeMs = Math.min(nextWakeMs, readyAt);
+          if (readyAt > now2) continue;
+          queue.shift();
+          pending2.queued = false;
+          this.queuedCount = Math.max(0, this.queuedCount - 1);
+          this.nextLaneIndex = this.laneOrder.length === 0 ? 0 : (index + 1) % this.laneOrder.length;
+          this.removeEmptyLane(laneKey);
+          return { pending: pending2 };
+        }
+        return {
+          nextWakeMs: Number.isFinite(nextWakeMs) ? nextWakeMs : void 0
+        };
+      }
+      pump() {
+        if (this.stoppedReason) return;
+        if (this.timer) {
+          clearTimeout(this.timer);
+          this.timer = null;
+        }
+        while (this.activeCount < this.maxConcurrentRequests) {
+          const now2 = this.now();
+          const { pending: pending2, nextWakeMs } = this.nextReadyRequest(now2);
+          if (!pending2) {
+            if (nextWakeMs !== void 0 && this.queuedCount > 0) {
+              this.timer = setTimeout(
+                () => {
+                  this.timer = null;
+                  this.pump();
+                },
+                Math.max(1, nextWakeMs - now2)
+              );
+            }
+            return;
+          }
+          if (pending2.settled) continue;
+          this.reserve(pending2, now2);
+          this.activeCount += 1;
+          void this.execute(pending2);
+        }
+      }
+      async execute(pending2) {
+        try {
+          const value2 = await pending2.execute();
+          const floodWait = pending2.floodWaitSeconds?.(value2) ?? telegramFloodWaitSeconds(value2);
+          if (floodWait !== void 0) {
+            const retryAt = this.now() + Math.ceil(floodWait * 1e3);
+            if (pending2.chatId === void 0) {
+              this.globalCooldownUntilMs = Math.max(
+                this.globalCooldownUntilMs,
+                retryAt
+              );
+            } else {
+              const chatKey = String(pending2.chatId);
+              this.chatCooldownUntilMs.set(
+                chatKey,
+                Math.max(this.chatCooldownUntilMs.get(chatKey) ?? 0, retryAt)
+              );
+            }
+            if (pending2.retryOnFlood !== false && !pending2.signal?.aborted) {
+              pending2.notBeforeMs = retryAt;
+              this.enqueue(pending2, true);
+              return;
+            }
+          }
+          if (!pending2.settled) {
+            pending2.settled = true;
+            pending2.resolve(value2);
+          }
+        } catch (error) {
+          if (!pending2.settled) {
+            pending2.settled = true;
+            pending2.reject(error);
+          }
+        } finally {
+          if (pending2.settled && pending2.abortListener) {
+            pending2.signal?.removeEventListener("abort", pending2.abortListener);
+          }
+          this.activeCount = Math.max(0, this.activeCount - 1);
+          this.pump();
+        }
+      }
+    };
+  }
+});
+
 // packages/cli/src/tui/vision-ingress.ts
 var vision_ingress_exports = {};
 __export(vision_ingress_exports, {
@@ -782719,6 +783151,7 @@ var init_telegram_bridge = __esm({
     init_telegram_social_event_log();
     init_dist();
     init_telegram_vision_router();
+    init_telegram_api_governor();
     TELEGRAM_TOOL_ACTION_GROUPS = [
       "read",
       "message",
@@ -783366,11 +783799,14 @@ Telegram link integrity contract:
       reminder: { limit: 20, windowMs: 24 * 60 * 6e4 }
     };
     TelegramBridge = class _TelegramBridge {
-      constructor(botToken, onMessage, agentConfig, repoRoot, toolPolicyConfig) {
+      constructor(botToken, onMessage, agentConfig, repoRoot, toolPolicyConfig, telegramApiGovernorOptions) {
         this.botToken = botToken;
         this.onMessage = onMessage;
         this.agentConfig = agentConfig;
         this.repoRoot = repoRoot;
+        this.telegramApiGovernor = new TelegramApiGovernor(
+          telegramApiGovernorOptions
+        );
         this.toolPolicyConfig = toolPolicyConfig;
         this.telegramToolPolicy = resolveSettings(repoRoot || ".").telegramToolPolicy ?? {};
         this.mediaCacheDir = resolve83(
@@ -783421,6 +783857,10 @@ Telegram link integrity contract:
       repoRoot;
       polling = false;
       abortController = null;
+      /** One fair outbound admission queue shared by every chat on this bot. */
+      telegramApiGovernor;
+      /** Chat types learned from inbound updates improve group quota accounting. */
+      telegramKnownChatTypes = /* @__PURE__ */ new Map();
       pollLoopPromise = null;
       pollFatalNotified = false;
       lastUpdateId = 0;
@@ -784978,11 +785418,11 @@ ${message2}`)
         for (const item of subAgent.pendingIntakeRecords.splice(0)) {
           pendingById.set(item.intake.inputId, item);
         }
-        const retainedSteeringIntakes = subAgent.retainedSteeringIntakes ?? (subAgent.retainedSteeringIntakes = /* @__PURE__ */ new Map());
-        for (const item of retainedSteeringIntakes.values()) {
+        subAgent.retainedSteeringIntakes ??= /* @__PURE__ */ new Map();
+        for (const item of subAgent.retainedSteeringIntakes.values()) {
           pendingById.set(item.intake.inputId, item);
         }
-        retainedSteeringIntakes.clear();
+        subAgent.retainedSteeringIntakes.clear();
         const pending2 = [...pendingById.values()];
         if (pending2.length === 0) return;
         for (const item of pending2) {
@@ -791918,7 +792358,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
         }
         const retryAfter = Number(result?.["parameters"]?.["retry_after"]);
         if (Number.isFinite(retryAfter) && retryAfter > 0) {
-          return Math.min(3e3, Math.floor(retryAfter * 1e3));
+          return Math.ceil(retryAfter * 1e3);
         }
         return [500, 1e3, 2e3][Math.min(attempt, 2)];
       }
@@ -791973,6 +792413,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
         this.state.active = false;
         this.abortController?.abort();
         this.abortController = null;
+        this.telegramApiGovernor.stop("Telegram bridge stopped");
         if (this.mediaCacheCleanupTimer) {
           clearInterval(this.mediaCacheCleanupTimer);
           this.mediaCacheCleanupTimer = null;
@@ -792354,6 +792795,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
           });
           if (result.error_code === 400 && result.description?.includes("not modified"))
             return true;
+          if (result.error_code === 429) return false;
           if (result.ok === false)
             throw new Error(
               String(result.description || "Telegram editMessageText failed")
@@ -796260,9 +796702,7 @@ Scoped workspace: ${scopedRoot}`,
                 enum: exposedActions,
                 description: [
                   "Exact Telegram operation from this enum.",
-                  ...moderationDescriptions.map(
-                    (description) => `${description}.`
-                  )
+                  ...moderationDescriptions.map((description) => `${description}.`)
                 ].join(" ")
               },
               target: {
@@ -797106,7 +797546,9 @@ Scoped workspace: ${scopedRoot}`,
           );
         }
         if (!Number.isSafeInteger(targetUserId) || targetUserId <= 0) {
-          throw new Error("A positive numeric Telegram target user_id is required.");
+          throw new Error(
+            "A positive numeric Telegram target user_id is required."
+          );
         }
         const group = await this.requireTelegramModerationGroup(chatId);
         const rights = await this.getBotChatRights(chatId, true);
@@ -797145,7 +797587,9 @@ Scoped workspace: ${scopedRoot}`,
             detail: "The exact action is already staged; no duplicate prompt was sent."
           };
         }
-        const conflicting = [...this.telegramPendingModerationApprovals.values()].find(
+        const conflicting = [
+          ...this.telegramPendingModerationApprovals.values()
+        ].find(
           (candidate) => candidate.state === "pending" && String(candidate.action.chatId) === String(chatId) && candidate.expiresAtMs > Date.now()
         );
         if (conflicting) {
@@ -797473,10 +797917,7 @@ ${this.quoteTelegramContextBlock(msg.text, 800)}`,
         }
         try {
           await this.requireTelegramModerationGroup(approval.action.chatId);
-          const rights = await this.getBotChatRights(
-            approval.action.chatId,
-            true
-          );
+          const rights = await this.getBotChatRights(approval.action.chatId, true);
           if (!rights.isAdministrator || !rights.canRestrictMembers) {
             throw new Error(
               `Bot no longer has administrator can_restrict_members authority; status=${rights.status}.`
@@ -800166,26 +800607,22 @@ Content-Type: ${contentType}\r
 `));
         const body = Buffer.concat(parts);
         const uploadUrl = `https://api.telegram.org/bot${this.botToken}/${method}`;
-        const MAX_UPLOAD_ATTEMPTS = 4;
-        const PER_RETRY_WAIT_CAP_MS = 3e4;
-        let result = {};
-        for (let attempt = 1; attempt <= MAX_UPLOAD_ATTEMPTS; attempt++) {
-          const res = await fetch(uploadUrl, {
-            method: "POST",
-            headers: {
-              "Content-Type": `multipart/form-data; boundary=${boundary}`,
-              "Content-Length": String(body.length)
-            },
-            body
-          });
-          result = await res.json();
-          if (result.ok) break;
-          const retryAfterSec = result["error_code"] === 429 ? Number(result["parameters"]?.retry_after) : NaN;
-          const canRetry = Number.isFinite(retryAfterSec) && retryAfterSec > 0 && attempt < MAX_UPLOAD_ATTEMPTS && !this.abortController?.signal.aborted;
-          if (!canRetry) break;
-          const waitMs = Math.min(retryAfterSec * 1e3, PER_RETRY_WAIT_CAP_MS);
-          await new Promise((r2) => setTimeout(r2, waitMs));
-        }
+        const result = await this.governedTelegramApiRequest(
+          method,
+          { chat_id: chatId },
+          async () => {
+            const res = await fetch(uploadUrl, {
+              method: "POST",
+              headers: {
+                "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                "Content-Length": String(body.length)
+              },
+              body,
+              signal: this.abortController?.signal
+            });
+            return await res.json();
+          }
+        );
         if (result.ok) {
           this.state.messagesSent++;
           const outboundMessageId = result.result?.message_id ?? null;
@@ -800494,18 +800931,21 @@ Content-Type: ${mimeForPath(pathOrFileId, field === "photo" ? "image" : "video")
         parts.push(Buffer.from(`--${boundary}--\r
 `));
         const body = Buffer.concat(parts);
-        const res = await fetch(
-          `https://api.telegram.org/bot${this.botToken}/${method}`,
-          {
-            method: "POST",
-            headers: {
-              "Content-Type": `multipart/form-data; boundary=${boundary}`,
-              "Content-Length": String(body.length)
-            },
-            body
-          }
-        );
-        return await res.json();
+        return this.governedTelegramApiRequest(method, { ...fields }, async () => {
+          const res = await fetch(
+            `https://api.telegram.org/bot${this.botToken}/${method}`,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                "Content-Length": String(body.length)
+              },
+              body,
+              signal: this.abortController?.signal
+            }
+          );
+          return await res.json();
+        });
       }
       /**
        * Bot API 10.0: send a message to another bot by username.
@@ -800816,15 +801256,22 @@ ${caption}\r
 `));
           const body = Buffer.concat(parts);
           const url = `https://api.telegram.org/bot${this.botToken}/${method}`;
-          const res = await fetch(url, {
-            method: "POST",
-            headers: {
-              "Content-Type": `multipart/form-data; boundary=${boundary}`,
-              "Content-Length": String(body.length)
-            },
-            body
-          });
-          const result = await res.json();
+          const result = await this.governedTelegramApiRequest(
+            method,
+            { chat_id: chatId },
+            async () => {
+              const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                  "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                  "Content-Length": String(body.length)
+                },
+                body,
+                signal: this.abortController?.signal
+              });
+              return await res.json();
+            }
+          );
           if (result.ok) {
             this.state.messagesSent++;
             return result.result?.message_id ?? null;
@@ -800898,6 +801345,7 @@ ${caption}\r
                 }
                 const msg = normalizeTelegramUpdate(update2);
                 if (!msg) continue;
+                this.telegramKnownChatTypes.set(String(msg.chatId), msg.chatType);
                 this.persistTelegramRawMessage(update2, msg);
                 this.state.messagesReceived++;
                 const isAdmin = this.adminUserId ? String(msg.fromUserId) === this.adminUserId || msg.username === this.adminUserId : false;
@@ -800970,44 +801418,64 @@ ${caption}\r
         if (raw >= floor && raw <= 3e5) return raw;
         return null;
       }
-      /** Make a Telegram Bot API call with rate-limit retry */
-      async apiCall(method, body, _retryDepth = 0) {
+      telegramApiChatId(body) {
+        const value2 = body?.["chat_id"];
+        return typeof value2 === "number" || typeof value2 === "string" && value2.length > 0 ? value2 : void 0;
+      }
+      telegramApiChatType(chatId) {
+        return chatId === void 0 ? void 0 : this.telegramKnownChatTypes.get(String(chatId));
+      }
+      async governedTelegramApiRequest(method, body, execute, options2 = {}) {
+        const chatId = this.telegramApiChatId(body);
+        return this.telegramApiGovernor.run({
+          method,
+          body,
+          chatId,
+          chatType: this.telegramApiChatType(chatId),
+          execute,
+          signal: this.abortController?.signal,
+          retryOnFlood: options2.retryOnFlood,
+          floodWaitSeconds: telegramFloodWaitSeconds,
+          coalesceKey: options2.coalesceKey,
+          supersededValue: options2.supersededValue
+        });
+      }
+      /** Make a Telegram Bot API call through the per-bot fair governor. */
+      async apiCall(method, body) {
         const url = `https://api.telegram.org/bot${this.botToken}/${method}`;
-        const options2 = {
-          method: "POST",
-          headers: { "Content-Type": "application/json" }
-        };
-        if (body) {
-          options2.body = JSON.stringify(body);
-        }
         const isLongPoll = method === "getUpdates";
-        if (isLongPoll && this.abortController) {
-          const timeoutFn = AbortSignal.timeout;
-          const anyFn = AbortSignal.any;
-          const bodyTimeout = typeof body?.["timeout"] === "number" ? body["timeout"] : void 0;
-          const clientTimeoutMs = this.telegramLongPollClientTimeoutMs(bodyTimeout);
-          const signals = [
-            this.abortController.signal,
-            clientTimeoutMs && typeof timeoutFn === "function" ? timeoutFn(clientTimeoutMs) : void 0
-          ].filter(
-            (signal) => signal instanceof AbortSignal
-          );
-          options2.signal = typeof anyFn === "function" && signals.length > 1 ? anyFn(signals) : signals[0];
-        } else if (!isLongPoll) {
-          options2.signal = AbortSignal.timeout(3e4);
-        }
-        const res = await fetch(url, options2);
-        const data = await res.json();
-        if (data["error_code"] === 429 && data["parameters"]?.retry_after) {
-          const waitSec = Math.min(3, data["parameters"].retry_after);
-          const isLiveEdit = method === "editMessageText";
-          if (isLiveEdit || _retryDepth >= 1) {
-            return data;
+        return this.governedTelegramApiRequest(
+          method,
+          body,
+          async () => {
+            const request = {
+              method: "POST",
+              headers: { "Content-Type": "application/json" }
+            };
+            if (body) request.body = JSON.stringify(body);
+            const timeoutFn = AbortSignal.timeout;
+            const anyFn = AbortSignal.any;
+            const bodyTimeout = typeof body?.["timeout"] === "number" ? body["timeout"] : void 0;
+            const clientTimeoutMs = isLongPoll ? this.telegramLongPollClientTimeoutMs(bodyTimeout) : 3e4;
+            const signals = [
+              this.abortController?.signal,
+              clientTimeoutMs && typeof timeoutFn === "function" ? timeoutFn(clientTimeoutMs) : void 0
+            ].filter(
+              (signal) => signal instanceof AbortSignal
+            );
+            request.signal = typeof anyFn === "function" && signals.length > 1 ? anyFn(signals) : signals[0];
+            const response = await fetch(url, request);
+            return await response.json();
+          },
+          // Progressive edits are disposable. A flood response still updates the
+          // chat cooldown, but replaying stale partial text would block inference
+          // and could overwrite a newer final reply.
+          {
+            retryOnFlood: method !== "editMessageText",
+            coalesceKey: method === "editMessageText" && body?.["message_id"] !== void 0 ? `editMessageText:${String(body["chat_id"])}:${String(body["message_id"])}` : void 0,
+            supersededValue: method === "editMessageText" ? () => ({ ok: true, result: true, omitted_by_governor: true }) : void 0
           }
-          await new Promise((r2) => setTimeout(r2, waitSec * 1e3));
-          return this.apiCall(method, body, _retryDepth + 1);
-        }
-        return data;
+        );
       }
     };
   }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.657",
+  "version": "1.0.659",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.657",
+      "version": "1.0.659",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.657",
+  "version": "1.0.659",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/library.js",