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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.503"
+version = "0.0.505"
 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.503 → kiwi_code-0.0.505}/src/kiwi_cli/cli.py

@@ -137,10 +137,13 @@ def _get_client() -> AuthenticatedClient:
         typer.echo("Not authenticated. Run `kiwi login` first.", err=True)
         raise typer.Exit(code=1)
 
+    from kiwi_cli.client import API_TIMEOUT
+
     return AuthenticatedClient(
         base_url=_backend_url(),
         token=str(access),
         raise_on_unexpected_status=False,
+        timeout=API_TIMEOUT,
     )
 
 

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

@@ -29,6 +29,11 @@ from .models import AuthTokens, LoginCredentials
 from .human_questions import WAITING_STATUS, human_event_type, parse_questions
 
 
+# Every API call gives up in the end: a request that never answers would otherwise hold its
+# thread, and the app, open for ever. Uploads get the long read; the live stream has its own.
+API_TIMEOUT = httpx.Timeout(120.0, connect=15.0)
+
+
 class AutobotsClientWrapper:
     """Wrapper around autobots_client for API calls."""
 
@@ -57,12 +62,14 @@ class AutobotsClientWrapper:
                 base_url=base_url,
                 token=token,
                 raise_on_unexpected_status=False,
+                timeout=API_TIMEOUT,
             )
             logger.info(f"Initialized authenticated client for {base_url}")
         else:
             self.client = Client(
                 base_url=base_url,
                 raise_on_unexpected_status=False,
+                timeout=API_TIMEOUT,
             )
             logger.info(f"Initialized unauthenticated client for {base_url}")
 
@@ -77,6 +84,7 @@ class AutobotsClientWrapper:
             base_url=self.base_url,
             token=self.access_token,
             raise_on_unexpected_status=False,
+            timeout=API_TIMEOUT,
         )
         logger.info("Client updated with new access token")
 
@@ -641,6 +649,7 @@ class AutobotsClientWrapper:
         topic: str | None = None,
         stop_on_terminal_status: bool = True,
         plain_text_type: str = "status",
+        on_open: Callable[[], None] | None = None,
     ) -> None:
         """Stream action run updates via Server-Sent Events.
 
@@ -663,6 +672,8 @@ class AutobotsClientWrapper:
                 `status` field. Disable for topics that don't send status (e.g. *-text).
             plain_text_type: When a frame is not valid JSON, wrap it as
                 `{'type': plain_text_type, 'text': <payload>}`.
+            on_open: Called once the stream is connected, e.g. to read back what was
+                published before it was.
         """
         topic = topic or run_id
         sse_endpoint = f"{self.base_url}/v1/server_sent_events/stream/{topic}"
@@ -684,6 +695,11 @@ class AutobotsClientWrapper:
                     if response.status_code != 200:
                         logger.error(f"SSE connection failed with status {response.status_code}")
                         return
+                    if on_open is not None:
+                        try:
+                            on_open()
+                        except Exception as e:
+                            logger.warning(f"SSE on_open failed: {e}")
 
                     decoder = codecs.getincrementaldecoder("utf-8")()
                     buffer = ""

kiwi_code-0.0.505/src/kiwi_cli/io_threads.py

@@ -0,0 +1,35 @@
+"""Where the TUI's blocking calls run: one daemon thread each.
+
+asyncio runs `asyncio.to_thread` and Textual's thread workers on the loop's default
+executor, whose threads Python waits for on exit, up to five minutes. A request still
+waiting on the network when the user quits would then keep the closed app alive. These
+threads end with the app; the calls they make are bounded by their own timeouts.
+"""
+from __future__ import annotations
+
+import threading
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Any, Callable
+
+
+class DaemonThreadExecutor(ThreadPoolExecutor):
+    """Runs each call on a thread of its own that does not hold the process open. A
+    `ThreadPoolExecutor` only so asyncio accepts it as the default; it keeps no pool,
+    whose threads Python would wait for."""
+
+    def submit(self, fn: Callable[..., Any], /, *args: Any, **kwargs: Any) -> Future:
+        future: Future = Future()
+
+        def run() -> None:
+            if not future.set_running_or_notify_cancel():
+                return
+            try:
+                future.set_result(fn(*args, **kwargs))
+            except BaseException as exc:  # noqa: BLE001 - handed to whoever awaits it
+                future.set_exception(exc)
+
+        threading.Thread(target=run, name="kiwi-io", daemon=True).start()
+        return future
+
+    def shutdown(self, wait: bool = True, *, cancel_futures: bool = False) -> None:
+        """Nothing to wait for: the threads end with the process."""

kiwi_code-0.0.505/src/kiwi_cli/run_activity.py

@@ -0,0 +1,532 @@
+"""A run's own turns as the TUI shows them, read off the backend's typed activity stream
+(`{run_id}-activity`), laid out the way Agent Studio lays them out: the answer as it
+happened (text, tool calls, notices and thinking in order), then one summary line.
+
+The stream sends one JSON event per message: `turn.started/finished`, `step.started`,
+`text.delta`, `reasoning.delta`, `tool.started/args.delta/ready/running/finished`,
+`notice`, plus `subagent.*` and `question.*`, which other parts of the TUI handle. A
+client that connects late reads the run's recent events back first
+(`GET /v1/server_sent_events/activity/{run_id}`); that read-back and the live stream
+overlap, so an event already seen (same `src` and `seq`) is dropped.
+
+Memory stays bounded however long a run goes: each turn keeps its latest steps only,
+the text of its latest thinking only, and the trace keeps its latest lines only.
+
+Nothing here talks to the network or draws anything.
+"""
+from __future__ import annotations
+
+import json
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Iterable
+
+#: Sent only by the process running a turn. While a turn is open, these from another
+#: process are an earlier attempt's (the backend retried the turn while it still ran).
+TURN_OWN = frozenset({
+    "turn.finished", "step.started", "text.delta", "reasoning.delta",
+    "tool.started", "tool.args.delta", "tool.ready", "tool.running", "tool.finished",
+})
+
+#: The steps a turn keeps; older ones are counted, not kept.
+TURN_ITEMS = 300
+#: The tool calls of a turn whose arguments are kept, for their details; the latest only.
+ARGS_KEPT = 50
+ARGS_CHARS = 2000
+NOTES_KEPT = 3
+#: The thinking blocks of a turn whose text is kept, and how much of each.
+THOUGHTS_KEPT = 20
+THOUGHT_CHARS = 8000
+#: The file changes whose diffs are kept, the latest only; older ones keep their counts.
+DIFFS_KEPT = 30
+#: The trace lines kept for the trace panel.
+TRACE_LINES = 200
+_TRACE_TEXT = 220
+_MAX_EVENTS = 3000
+_KEPT_TURNS = 8
+
+
+@dataclass
+class ToolLine:
+    kind = "tool"
+    call_id: str
+    name: str
+    step: int | None = None
+    label: str = ""
+    state: str = "forming"  # forming / ready / running / ok / fail
+    parent: str | None = None
+    hosted: bool = False
+    duration_ms: int | None = None
+    error: str = ""
+    note: str = ""  # its latest notice, shown while it runs
+    notes: list[str] = field(default_factory=list)  # its latest few, for its details
+    args: str = ""  # the server's preview of its arguments, as indented JSON
+    args_chars: int | None = None
+    args_truncated: bool = False
+    #: The changes it made to files, as the user's runtime recorded them: path, added,
+    #: removed, diff (unified, without its header), truncated, created, deleted.
+    edits: list[dict] = field(default_factory=list)
+
+
+@dataclass
+class Block:
+    kind: str  # text / reasoning / notice
+    step: int | None = None
+    text: str = ""
+    chars: int = 0  # all of it, however much of `text` is kept
+    id: int = 0  # numbers a turn's blocks, so one can be opened on screen
+    dropped: bool = False  # its text was let go, to keep the latest turns' thinking
+
+
+@dataclass
+class TurnView:
+    key: tuple[str, int]
+    src: str | None
+    name: str = ""
+    started_at: int = 0
+    finished: dict | None = None  # {"ok", "error", "at"}
+    items: list = field(default_factory=list)  # ToolLine / Block, in the order they happened
+    tools: dict[str, ToolLine] = field(default_factory=dict)
+    tool_total: int = 0
+    dropped: int = 0  # steps no longer kept
+    step: int | None = None  # the model call it is on
+    text_chars: int = 0  # all the answer text it has streamed
+    #: How much of that text the screen has revealed so far: text arrives in bursts, and
+    #: the screen shows it at a steady pace. None (the default) shows it all.
+    revealed: int | None = None
+    _with_args: deque = field(default_factory=deque, repr=False)
+    _thoughts: deque = field(default_factory=deque, repr=False)
+    _blocks: int = 0
+
+    def new_block(self, kind: str, step: int | None) -> "Block":
+        self._blocks += 1
+        block = Block(kind=kind, step=step, id=self._blocks)
+        self._add(block)
+        if kind == "reasoning":
+            self._thoughts.append(block)
+            while len(self._thoughts) > THOUGHTS_KEPT:
+                old = self._thoughts.popleft()
+                old.text, old.dropped = "", True
+        return block
+
+    @property
+    def has_text(self) -> bool:
+        return any(isinstance(i, Block) and i.kind == "text" and i.text.strip() for i in self.items)
+
+    def doing(self) -> tuple[str, str]:
+        """What the turn is doing now, for the status line: (kind, text), kind one of
+        tool / thinking / writing / working."""
+        running = [t for t in self.tools.values() if t.state == "running" and not t.parent]
+        if running:
+            tool = running[-1]
+            return "tool", tool.label or tool.name
+        last = self.items[-1] if self.items else None
+        if isinstance(last, Block) and last.kind == "reasoning":
+            return "thinking", "Thinking"
+        if isinstance(last, Block) and last.kind == "text":
+            return "writing", "Writing"
+        if isinstance(last, ToolLine) and last.state in ("forming", "ready"):
+            return "tool", f"Preparing {last.label or last.name}"
+        return "working", "Working"
+
+    @property
+    def steps_key(self) -> str:
+        """What opens or closes this turn's steps on screen."""
+        return f"steps:{self.key[0]}:{self.key[1]}"
+
+    @property
+    def has_steps(self) -> bool:
+        """Whether there is more to the turn than its answer."""
+        return any(not (isinstance(i, Block) and i.kind == "text") for i in self.items) or self.dropped > 0
+
+    def summary(self) -> str:
+        """"Used 3 tools · 12.4s", as Agent Studio ends a finished turn."""
+        if self.finished is None:
+            return ""
+        took = _took(max(0, (self.finished.get("at") or 0) - (self.started_at or 0)))
+        n = self.tool_total
+        used = f"Used {n} tool{'s' if n != 1 else ''} · {took}" if n else took
+        if self.finished.get("ok"):
+            return used
+        return f"{used} · {self.finished.get('error') or 'failed'}"
+
+    def keep_args(self, tool: "ToolLine", args: object, chars: object, truncated: object) -> None:
+        """Keep a call's argument preview; the oldest calls give theirs up."""
+        try:
+            text = json.dumps(args, indent=2, ensure_ascii=False, default=str) if args else ""
+        except (TypeError, ValueError):
+            text = str(args)
+        tool.args = text if len(text) <= ARGS_CHARS else text[: ARGS_CHARS - 1] + "…"
+        tool.args_chars = chars if isinstance(chars, int) else None
+        tool.args_truncated = bool(truncated)
+        if tool.call_id not in self._with_args:
+            self._with_args.append(tool.call_id)
+        while len(self._with_args) > ARGS_KEPT:
+            old = self.tools.get(self._with_args.popleft())
+            if old is not None:
+                old.args = ""
+
+    def _add(self, item) -> None:
+        self.items.append(item)
+        if len(self.items) > TURN_ITEMS:
+            old = self.items.pop(0)
+            self.dropped += 1
+            if isinstance(old, ToolLine):
+                self.tools.pop(old.call_id, None)
+
+
+@dataclass
+class TraceLine:
+    seq: int
+    at: int
+    type: str
+    what: str
+    count: int = 1
+
+
+def _took(ms: int) -> str:
+    secs = ms / 1000
+    if secs < 60:
+        return f"{secs:.1f}s"
+    if secs < 3600:
+        return f"{int(secs // 60)}m {int(secs % 60)}s"
+    return f"{int(secs // 3600)}h {int(secs % 3600 // 60)}m"
+
+
+def _event_key(event: dict) -> tuple[str, int]:
+    try:
+        return str(event.get("src") or ""), int(event.get("seq") or 0)
+    except (TypeError, ValueError):
+        return str(event.get("src") or ""), 0
+
+
+def _order(event: dict) -> tuple:
+    src, seq = _event_key(event)
+    return (event.get("at") or 0, src, seq)
+
+
+def _one_line(text: object, limit: int = _TRACE_TEXT) -> str:
+    line = " ".join(str(text or "").split())
+    return line if len(line) <= limit else line[: limit - 1] + "…"
+
+
+def describe(event: dict) -> str:
+    """One line on what an event says, as Agent Studio's trace shows it."""
+    kind = str(event.get("type") or "")
+    if kind.endswith(".delta") or kind == "notice":
+        return _one_line(event.get("text"))
+    if kind.startswith("subagent."):
+        who = event.get("name") or f"…{str(event.get('child_run_id') or '')[-6:]}"
+        if kind == "subagent.progress":
+            what = event.get("label")
+        elif kind == "subagent.finished":
+            what = "ok" if event.get("ok") else (event.get("error") or "failed")
+        elif kind == "subagent.started":
+            what = event.get("goal")
+        else:
+            what = "sent a message"
+        return _one_line(f"{who} · {what or ''}")
+    if kind.startswith("tool."):
+        text = str(event.get("label") or event.get("name") or "")
+        if kind == "tool.finished":
+            ms = event.get("duration_ms")
+            text += f" · {'ok' if event.get('ok') else 'failed'} · {ms if ms is not None else '–'} ms"
+        return _one_line(text)
+    if kind.startswith("question."):
+        n = len(event.get("questions") or event.get("question_ids") or [])
+        return _one_line(f"{n} question{'s' if n != 1 else ''}" + (f" · {event['status']}" if event.get("status") else ""))
+    if kind == "step.started":
+        return f"step {event.get('step')}"
+    if kind == "turn.started":
+        return _one_line(event.get("name"))
+    if kind == "turn.finished":
+        return "ok" if event.get("ok") else _one_line(event.get("error") or "failed")
+    return ""
+
+
+class RunActivityView:
+    """The turns of one run, built from its activity events; which of them the streaming
+    row follows; and a short trace of the latest events."""
+
+    def __init__(self) -> None:
+        self._events: list[dict] = []
+        self._seen: set[tuple[str, int]] = set()
+        self._turns: list[TurnView] = []
+        self._open: TurnView | None = None
+        self._stale: set[tuple[str, int]] = set()
+        self._followed: tuple[str, int] | None = None
+        self._following = False
+        self.trace: deque[TraceLine] = deque(maxlen=TRACE_LINES)
+        # Each call's file changes, kept apart from the turns so a rebuild keeps them.
+        self._edits: dict[str, list[dict]] = {}
+        self._with_diff: deque[dict] = deque()
+        self._edits_seen: deque[tuple] = deque(maxlen=DIFFS_KEPT * 8)
+        self.trace_start: int | None = None
+        #: Counts every change, so a redraw can tell whether there is anything new.
+        self.version = 0
+
+    # ---- input ----
+
+    def take(self, event: object) -> bool:
+        """Add one event; whether it was new."""
+        if not isinstance(event, dict) or not event.get("type"):
+            return False
+        key = _event_key(event)
+        if key[0]:
+            if key in self._seen:
+                return False
+            self._seen.add(key)
+        in_order = not self._events or _order(event) >= _order(self._events[-1])
+        self._events.append(event)
+        self._trace(event)
+        if len(self._events) > _MAX_EVENTS:
+            del self._events[: len(self._events) - _MAX_EVENTS]
+            self._seen = {_event_key(e) for e in self._events}
+            in_order = False
+        if in_order:
+            self._apply(event)
+        else:
+            self._rebuild()
+        self.version += 1
+        return True
+
+    def take_all(self, events: Iterable[object]) -> bool:
+        """Add a batch, such as a read-back; whether anything was new."""
+        fresh = []
+        for e in events:
+            if not isinstance(e, dict) or not e.get("type"):
+                continue
+            key = _event_key(e)
+            if key[0] and key in self._seen:
+                continue
+            if key[0]:
+                self._seen.add(key)
+            fresh.append(e)
+        if not fresh:
+            return False
+        self._events.extend(fresh)
+        self._events.sort(key=_order)
+        del self._events[: max(0, len(self._events) - _MAX_EVENTS)]
+        for e in sorted(fresh, key=_order):
+            self._trace(e)
+        self._rebuild()
+        self.version += 1
+        return True
+
+    # ---- following ----
+
+    def start_following(self) -> None:
+        """From now on the row follows a turn that has not already finished: what the
+        read-back holds of earlier turns is not this prompt's."""
+        self._stale = {t.key for t in self._turns if t.finished is not None}
+        self._followed = None
+        self._following = True
+        self.version += 1
+
+    def follow_next(self) -> None:
+        """The run has moved on to a newer turn: follow the next one that has not finished
+        (one that has is already on screen from the stored run). A turn still running is
+        that newer turn, already being followed, and stays followed."""
+        self._stale |= {t.key for t in self._turns if t.finished is not None}
+        if self._followed in self._stale:
+            self._followed = None
+        self.version += 1
+
+    @property
+    def followed(self) -> TurnView | None:
+        if not self._following:
+            return None
+        last = self._turns[-1] if self._turns else None
+        if self._followed is not None:
+            for t in self._turns:
+                if t.key == self._followed and not self._abandoned(t, last):
+                    return t
+        for t in self._turns:
+            if t.key not in self._stale and not self._abandoned(t, last):
+                self._followed = t.key
+                return t
+        return None
+
+    @staticmethod
+    def _abandoned(turn: TurnView, last: TurnView | None) -> bool:
+        """A turn that never finished yet has a newer one after it: a run runs one turn
+        at a time, so it was given up (a retried or lost attempt)."""
+        return turn.finished is None and last is not None and turn is not last
+
+    def followed_finished(self) -> bool:
+        turn = self.followed
+        return turn is not None and turn.finished is not None
+
+    # ---- file changes ----
+
+    def add_edit(self, record: object) -> bool:
+        """A change the user's runtime made to a file, shown under the call that made it.
+        A record that names no call (an older backend) goes to the latest file tool of
+        the turn being followed. Whether it found a call."""
+        if not isinstance(record, dict):
+            return False
+        seen = (record.get("at"), record.get("call_id"), record.get("path"), record.get("op"))
+        if seen in self._edits_seen:
+            return False  # read again after the record file was trimmed
+        self._edits_seen.append(seen)
+        call_id = str(record.get("call_id") or "")
+        tool = self._tool(call_id) if call_id else None
+        if not call_id:
+            tool = self._latest_file_tool()
+            if tool is None:
+                return False
+            call_id = tool.call_id
+        edit = {k: record.get(k) for k in ("path", "added", "removed", "diff", "truncated", "created", "deleted")}
+        edits = self._edits.setdefault(call_id, [])
+        edits.append(edit)
+        if tool is not None:
+            tool.edits = edits
+        self._with_diff.append(edit)
+        while len(self._with_diff) > DIFFS_KEPT:
+            self._with_diff.popleft()["diff"] = ""
+        if len(self._edits) > DIFFS_KEPT * 4:
+            for key in list(self._edits)[: len(self._edits) - DIFFS_KEPT * 4]:
+                del self._edits[key]
+        self.version += 1
+        return True
+
+    def _tool(self, call_id: str) -> ToolLine | None:
+        for turn in reversed(self._turns):
+            if call_id in turn.tools:
+                return turn.tools[call_id]
+        return None
+
+    def _latest_file_tool(self) -> ToolLine | None:
+        turn = self.followed
+        if turn is None:
+            return None
+        for tool in reversed(list(turn.tools.values())):
+            if tool.name == "file_system_tool":
+                return tool
+        return None
+
+    # ---- trace ----
+
+    def _trace(self, event: dict) -> None:
+        kind = str(event.get("type") or "")
+        at = int(event.get("at") or 0)
+        if self.trace_start is None:
+            self.trace_start = at
+        last = self.trace[-1] if self.trace else None
+        # Deltas arrive many to a sentence: one line counts them.
+        if kind.endswith(".delta") and last is not None and last.type == kind:
+            last.count += 1
+            last.what = _one_line(last.what + str(event.get("text") or ""))
+            return
+        self.trace.append(TraceLine(seq=_event_key(event)[1], at=at, type=kind, what=describe(event)))
+
+    # ---- reducer ----
+
+    def _rebuild(self) -> None:
+        # How far each turn's text was revealed is the screen's, not the events': keep it.
+        revealed = {t.key: t.revealed for t in self._turns}
+        self._turns = []
+        self._open = None
+        for e in self._events:
+            self._apply(e)
+        for t in self._turns:
+            if t.key in revealed:
+                t.revealed = revealed[t.key] if revealed[t.key] is None else min(revealed[t.key], t.text_chars)
+
+    def _turn_for(self, event: dict) -> TurnView:
+        if self._open is None:
+            src, seq = _event_key(event)
+            # Its `turn.started` is not in what was read back.
+            self._open = TurnView(key=(f"~{src}", seq), src=None, started_at=event.get("at") or 0)
+            self._add_turn(self._open)
+        return self._open
+
+    def _add_turn(self, turn: TurnView) -> None:
+        self._turns.append(turn)
+        # Only the latest few turns can be followed; the rest are on screen already.
+        if len(self._turns) > _KEPT_TURNS:
+            del self._turns[:-_KEPT_TURNS]
+
+    def _apply(self, event: dict) -> None:
+        kind = str(event.get("type") or "")
+        if kind.startswith("subagent.") or kind.startswith("question."):
+            return
+        if kind == "turn.started":
+            src, seq = _event_key(event)
+            self._open = TurnView(
+                key=(src, seq), src=src or None, name=str(event.get("name") or ""),
+                started_at=event.get("at") or 0,
+            )
+            self._add_turn(self._open)
+            return
+        if kind not in TURN_OWN and kind != "notice":
+            return
+        turn = self._turn_for(event)
+        if (
+            turn.src and kind in TURN_OWN and event.get("src") != turn.src
+            and not (kind == "turn.finished" and event.get("status"))
+        ):
+            return
+        if kind == "turn.finished":
+            turn.finished = {"ok": bool(event.get("ok")), "error": str(event.get("error") or ""), "at": event.get("at") or 0}
+            self._open = None
+            return
+        if kind == "step.started":
+            if isinstance(event.get("step"), int):
+                turn.step = event["step"]
+            return
+        last = turn.items[-1] if turn.items else None
+        step = event.get("step")
+        if kind in ("text.delta", "reasoning.delta"):
+            block_kind = "text" if kind == "text.delta" else "reasoning"
+            text = str(event.get("text") or "")
+            if not (isinstance(last, Block) and last.kind == block_kind and last.step == step):
+                last = turn.new_block(block_kind, step)
+            last.chars += len(text)
+            if block_kind == "text":
+                last.text += text
+                turn.text_chars += len(text)
+            elif not last.dropped and len(last.text) < THOUGHT_CHARS:
+                last.text = (last.text + text)[:THOUGHT_CHARS]
+            return
+        call_id = str(event.get("call_id") or "")
+        if kind == "notice":
+            text = str(event.get("text") or "")
+            tool = turn.tools.get(call_id) if call_id else None
+            if tool is not None:
+                tool.note = text
+                tool.notes.append(text)
+                del tool.notes[:-NOTES_KEPT]
+            elif text:
+                turn.new_block("notice", None).text = text
+            return
+        if not call_id:
+            return
+        tool = turn.tools.get(call_id)
+        if tool is None:
+            tool = ToolLine(
+                call_id=call_id, name=str(event.get("name") or "tool"), step=step,
+                parent=event.get("parent_call_id"),
+            )
+            if call_id in self._edits:
+                tool.edits = self._edits[call_id]
+            turn.tools[call_id] = tool
+            turn.tool_total += 1
+            turn._add(tool)
+        if event.get("name"):
+            tool.name = str(event["name"])
+        if event.get("label"):
+            tool.label = str(event["label"])
+        if event.get("hosted"):
+            tool.hosted = True
+        if kind == "tool.ready":
+            turn.keep_args(tool, event.get("args"), event.get("args_chars"), event.get("args_truncated"))
+            if tool.state == "forming":
+                tool.state = "ready"
+        elif kind == "tool.running":
+            tool.state = "running"
+        elif kind == "tool.finished":
+            tool.state = "ok" if event.get("ok") else "fail"
+            tool.error = str(event.get("error") or "")
+            tool.duration_ms = event.get("duration_ms")
+            tool.note = ""