@inetafrica/open-claudia 2.6.27 → 2.6.29

package/channels/kazee/adapter.js

@@ -12,6 +12,7 @@ const { TEMP_DIR, FILES_DIR } = require("../../core/config");
 const { canonicalForChannel } = require("../../core/identity");
 const { inlineKeyboardToPortable } = require("../types");
 const { createKazeeSocket } = require("./socket");
+const { normalize } = require("./format");
 
 class KazeeAdapter {
   constructor({ id = "kazee", url, token, ownerUserId, botUserId }) {
@@ -98,7 +99,7 @@ class KazeeAdapter {
     });
   }
 
-  _handleInboundMessage(msg) {
+  async _handleInboundMessage(msg) {
     if (!msg) return;
     const senderId = String(msg.sender?._id || msg.sender?.id || msg.senderId || "");
     if (this.botUserId && senderId === String(this.botUserId)) return; // ignore our own echoes
@@ -169,6 +170,37 @@ class KazeeAdapter {
       }
     }
 
+    // Voice/audio distinction: chat-central has no "voice" type, so voice
+    // notes arrive as "audio". Detect them by mimeType (ogg/opus) and
+    // promote to "voice" so the router can transcribe them correctly.
+    if (envelope.type === "audio" && envelope.media?.length) {
+      const mime = (envelope.media[0].mimeType || "").toLowerCase();
+      if (mime.includes("ogg") || mime.includes("opus")) {
+        envelope.type = "voice";
+        envelope.media[0].type = "voice";
+      }
+    }
+
+    // Reply-to context: fetch the replied-to message content so the router
+    // has the same context Telegram provides. Best-effort — failure is silent.
+    if (msg.replyTo) {
+      try {
+        const data = await this._request("GET", `/message/${encodeURIComponent(String(msg.replyTo))}`);
+        const m = data?.message || data;
+        if (m && (m._id || m.id)) {
+          envelope.reply = {
+            text: m.content || "",
+            from: {
+              id: String(m.sender?._id || m.sender?.id || ""),
+              name: m.sender?.name || m.sender?.displayName || "",
+              username: m.sender?.username || "",
+            },
+            messageId: m._id || m.id,
+          };
+        }
+      } catch (e) { /* best-effort — envelope is still valid without reply context */ }
+    }
+
     this._emit("message", envelope);
   }
 
@@ -184,24 +216,42 @@ class KazeeAdapter {
     const body = {
       chat_id: channelId,
       sender: this.botUserId,
-      content: text,
+      content: normalize(text),
       type: buttons ? "interactive" : "text",
       findMeCode: `oc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
     };
     if (opts.replyTo) body.replyTo = opts.replyTo;
     if (buttons) body.interactive = { buttons };
-    try {
-      const res = await this._request("POST", `/chat/${encodeURIComponent(channelId)}/message`, body);
-      return res?.message?._id || res?.messageId || res?._id || null;
-    } catch (e) {
-      console.error("Kazee send error:", e.message);
-      return null;
+
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const res = await this._request("POST", `/chat/${encodeURIComponent(channelId)}/message`, body);
+        return res?.message?._id || res?.messageId || res?._id || null;
+      } catch (e) {
+        const errMsg = e.message || "";
+        // Don't retry on client errors (4xx) — they won't self-heal.
+        const statusMatch = errMsg.match(/→ (\d{3})/);
+        const status = statusMatch ? parseInt(statusMatch[1], 10) : 0;
+        if (status >= 400 && status < 500) {
+          console.error("Kazee send error (not retrying):", errMsg);
+          return null;
+        }
+        if (attempt < 2) {
+          const delay = (attempt + 1) * 1000;
+          console.error(`Kazee send error (attempt ${attempt + 1}/3, retrying in ${delay}ms):`, errMsg);
+          await new Promise((r) => setTimeout(r, delay));
+          continue;
+        }
+        console.error("Kazee send error (exhausted retries):", errMsg);
+        return null;
+      }
     }
+    return null;
   }
 
   async edit(channelId, messageId, text, opts = {}) {
     const buttons = this._normalizeKeyboard(opts.keyboard);
-    const body = { content: text };
+    const body = { content: normalize(text) };
     if (buttons) {
       body.type = "interactive";
       body.interactive = { buttons };

package/channels/kazee/format.js

@@ -1,9 +1,27 @@
-// Kazee uses standard markdown end-to-end. Telegram-flavoured asterisks
-// and underscores still render fine, so this is mostly a hook for future
-// divergence (image embeds, code-block fences, etc.).
+// Kazee renders standard markdown end-to-end. This module normalizes text
+// before sending: converts any stray Telegram HTML tags (which the model may
+// accidentally emit) into their markdown equivalents so they render correctly
+// instead of appearing as raw tag noise.
+
+function htmlToMarkdown(text) {
+  return String(text || "")
+    .replace(/<pre><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_, code) => "```\n" + code + "\n```")
+    .replace(/<pre>([\s\S]*?)<\/pre>/gi, (_, code) => "```\n" + code + "\n```")
+    .replace(/<code>([\s\S]*?)<\/code>/gi, "`$1`")
+    .replace(/<b>([\s\S]*?)<\/b>/gi, "**$1**")
+    .replace(/<strong>([\s\S]*?)<\/strong>/gi, "**$1**")
+    .replace(/<i>([\s\S]*?)<\/i>/gi, "_$1_")
+    .replace(/<em>([\s\S]*?)<\/em>/gi, "_$1_")
+    .replace(/<s>([\s\S]*?)<\/s>/gi, "~~$1~~")
+    .replace(/<strike>([\s\S]*?)<\/strike>/gi, "~~$1~~")
+    .replace(/<del>([\s\S]*?)<\/del>/gi, "~~$1~~")
+    .replace(/<a href="([^"]+)">([\s\S]*?)<\/a>/gi, "[$2]($1)")
+    .replace(/<[^>]+>/g, "")
+    .replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n)));
+}
 
 function normalize(text) {
-  return String(text || "");
+  return htmlToMarkdown(String(text || ""));
 }
 
 module.exports = { normalize };

package/core/runner.js

@@ -130,6 +130,11 @@ function logTurnUsage(state, usage, costUsd, announce, opts = {}) {
   const backend = state.settings?.backend || "claude";
   const parts = usageParts(usage, backend);
   const usageScope = opts.usageScope || "turn_delta";
+  // `parts.context` is the per-turn SUM of every API call's prefix, inflated
+  // by re-counting the cached prefix once per tool round-trip. When the caller
+  // tracked the true peak single-call prefix, report that as contextTokens and
+  // keep the inflated sum as billedContextTokens for cost attribution.
+  const hasPeak = Number.isFinite(opts.liveContextTokens) && opts.liveContextTokens > 0;
   const record = {
     ts: new Date().toISOString(),
     version: PKG_VERSION,
@@ -142,7 +147,8 @@ function logTurnUsage(state, usage, costUsd, announce, opts = {}) {
     outputTokens: parts.output,
     cacheReadTokens: parts.cacheRead,
     cacheCreationTokens: parts.cacheCreation,
-    contextTokens: parts.context,
+    contextTokens: hasPeak ? opts.liveContextTokens : parts.context,
+    billedContextTokens: parts.context,
     costUsd: typeof costUsd === "number" ? costUsd : 0,
   };
   if (opts.rawUsage && opts.rawUsage !== usage) {
@@ -785,6 +791,11 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   let toolUses = [];
   let currentTool = null;
   let currentToolDetail = "";
+  // True context-window occupancy is the largest single API call's prefix
+  // (input + cache_read + cache_creation), NOT the per-turn sum the result
+  // event reports — that sum re-counts the cached prefix once per tool
+  // round-trip and balloons to millions. Track the peak per-call prefix.
+  let peakContextTokens = 0;
 
   // Hermes-style skill announcements: one chat line when a learned skill
   // is invoked or its SKILL.md is written/patched. Deduped per turn.
@@ -897,6 +908,10 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     const lastNewline = state.streamBuffer.lastIndexOf("\n");
     state.streamBuffer = lastNewline >= 0 ? state.streamBuffer.slice(lastNewline + 1) : state.streamBuffer;
     for (const evt of events) {
+      if (evt.type === "assistant" && evt.message?.usage) {
+        const callPrefix = usageParts(evt.message.usage, settings.backend || "claude").context;
+        if (callPrefix > peakContextTokens) peakContextTokens = callPrefix;
+      }
       if (evt.type === "assistant" && evt.message?.content) {
         for (const block of evt.message.content) {
           if (block.type === "text") assistantText += block.text;
@@ -1003,8 +1018,10 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         // Codex already reports usage at turn.completed. A result usage block,
         // if present, is the same cumulative total and must not be counted again.
         if (evt.usage && settings.backend !== "codex") {
-          applyUsageToState(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, { usageScope: "turn_delta" });
-          logTurnUsage(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, (text) => chatContext.run(store, () => send(text)), { usageScope: "turn_delta" });
+          const peakOpts = { usageScope: "turn_delta" };
+          if (peakContextTokens > 0) peakOpts.liveContextTokens = peakContextTokens;
+          applyUsageToState(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, peakOpts);
+          logTurnUsage(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, (text) => chatContext.run(store, () => send(text)), peakOpts);
         }
         if (typeof evt.total_cost_usd === "number" && settings.backend === "codex") state.sessionUsage.costUsd += evt.total_cost_usd;
         saveState();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.27",
+  "version": "2.6.29",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {