codeer-cli 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

codeer_cli/chats.py

@@ -1,15 +1,10 @@
-"""Chat creation and SSE-streamed agent responses — the Live Test surface.
-
-The send_message() path is the main dogfood driver: open a chat against a
-specific agent version (unpublished draft is fine) and consume the SSE stream
-to get tool calls, reasoning, and final text back.
-"""
+"""Chat V2 creation, structured SSE responses, and persisted message reads."""
 
 from __future__ import annotations
 
 from typing import Any, Iterator, List, Optional
 
-from .client import CodeerClient
+from .client import CodeerClient, TransportError
 
 
 def create(
@@ -19,12 +14,13 @@ def create(
     title: Optional[str] = None,
     external_user_id: Optional[str] = None,
 ) -> dict:
-    body: dict[str, Any] = {"agent_id": agent_id}
-    if title is not None:
-        body["name"] = title
+    body: dict[str, Any] = {
+        "agent_id": agent_id,
+        "name": title or "CLI conversation",
+    }
     if external_user_id is not None:
         body["external_user_id"] = external_user_id
-    return client.post("/chats", json=body)
+    return client.post("/chats", api_version="v2", json=body)
 
 
 def send_published_agent_message(
@@ -35,7 +31,7 @@ def send_published_agent_message(
     agent_id: str,
     external_user_id: Optional[str] = None,
     attachment_ids: Optional[List[str]] = None,
-    stream: bool = False,
+    stream: bool = True,
     timeout: Optional[float] = None,
 ) -> Iterator[dict] | dict:
     """Send a user message through the API-key external chat flow.
@@ -51,8 +47,14 @@ def send_published_agent_message(
 
     path = f"/chats/{chat_id}/messages"
     if stream:
-        return client.stream_sse("POST", path, json=body)
-    return client.post(path, json=body, timeout=timeout)
+        return client.stream_sse(
+            "POST",
+            path,
+            api_version="v2",
+            json=body,
+            timeout=timeout,
+        )
+    return client.post(path, api_version="v2", json=body, timeout=timeout)
 
 
 def send_message(
@@ -63,25 +65,173 @@ def send_message(
     agent_history_id: str,
     attachment_ids: Optional[List[str]] = None,
     stream: bool = True,
+    timeout: Optional[float] = None,
 ) -> Iterator[dict] | dict:
-    """Send a user message; yield SSE events (if stream=True) or return the final payload.
+    """Use legacy Chat V1 to pin an unpublished agent version.
 
-    ``agent_history_id`` is required — this is how you pin Live Test to a specific
-    (possibly unpublished) agent version without affecting production users.
+    Chat V2's API-key external flow only accepts the published ``agent_id``.
+    Keep this low-level compatibility helper on V1 until V2 supports external
+    ``agent_history_id`` pinning. It remains streaming by default.
     """
-    body: dict[str, Any] = {"message": message, "agent_history_id": agent_history_id}
+    body: dict[str, Any] = {
+        "message": message,
+        "agent_history_id": agent_history_id,
+        "stream": stream,
+    }
     if attachment_ids:
         body["attachment_ids"] = attachment_ids
 
     path = f"/chats/{chat_id}/messages"
     if stream:
-        return client.stream_sse("POST", path, json=body)
-    return client.post(path, json=body)
+        return client.stream_sse(
+            "POST",
+            path,
+            json=body,
+            timeout=timeout,
+        )
+    return client.post(path, json=body, timeout=timeout)
+
 
+def collect_stream(events: Iterator[dict]) -> dict:
+    """Collect a Chat V2 SSE stream and require an explicit completion event."""
+    raw_events: list[dict] = []
+    parts: list[dict] = []
+    interactions: list[dict] = []
+    text_deltas: list[str] = []
+    final_text: str | None = None
+    response_id: str | None = None
+    conversation_group_id: str | None = None
+    updated_title: str | None = None
+    completed = False
+
+    for event in events:
+        data = event.get("data")
+        if data == "[DONE]":
+            continue
+        raw_events.append(event)
+        if not isinstance(data, dict):
+            continue
+
+        event_type = str(data.get("type") or event.get("event") or "message")
+        response_id = str(data.get("response_id") or response_id or "") or None
+        conversation_group_id = str(
+            data.get("conversation_group_id") or conversation_group_id or ""
+        ) or None
+
+        if event_type == "response.part.delta":
+            delta = data.get("delta")
+            if data.get("part_kind") == "text" and isinstance(delta, str):
+                text_deltas.append(delta)
+        elif event_type in ("response.part.created", "response.part.completed"):
+            part = data.get("part")
+            if isinstance(part, dict):
+                parts.append({"event": event_type, "part": part})
+                content = part.get("content")
+                if (
+                    event_type == "response.part.completed"
+                    and part.get("part_kind") == "text"
+                    and isinstance(content, dict)
+                    and isinstance(content.get("content"), str)
+                ):
+                    final_text = content["content"]
+        elif event_type in ("response.interaction.created", "response.interaction.resolved"):
+            interactions.append(data)
+        elif event_type == "response.chat.title.updated":
+            name = data.get("name")
+            if isinstance(name, str):
+                updated_title = name
+        elif event_type == "response.failed":
+            message = data.get("message") or "Chat V2 stream failed"
+            raise TransportError(
+                str(message),
+                {
+                    "code": data.get("code"),
+                    "response_id": response_id,
+                    "conversation_group_id": conversation_group_id,
+                    "outcome_uncertain": True,
+                    "events": raw_events,
+                },
+            )
+        elif event_type == "response.completed":
+            completed = True
+
+    if not completed:
+        raise TransportError(
+            "Chat V2 stream ended before response.completed. Inspect the history before retrying.",
+            {
+                "response_id": response_id,
+                "conversation_group_id": conversation_group_id,
+                "outcome_uncertain": True,
+                "events": raw_events,
+            },
+        )
+
+    return {
+        "stream": True,
+        "completed": True,
+        "response_id": response_id,
+        "conversation_group_id": conversation_group_id,
+        "final_text": final_text if final_text is not None else "".join(text_deltas),
+        "updated_title": updated_title,
+        "parts": parts,
+        "interactions": interactions,
+        "events": raw_events,
+    }
+
+
+def list_messages(
+    client: CodeerClient,
+    chat_id: int,
+    *,
+    external_user_id: Optional[str] = None,
+    limit: int = 500,
+) -> dict:
+    """Return every client-visible Chat V2 part for a persisted chat.
 
-def list_messages(client: CodeerClient, chat_id: int) -> list[dict]:
-    return client.get(f"/chats/{chat_id}/messages")
+    ``limit`` is the per-request page size, not a cap on the returned history.
+    The HTTP client unwraps Codeer's response envelope (and therefore its
+    pagination object), so exhaustion is detected from the number of messages
+    returned by each page. A final empty request is possible when the total is
+    an exact multiple of ``limit``.
+    """
+    if limit <= 0:
+        raise ValueError("limit must be greater than zero")
+
+    offset = 0
+    result: dict[str, Any] | None = None
+    messages: list[dict] = []
+    while True:
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        if external_user_id is not None:
+            params["external_user_id"] = external_user_id
+        page = client.get(
+            f"/chats/{chat_id}/messages",
+            api_version="v2",
+            params=params,
+        )
+        if not isinstance(page, dict):
+            raise ValueError("Chat V2 messages response must be an object")
+
+        page_messages = page.get("messages") or []
+        if not isinstance(page_messages, list):
+            raise ValueError("Chat V2 messages response must contain a messages list")
+        if result is None:
+            result = dict(page)
+        else:
+            for key, value in page.items():
+                if key != "messages" and value is not None:
+                    result[key] = value
+        messages.extend(page_messages)
+
+        if len(page_messages) < limit:
+            break
+        offset += len(page_messages)
+
+    assert result is not None
+    result["messages"] = messages
+    return result
 
 
 def list_chats(client: CodeerClient) -> list[dict]:
+    """List chats through the legacy v1 endpoint; Chat V2 has no list route."""
     return client.get("/chats")

codeer_cli/client.py

@@ -12,11 +12,12 @@ from __future__ import annotations
 import json as json_lib
 import os
 from dataclasses import dataclass
-from typing import Any, Iterable, Iterator, Mapping, Optional
+from typing import Any, Iterable, Iterator, Literal, Mapping, Optional
 
 import httpx
 
 DEFAULT_CODEER_API_BASE = "https://api.codeer.ai"
+ApiVersion = Literal["v1", "v2"]
 
 
 class CodeerError(RuntimeError):
@@ -154,13 +155,14 @@ class CodeerClient:
         method: str,
         path: str,
         *,
+        api_version: ApiVersion = "v1",
         params: Optional[Mapping[str, Any]] = None,
         json: Any = None,
         files: Any = None,
         data: Any = None,
         timeout: Optional[float] = None,
     ) -> Any:
-        url = path if path.startswith("http") else f"/api/v1{path if path.startswith('/') else '/' + path}"
+        url = _api_url(path, api_version=api_version)
         request_kwargs: dict[str, Any] = {}
         if timeout is not None:
             request_kwargs["timeout"] = timeout
@@ -206,17 +208,28 @@ class CodeerClient:
         method: str,
         path: str,
         *,
+        api_version: ApiVersion = "v1",
         params: Optional[Mapping[str, Any]] = None,
         json: Any = None,
+        timeout: Optional[float] = None,
     ) -> Iterator[dict]:
         """Yield parsed SSE events from a streaming endpoint (e.g. POST /chats/{id}/messages).
 
         Each event is a dict like ``{"event": "message", "data": <parsed-json-or-str>}``.
         """
-        url = path if path.startswith("http") else f"/api/v1{path if path.startswith('/') else '/' + path}"
+        url = _api_url(path, api_version=api_version)
         method_upper = method.upper()
+        request_kwargs: dict[str, Any] = {}
+        if timeout is not None:
+            request_kwargs["timeout"] = timeout
         try:
-            with self._client.stream(method_upper, url, params=params, json=json) as r:
+            with self._client.stream(
+                method_upper,
+                url,
+                params=params,
+                json=json,
+                **request_kwargs,
+            ) as r:
                 if r.status_code >= 400:
                     body = r.read().decode("utf-8", "replace")
                     self._raise_for_error(r.status_code, body)
@@ -244,7 +257,7 @@ class CodeerClient:
                 method_upper,
                 path,
                 exc,
-                timeout_seconds=self.timeout,
+                timeout_seconds=timeout if timeout is not None else self.timeout,
             ) from exc
         except httpx.RequestError as exc:
             raise self._transport_error(method_upper, path, exc) from exc
@@ -314,6 +327,18 @@ def _maybe_json(raw: str) -> Any:
         return raw
 
 
+def _api_url(path: str, *, api_version: ApiVersion = "v1") -> str:
+    """Resolve a relative domain path without forcing every API onto one version."""
+    if path.startswith("http"):
+        return path
+    normalized = path if path.startswith("/") else f"/{path}"
+    if normalized.startswith("/api/"):
+        return normalized
+    if api_version not in ("v1", "v2"):
+        raise ValueError(f"Unsupported API version: {api_version}")
+    return f"/api/{api_version}{normalized}"
+
+
 def _workspace_names(profile: Mapping[str, Any]) -> dict[str, str]:
     names: dict[str, str] = {}
     for ws in profile.get("workspaces") or []:

codeer_cli/commands/history.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import math
 import os
 
@@ -47,13 +48,13 @@ def register(subparsers):
     # codeer history conversations <id>
     p = sub.add_parser(
         "conversations",
-        help="Summarize all turns in a history. Complete turns/tool payloads require --out.",
+        help="Summarize all Chat V2 parts in a history. Complete parts/tool payloads require --out.",
     )
     p.add_argument("history_id", type=int)
     p.add_argument("--full", action="store_true",
-                   help="Require --out and write complete stripped turns there; stdout remains a summary.")
+                   help="Require --out and include longer stdout previews; the artifact is always complete.")
     p.add_argument("--out", default=None,
-                   help="Write complete stripped turns to this file. Use for debugging or eval-case extraction.")
+                   help="Write every unmodified client-visible Chat V2 part to this file.")
     p.set_defaults(func=run_conversations)
 
     # codeer history negative-feedback
@@ -76,8 +77,8 @@ def register(subparsers):
     p.add_argument("--user", default=None, help="external_user_id to associate with the history")
     p.add_argument("--message", action="append", required=True,
                    help="User message to send. Repeat for multi-turn histories.")
-    p.add_argument("--timeout", type=float, default=120.0,
-                   help="Per-message response timeout in seconds (default: 120).")
+    p.add_argument("--timeout", type=float, default=240.0,
+                   help="Per-message SSE read timeout in seconds (default: 240).")
     p.add_argument("--out", default=None,
                    help="Write complete create response/conversation artifact to this file; stdout stays compact.")
     p.set_defaults(func=run_create)
@@ -91,8 +92,8 @@ def register(subparsers):
                    help="external_user_id override (defaults to the history's user)")
     p.add_argument("--message", action="append", required=True,
                    help="User message to send. Repeat to append multiple turns.")
-    p.add_argument("--timeout", type=float, default=120.0,
-                   help="Per-message response timeout in seconds (default: 120).")
+    p.add_argument("--timeout", type=float, default=240.0,
+                   help="Per-message SSE read timeout in seconds (default: 240).")
     p.add_argument("--out", default=None,
                    help="Write complete send response/conversation artifact to this file; stdout stays compact.")
     p.set_defaults(func=run_send)
@@ -155,18 +156,33 @@ def _history_summary(row: dict, *, full: bool = False) -> dict:
     return out
 
 
-def _turn_summary(turn: dict, idx: int, *, full: bool = False) -> dict:
-    content = turn.get("content") or turn.get("message") or ""
-    tool_calls = turn.get("tool_calls") or turn.get("tools") or []
+def _part_summary(part: dict, idx: int, *, full: bool = False) -> dict:
+    raw_content = part.get("content")
+    if isinstance(raw_content, dict):
+        content_value = raw_content.get("content")
+        if content_value is None and part.get("part_kind") == "tool-call":
+            content_value = raw_content.get("args")
+    else:
+        content_value = raw_content
+    if isinstance(content_value, str):
+        content = content_value
+    elif content_value is None:
+        content = ""
+    else:
+        content = json.dumps(content_value, ensure_ascii=False, default=str)
     row = {
-        "turn_idx": idx,
-        "id": turn.get("id"),
-        "role": turn.get("role"),
-        "created_at": turn.get("created_at"),
+        "part_idx": idx,
+        "id": part.get("id"),
+        "conversation_id": part.get("conversation_id"),
+        "conversation_group_id": part.get("conversation_group_id"),
+        "sequence": part.get("sequence"),
+        "part_kind": part.get("part_kind"),
+        "source": part.get("source"),
+        "created_at": part.get("created_at"),
         "content_preview": truncate(content, 600 if full else 240),
         "content_chars": len(content),
-        "tool_call_count": len(tool_calls) if isinstance(tool_calls, list) else None,
-        "feedback_count": len(turn.get("feedbacks") or []),
+        "attachment_count": len(part.get("attached_files") or []),
+        "feedback_count": len(part.get("feedbacks") or []),
     }
     if full:
         row["feedbacks"] = [
@@ -175,7 +191,7 @@ def _turn_summary(turn: dict, idx: int, *, full: bool = False) -> dict:
                 "tag": fb.get("tag"),
                 "content_preview": truncate(fb.get("content") or "", 240),
             }
-            for fb in (turn.get("feedbacks") or [])
+            for fb in (part.get("feedbacks") or [])
         ]
     return row
 
@@ -231,16 +247,24 @@ def run_get(args, client) -> int:
 
 
 def run_conversations(args, client) -> int:
-    result = hist_mod.get_conversations(client, args.history_id)
+    result = chats_mod.list_messages(client, args.history_id)
+    parts = result.get("messages") or []
     if args.full and not args.out:
         log("error: full conversation payloads are unbounded; pass --out <path>")
         return 2
-    write_json(args.out, strip_noisy_fields(result))
+    write_json(args.out, result)
+    group_ids = {
+        p.get("conversation_group_id")
+        for p in parts
+        if p.get("conversation_group_id")
+    }
     print_json({
         "history_id": args.history_id,
-        "turn_count": len(result),
+        "turn_count": len(group_ids),
+        "part_count": len(parts),
         "wrote_full_detail": bool(args.out),
-        "turns": [_turn_summary(t, i, full=args.full) for i, t in enumerate(result)],
+        "stdout_is_summary": True,
+        "parts": [_part_summary(p, i, full=args.full) for i, p in enumerate(parts)],
     })
     return 0
 
@@ -285,15 +309,19 @@ def _send_messages(
     for idx, message in enumerate(messages, 1):
         log(f"sending turn {idx}/{len(messages)}")
         try:
-            result = chats_mod.send_published_agent_message(
+            stream = chats_mod.send_published_agent_message(
                 client,
                 chat_id=history_id,
                 message=message,
                 agent_id=agent_id,
                 external_user_id=external_user_id,
-                stream=False,
+                stream=True,
                 timeout=timeout,
             )
+            if isinstance(stream, dict):
+                result = stream
+            else:
+                result = chats_mod.collect_stream(stream)
         except TransportError as exc:
             body = dict(exc.body) if isinstance(exc.body, dict) else {}
             body.update({"history_id": history_id, "turn": idx, "turn_count": len(messages)})
@@ -337,23 +365,28 @@ def run_create(args, client) -> int:
         timeout=args.timeout,
     )
 
-    conversations = hist_mod.get_conversations(client, history_id)
+    chat_messages = chats_mod.list_messages(
+        client,
+        history_id,
+        external_user_id=args.user,
+    )
+    conversation_parts = chat_messages.get("messages") or []
     out = {
         "agent_id": agent_id,
         "history_id": history_id,
         "external_user_id": args.user,
         "url": _history_url(client, workspace_id, history_id),
         "messages": message_results,
-        "conversations": conversations,
+        "conversation_parts": conversation_parts,
     }
-    write_json(args.out, strip_noisy_fields(out))
+    write_json(args.out, out)
     print_json({
         "agent_id": agent_id,
         "history_id": history_id,
         "external_user_id": args.user,
         "url": out["url"],
         "message_count": len(message_results),
-        "turn_count": len(conversations),
+        "part_count": len(conversation_parts),
         "wrote_full_detail": bool(args.out),
     })
     return 0
@@ -395,23 +428,28 @@ def run_send(args, client) -> int:
         messages=args.message,
         timeout=args.timeout,
     )
-    conversations = hist_mod.get_conversations(client, args.history_id)
+    chat_messages = chats_mod.list_messages(
+        client,
+        args.history_id,
+        external_user_id=external_user_id,
+    )
+    conversation_parts = chat_messages.get("messages") or []
     out = {
         "agent_id": agent_id,
         "history_id": args.history_id,
         "external_user_id": external_user_id,
         "url": _history_url(client, workspace_id, args.history_id),
         "messages": message_results,
-        "conversations": conversations,
+        "conversation_parts": conversation_parts,
     }
-    write_json(args.out, strip_noisy_fields(out))
+    write_json(args.out, out)
     print_json({
         "agent_id": agent_id,
         "history_id": args.history_id,
         "external_user_id": external_user_id,
         "url": out["url"],
         "message_count": len(message_results),
-        "turn_count": len(conversations),
+        "part_count": len(conversation_parts),
         "wrote_full_detail": bool(args.out),
     })
     return 0

codeer_cli/histories.py

@@ -94,11 +94,10 @@ def list_negative_feedback_turns(
     the source channel — usually "system"). Pass the desired sentiment(s)
     in ``feedback_types``.
 
-    Cost: O(N histories) network calls — one ``/histories/{id}/conversations``
-    per history. Filter aggressively via ``exclude_users`` and ``limit``
-    before invoking on a busy agent.
+    Cost: O(N histories) paginated Chat V2 reads. Filter aggressively via
+    ``exclude_users`` and ``limit`` before invoking on a busy agent.
     """
-    from .parse import strip_tool_markers  # local import to avoid cycle
+    from . import chats
 
     type_set = {t.lower() for t in feedback_types}
     histories = list(
@@ -115,33 +114,42 @@ def list_negative_feedback_turns(
         if hid is None:
             continue
         try:
-            convs = get_conversations(client, hid)
+            parts = (chats.list_messages(client, hid).get("messages") or [])
         except Exception:
             continue
-        for i, c in enumerate(convs):
-            if (c.get("role") or "") != "assistant":
+
+        turn_indexes: dict[str, int] = {}
+        user_messages: dict[str, str] = {}
+        next_turn_idx = 0
+        for part_idx, part in enumerate(parts):
+            group_id = str(part.get("conversation_group_id") or "")
+            part_kind = part.get("part_kind") or ""
+            if group_id and group_id not in turn_indexes:
+                turn_indexes[group_id] = next_turn_idx
+                next_turn_idx += 1
+            if part_kind == "user-prompt":
+                user_messages[group_id] = _part_text(part)
+                continue
+            if part_kind != "text":
                 continue
-            fbs = c.get("feedbacks") or []
+            fbs = part.get("feedbacks") or []
             for fb in fbs:
                 ftype = (fb.get("type") or "").lower()
                 if ftype not in type_set:
                     continue
-                # Find the most recent user turn before this assistant turn.
-                prior_user = ""
-                for j in range(i - 1, -1, -1):
-                    if (convs[j].get("role") or "") == "user":
-                        prior_user = (convs[j].get("content") or "")[:user_excerpt_chars]
-                        break
                 out.append({
                     "history_id": hid,
                     "history_title": h.get("name") or h.get("title") or "",
                     "external_user_id": h.get("external_user_id") or "",
                     "created_at": h.get("created_at"),
-                    "turn_idx": i,
+                    "turn_idx": turn_indexes.get(group_id),
+                    "part_idx": part_idx,
+                    "conversation_group_id": group_id or None,
+                    "conversation_part_id": part.get("id"),
                     "feedback_type": ftype,
                     "feedback_text": fb.get("content") or "",
-                    "user_message": prior_user,
-                    "assistant_excerpt": strip_tool_markers(c.get("content") or "")[:assistant_excerpt_chars],
+                    "user_message": user_messages.get(group_id, "")[:user_excerpt_chars],
+                    "assistant_excerpt": _part_text(part)[:assistant_excerpt_chars],
                 })
     return out
 
@@ -151,6 +159,20 @@ def get(client: CodeerClient, history_id: int) -> dict:
 
 
 def get_conversations(client: CodeerClient, history_id: int) -> list[dict]:
-    """Return all conversation turns for a history — includes tool calls and reasoning."""
+    """Return legacy V1 conversation rows.
+
+    Prefer ``codeer_cli.chats.list_messages`` whenever exact Chat V2 parts,
+    tool inputs/results, or event order matter.
+    """
     return client.get(f"/external/histories/{history_id}/conversations")
 
+
+def _part_text(part: dict) -> str:
+    content = part.get("content")
+    if isinstance(content, dict):
+        value = content.get("content")
+    else:
+        value = content
+    if value is None:
+        return ""
+    return value if isinstance(value, str) else str(value)

codeer_cli/parse.py

@@ -9,21 +9,20 @@ Parsers are deliberately tolerant: missing/extra fields don't raise, casing
 mismatches (``FILE`` vs ``file``) are normalized to lowercase. They are NOT a
 schema validator.
 
-KEY GAP, called out here so you don't waste time:
+LEGACY V1 HISTORY GAP, called out here so you don't waste time:
 
-  Tool **arguments** (e.g. the regex passed to ``list_kb_files`` or the query
-  passed to ``retrieve_context_objs``) and **outputs** are not persisted on the
-  Conversation row. They flow over the WebSocket during execution and are
-  dropped after the assistant turn is saved. What you CAN recover from a
-  history is:
+  Tool **arguments** and **outputs** are not available on the legacy
+  ``Conversation`` row returned by ``/histories/{id}/conversations``. What you
+  CAN recover from that legacy history shape is:
 
     - tool name + call id     (regex over ``content``: ``<tool id=...>name</tool>``)
     - per-call token usage    (``meta.token_usage.tool_calls[]``)
     - retrieved primary sources (``primary_sources[]`` — the end-to-end trace)
     - assistant's final text   (``content`` with tool markers stripped)
 
-  If you need the raw tool args, you must capture them at execution time via
-  the chat SSE stream, not from history reads.
+  Chat V2 structured SSE and ``GET /api/v2/chats/{id}/messages`` expose
+  persisted tool-call and tool-return parts. Use those surfaces when raw tool
+  I/O or exact event order matters.
 """
 
 from __future__ import annotations

{codeer_cli-0.1.10.dist-info → codeer_cli-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeer-cli
-Version: 0.1.10
+Version: 0.1.12
 Summary: Command line tools for managing Codeer agents over the Codeer API.
 Project-URL: Homepage, https://www.codeer.ai
 Author: Codeer.AI
@@ -172,15 +172,18 @@ Use this pattern during agent lifecycle work:
 ```bash
 codeer agent list
 codeer history list --agent <agent-id> --limit 50
-codeer history create --agent <agent-id> --message "Review this plan" --timeout 120
-codeer history send <history-id> --message "Use the recommended options" --timeout 120
+codeer history conversations <history-id> --out .codeer/current/history-<history-id>.json
+codeer history create --agent <agent-id> --message "Review this plan" --timeout 240
+codeer history send <history-id> --message "Use the recommended options" --timeout 240
 codeer eval run --agent <agent-id> --cases <case-ids> --evaluator <evaluator-id> --out .codeer/eval_run.json
 ```
 
 `history create` and `history send` use the agent's current published version.
-Their per-message timeout defaults to 120 seconds. If a write request times
-out, inspect the history before retrying: the server may have completed the
-turn after the client stopped waiting.
+They use Chat V2 structured SSE with `stream: true`; their per-message read
+timeout defaults to 240 seconds. Success requires a `response.completed`
+event. If the stream times out, reports `response.failed`, or disconnects
+early, inspect the history before retrying: the server may already have
+persisted the turn.
 
 Eval case label commands always operate on the active API-key workspace. They
 do not accept a workspace override; switch CLI profiles to target another
@@ -194,6 +197,11 @@ Flags:
   for raw eval results, full conversation turns, full rubric matrices, and
   other data that can grow with cases, versions, or turns.
 
+`history conversations` reads Chat V2 parts and follows all pages
+automatically. Its stdout is still a bounded summary; the `--out` artifact is
+the complete client-visible history, including tool calls/results,
+attachments, interactions, feedback, and passthrough metadata.
+
 Avoid piping large raw JSON directly into agent chat. Prefer `--out`, then ask
 the coding agent to inspect targeted summaries, IDs, failing cases, or selected
 snippets from the saved file.

{codeer_cli-0.1.10.dist-info → codeer_cli-0.1.12.dist-info}/RECORD

@@ -1,25 +1,25 @@
 codeer_cli/__init__.py,sha256=z3rkUdVCt11c8QE3-YFkG5cFObM6QhPe2yKugA8k3aA,1915
 codeer_cli/_validate.py,sha256=lqMwkhsBy1g0o5CINBp1HdBCjMawgUaEsZygjJaAPL0,6943
 codeer_cli/agents.py,sha256=HWfz6QgU4wn07df5s3twxVJfAhb0vLJHIfxTjvDMUzU,6045
-codeer_cli/chats.py,sha256=pww_AVByTh_AT2Td0gj2OomJrcw7D-cjDIpQ0ZQOlrM,2728
+codeer_cli/chats.py,sha256=Vg1DIu8fT6mPyPpfqLpExKvXhdZEWCyJGPvalQy3BXg,7989
 codeer_cli/cli.py,sha256=ghZMn7LUxDDvb3f82mDYW5hIFLk7dtlrCrGGP40Gygw,4637
-codeer_cli/client.py,sha256=x-5sx06dgS6P8siKOTCVNM8JlBST5e6PsOD83KKkpN8,12361
+codeer_cli/client.py,sha256=apUycjK-OvHEquAj58FqOy8FHmHjA6K9dScaYQ4M-VU,13175
 codeer_cli/constants.py,sha256=D1pV3wCoqYybrKGKeoupYjjFWLfaFviKp1yL7oh6Qso,2323
 codeer_cli/eval_.py,sha256=2Tz4qokctocZ0fqLYL8Sk9UV8yJ7p-9zYiUFljsRRCs,17478
-codeer_cli/histories.py,sha256=tk28git_peX4x703CIDU8u72JtlGaytyrtlHfxlK-7A,5979
+codeer_cli/histories.py,sha256=WvpqvuprPc1nJJCTElyM_eoUabyooACfmRCwYlcvPnI,6637
 codeer_cli/kb.py,sha256=Ad4h65NByq5Rq5BTeMghLTKlWRhmOC2jxL0BaTGX3EM,10631
 codeer_cli/models.py,sha256=Ama9fx8hyRMdysiUNA3Ty0sYIYwzFDkOcAZg-id3-vQ,362
-codeer_cli/parse.py,sha256=qrjZn0MUTjGfucp4cwxy8Pt7WS-0x15kK5F7kWTY8Ps,21818
+codeer_cli/parse.py,sha256=-txMtIxPfeg_i4McEskVKxo8p4438gKS-sFTI38RoBs,21772
 codeer_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeer_cli/commands/_util.py,sha256=X9-9cYgnBYz94hVG4Pe9SsI97DHNv3HE5_7GlPMn93I,1708
 codeer_cli/commands/agent.py,sha256=6qtYcQYgdJE26V6Nw6parB_3RYAYXcOpPE9iJLuLGHo,15888
 codeer_cli/commands/check.py,sha256=lTxolx1mIJ8jldPhJ5FXqie9nbCLVOO-sDPOHTSy1-w,3817
 codeer_cli/commands/eval_cmd.py,sha256=Zlt_YIA3D5-Y8WL1HZ6PxZgL-TcwFTDoXvO2gv7yfOM,71989
-codeer_cli/commands/history.py,sha256=bVBlCMStTvTxG23bggASHkHKuI0RMPdiXjcrs3U04yw,16081
+codeer_cli/commands/history.py,sha256=2p9VuPwyexr7Q2FFIBSuv9hNzn7VdIMa-AtvtP-8LvI,17253
 codeer_cli/commands/kb.py,sha256=kVEinBVM6NN8_0djOqIQErh46dLmArwFngXMNzvGeAI,28345
 codeer_cli/commands/model.py,sha256=91LDo_YeHi3POZV7KTCkoCcgtK5p87LwrHX1lZgfCps,1698
 codeer_cli/commands/profile.py,sha256=IdlXC_6cqobsfN3JRrAnt-1OgBUsIFneS9QtR4Un6Kc,6521
-codeer_cli-0.1.10.dist-info/METADATA,sha256=OFyEgLMBpMJ2cUkG58dei40u1BBtmSEF8HdPeyGbCek,7396
-codeer_cli-0.1.10.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-codeer_cli-0.1.10.dist-info/entry_points.txt,sha256=-nXIrlm5SR5r7gg3y8AS0tN66MwmvNHsrlwLNQNGD50,47
-codeer_cli-0.1.10.dist-info/RECORD,,
+codeer_cli-0.1.12.dist-info/METADATA,sha256=CFrY9ndSNGm4K5UC0A9tZyCXAQPOgWMO5CcGMMNRda0,7885
+codeer_cli-0.1.12.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+codeer_cli-0.1.12.dist-info/entry_points.txt,sha256=-nXIrlm5SR5r7gg3y8AS0tN66MwmvNHsrlwLNQNGD50,47
+codeer_cli-0.1.12.dist-info/RECORD,,