nullabot 1.0.1__tar.gz → 1.0.3__tar.gz

{nullabot-1.0.1 → nullabot-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nullabot
-Version: 1.0.1
+Version: 1.0.3
 Summary: 24/7 AI agents that think, design, and code - controlled via Telegram
 Project-URL: Homepage, https://github.com/ebokoo/nullabot
 Project-URL: Repository, https://github.com/ebokoo/nullabot

{nullabot-1.0.1 → nullabot-1.0.3}/nullabot/agents/claude_agent.py

@@ -300,12 +300,17 @@ IMPORTANT:
     async def _run_claude_async(
         self,
         prompt: str,
-    ) -> tuple[str, bool]:
-        """Run Claude Code CLI asynchronously."""
+    ) -> tuple[str, bool, int, int]:
+        """
+        Run Claude Code CLI asynchronously.
+
+        Returns:
+            tuple: (response_text, success, input_tokens, output_tokens)
+        """
         cmd = [
             "claude",
             "-p",
-            "--output-format", "text",
+            "--output-format", "json",
             "--model", self.model,
             "--max-turns", "50",
             "--dangerously-skip-permissions",
@@ -332,15 +337,51 @@ IMPORTANT:
             output = stdout.decode().strip()
             if process.returncode != 0:
                 error = stderr.decode() or "Unknown error"
-                return f"Error: {error}", False
+                return f"Error: {error}", False, 0, 0
+
+            # Parse JSON response to extract tokens
+            try:
+                data = json.loads(output)
 
-            return output, True
+                # Get result text - try multiple fields
+                result_text = data.get("result") or data.get("content") or ""
+
+                # If no result text but we have the raw output, use a summary
+                if not result_text and data.get("subtype") == "error_max_turns":
+                    result_text = "Reached max turns limit. Work saved."
+                elif not result_text:
+                    result_text = output  # Fallback to raw output
+
+                # Extract token usage from nested usage object
+                usage = data.get("usage", {})
+
+                # Input includes regular + cache tokens
+                input_tokens = (
+                    usage.get("input_tokens", 0) +
+                    usage.get("cache_read_input_tokens", 0) +
+                    usage.get("cache_creation_input_tokens", 0)
+                )
+                output_tokens = usage.get("output_tokens", 0)
+
+                # Also check modelUsage for more detailed breakdown
+                model_usage = data.get("modelUsage", {})
+                if model_usage and not input_tokens:
+                    for model, mu in model_usage.items():
+                        input_tokens += mu.get("inputTokens", 0)
+                        input_tokens += mu.get("cacheReadInputTokens", 0)
+                        input_tokens += mu.get("cacheCreationInputTokens", 0)
+                        output_tokens += mu.get("outputTokens", 0)
+
+                return result_text, True, input_tokens, output_tokens
+            except json.JSONDecodeError:
+                # Fallback if not valid JSON
+                return output, True, 0, 0
 
         except asyncio.TimeoutError:
             timeout_min = self.timeout // 60
-            return f"Error: Claude timed out after {timeout_min} minutes", False
+            return f"Error: Claude timed out after {timeout_min} minutes", False, 0, 0
         except Exception as e:
-            return f"Error: {str(e)}", False
+            return f"Error: {str(e)}", False, 0, 0
 
     def _get_previous_work_hint(self) -> str:
         """Get hint about where to find previous agents' work."""
@@ -500,16 +541,16 @@ IMPORTANT:
                 )
 
                 # Run Claude
-                response, success = await self._run_claude_async(current_prompt)
+                response, success, input_tokens, output_tokens = await self._run_claude_async(current_prompt)
 
                 cycle_duration = (datetime.now() - cycle_start).total_seconds()
 
-                # Track usage
+                # Track usage with actual token counts
                 usage_info = self.usage.record_cycle(
                     model=self.model,
                     agent_type=self.agent_type,
-                    input_tokens=len(current_prompt) // 4,  # Rough estimate
-                    output_tokens=len(response) // 4 if success else 0,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
                     duration_seconds=cycle_duration,
                 )
 
@@ -636,14 +677,25 @@ IMPORTANT:
                 state["total_time_seconds"] = (datetime.now() - start_time).total_seconds()
                 self._save_state(state)
 
-                # Send cycle complete notification with window usage
+                # Send cycle complete notification with window usage and tokens
                 window_pct = usage_info.get('window_usage_pct', 0)
                 window_bar = self._make_progress_bar(window_pct)
+                cycle_tokens = usage_info.get('cycle_tokens', 0)
+                total_tokens = usage_info.get('total_tokens', 0)
+
+                # Format token counts (K for thousands, M for millions)
+                def fmt_tokens(n):
+                    if n >= 1_000_000:
+                        return f"{n/1_000_000:.1f}M"
+                    elif n >= 1_000:
+                        return f"{n/1_000:.1f}K"
+                    return str(n)
 
                 await self._notify(
                     "cycle_complete",
                     f"✅ *Cycle {cycle}* complete ({cycle_duration:.0f}s)\n\n"
                     f"📁 *Files:* {file_count}\n"
+                    f"🔤 *Tokens:* {fmt_tokens(cycle_tokens)} (Total: {fmt_tokens(total_tokens)})\n"
                     f"⏱ *5hr window:* {window_bar} {window_pct:.0f}%\n"
                     f"💰 *Est. cost:* ${usage_info['cycle_cost']:.2f} (Total: ${usage_info['total_cost']:.2f})\n"
                     f"📊 {status_line}\n\n"
@@ -741,6 +793,17 @@ Remember to include STATUS and SUMMARY lines at the end."""
             window_pct = usage_summary.get('window_usage_pct', 0)
             window_hours = usage_summary.get('window_hours', 0)
             window_bar = self._make_progress_bar(window_pct)
+            total_tokens = usage_summary.get('total_tokens', 0)
+            input_tokens = usage_summary.get('total_input_tokens', 0)
+            output_tokens = usage_summary.get('total_output_tokens', 0)
+
+            # Format token counts
+            def fmt_tokens(n):
+                if n >= 1_000_000:
+                    return f"{n/1_000_000:.1f}M"
+                elif n >= 1_000:
+                    return f"{n/1_000:.1f}K"
+                return str(n)
 
             await self._notify(
                 "complete",
@@ -749,6 +812,7 @@ Remember to include STATUS and SUMMARY lines at the end."""
                 f"🔄 *Cycles:* {cycle}\n"
                 f"⏱ *Duration:* {time_str}\n"
                 f"📂 *Files created:* {file_count}\n"
+                f"🔤 *Tokens:* {fmt_tokens(total_tokens)} ({fmt_tokens(input_tokens)} in / {fmt_tokens(output_tokens)} out)\n"
                 f"⏱ *5hr window:* {window_bar} {window_pct:.0f}% ({window_hours:.1f}h used)\n"
                 f"💰 *Est. cost:* ${usage_summary['total_cost_usd']:.2f}\n\n"
                 f"*Files:*\n" + "\n".join(f"• `{f}`" for f in file_list[:10]),

{nullabot-1.0.1 → nullabot-1.0.3}/nullabot/bot/telegram.py

@@ -1097,6 +1097,14 @@ class TelegramBot:
 
         base_dir = self.base_projects_dir.parent
 
+        # Format token counts
+        def fmt_tokens(n):
+            if n >= 1_000_000:
+                return f"{n/1_000_000:.1f}M"
+            elif n >= 1_000:
+                return f"{n/1_000:.1f}K"
+            return str(n)
+
         lines = [
             "📈 *Nullabot Usage*\n",
         ]
@@ -1105,6 +1113,7 @@ class TelegramBot:
         total_cost = 0
         total_cycles = 0
         total_hours = 0
+        total_tokens = 0
 
         for item in self.base_projects_dir.iterdir():
             if item.is_dir() and (item / ".nullabot").exists():
@@ -1112,16 +1121,18 @@ class TelegramBot:
                     tracker = UsageTracker(item, base_dir)
                     summary = tracker.get_summary()
                     if summary["total_cycles"] > 0:
+                        tokens = summary.get("total_tokens", 0)
                         lines.append(f"📁 *{item.name}*")
-                        lines.append(f"   {summary['total_cycles']} cycles · {summary['total_hours']:.1f}hrs · ${summary['total_cost_usd']:.2f}")
+                        lines.append(f"   {summary['total_cycles']} cycles · {fmt_tokens(tokens)} tokens · ${summary['total_cost_usd']:.2f}")
                         total_cost += summary["total_cost_usd"]
                         total_cycles += summary["total_cycles"]
                         total_hours += summary["total_hours"]
+                        total_tokens += tokens
                 except:
                     pass
 
         if total_cycles > 0:
-            lines.append(f"\n💰 *Total:* {total_cycles} cycles · {total_hours:.1f}hrs · ${total_cost:.2f}")
+            lines.append(f"\n💰 *Total:* {total_cycles} cycles · {fmt_tokens(total_tokens)} tokens · ${total_cost:.2f}")
         else:
             lines.append("_No usage yet_")
 
@@ -1595,6 +1606,14 @@ class TelegramBot:
 
         base_dir = self.base_projects_dir.parent
 
+        # Format token counts
+        def fmt_tokens(n):
+            if n >= 1_000_000:
+                return f"{n/1_000_000:.1f}M"
+            elif n >= 1_000:
+                return f"{n/1_000:.1f}K"
+            return str(n)
+
         lines = [
             "📈 *Nullabot Usage*\n",
         ]
@@ -1603,6 +1622,7 @@ class TelegramBot:
         total_cost = 0
         total_cycles = 0
         total_hours = 0
+        total_tokens = 0
 
         for item in self.base_projects_dir.iterdir():
             if item.is_dir() and (item / ".nullabot").exists():
@@ -1610,16 +1630,18 @@ class TelegramBot:
                     tracker = UsageTracker(item, base_dir)
                     summary = tracker.get_summary()
                     if summary["total_cycles"] > 0:
+                        tokens = summary.get("total_tokens", 0)
                         lines.append(f"📁 *{item.name}*")
-                        lines.append(f"   {summary['total_cycles']} cycles · {summary['total_hours']:.1f}hrs · ${summary['total_cost_usd']:.2f}")
+                        lines.append(f"   {summary['total_cycles']} cycles · {fmt_tokens(tokens)} tokens · ${summary['total_cost_usd']:.2f}")
                         total_cost += summary["total_cost_usd"]
                         total_cycles += summary["total_cycles"]
                         total_hours += summary["total_hours"]
+                        total_tokens += tokens
                 except:
                     pass
 
         if total_cycles > 0:
-            lines.append(f"\n💰 *Total:* {total_cycles} cycles · {total_hours:.1f}hrs · ${total_cost:.2f}")
+            lines.append(f"\n💰 *Total:* {total_cycles} cycles · {fmt_tokens(total_tokens)} tokens · ${total_cost:.2f}")
         else:
             lines.append("_No usage yet_")
 

{nullabot-1.0.1 → nullabot-1.0.3}/nullabot/core/memory.py

@@ -776,33 +776,50 @@ class UsageTracker:
         self,
         model: str,
         agent_type: str,
-        input_tokens: int = 0,  # Kept for compatibility but not used
-        output_tokens: int = 0,  # Kept for compatibility but not used
+        input_tokens: int = 0,
+        output_tokens: int = 0,
         duration_seconds: float = 0,
     ) -> dict:
-        """Record a cycle's usage based on actual duration."""
+        """Record a cycle's usage based on actual duration and tokens."""
         # Calculate cost based on time (more accurate for subscriptions)
         hourly_rate = self.COST_PER_HOUR.get(model, self.COST_PER_HOUR["opus"])
         cost = (duration_seconds / 3600) * hourly_rate
 
+        # Initialize token tracking if not present
+        if "total_input_tokens" not in self._usage:
+            self._usage["total_input_tokens"] = 0
+            self._usage["total_output_tokens"] = 0
+
         # Update project totals
         self._usage["total_cycles"] += 1
         self._usage["total_duration_seconds"] += duration_seconds
         self._usage["total_cost_usd"] += cost
+        self._usage["total_input_tokens"] += input_tokens
+        self._usage["total_output_tokens"] += output_tokens
 
         # By model
         if model not in self._usage["by_model"]:
-            self._usage["by_model"][model] = {"cycles": 0, "duration": 0.0, "cost": 0.0}
+            self._usage["by_model"][model] = {
+                "cycles": 0, "duration": 0.0, "cost": 0.0,
+                "input_tokens": 0, "output_tokens": 0
+            }
         self._usage["by_model"][model]["cycles"] += 1
         self._usage["by_model"][model]["duration"] += duration_seconds
         self._usage["by_model"][model]["cost"] += cost
+        self._usage["by_model"][model]["input_tokens"] += input_tokens
+        self._usage["by_model"][model]["output_tokens"] += output_tokens
 
         # By agent
         if agent_type not in self._usage["by_agent"]:
-            self._usage["by_agent"][agent_type] = {"cycles": 0, "duration": 0.0, "cost": 0.0}
+            self._usage["by_agent"][agent_type] = {
+                "cycles": 0, "duration": 0.0, "cost": 0.0,
+                "input_tokens": 0, "output_tokens": 0
+            }
         self._usage["by_agent"][agent_type]["cycles"] += 1
         self._usage["by_agent"][agent_type]["duration"] += duration_seconds
         self._usage["by_agent"][agent_type]["cost"] += cost
+        self._usage["by_agent"][agent_type]["input_tokens"] += input_tokens
+        self._usage["by_agent"][agent_type]["output_tokens"] += output_tokens
 
         # Session log
         self._usage["sessions"].append({
@@ -811,6 +828,8 @@ class UsageTracker:
             "agent": agent_type,
             "duration": round(duration_seconds, 1),
             "cost": round(cost, 4),
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
         })
         # Keep last 500 sessions
         self._usage["sessions"] = self._usage["sessions"][-500:]
@@ -820,12 +839,20 @@ class UsageTracker:
         # Update GLOBAL 5-hour window (shared across all projects)
         window_status = self._global_window.record_usage(duration_seconds)
 
+        total_tokens = self._usage["total_input_tokens"] + self._usage["total_output_tokens"]
+
         return {
             "cycle_cost": round(cost, 2),
             "total_cost": round(self._usage["total_cost_usd"], 2),
             "total_cycles": self._usage["total_cycles"],
             "cycle_duration": round(duration_seconds, 1),
             "total_duration": round(self._usage["total_duration_seconds"], 1),
+            "cycle_input_tokens": input_tokens,
+            "cycle_output_tokens": output_tokens,
+            "cycle_tokens": input_tokens + output_tokens,
+            "total_input_tokens": self._usage["total_input_tokens"],
+            "total_output_tokens": self._usage["total_output_tokens"],
+            "total_tokens": total_tokens,
             "window_usage_pct": window_status["usage_pct"],
             "window_duration": window_status["used_seconds"],
             "window_hours": window_status["used_hours"],
@@ -839,10 +866,17 @@ class UsageTracker:
         # Get global window status
         window_status = self._global_window.get_status()
 
+        # Token totals (with backwards compatibility)
+        total_input = self._usage.get("total_input_tokens", 0)
+        total_output = self._usage.get("total_output_tokens", 0)
+
         return {
             "total_cycles": self._usage["total_cycles"],
             "total_cost_usd": round(self._usage["total_cost_usd"], 2),
             "total_hours": round(total_hours, 2),
+            "total_input_tokens": total_input,
+            "total_output_tokens": total_output,
+            "total_tokens": total_input + total_output,
             "window_hours": window_status["used_hours"],
             "window_usage_pct": window_status["usage_pct"],
             "window_remaining_hours": window_status["remaining_hours"],

{nullabot-1.0.1 → nullabot-1.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nullabot"
-version = "1.0.1"
+version = "1.0.3"
 description = "24/7 AI agents that think, design, and code - controlled via Telegram"
 readme = "README.md"
 license = "MIT"