tsugite-cli 0.17.2__tar.gz → 0.17.3__tar.gz

{tsugite_cli-0.17.2 → tsugite_cli-0.17.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsugite-cli
-Version: 0.17.2
+Version: 0.17.3
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE

{tsugite_cli-0.17.2 → tsugite_cli-0.17.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.17.2"
+version = "0.17.3"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"

{tsugite_cli-0.17.2 → tsugite_cli-0.17.3}/tsugite/agent_runner/runner.py

@@ -681,7 +681,7 @@ async def _execute_agent_with_prompt(
                 model=model_string,
                 source="cli",
                 total_tokens=agent.total_tokens,
-                cost_usd=agent.total_cost if agent.total_cost > 0 else None,
+                cost_usd=agent.reported_cost,
                 cache_creation_tokens=agent.cache_creation_tokens,
                 cache_read_tokens=agent.cache_read_tokens,
             )

{tsugite_cli-0.17.2 → tsugite_cli-0.17.3}/tsugite/core/agent.py

@@ -339,6 +339,9 @@ class TsugiteAgent:
         self._resume_after_compaction = resume_after_compaction
 
         self.total_cost = 0.0
+        # Distinguishes "provider reported $0" (subscription models) from "no
+        # cost data at all" (interrupted turn) - only the latter records NULL.
+        self.cost_reported = False
         self.total_tokens = 0
         self.last_input_tokens = 0
         self.cache_creation_tokens = 0
@@ -571,7 +574,7 @@ class TsugiteAgent:
                 "answer": str(final_value)[:500] if final_value is not None else "",
                 "turns": turn_num + 1,
                 "tokens": total_tokens,
-                "cost": self.total_cost if self.total_cost > 0 else None,
+                "cost": self.reported_cost,
             }
 
             from tsugite.hooks import fire_hooks_background
@@ -585,13 +588,13 @@ class TsugiteAgent:
                         answer_data=_safe_json(final_value),
                         turns=turn_num + 1,
                         tokens=total_tokens,
-                        cost=self.total_cost if self.total_cost > 0 else None,
+                        cost=self.reported_cost,
                     )
                 )
                 self.event_bus.emit(
                     CostSummaryEvent(
                         tokens=total_tokens,
-                        cost=self.total_cost if self.total_cost > 0 else None,
+                        cost=self.reported_cost,
                         model=self.model_name,
                         duration_seconds=time.time() - start_time,
                         cache_creation_input_tokens=self.cache_creation_tokens or None,
@@ -610,7 +613,7 @@ class TsugiteAgent:
                 return AgentResult(
                     output=final_value,
                     token_usage=total_tokens,
-                    cost=self.total_cost if self.total_cost > 0 else None,
+                    cost=self.reported_cost,
                     steps=self.memory.steps,
                     error=error_message,
                     provider_state=self._provider.get_state(),
@@ -731,7 +734,7 @@ class TsugiteAgent:
             self.event_bus.emit(StreamCompleteEvent())
 
         if final_chunk and final_chunk.usage:
-            step_cost = self._accumulate_usage(final_chunk.usage, final_chunk.cost or 0.0)
+            step_cost = self._accumulate_usage(final_chunk.usage, final_chunk.cost)
 
         accumulated_content, spoofed = escape_runtime_injection_tags(accumulated_content)
         parsed = self._parse_response_from_text(accumulated_content)
@@ -765,8 +768,10 @@ class TsugiteAgent:
 
         step_cost = response.cost or 0.0
         if response.usage:
-            self._accumulate_usage(response.usage, step_cost)
+            self._accumulate_usage(response.usage, response.cost)
         else:
+            if response.cost is not None:
+                self.cost_reported = True
             self.total_cost += step_cost
 
         if response.reasoning_content:
@@ -1135,7 +1140,12 @@ class TsugiteAgent:
             parts.append('warning="approaching turn limit, wrap up soon"')
         return f"\n<tsugite_budget {' '.join(parts)} />"
 
-    def _accumulate_usage(self, usage, cost: float = 0.0) -> float:
+    @property
+    def reported_cost(self) -> float | None:
+        """Cumulative cost when any provider response carried one, else None."""
+        return self.total_cost if (self.cost_reported or self.total_cost > 0) else None
+
+    def _accumulate_usage(self, usage, cost: float | None = None) -> float:
         """Update cumulative token/cost counters from a usage object.
 
         Returns the step cost for caller convenience.
@@ -1146,8 +1156,10 @@ class TsugiteAgent:
         )
         self.cache_creation_tokens += usage.cache_creation_input_tokens or 0
         self.cache_read_tokens += usage.cache_read_input_tokens or 0
-        self.total_cost += cost
-        return cost
+        if cost is not None:
+            self.cost_reported = True
+        self.total_cost += cost or 0.0
+        return cost or 0.0
 
     def _parse_response_from_text(self, content: str) -> ParsedResponse:
         """Parse text content into thought, code, and content blocks."""

{tsugite_cli-0.17.2 → tsugite_cli-0.17.3}/tsugite/tools/jobs.py

@@ -37,6 +37,7 @@ def spawn_job(
     repo: Optional[str] = None,
     model: Optional[str] = None,
     verifier_model: Optional[str] = None,
+    model_ladder: Optional[list] = None,
     timeout_minutes: int = 30,
     agent: Optional[str] = None,
     max_attempts: Optional[int] = None,
@@ -67,6 +68,11 @@ def spawn_job(
         verifier_model: Optional separate model for the verifier round. Defaults
             to `model` (then the workspace default) when unset - handy to pin
             verification to a cheaper/more-available model than the worker.
+        model_ladder: Ordered "cheap first" model list, e.g.
+            ["claude_code:haiku", "claude_code:opus"]. The Job starts on the
+            first entry; when a rung exhausts its verifier attempts or the
+            worker dies on a usage/rate limit, the next attempt escalates to
+            the next model with a fresh budget. Overrides `model`.
         timeout_minutes: Per-phase budget for each worker run and verifier round
             (re-armed each phase, not a whole-job wall clock); on expiry the Job
             transitions to `stuck`.
@@ -104,6 +110,7 @@ def spawn_job(
             repo=repo,
             model=model,
             verifier_model=verifier_model,
+            model_ladder=model_ladder,
             agent=agent,
             timeout_minutes=timeout_minutes,
             spawned_by="agent-tool",

{tsugite_cli-0.17.2 → tsugite_cli-0.17.3}/tsugite/tools/schedule.py

@@ -36,14 +36,27 @@ def _call(fn, *args, **kwargs):
     return call_on_loop(_loop, fn, *args, timeout=10, **kwargs)
 
 
-def _validate_notify(notify: Optional[list[str]], notify_tool: bool) -> None:
-    """Validate notification channels and notify_tool requirement."""
+def _validate_notify(notify, notify_tool: bool) -> Optional[list[str]]:
+    """Normalize and validate the notify argument; returns the coerced list.
+
+    Agents pass booleans and bare strings here in practice - those must coerce
+    or produce a message that names the argument and the expected type, never
+    leak "'bool' object is not iterable"."""
+    if notify is True or (notify is not None and notify is not False and not isinstance(notify, (list, str))):
+        channels = f"Available channels: {', '.join(sorted(_channel_names))}" if _channel_names else ""
+        got = "True" if notify is True else type(notify).__name__
+        raise ValueError(f"notify must be a list of channel names, got {got}. {channels}".strip())
+    if notify is False:
+        notify = None
+    elif isinstance(notify, str):
+        notify = [notify]
     if notify_tool and not notify:
         raise ValueError("notify_tool=True requires a non-empty 'notify' list")
     if notify:
         unknown = set(notify) - _channel_names
         if unknown:
             raise ValueError(f"Unknown notification channel(s): {', '.join(sorted(unknown))}")
+    return notify
 
 
 def _validate_agent(agent: str) -> None:
@@ -128,7 +141,7 @@ def schedule_create(
         if not prompt and not agent_file:
             raise ValueError("Provide at least one of 'prompt' or 'agent_file'")
 
-    _validate_notify(notify, notify_tool)
+    notify = _validate_notify(notify, notify_tool)
     agent = _resolve_agent(agent)
     _validate_agent(agent)
 
@@ -274,8 +287,8 @@ def schedule_update(
     fields = {k: v for k, v in simple.items() if v is not None}
 
     if notify is not None:
-        _validate_notify(notify, False)
-        fields["notify"] = notify
+        notify = _validate_notify(notify, False)
+        fields["notify"] = notify or []
     if notify_tool is not None:
         if notify_tool:
             effective_notify = notify if notify is not None else _call(_scheduler.get, id).notify
@@ -436,7 +449,7 @@ def background_task(
     if on_complete and (not isinstance(on_complete, dict) or on_complete.get("action") != "reply"):
         raise ValueError("on_complete must be {'action': 'reply'}")
 
-    _validate_notify(notify, notify_tool)
+    notify = _validate_notify(notify, notify_tool)
     agent = _resolve_agent(agent)
     _validate_agent(agent)