@inetafrica/open-claudia 2.9.1 → 2.9.3

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v2.9.3
+- **Bot advertises a distinct "thinking" state before its first token (Kazee parity Phase 2).** The typing pipeline now carries an additive `state` discriminator (`'thinking' | 'typing'`) — no new socket event. The runner advertises `thinking` from the moment a turn starts until the first stream event (text delta, assistant content, tool call, or result), then flips to plain `typing`; Kazee clients render "<name> is thinking…" in the header/chat-list for that pre-token window and fall back to normal typing text otherwise. The Telegram adapter ignores `state` (its chat action has no such distinction), so the change is inert there. Pairs with the chat-central `message:interactiveUpdated` broadcast (server-authoritative button selection) landing in the same release across chat-central/web/mobile.
+- **Ships the v2.9.2 work that never published.** v2.9.2 (Kazee REST media fallback when a socket send lacks a media path, plus an explicit `typing:stop` on turn end) was committed to main but no tag was ever pushed, so CI never published it. This tag carries it to npm alongside the thinking-state change.
+
 ## v2.9.1
 - **Post-turn reviewer no longer rewrites pack sections blind — context starvation fixed.** The reviewer prompt showed only the pack *index* (name + description), so a State rewrite was regenerated from the turn text alone and silently destroyed durable facts the turn didn't restate; worse, with no project name in the turn text it could attribute the work to the wrong pack entirely (observed live: an AQUELLE product-shot turn filed under Alpha Protein, wiping a promoted root-cause fact). The runner now passes the turn's **active packs** (recall-surfaced ∪ explicitly opened) into `reviewTurn`; the prompt includes their **full current Stance/Procedure/State + recent journal**, with two new rules: attribute updates to an active pack unless the turn clearly names another, and treat section rewrites as **merges** — carry forward every still-true fact, drop only what the turn contradicted or completed.
 - **Structural enforcement, not just prompt guidance.** `applyAction` drops section rewrites (State/Stance/Procedure) targeting any pack whose current content the reviewer did not see — journal lines still land; the announce line notes the drop. Applies to the update path, the exists-on-create path, and the versioned-duplicate fold.

package/channels/kazee/adapter.js

@@ -256,6 +256,9 @@ class KazeeAdapter {
       body.type = "interactive";
       body.interactive = { buttons };
     }
+    // Progressive delivery of the bot's own answer — tell the server this is a
+    // streaming edit so it skips editHistory + the "edited" marker.
+    if (opts.streaming) body.streaming = true;
     try {
       await this._request("PUT", `/message/${encodeURIComponent(messageId)}`, body);
     } catch (e) {
@@ -299,30 +302,56 @@ class KazeeAdapter {
         console.error("Kazee upload returned no media id:", JSON.stringify(upload).slice(0, 300));
         return false;
       }
-      // Post the message via the v2 socket event `message:send`, which
-      // accepts `mediaIds` referencing already-saved Media docs. We avoid
-      // the REST sendMessage action because it tries to re-Media.create
-      // from media_url and that call omits required schema fields
-      // (chat/bucketName/fileName/minioPath) — it always 500s.
+      const type = this._kazeeFileType(fileName);
+      // Prefer the v2 socket event `message:send` (real-time fan-out), which
+      // accepts `mediaIds` referencing already-saved Media docs. If the socket
+      // is down or the ack errors, fall back to the REST sendMessage action —
+      // it now accepts already-uploaded media via `media_ids` (previously it
+      // only took media_url and re-Media.create'd, which always 500'd).
       const payload = {
         chatId: channelId,
         content: caption || "",
-        type: this._kazeeFileType(fileName),
+        type,
         findMeCode: `oc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
         mediaIds: [mediaId],
       };
-      const res = await this._socketEmit("message:send", payload, 30000);
-      if (res && res.code) {
-        console.error("Kazee message:send error:", res.code, res.message);
-        return false;
+      try {
+        const res = await this._socketEmit("message:send", payload, 30000);
+        if (res && res.code) {
+          console.error(`Kazee message:send error (${res.code}), falling back to REST:`, res.message);
+          return await this._sendMediaViaRest(channelId, mediaId, type, caption);
+        }
+        return true;
+      } catch (sockErr) {
+        console.error("Kazee message:send unavailable, falling back to REST:", sockErr.message);
+        return await this._sendMediaViaRest(channelId, mediaId, type, caption);
       }
-      return true;
     } catch (e) {
       console.error("Kazee sendFile error:", e.message);
       return false;
     }
   }
 
+  // REST fallback for posting an already-uploaded Media doc when the socket
+  // path is unavailable. Mirrors send()'s route (POST /chat/:id/message →
+  // sendMessage action) but references the saved media by id.
+  async _sendMediaViaRest(channelId, mediaId, type, caption) {
+    try {
+      await this._request("POST", `/chat/${encodeURIComponent(channelId)}/message`, {
+        chat_id: channelId,
+        sender: this.botUserId,
+        content: caption || "",
+        type,
+        media_ids: [mediaId],
+        findMeCode: `oc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      });
+      return true;
+    } catch (e) {
+      console.error("Kazee REST media send failed:", e.message);
+      return false;
+    }
+  }
+
   // Promisified ack-style socket emit. chat-central v2 handlers respond
   // either with a success body or an { code, message, action } error.
   _socketEmit(event, payload, timeoutMs = 15000) {
@@ -355,8 +384,22 @@ class KazeeAdapter {
     return "file";
   }
 
-  async typing(channelId) {
-    try { this._socket?.emit?.("typing:start", { chatId: channelId }); } catch (e) {}
+  // `state` is an optional richer indicator: "thinking" (the bot is reasoning
+  // pre-first-token) vs the default "typing". Kazee clients render "thinking"
+  // distinctly; older clients ignore the field and fall back to "typing".
+  async typing(channelId, state) {
+    try {
+      const payload = { chatId: channelId };
+      if (state) payload.state = state;
+      this._socket?.emit?.("typing:start", payload);
+    } catch (e) {}
+  }
+
+  // Socket channels keep rendering "typing…" until an explicit stop. Telegram
+  // has no equivalent (its chat action self-expires), so this is Kazee-only and
+  // called via optional chaining from the core typing heartbeat cleanup.
+  async typingStop(channelId) {
+    try { this._socket?.emit?.("typing:stop", { chatId: channelId }); } catch (e) {}
   }
 
   async downloadMedia(media) {

package/channels/telegram/adapter.js

@@ -351,7 +351,9 @@ class TelegramAdapter {
     }
   }
 
-  async typing(channelId) {
+  // Telegram exposes only a single "typing" chat action, so the optional
+  // `state` (thinking vs typing) is accepted for signature parity but ignored.
+  async typing(channelId, _state) {
     try { await this.bot.sendChatAction(channelId, "typing"); } catch (e) {}
   }
 

package/channels/types.js

@@ -55,7 +55,8 @@
  *   delete(channelId, messageId): Promise<void>
  *   sendVoice(channelId, oggPath): Promise<boolean>
  *   sendFile(channelId, filePath, caption?): Promise<boolean>
- *   typing(channelId): Promise<void>
+ *   typing(channelId, state?): Promise<void>  // state: "thinking" | "typing" (default). Non-socket channels ignore state.
+ *   typingStop?(channelId): Promise<void>     // optional — socket channels only
  *   downloadMedia(mediaRef): Promise<localPath|null>
  *   registerCommands(commands: CommandSpec[]): Promise<void>
  */

package/core/io.js

@@ -52,11 +52,11 @@ async function sendFile(filePath, caption) {
   return adapter.sendFile(channelId, filePath, caption);
 }
 
-async function typing() {
+async function typing(state) {
   const adapter = currentAdapter();
   const channelId = currentChannelId();
   if (!adapter || !channelId) return;
-  return adapter.typing(channelId);
+  return adapter.typing(channelId, state);
 }
 
 function splitMessage(text, maxLen = 4000) {

package/core/runner.js

@@ -812,12 +812,30 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   // receipt through the recall/discoverer phase and into streaming, not just
   // for the ~5s a single typing action lasts. Stored on state so /stop can
   // clear it instantly. Cleared on close/error/cancel.
+  // While true, the bot is reasoning before its first output token, so the
+  // typing heartbeat advertises the richer "thinking" state. Flipped to false
+  // the moment the first assistant text / tool_use / text_delta arrives.
+  state.thinkingPhase = true;
   const startTyping = () => {
     if (!adapter || !channelId) return;
-    adapter.typing(channelId).catch(() => {});
-    if (!state.typingHeartbeat) state.typingHeartbeat = setInterval(() => adapter.typing(channelId).catch(() => {}), 4000);
+    adapter.typing(channelId, state.thinkingPhase ? "thinking" : undefined).catch(() => {});
+    if (!state.typingHeartbeat) state.typingHeartbeat = setInterval(() => adapter.typing(channelId, state.thinkingPhase ? "thinking" : undefined).catch(() => {}), 4000);
+  };
+  // Called on the first real output token to leave the thinking phase and, if
+  // the turn is still live, immediately advertise plain "typing" so the client
+  // flips without waiting for the next 4s heartbeat.
+  const endThinking = () => {
+    if (!state.thinkingPhase) return;
+    state.thinkingPhase = false;
+    if (adapter && channelId && state.typingHeartbeat) adapter.typing(channelId).catch(() => {});
+  };
+  const stopTyping = () => {
+    state.thinkingPhase = false;
+    if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; }
+    // Telegram's chat action auto-expires, but socket-based channels (Kazee)
+    // keep showing "typing…" until told to stop. Optional on the adapter.
+    if (adapter && channelId) { try { adapter.typingStop?.(channelId); } catch (e) {} }
   };
-  const stopTyping = () => { if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; } };
   // Pre-spawn window (recall/compaction/auth): /stop has no process to kill, so
   // it sets state.cancelRequested and we bail at the checkpoint before spawning.
   state.preparingRun = true;
@@ -1173,7 +1191,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         if (!state.statusMessageId && assistantText) {
           state.statusMessageId = await send(display.length > 4000 ? display.slice(-4000) : display, telegramHtmlOpts({ replyTo: replyToMsgId }));
         } else if (state.statusMessageId) {
-          await editMessage(state.statusMessageId, display.length > 4000 ? display.slice(-4000) : display, telegramHtmlOpts());
+          await editMessage(state.statusMessageId, display.length > 4000 ? display.slice(-4000) : display, telegramHtmlOpts({ streaming: true }));
         }
         lastUpdate = display;
       }
@@ -1195,6 +1213,17 @@ 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) {
+      // Leave the "thinking" phase the moment the model produces any real
+      // output — streamed text, a finished assistant block, a tool call, or a
+      // terminal result. Idempotent (guards on state.thinkingPhase internally).
+      if (state.thinkingPhase && (
+        (evt.type === "stream_event" && evt.event?.type === "content_block_delta" && evt.event.delta?.type === "text_delta") ||
+        (evt.type === "assistant" && evt.message?.content) ||
+        (evt.type === "tool_call" && evt.subtype === "started") ||
+        evt.type === "result"
+      )) {
+        endThinking();
+      }
       // Voice latency probe: first "system" event = CLI ready (cold-start done);
       // "result" = generation finished (before the TTS tail drains).
       if (voiceStreaming && vlFirstSysAt == null && evt.type === "system") vlFirstSysAt = Date.now();
@@ -1399,7 +1428,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       const firstChunk = chunks[0];
 
       if (state.statusMessageId && chunks.length === 1) {
-        await editMessage(state.statusMessageId, firstChunk, telegramHtmlOpts());
+        await editMessage(state.statusMessageId, firstChunk, telegramHtmlOpts({ streaming: true }));
       } else {
         const sent = await send(firstChunk, telegramHtmlOpts({ replyTo: replyToMsgId }));
         if (!sent) await send(firstChunk);

package/package.json

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