cinna-cli 0.2.4__tar.gz → 0.2.5__tar.gz

{cinna_cli-0.2.4 → cinna_cli-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinna-cli
-Version: 0.2.4
+Version: 0.2.5
 Summary: Local development CLI for Cinna Core agents
 Project-URL: Homepage, https://github.com/opencinna/cinna-cli
 Project-URL: Repository, https://github.com/opencinna/cinna-cli

{cinna_cli-0.2.4 → cinna_cli-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cinna-cli"
-version = "0.2.4"
+version = "0.2.5"
 description = "Local development CLI for Cinna Core agents"
 readme = "README.md"
 requires-python = ">=3.10"

{cinna_cli-0.2.4 → cinna_cli-0.2.5}/src/cinna/chat.py

@@ -104,6 +104,24 @@ class _Emitter:
                 console.console.print(f"  [dim]📎 {att.get('filename')} → {loc}[/dim]")
         elif kind == "status":
             console.console.print(f"[dim]· {event.get('state')}…[/dim]")
+        elif kind == "delta":
+            for ev in event.get("events", []):
+                etype = ev.get("type")
+                if etype == "assistant":
+                    if ev.get("content"):
+                        console.console.print(ev["content"], end="")
+                elif etype == "thinking":
+                    console.console.print(
+                        f"  [magenta]🧠 thinking:[/magenta] {ev.get('content', '')}"
+                    )
+                elif etype in ("tool", "tool_use"):
+                    payload = ev.get("tool_input")
+                    console.console.print(
+                        f"  [cyan]🔧 {ev.get('tool_name', 'tool')}[/cyan] "
+                        f"[dim]{json.dumps(payload, ensure_ascii=False) if payload is not None else ''}[/dim]"
+                    )
+                elif ev.get("content"):
+                    console.console.print(f"  [dim]{etype}: {ev['content']}[/dim]")
         elif kind == "done":
             console.console.print(
                 f"[dim]done — result: {event.get('result_state')}[/dim]"
@@ -274,6 +292,12 @@ def _poll_turn(
     start_deadline = started + START_GRACE_SECONDS
     turn_started = not expect_turn
     flagged_in_progress: set[str] = set()
+    # How much of an in-progress message's trace we've already surfaced —
+    # the row is periodically re-flushed server-side with its *full*
+    # accumulated ``streaming_events`` so far, so this is what lets us emit
+    # only what's new since the last poll instead of going silent until the
+    # whole (possibly many-minutes-long) message finalizes.
+    shown_event_count: dict[str, int] = {}
 
     while True:
         # Drain newly-finalized messages; stop at the first in-progress one
@@ -285,16 +309,19 @@ def _poll_turn(
             advanced = False
             for m in batch:
                 meta = m.get("message_metadata") or {}
+                mid = m.get("id")
                 if meta.get("streaming_in_progress"):
                     in_progress = True
-                    mid = m.get("id")
                     if mid not in flagged_in_progress:
                         flagged_in_progress.add(mid)
                         emit.emit(
                             {"event": "status", "state": "working", "message_id": mid}
                         )
+                    if include_events:
+                        _emit_delta(emit, m, shown_event_count)
                     break
                 _emit_message(client, emit, m, dl_dir, include_events)
+                shown_event_count.pop(mid, None)
                 consumed += 1
                 advanced = True
                 if m.get("role") and m["role"] != "user":
@@ -328,6 +355,29 @@ def _poll_turn(
     _emit_done(client, emit, session_id)
 
 
+def _emit_delta(
+    emit: _Emitter,
+    m: dict,
+    shown_event_count: dict[str, int],
+) -> None:
+    """Emit trace events newly appended to a still-in-progress message.
+
+    ``streaming_events`` (thinking blocks, tool calls, tool results, and
+    individual assistant-text chunks) accumulates on the row as the turn
+    progresses and is what the server periodically flushes; this diffs
+    against what's already been shown for this message id so a long-running
+    turn surfaces gradual output instead of nothing until it finalizes.
+    """
+    mid = m.get("id")
+    events = _extract_events(m)
+    prev_count = shown_event_count.get(mid, 0)
+    new_events = events[prev_count:]
+    if not new_events:
+        return
+    emit.emit({"event": "delta", "message_id": mid, "role": m.get("role"), "events": new_events})
+    shown_event_count[mid] = len(events)
+
+
 def _emit_message(
     client: AccountClient,
     emit: _Emitter,

{cinna_cli-0.2.4 → cinna_cli-0.2.5}/tests/test_chat.py

@@ -165,6 +165,81 @@ class FakeClient:
         return {}
 
 
+class FakeStreamingClient(FakeClient):
+    """Scripts a turn whose agent message streams in two chunks before it
+    finalizes — models a long-running turn so progressive delta emission can
+    be exercised (see test_chat_streams_progressive_deltas_while_in_progress)."""
+
+    def __init__(self):
+        super().__init__()
+        self.poll_count = 0
+
+    def _user_msg(self):
+        return {
+            "id": "m1",
+            "role": "user",
+            "sequence_number": 1,
+            "timestamp": "2026-06-22T00:00:00Z",
+            "content": self.last_content,
+            "message_metadata": {},
+            "files": [],
+        }
+
+    def _agent_msg(self):
+        thinking = {"type": "thinking", "event_seq": 1, "content": "Step one."}
+        tool = {
+            "type": "tool",
+            "event_seq": 2,
+            "tool_name": "calculator",
+            "content": "calculator",
+            "metadata": {"tool_id": "tool-1", "tool_input": {"expression": "2+2"}},
+        }
+        assistant = {"type": "assistant", "event_seq": 3, "content": "Here you go"}
+        base = {
+            "id": "m2",
+            "role": "agent",
+            "sequence_number": 2,
+            "timestamp": "2026-06-22T00:00:01Z",
+            "files": [],
+        }
+        if self.poll_count == 1:
+            return {
+                **base,
+                "content": "Agent is responding...",
+                "message_metadata": {
+                    "streaming_in_progress": True,
+                    "streaming_events": [thinking],
+                },
+            }
+        if self.poll_count == 2:
+            return {
+                **base,
+                "content": "Agent is responding...",
+                "message_metadata": {
+                    "streaming_in_progress": True,
+                    "streaming_events": [thinking, tool],
+                },
+            }
+        return {
+            **base,
+            "content": "Here you go",
+            "message_metadata": {"streaming_events": [thinking, tool, assistant]},
+        }
+
+    def get_messages(self, session_id, limit=100, offset=0):
+        if not self.sent:
+            return {"data": [], "count": 0}
+        self.poll_count += 1
+        if offset == 0:
+            return {"data": [self._user_msg(), self._agent_msg()], "count": 2}
+        if offset == 1:
+            return {"data": [self._agent_msg()], "count": 1}
+        return {"data": [], "count": 0}
+
+    def get_streaming_status(self, session_id):
+        return {"is_streaming": self.poll_count < 3}
+
+
 def _ndjson(output: str) -> list[dict]:
     return [json.loads(line) for line in output.splitlines() if line.strip()]
 
@@ -247,6 +322,37 @@ def test_chat_no_events_flag_omits_trace(runner, account_root, monkeypatch):
     assert agent_msg["content"] == "Here you go"
 
 
+def test_chat_streams_progressive_deltas_while_in_progress(
+    runner, account_root, monkeypatch
+):
+    """A long-running turn (agent message stays `streaming_in_progress` across
+    several polls) surfaces its trace incrementally via `delta` events instead
+    of going silent until the whole message finalizes."""
+    monkeypatch.chdir(account_root)
+    fake = FakeStreamingClient()
+    monkeypatch.setattr("cinna.chat.AccountClient", lambda cfg: fake)
+
+    result = runner.invoke(
+        cli, ["chat", "--agent", "CRM Agent", "--interval", "0", "2+2"]
+    )
+    assert result.exit_code == 0, result.output
+
+    events = _ndjson(result.output)
+    deltas = [e for e in events if e["event"] == "delta"]
+    assert len(deltas) == 2
+    assert [ev["type"] for ev in deltas[0]["events"]] == ["thinking"]
+    # Second delta carries only the newly-appended event, not a repeat of
+    # what was already shown.
+    assert [ev["type"] for ev in deltas[1]["events"]] == ["tool"]
+
+    agent_msg = [
+        e
+        for e in events
+        if e["event"] == "message" and e["role"] == "agent"
+    ][0]
+    assert agent_msg["content"] == "Here you go"
+
+
 def test_chat_downloads_agent_attachment(runner, account_root, monkeypatch):
     monkeypatch.chdir(account_root)
     fake = FakeClient()

{cinna_cli-0.2.4 → cinna_cli-0.2.5}/uv.lock

@@ -136,7 +136,7 @@ wheels = [
 
 [[package]]
 name = "cinna-cli"
-version = "0.2.4"
+version = "0.2.5"
 source = { editable = "." }
 dependencies = [
     { name = "click" },