kiwi-code 0.0.502__tar.gz → 0.0.503__tar.gz

{kiwi_code-0.0.502 → kiwi_code-0.0.503}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kiwi-code
-Version: 0.0.502
+Version: 0.0.503
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://kiwicode.ai
 Author-email: Anurag <anurag@meetkiwi.co>

{kiwi_code-0.0.502 → kiwi_code-0.0.503}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.502"
+version = "0.0.503"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

{kiwi_code-0.0.502 → kiwi_code-0.0.503}/src/kiwi_cli/client.py

@@ -16,6 +16,7 @@ from pykiwiai.api.actions import (
     async_run_action_v1_actions_id_async_run_post,
 )
 from pykiwiai.api.action_results import get_action_result_v1_action_results_id_get
+from pykiwiai.api.subagents import list_subagents_of_run_v1_subagents_runs_parent_action_run_id_get
 from pykiwiai.models.human_answers_request import HumanAnswersRequest
 from pykiwiai.models.body_return_user_and_session_v1_auth_post import (
     BodyReturnUserAndSessionV1AuthPost,
@@ -811,6 +812,44 @@ class AutobotsClientWrapper:
             logger.error(f"Error answering questions on run {run_id}: {e}")
             return 0, None, f"Error sending answer: {e}"
 
+    def list_subagents(self, run_id: str) -> tuple[int, Optional[dict], str]:
+        """The subagents `run_id` has spawned, once each with its status:
+        `GET /v1/subagents/runs/{run_id}`.
+
+        Returns:
+            Tuple of (http_status, body, message); body is the `SubagentsOfRun` dict on 200.
+        """
+        try:
+            if not isinstance(self.client, AuthenticatedClient):
+                return 401, None, "Authentication required"
+            response = list_subagents_of_run_v1_subagents_runs_parent_action_run_id_get.sync_detailed(
+                parent_action_run_id=run_id, client=self.client
+            )
+            code = int(response.status_code)
+            if code == 200 and response.parsed is not None and hasattr(response.parsed, "subagents"):
+                return 200, response.parsed.to_dict(), "ok"
+            return code, None, f"HTTP {code}"
+        except Exception as e:
+            logger.warning(f"Listing subagents of run {run_id} failed: {e}")
+            return 0, None, f"Error listing subagents: {e}"
+
+    def get_run_activity(self, run_id: str) -> tuple[int, list[dict]]:
+        """A run's recent typed activity events, oldest first
+        (`GET /v1/server_sent_events/activity/{run_id}`), for a client that subscribes to
+        `{run_id}-activity` late. A backend without the activity stream answers 404.
+        """
+        try:
+            if not isinstance(self.client, AuthenticatedClient):
+                return 401, []
+            response = self.client.get_httpx_client().get(f"/v1/server_sent_events/activity/{run_id}")
+            if response.status_code != 200:
+                return response.status_code, []
+            events = (response.json() or {}).get("events")
+            return 200, [e for e in events if isinstance(e, dict)] if isinstance(events, list) else []
+        except Exception as e:
+            logger.warning(f"Reading activity of run {run_id} failed: {e}")
+            return 0, []
+
     def close(self) -> None:
         """Close the client connection."""
         try:

{kiwi_code-0.0.502 → kiwi_code-0.0.503}/src/kiwi_cli/commands.py

@@ -770,6 +770,7 @@ Session:
   /queue remove <n>     Drop one waiting prompt, by its number in /queue list
   /queue clear          Drop every prompt waiting to run
   /stats [7d|30d|90d|1y] Show run statistics: runs, tokens, spend (default: 7d)
+  /agents               Show this run's subagents (also ctrl+g)
   /usage [run_id]       Show token usage for a run and its subagents (default: current run)
 
 Files:

kiwi_code-0.0.503/src/kiwi_cli/subagents.py

@@ -0,0 +1,383 @@
+"""The subagents a run has spawned, as the TUI shows them.
+
+`GET /v1/subagents/runs/{run_id}` is the source of truth: every subagent once, with its
+status. The parent's typed activity stream (`{run_id}-activity`, where the backend has it)
+makes the list live: `subagent.started` / `.progress` / `.finished` / `.message` events,
+keyed by `child_run_id`. Older backends only publish display strings on the run topic
+(`Spawned subagents: a, b`, `Subagent "a" finished: success`, `Subagent "a" sent a
+message`); those are used as a signal to refetch, never shown as text.
+
+Nothing here talks to the network or draws anything.
+"""
+from __future__ import annotations
+
+import re
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Iterable
+
+RUNNING = "running"
+DONE = "done"
+FAILED = "failed"
+CANCELLED = "cancelled"
+#: Filter chips, in display order.
+CATEGORIES = (RUNNING, DONE, FAILED, CANCELLED)
+
+_STATUS_CATEGORY = {
+    "processing": RUNNING,
+    "running": RUNNING,
+    "pending": RUNNING,
+    "request_cancel": RUNNING,
+    "waiting": RUNNING,
+    "success": DONE,
+    "completed": DONE,
+    "finished": DONE,
+    "error": FAILED,
+    "failed": FAILED,
+    "stuck": FAILED,
+    "cancelled": CANCELLED,
+}
+
+ICONS = {RUNNING: "●", DONE: "✓", FAILED: "✗", CANCELLED: "⊘"}
+
+# The display strings older backends publish on the parent's run topic.
+_SPAWNED = re.compile(r"^Spawned subagents: (?P<names>.+)$")
+_FINISHED = re.compile(r'^Subagent "(?P<name>.+)" finished: (?P<status>\S+)$')
+_MESSAGE = re.compile(r'^Subagent "(?P<name>.+)" sent a message$')
+
+
+def category_of(status: str | None) -> str:
+    """running / done / failed / cancelled; a run without a status yet is starting."""
+    return _STATUS_CATEGORY.get(str(status or "").lower(), RUNNING)
+
+
+def legacy_subagent_line(text: str) -> bool:
+    """Whether a status line on the run topic is one of the subagent display strings."""
+    line = (text or "").strip()
+    return bool(_SPAWNED.match(line) or _FINISHED.match(line) or _MESSAGE.match(line))
+
+
+def _epoch(value: Any) -> float:
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, datetime):
+        return value.timestamp()
+    if isinstance(value, str) and value:
+        try:
+            return datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp()
+        except ValueError:
+            return 0.0
+    return 0.0
+
+
+@dataclass
+class Subagent:
+    run_id: str
+    name: str
+    goal: str = ""
+    action_id: str = ""
+    status: str | None = None
+    error: str | None = None
+    group_id: str = ""
+    spawned_at: float = 0.0
+    #: When it finished, as seen by this client (for "finished newest first").
+    finished_at: float = 0.0
+    #: What it is doing now, from `subagent.progress`.
+    activity: str = ""
+    activity_at: float = 0.0
+    #: The last time it messaged its parent, from `subagent.message`.
+    messaged_at: float = 0.0
+
+    @property
+    def category(self) -> str:
+        return category_of(self.status)
+
+    @property
+    def icon(self) -> str:
+        return ICONS[self.category]
+
+    def elapsed(self, now: float | None = None) -> float | None:
+        """Seconds it has run (running) or ran (finished). None when unknown: no spawn
+        time, or it had finished before this client saw it end."""
+        if not self.spawned_at:
+            return None
+        if self.category != RUNNING:
+            if not self.finished_at:
+                return None
+            return max(0.0, self.finished_at - self.spawned_at)
+        return max(0.0, (now or time.time()) - self.spawned_at)
+
+
+def format_elapsed(seconds: float | None) -> str:
+    if seconds is None:
+        return "\u2014"
+    seconds = int(seconds)
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes, seconds = divmod(seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m {seconds:02d}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes:02d}m"
+
+
+@dataclass
+class Batch:
+    """One `spawn_subagents` call: its subagents, in spawn order."""
+
+    group_id: str
+    spawned_at: float
+    subagents: list[Subagent] = field(default_factory=list)
+    #: 1 for the run's first batch, in spawn order.
+    number: int = 0
+
+    def counts(self) -> dict[str, int]:
+        return counts_of(self.subagents)
+
+
+def counts_of(subagents: Iterable[Subagent]) -> dict[str, int]:
+    """How many are running / done / failed / cancelled."""
+    counts = {c: 0 for c in CATEGORIES}
+    for s in subagents:
+        counts[s.category] += 1
+    return counts
+
+
+def _attention_key(s: Subagent) -> tuple:
+    """Failed first, then running (most recently active first), then the rest."""
+    rank = {FAILED: 0, RUNNING: 1, CANCELLED: 2, DONE: 3}[s.category]
+    recent = s.activity_at or s.spawned_at
+    return (rank, -recent, s.name)
+
+
+def _panel_key(s: Subagent) -> tuple:
+    """Inside a batch: running, then failed, then finished newest first."""
+    rank = {RUNNING: 0, FAILED: 1, CANCELLED: 2, DONE: 2}[s.category]
+    return (rank, -(s.finished_at or 0.0), s.spawned_at, s.name)
+
+
+class SubagentBoard:
+    """Every subagent of one parent run, merged from snapshots and live events."""
+
+    def __init__(self, parent_run_id: str | None = None) -> None:
+        self.parent_run_id = parent_run_id
+        self._by_id: dict[str, Subagent] = {}
+        #: group_id -> index into the parent's `result.results` of the turn that spawned it.
+        self.turn_of_group: dict[str, int] = {}
+        self.version = 0
+
+    def __len__(self) -> int:
+        return len(self._by_id)
+
+    def get(self, run_id: str) -> Subagent | None:
+        return self._by_id.get(run_id)
+
+    @property
+    def subagents(self) -> list[Subagent]:
+        return list(self._by_id.values())
+
+    def counts(self) -> dict[str, int]:
+        return counts_of(self._by_id.values())
+
+    @property
+    def running(self) -> int:
+        return self.counts()[RUNNING]
+
+    # ---- input ----
+
+    def apply_snapshot(self, payload: dict | None) -> bool:
+        """Merge `GET /subagents/runs/{run_id}`. Statuses and names come from it; live-only
+        fields (activity, finished time) are kept. Returns whether anything changed."""
+        if not isinstance(payload, dict):
+            return False
+        changed = False
+        now = time.time()
+        for raw in payload.get("subagents") or []:
+            if not isinstance(raw, dict) or not raw.get("run_id"):
+                continue
+            run_id = str(raw["run_id"])
+            s = self._by_id.get(run_id)
+            seen_running = s is not None and s.category == RUNNING
+            if s is None:
+                s = Subagent(run_id=run_id, name=str(raw.get("name") or run_id))
+                self._by_id[run_id] = s
+                changed = True
+            fields = {
+                "name": str(raw.get("name") or s.name),
+                "goal": str(raw.get("goal") or s.goal),
+                "action_id": str(raw.get("action_id") or s.action_id),
+                "status": raw.get("status") or s.status,
+                "error": raw.get("error_message") or None,
+                "group_id": str(raw.get("group_id") or s.group_id),
+                "spawned_at": _epoch(raw.get("spawned_at")) or s.spawned_at,
+            }
+            for key, value in fields.items():
+                if getattr(s, key) != value:
+                    setattr(s, key, value)
+                    changed = True
+            # Only an end this client saw has a time; one that ended earlier has none.
+            if seen_running and s.category != RUNNING and not s.finished_at:
+                s.finished_at = now
+        if changed:
+            self.version += 1
+        return changed
+
+    def apply_activity(self, event: dict, *, turn_index: int | None = None) -> bool:
+        """Apply one event from the parent's activity stream. `turn_index` is the parent
+        turn being streamed, so a batch started now is drawn under it."""
+        if not isinstance(event, dict):
+            return False
+        kind = event.get("type")
+        run_id = event.get("child_run_id")
+        if not run_id or kind not in (
+            "subagent.started", "subagent.progress", "subagent.finished", "subagent.message"
+        ):
+            return False
+        run_id = str(run_id)
+        at = (event.get("at") or 0) / 1000.0 or time.time()
+        s = self._by_id.get(run_id)
+        if s is None:
+            s = Subagent(run_id=run_id, name=str(event.get("name") or run_id), spawned_at=at)
+            self._by_id[run_id] = s
+        if kind == "subagent.started":
+            s.name = str(event.get("name") or s.name)
+            s.goal = str(event.get("goal") or s.goal)
+            s.group_id = str(event.get("group_id") or s.group_id)
+            s.status = s.status or "processing"
+            s.spawned_at = s.spawned_at or at
+            if turn_index is not None and s.group_id:
+                self.turn_of_group.setdefault(s.group_id, turn_index)
+        elif kind == "subagent.progress":
+            s.activity = str(event.get("label") or "")
+            s.activity_at = at
+        elif kind == "subagent.finished":
+            ok = bool(event.get("ok"))
+            error = event.get("error")
+            # The event says ok or not; "cancelled" arrives as its error.
+            s.status = "success" if ok else ("cancelled" if error == "cancelled" else "error")
+            s.error = None if ok else (str(error) if error else None)
+            s.finished_at = at
+            s.activity = ""
+        elif kind == "subagent.message":
+            s.messaged_at = at
+        self.version += 1
+        return True
+
+    def place_batches(self, turn_index: int) -> None:
+        """Draw every batch not placed yet under turn `turn_index`."""
+        for s in self._by_id.values():
+            if s.group_id and s.group_id not in self.turn_of_group:
+                self.turn_of_group[s.group_id] = turn_index
+
+    # ---- views ----
+
+    def batches(self, *, turn_index: int | None = None) -> list[Batch]:
+        """Spawn batches, newest first; only those under `turn_index` when given."""
+        groups: dict[str, Batch] = {}
+        for s in sorted(self._by_id.values(), key=lambda s: (s.spawned_at, s.name)):
+            gid = s.group_id or "_"
+            if turn_index is not None and self.turn_of_group.get(gid) != turn_index:
+                continue
+            batch = groups.get(gid)
+            if batch is None:
+                batch = groups[gid] = Batch(group_id=gid, spawned_at=s.spawned_at)
+            batch.subagents.append(s)
+        numbers = self._batch_numbers()
+        out = sorted(groups.values(), key=lambda b: b.spawned_at, reverse=True)
+        for b in out:
+            b.number = numbers.get(b.group_id, 0)
+            b.subagents.sort(key=_panel_key)
+        return out
+
+    def _batch_numbers(self) -> dict[str, int]:
+        first: dict[str, float] = {}
+        for s in self._by_id.values():
+            gid = s.group_id or "_"
+            first[gid] = min(first.get(gid, s.spawned_at), s.spawned_at)
+        return {gid: i + 1 for i, gid in enumerate(sorted(first, key=lambda g: (first[g], g)))}
+
+    def of_turn(self, turn_index: int) -> list[Subagent]:
+        return [s for b in self.batches(turn_index=turn_index) for s in b.subagents]
+
+    def turns(self) -> set[int]:
+        """Parent turns that have subagents drawn under them."""
+        return {t for g, t in self.turn_of_group.items() if any(s.group_id == g for s in self._by_id.values())}
+
+    @staticmethod
+    def attention(subagents: Iterable[Subagent], limit: int = 3) -> list[Subagent]:
+        """The few rows worth showing inline: failed, then running, then the rest."""
+        return sorted(subagents, key=_attention_key)[:limit]
+
+    @staticmethod
+    def matches(s: Subagent, *, category: str | None = None, query: str = "") -> bool:
+        if category and s.category != category:
+            return False
+        q = query.strip().lower()
+        if q and q not in s.name.lower() and q not in s.goal.lower() and q not in (s.activity or "").lower():
+            return False
+        return True
+
+
+class ActivityFeed:
+    """A subagent's own activity stream as lines to show: tools it runs, notices, and the
+    text it is writing (one growing entry). Events already seen (same `src` and `seq`) are
+    dropped, so a replay and the live stream can overlap."""
+
+    def __init__(self, limit: int = 300) -> None:
+        self.limit = limit
+        self.lines: list[tuple[str, str]] = []  # (kind, text): kind in tool/fail/note/text/turn/agent
+        self._seen: set[tuple[str, int]] = set()
+        self._text_open = False
+
+    def _push(self, kind: str, text: str) -> None:
+        self._text_open = False
+        self.lines.append((kind, text))
+        del self.lines[: -self.limit]
+
+    def apply(self, event: dict) -> bool:
+        """Apply one event; whether the lines changed."""
+        if not isinstance(event, dict):
+            return False
+        key = (str(event.get("src") or ""), int(event.get("seq") or 0))
+        if key[0] and key in self._seen:
+            return False
+        if key[0]:
+            self._seen.add(key)
+        kind = event.get("type")
+        label = event.get("label") or event.get("name") or ""
+        if kind == "text.delta":
+            text = str(event.get("text") or "")
+            if not text:
+                return False
+            if self._text_open and self.lines and self.lines[-1][0] == "text":
+                self.lines[-1] = ("text", self.lines[-1][1] + text)
+            else:
+                self._push("text", text)
+                self._text_open = True
+            return True
+        if kind == "tool.running":
+            self._push("tool", str(label))
+        elif kind == "tool.finished" and event.get("ok") is False:
+            self._push("fail", f"{label}: {event.get('error') or 'failed'}")
+        elif kind == "notice" and event.get("text"):
+            self._push("note", str(event["text"]))
+        elif kind == "turn.started":
+            self._push("turn", "Started")
+        elif kind == "turn.finished":
+            self._push("turn" if event.get("ok") else "fail", "Finished" if event.get("ok") else f"Failed: {event.get('error') or 'error'}")
+        elif kind == "subagent.started":
+            self._push("agent", f"Spawned {event.get('name') or 'a subagent'}")
+        elif kind == "subagent.finished":
+            self._push("agent", f"{event.get('name') or 'A subagent'} finished")
+        else:
+            return False
+        return True
+
+    def apply_legacy(self, text: str) -> bool:
+        """A display string from a backend without the activity stream."""
+        line = " ".join((text or "").split())
+        if not line or (self.lines and self.lines[-1] == ("note", line)):
+            return False
+        self._push("note", line)
+        return True

{kiwi_code-0.0.502 → kiwi_code-0.0.503}/src/kiwi_tui/main.py

@@ -175,7 +175,9 @@ class AutobotsTUI(App):
             config: Runtime configuration (no persistence)
             token_manager: Token manager instance
         """
-        super().__init__()
+        # Painting with the terminal's own default colour needs ANSI colours passed through
+        # to the terminal; Textual otherwise converts them to a fixed RGB guess.
+        super().__init__(ansi_color=True if self.use_terminal_background() else None)
         self.config: AppConfig = config or AppConfig()
 
         try:
@@ -372,6 +374,13 @@ class AutobotsTUI(App):
         # Fallback for older Textual versions that only expose `dark`.
         return bool(getattr(self, "dark", True))
 
+    @staticmethod
+    def use_terminal_background() -> bool:
+        """Kiwi's dark palette uses the terminal's own background colour, so the app meets
+        the terminal's window padding without a frame. `KIWI_TERMINAL_BACKGROUND=0` keeps
+        the fixed colour instead."""
+        return os.environ.get("KIWI_TERMINAL_BACKGROUND", "1").strip().lower() not in ("0", "false", "no", "off")
+
     def get_css_variables(self) -> dict[str, str]:
         variables = super().get_css_variables()
         theme_name = str(getattr(self, "theme", "") or "").strip()
@@ -382,7 +391,9 @@ class AutobotsTUI(App):
         use_kiwi_palette = (not theme_name) or (theme_name == self.DEFAULT_THEME)
         if use_kiwi_palette:
             if dark:
-                bg = "#1E1E1E"
+                # The terminal's default background (a light theme keeps its own: its dark
+                # text could not be read on a dark terminal).
+                bg = "ansi_default" if self.use_terminal_background() else "#1E1E1E"
                 surface = "#252526"
                 raised = "#2D2D2D"
                 panel = "#333333"