polygram 0.9.0-rc.5 → 0.9.0-rc.7

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.9.0-rc.5",
+  "version": "0.9.0-rc.7",
   "description": "Telegram integration for Claude Code that preserves the OpenClaw per-chat session model. Migration target for OpenClaw users. Multi-bot, multi-chat, per-topic isolation; SQLite transcripts; inline-keyboard approvals. Bundles /polygram:status|logs|pair-code|approvals admin commands plus history (transcript queries) and polygram-send (out-of-turn IPC sends with file-upload validation) skills.",
   "keywords": [
     "telegram",

package/lib/error/classify.js

@@ -60,6 +60,20 @@ const PATTERNS = {
   // "input...missing" or "missing...input" within a tool_use mention.
   missingToolInput: /tool[_ ]use.*(input.*missing|missing.*input)|missing tool call input|tool input required/i,
 
+  // Anthropic API rejected an image content block in the conversation.
+  // 2026-05-13: shumabit Dina DM hit this after accumulating 53 images
+  // over 2 weeks — every new turn 400'd with raw API JSON dumped to
+  // the user. Most common cause: a persisted image in the resumed
+  // transcript that the API now considers invalid (model snapshot
+  // drift, expired URL, bad base64, dimension/size cap, format the
+  // API stopped accepting). Recovery: reset_session — /compact has
+  // to load the same history so it usually fails too.
+  //
+  // Anchor on the literal Anthropic phrase to avoid false positives
+  // on routine "image" mentions. Tightened by requiring an
+  // image-failure verb co-located with "image" or "photo".
+  imageProcess:     /(could not process|cannot process|failed to (process|load|decode)|unsupported|invalid|corrupt(?:ed)?)[^\n]{0,80}\b(image|photo)\b|\b(image|photo)\b[^\n]{0,80}(could not process|failed to (process|load|decode)|is (invalid|corrupted|unsupported))/i,
+
   // Idle/wall-clock timeout from polygram's pm timers, OR
   // model-side timeout. Mapped to a single class; user message is
   // identical either way.
@@ -87,6 +101,7 @@ const USER_MESSAGES = {
   contextOverflow:  '📚 Conversation got too long. Send /new to start fresh.',
   roleOrdering:     '⚠️ Conversation got into a tangled state. Try /new.',
   missingToolInput: '⚠️ Session history looks corrupted. Try /new.',
+  imageProcess:     '🖼 One of the images in this conversation can\'t be re-processed by Claude — likely an older one in the history. Starting a fresh session for this chat.',
   timeout:          '⏳ I went quiet too long without finishing. Try resending or simplifying.',
   format:           '⚠️ Invalid request format. Try rephrasing or /new.',
   // Used both for in-flight retry attempts AND for the post-retry-failed
@@ -106,6 +121,7 @@ const AUTO_RECOVER = {
   roleOrdering:     'reset_session',
   contextOverflow:  'reset_session',
   missingToolInput: 'reset_session',
+  imageProcess:     'reset_session',
 };
 
 // Typed-code short-circuits — set on errors polygram throws itself
@@ -300,8 +316,45 @@ function isTransientHttpError(err) {
   return classify(err).isTransient;
 }
 
+// 2026-05-13: detect the case where SDK reports result_subtype=success
+// BUT the assistant text is actually an API error JSON the SDK wrapped
+// as if it were the model's reply. Happens when the resumed session's
+// transcript has data the API can't reload — most commonly an image
+// content block. Pattern is distinctive ("API Error: <code> {...
+// type:error ...}") so false positives are unlikely.
+//
+// When this matches:
+//   - The text we'd deliver to Telegram is garbage (raw JSON).
+//   - The Claude session is wedged — every future turn will fail the
+//     same way until reset.
+// Returns the same shape as classify() so callers can use it uniformly,
+// or null when the text looks like a legitimate assistant reply.
+const WEDGED_SESSION_RE = /^API Error: \d{3}\s+\{[^}]*"type"\s*:\s*"error"/;
+
+function detectWedgedSessionError(text) {
+  if (typeof text !== 'string' || text.length === 0) return null;
+  if (!WEDGED_SESSION_RE.test(text)) return null;
+  // Once we've confirmed it's a wrapped API error, run classify on the
+  // text — it picks up imageProcess / rateLimit / billing / etc. from
+  // the JSON body. classify is robust to JSON-ish input.
+  const cls = classify(new Error(text));
+  // If classify fell through to 'unknown', return a safe imageProcess
+  // shape — wedged sessions are most commonly image-driven and the
+  // recovery action (reset_session) is correct for all wedge classes.
+  if (cls.kind === 'unknown') {
+    return {
+      kind: 'imageProcess',
+      userMessage: USER_MESSAGES.imageProcess,
+      isTransient: false,
+      autoRecover: 'reset_session',
+    };
+  }
+  return cls;
+}
+
 module.exports = {
   classify,
+  detectWedgedSessionError,
   isTransientHttpError,
   PATTERNS,
   USER_MESSAGES,

package/lib/handlers/dispatcher.js

@@ -41,7 +41,13 @@ function createDispatcher({
   autoResumeTracker,              // lib/db/auto-resume.js instance
   chunkMarkdownText,              // lib/telegram/chunk.js
   deliverReplies,                 // lib/telegram/deliver.js
-  TG_MAX_LEN = 4096,
+  // Raw-markdown size budget for chunkMarkdownText. Set BELOW Telegram's
+  // 4096 hard limit to leave headroom for HTML inflation (toTelegramHtml
+  // adds <b>/<i>/<code> tags + entity escapes; ~10-15% in practice).
+  // Polygram passes TG_CHUNK_BUDGET (default 3500). Test default keeps
+  // the historic 4096 for back-compat in synthetic test runs that pass
+  // pre-formatted text.
+  chunkBudget = 4096,
   // State accessors (need late binding because polygram.js mutates):
   getIsShuttingDown,              // () → boolean
   logger = console,
@@ -119,7 +125,7 @@ function createDispatcher({
 
     // 4. Send the continuation reply as regular Telegram messages,
     //    threaded under the original user message.
-    const chunks = chunkMarkdownText(result.text, TG_MAX_LEN);
+    const chunks = chunkMarkdownText(result.text, chunkBudget);
     await deliverReplies({
       bot,
       send: (b, method, params, m) => tg(b, method, params, m),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.9.0-rc.5",
+  "version": "0.9.0-rc.7",
   "description": "Telegram daemon for Claude Code that preserves the OpenClaw per-chat session model. Migration path for OpenClaw users moving to Claude Code.",
   "main": "lib/ipc/client.js",
   "bin": {

package/polygram.js

@@ -75,7 +75,7 @@ const { startTyping } = require('./lib/telegram/typing');
 // consumer is lib/handlers/download.js.
 const { createReactionManager, classifyToolName } = require('./lib/telegram/reactions');
 const { createMediaGroupBuffer } = require('./lib/media-group-buffer');
-const { classify: classifyError, isTransientHttpError } = require('./lib/error/classify');
+const { classify: classifyError, detectWedgedSessionError, isTransientHttpError } = require('./lib/error/classify');
 const { createAutoResumeTracker, isAutoResumable } = require('./lib/db/auto-resume');
 const { resolveReplayWindowMs } = require('./lib/db/replay-window');
 // validateIpcFileParam moved with handleSendOverIpc to
@@ -109,6 +109,15 @@ const CLAUDE_BIN = process.env.POLYGRAM_CLAUDE_BIN
   || path.join(process.env.HOME || '', '.npm-global/bin/claude');
 const CHILD_HOME = process.env.POLYGRAM_CHILD_HOME || process.env.HOME || '';
 const TG_MAX_LEN = 4096;
+// 0.9.0-rc.6: chunker budget is intentionally lower than TG_MAX_LEN to
+// leave HTML headroom. toTelegramHtml converts markdown to HTML for
+// parse_mode=HTML — that conversion adds <b>/<i>/<code>/<a> tags and
+// entity-escapes &/</> chars, inflating length by ~10-15% for realistic
+// markdown. 2026-05-11 incident proved a 4044-char chunk inflated to
+// 4506 HTML chars and Telegram rejected. 3500 raw → max ~4030 HTML on
+// observed inputs, with headroom for adversarial code-heavy text.
+// Override via POLYGRAM_CHUNK_BUDGET if your traffic profile differs.
+const TG_CHUNK_BUDGET = Number.parseInt(process.env.POLYGRAM_CHUNK_BUDGET, 10) || 3500;
 const DEFAULT_MAX_WARM_PROCS = 10;
 
 let stickerMap = {}; // name → file_id
@@ -1010,14 +1019,41 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
 
     stopTyping();
 
+    // 2026-05-13 Dina-DM incident: SDK reports result_subtype=success
+    // but the "assistant text" is actually an API error JSON the SDK
+    // wrapped (e.g. wedged image content block in resumed transcript).
+    // Without this guard, polygram delivers the raw JSON to Telegram
+    // as the bot's reply AND never resets the session — every
+    // subsequent turn loops the same wedge.
+    //
+    // Sniff result.text for the wrapper pattern BEFORE the error/text
+    // branch decisions. When detected: synthesize an Error so the
+    // standard result.error path runs (classification → reset_session
+    // → friendly user message → no raw-JSON delivery).
+    if (!result.error && detectWedgedSessionError(result.text)) {
+      const wedge = detectWedgedSessionError(result.text);
+      logEvent('wedged-session-detected', {
+        chat_id: chatId, session_key: sessionKey,
+        kind: wedge.kind,
+        text_preview: result.text.slice(0, 200),
+      });
+      // Promote the wrapped error to result.error so the existing
+      // auto-recover + thrown-error machinery handles it uniformly.
+      // Clear result.text so downstream delivery doesn't send the
+      // raw JSON.
+      result.error = result.text;
+      result.text = '';
+    }
+
     if (result.error) {
       console.error(`[${label}] Error (${elapsed}s):`, result.error);
       reactor.setState('ERROR');
       // 0.8.0 Phase 2 step 8: classifier-driven auto-recovery. If
       // the error kind has autoRecover === 'reset_session' (i.e.
-      // role_ordering / context_overflow / missing_tool_input),
-      // tell pm to reset the session NOW so the user's NEXT
-      // message starts fresh — without them having to type /new.
+      // role_ordering / context_overflow / missing_tool_input /
+      // imageProcess), tell pm to reset the session NOW so the
+      // user's NEXT message starts fresh — without them having
+      // to type /new.
       const cls = classifyError(result.error);
       if (cls.autoRecover === 'reset_session') {
         pm.resetSession(sessionKey, { reason: cls.kind })
@@ -1253,7 +1289,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
         // send the body as proper chunks.
         try { await streamer.discard(); }
         catch (err) { console.error(`[${label}] discard failed: ${err.message}`); }
-        const chunks = chunkMarkdownText(parsed.text, TG_MAX_LEN);
+        const chunks = chunkMarkdownText(parsed.text, TG_CHUNK_BUDGET);
         const r = await deliverReplies({
           bot,
           send: (b, method, params, m) => tg(b, method, params, m),
@@ -1319,7 +1355,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       // 0.7.0: use markdown-aware chunker + deliverReplies primitive.
       // The old chunkText was newline/byte-only; chunkMarkdownText also
       // respects code-fence boundaries (closes + reopens across chunks).
-      const chunks = chunkMarkdownText(parsed.text, TG_MAX_LEN);
+      const chunks = chunkMarkdownText(parsed.text, TG_CHUNK_BUDGET);
       await deliverReplies({
         bot,
         send: (b, method, params, m) => tg(b, method, params, m),
@@ -1990,7 +2026,7 @@ async function main() {
     classifyError, isAutoResumable,
     abortGrace, autoResumeTracker,
     chunkMarkdownText, deliverReplies,
-    TG_MAX_LEN,
+    chunkBudget: TG_CHUNK_BUDGET,
     getIsShuttingDown: () => isShuttingDown,
     logger: console,
   }));