codeer-cli 0.1.10__tar.gz → 0.1.11__tar.gz

{codeer_cli-0.1.10 → codeer_cli-0.1.11}/API_REFERENCE.md

@@ -3,8 +3,9 @@
 > This file is the request-shape reference for maintaining `codeer-cli`.
 
 The 9 stages below mirror the user-docs lifecycle (`agent-creation` →
-`optimization-loop` → `publish`). Every path is under `/api/v1/`. All endpoints
-authenticate via `x-api-key` from `CODEER_API_KEY`.
+`optimization-loop` → `publish`). Agent, KB, eval, history, and model paths are
+under `/api/v1/`; Chat create/message/read paths use `/api/v2/chats`. All
+endpoints authenticate via `x-api-key` from `CODEER_API_KEY`.
 
 Envelope: successful responses look like
 `{"error_code": 0, "message": "", "pagination": null, "data": <payload>}`.
@@ -140,19 +141,21 @@ codeer kb files --kb-id <kb-id>
 codeer kb faq-create --context-object-id <snapshot-object-id> --question "..." --range 12:0-12:42 --dry-run
 ```
 
-## Stage 3 — Live Test on a specific version
+## Stage 3 — Live Test on a specific version (legacy V1 compatibility)
 
 | Method & path | Purpose |
 | --- | --- |
-| `POST /chats` | Create a new chat session bound to an agent |
-| `POST /chats/{chat_id}/messages` | Send a message; **SSE stream** of tool calls + reasoning + final text |
-| `GET /chats/{chat_id}/messages` | Read historical messages for a chat |
-| `POST /chats/{chat_id}/regenerate` | Re-run the last turn |
-| `POST /chats/{chat_id}/messages/{msg_id}/feedbacks` | Thumbs up/down on a reply |
-
-`POST /chats/.../messages` requires `agent_history_id` — this is the key hook
-for the apply → test → publish workflow. Pass the draft `AgentHistory.id` from
-`PUT /agents/{id}` to test an unpublished version.
+| `POST /api/v1/chats` | Create a legacy chat session bound to an agent |
+| `POST /api/v1/chats/{chat_id}/messages` | Send a version-pinned message through legacy SSE |
+| `GET /api/v1/chats/{chat_id}/messages` | Read legacy messages for a chat |
+| `POST /api/v1/chats/{chat_id}/regenerate` | Re-run the last turn |
+| `POST /api/v1/chats/{chat_id}/messages/{msg_id}/feedbacks` | Thumbs up/down on a reply |
+
+Legacy V1 `POST /chats/.../messages` accepts `agent_history_id` — this is the
+compatibility hook for the apply → test → publish workflow. Pass the draft
+`AgentHistory.id` from `PUT /agents/{id}` to test an unpublished version.
+The API-key external flow in Chat V2 accepts `agent_id` and runs its published
+version; it does not currently replace this draft-pinning path.
 
 ## Stage 4 — Version management
 
@@ -267,8 +270,9 @@ the public CLI.
 
 | Method & path | Purpose |
 | --- | --- |
-| `POST /chats` | Create a persisted history using an agent's current published version |
-| `POST /chats/{id}/messages` | Append a turn to an existing persisted history using the current published version |
+| `POST /api/v2/chats` | Create a persisted history using an agent's current published version |
+| `POST /api/v2/chats/{id}/messages` | Append a turn through structured SSE using the current published version |
+| `GET /api/v2/chats/{id}/messages` | Read persisted Chat V2 conversation parts |
 | `GET /histories?agent_id=X&feedback_filter=improve_feedback&external_user_id=…` | List conversations with filters |
 | `GET /histories/{id}` | Read one history's metadata |
 | `GET /histories/{id}/conversations` | Full conversation turns incl. tool calls |
@@ -276,9 +280,11 @@ the public CLI.
 | `POST /histories/{hid}/conversations/{cid}/score` | Numeric score |
 
 The CLI exposes the first two operations as `codeer history create` and
-`codeer history send`. Non-streaming message requests default to a 120-second
-per-message timeout. A timeout has an uncertain write outcome, so read the
-history before retrying to avoid duplicate turns.
+`codeer history send`. Messages explicitly set `stream: true`, consume Chat V2
+SSE, and require `response.completed` before reporting success. Their
+per-message SSE read timeout defaults to 240 seconds. A timeout,
+`response.failed`, or disconnect before completion has an uncertain write
+outcome, so read the history before retrying to avoid duplicate turns.
 
 `feedback_filter` accepts the `FeedbackFilterType` enum values:
 `no_feedback`, `with_feedback`, `helpful_feedback`, `improve_feedback`.
@@ -357,7 +363,7 @@ said (scope, factuality, tool-use rules).
 
 ### 4. Agent version pinning works everywhere — use it
 
-Both `POST /chats/{id}/messages` (`agent_history_id` required) and
+Legacy V1 `POST /chats/{id}/messages` (`agent_history_id` required) and
 `POST /eval/trigger` (`agent_history_id` optional, null = live state) accept
 the draft history id. The apply-→-test-→-publish loop:
 
@@ -463,9 +469,10 @@ pass. Workspace scope is inferred from the API-key virtual user profile.
 
 ### 11. Tool args + outputs are NOT persisted in history reads
 
-Conversations have only three roles (`OpenAIChatRole = system | user | assistant`)
-— there is no `tool` role row. When you read a history, here's what you can
-and can't recover from each assistant turn:
+Legacy V1 `History` conversation rows have only three roles
+(`OpenAIChatRole = system | user | assistant`) — there is no `tool` role row.
+When you read those rows through `/histories/{id}/conversations`, here's what
+you can and can't recover from each assistant turn:
 
 | Recoverable | Where |
 | --- | --- |
@@ -481,10 +488,12 @@ and can't recover from each assistant turn:
 | Tool **outputs** (raw JSON returned by the tool) | same — stored only as derived `primary_sources` for retrieval tools |
 | Reasoning steps mid-turn | `meta.reasoning_steps` is currently always `null` |
 
-If you need full tool I/O, capture it at execution time via the chat SSE
-stream (`POST /chats/{id}/messages`), not from history reads. For after-the-
-fact analysis, the persisted shape is sufficient to surface tool-selection
-patterns, token costs, and which sources the agent ended up citing.
+Chat V2 improves this contract: structured SSE emits tool calls and returns as
+`response.part.created` / `response.part.completed`, and
+`GET /api/v2/chats/{id}/messages` reads the persisted conversation parts.
+Capture the SSE artifact with `--out` when exact event order matters; use the
+V2 message read for persisted after-the-fact tool I/O. The legacy v1 history
+read remains useful for compact turn-level analysis.
 
 ### 10. A KB has exactly ONE level of folders — no nesting
 

{codeer_cli-0.1.10 → codeer_cli-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeer-cli
-Version: 0.1.10
+Version: 0.1.11
 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,17 @@ 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 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

{codeer_cli-0.1.10 → codeer_cli-0.1.11}/README.md

@@ -154,15 +154,17 @@ 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 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

{codeer_cli-0.1.10 → codeer_cli-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codeer-cli"
-version = "0.1.10"
+version = "0.1.11"
 description = "Command line tools for managing Codeer agents over the Codeer API."
 readme = "README.md"
 requires-python = ">=3.11"

codeer_cli-0.1.11/src/codeer_cli/chats.py

@@ -0,0 +1,201 @@
+"""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, TransportError
+
+
+def create(
+    client: CodeerClient,
+    *,
+    agent_id: str,
+    title: Optional[str] = None,
+    external_user_id: Optional[str] = None,
+) -> dict:
+    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", api_version="v2", json=body)
+
+
+def send_published_agent_message(
+    client: CodeerClient,
+    *,
+    chat_id: int,
+    message: str,
+    agent_id: str,
+    external_user_id: Optional[str] = None,
+    attachment_ids: Optional[List[str]] = None,
+    stream: bool = True,
+    timeout: Optional[float] = None,
+) -> Iterator[dict] | dict:
+    """Send a user message through the API-key external chat flow.
+
+    API-key chat endpoints use the agent's published version. They accept
+    ``agent_id`` rather than ``agent_history_id``.
+    """
+    body: dict[str, Any] = {"message": message, "agent_id": agent_id, "stream": stream}
+    if external_user_id is not None:
+        body["external_user_id"] = external_user_id
+    if attachment_ids:
+        body["attached_file_uuids"] = attachment_ids
+
+    path = f"/chats/{chat_id}/messages"
+    if stream:
+        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(
+    client: CodeerClient,
+    *,
+    chat_id: int,
+    message: str,
+    agent_history_id: str,
+    attachment_ids: Optional[List[str]] = None,
+    stream: bool = True,
+    timeout: Optional[float] = None,
+) -> Iterator[dict] | dict:
+    """Use legacy Chat V1 to pin an unpublished agent version.
+
+    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,
+        "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,
+            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:
+    params: dict[str, Any] = {"limit": limit, "offset": 0}
+    if external_user_id is not None:
+        params["external_user_id"] = external_user_id
+    return client.get(
+        f"/chats/{chat_id}/messages",
+        api_version="v2",
+        params=params,
+    )
+
+
+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-0.1.10 → codeer_cli-0.1.11}/src/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-0.1.10 → codeer_cli-0.1.11}/src/codeer_cli/commands/history.py

@@ -76,8 +76,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 +91,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)
@@ -285,15 +285,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,14 +341,19 @@ 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))
     print_json({
@@ -353,7 +362,7 @@ def run_create(args, client) -> int:
         "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,14 +404,19 @@ 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))
     print_json({
@@ -411,7 +425,7 @@ def run_send(args, client) -> int:
         "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-0.1.10 → codeer_cli-0.1.11}/src/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.11/tests/test_chats_v2.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import unittest
+
+from codeer_cli import chats
+from codeer_cli.client import TransportError
+
+
+class RecordingClient:
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, str, dict]] = []
+
+    def post(self, path: str, **kwargs):
+        self.calls.append(("POST", path, kwargs))
+        return {"id": 123, "name": kwargs["json"]["name"]}
+
+    def get(self, path: str, **kwargs):
+        self.calls.append(("GET", path, kwargs))
+        return {"chat_id": 123, "messages": []}
+
+
+class ChatV2RequestTests(unittest.TestCase):
+    def test_create_uses_v2_and_always_sends_name(self) -> None:
+        client = RecordingClient()
+
+        result = chats.create(client, agent_id="agent-1")  # type: ignore[arg-type]
+
+        self.assertEqual(result["id"], 123)
+        self.assertEqual(client.calls, [(
+            "POST",
+            "/chats",
+            {
+                "api_version": "v2",
+                "json": {"agent_id": "agent-1", "name": "CLI conversation"},
+            },
+        )])
+
+    def test_list_messages_uses_v2_pagination(self) -> None:
+        client = RecordingClient()
+
+        result = chats.list_messages(  # type: ignore[arg-type]
+            client,
+            123,
+            external_user_id="user-1",
+            limit=200,
+        )
+
+        self.assertEqual(result, {"chat_id": 123, "messages": []})
+        self.assertEqual(client.calls[0], (
+            "GET",
+            "/chats/123/messages",
+            {
+                "api_version": "v2",
+                "params": {
+                    "limit": 200,
+                    "offset": 0,
+                    "external_user_id": "user-1",
+                },
+            },
+        ))
+
+
+class ChatV2StreamTests(unittest.TestCase):
+    def test_collects_structured_events_and_final_text(self) -> None:
+        result = chats.collect_stream(iter([
+            {
+                "event": "response.part.delta",
+                "data": {
+                    "type": "response.part.delta",
+                    "response_id": "response-1",
+                    "conversation_group_id": "group-1",
+                    "part_kind": "text",
+                    "delta": "Hel",
+                },
+            },
+            {
+                "event": "response.part.completed",
+                "data": {
+                    "type": "response.part.completed",
+                    "response_id": "response-1",
+                    "part": {
+                        "part_kind": "text",
+                        "content": {"content": "Hello"},
+                    },
+                },
+            },
+            {
+                "event": "response.completed",
+                "data": {
+                    "type": "response.completed",
+                    "response_id": "response-1",
+                    "conversation_group_id": "group-1",
+                },
+            },
+            {"event": "message", "data": "[DONE]"},
+        ]))
+
+        self.assertTrue(result["completed"])
+        self.assertEqual(result["response_id"], "response-1")
+        self.assertEqual(result["conversation_group_id"], "group-1")
+        self.assertEqual(result["final_text"], "Hello")
+
+    def test_response_failed_is_not_retried_as_non_streaming(self) -> None:
+        with self.assertRaises(TransportError) as raised:
+            chats.collect_stream(iter([{
+                "event": "response.failed",
+                "data": {
+                    "type": "response.failed",
+                    "response_id": "response-1",
+                    "message": "Model unavailable",
+                    "code": 503,
+                },
+            }]))
+
+        self.assertIn("Model unavailable", raised.exception.message)
+        self.assertTrue(raised.exception.body["outcome_uncertain"])
+
+    def test_disconnect_before_completed_has_uncertain_outcome(self) -> None:
+        with self.assertRaises(TransportError) as raised:
+            chats.collect_stream(iter([{
+                "event": "response.part.delta",
+                "data": {
+                    "type": "response.part.delta",
+                    "response_id": "response-1",
+                    "part_kind": "text",
+                    "delta": "Partial",
+                },
+            }]))
+
+        self.assertIn("before response.completed", raised.exception.message)
+        self.assertTrue(raised.exception.body["outcome_uncertain"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{codeer_cli-0.1.10 → codeer_cli-0.1.11}/tests/test_client_transport.py

@@ -22,8 +22,56 @@ class ClientTransportTests(unittest.TestCase):
             client.close()
 
         self.assertEqual(result, {"ok": True})
+        self.assertEqual(requests[0].url.path, "/api/v1/chats/1/messages")
         self.assertEqual(requests[0].extensions["timeout"]["read"], 120.0)
 
+    def test_request_can_target_v2_without_changing_v1_default(self) -> None:
+        requests: list[httpx.Request] = []
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            requests.append(request)
+            return httpx.Response(200, json={"data": {"id": 1}, "error_code": 0})
+
+        client = self._client(handler)
+        try:
+            result = client.post("/chats", api_version="v2", json={"name": "Test"})
+        finally:
+            client.close()
+
+        self.assertEqual(result, {"id": 1})
+        self.assertEqual(requests[0].url.path, "/api/v2/chats")
+
+    def test_stream_can_target_v2_and_forward_read_timeout(self) -> None:
+        requests: list[httpx.Request] = []
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            requests.append(request)
+            return httpx.Response(
+                200,
+                text=(
+                    "event: response.completed\n"
+                    'data: {"type":"response.completed","response_id":"r1"}\n\n'
+                    "data: [DONE]\n\n"
+                ),
+            )
+
+        client = self._client(handler)
+        try:
+            events = list(client.stream_sse(
+                "POST",
+                "/chats/1/messages",
+                api_version="v2",
+                json={"message": "Hi", "stream": True},
+                timeout=240.0,
+            ))
+        finally:
+            client.close()
+
+        self.assertEqual(requests[0].url.path, "/api/v2/chats/1/messages")
+        self.assertEqual(requests[0].extensions["timeout"]["read"], 240.0)
+        self.assertEqual(events[0]["event"], "response.completed")
+        self.assertEqual(events[0]["data"]["response_id"], "r1")
+
     def test_timeout_becomes_transport_error_with_uncertain_write_outcome(self) -> None:
         def handler(request: httpx.Request) -> httpx.Response:
             raise httpx.ReadTimeout("response took too long", request=request)

{codeer_cli-0.1.10 → codeer_cli-0.1.11}/tests/test_history_send.py

@@ -24,9 +24,23 @@ class FakeClient:
         self.calls.append((path, kwargs))
         return {"ok": True}
 
+    def stream_sse(self, method: str, path: str, **kwargs):
+        self.calls.append((path, {"method": method, **kwargs}))
+        return iter([
+            {
+                "event": "response.completed",
+                "data": {
+                    "type": "response.completed",
+                    "response_id": "response-1",
+                    "conversation_group_id": "group-1",
+                },
+            },
+            {"event": "message", "data": "[DONE]"},
+        ])
+
 
 class HistorySendTests(unittest.TestCase):
-    def test_chat_send_forwards_response_timeout(self) -> None:
+    def test_chat_send_uses_v2_stream_and_forwards_timeout(self) -> None:
         client = FakeClient()
 
         chats_mod.send_published_agent_message(
@@ -38,6 +52,9 @@ class HistorySendTests(unittest.TestCase):
         )
 
         self.assertEqual(client.calls[0][0], "/chats/18649/messages")
+        self.assertEqual(client.calls[0][1]["method"], "POST")
+        self.assertEqual(client.calls[0][1]["api_version"], "v2")
+        self.assertEqual(client.calls[0][1]["json"]["stream"], True)
         self.assertEqual(client.calls[0][1]["timeout"], 120.0)
 
     def test_run_send_resolves_agent_and_appends_to_existing_history(self) -> None:
@@ -66,32 +83,55 @@ class HistorySendTests(unittest.TestCase):
                 },
             ),
             patch.object(
-                history_cmd.hist_mod,
-                "get_conversations",
-                return_value=[
-                    {"role": "user", "content": "Initial"},
-                    {"role": "assistant", "content": "Reply"},
-                    {"role": "user", "content": "Use the recommended options"},
-                    {"role": "assistant", "content": "Final"},
-                ],
-            ),
+                history_cmd.chats_mod,
+                "list_messages",
+                return_value={"chat_id": 18649, "messages": [
+                    {"part_kind": "user-prompt"},
+                    {"part_kind": "text"},
+                ]},
+            ) as list_messages,
             patch.object(
                 history_cmd.chats_mod,
                 "send_published_agent_message",
-                return_value={"conversation_id": 4},
+                return_value=iter([
+                    {
+                        "event": "response.part.delta",
+                        "data": {
+                            "type": "response.part.delta",
+                            "response_id": "response-1",
+                            "conversation_group_id": "group-1",
+                            "part_kind": "text",
+                            "delta": "Final",
+                        },
+                    },
+                    {
+                        "event": "response.completed",
+                        "data": {
+                            "type": "response.completed",
+                            "response_id": "response-1",
+                            "conversation_group_id": "group-1",
+                        },
+                    },
+                    {"event": "message", "data": "[DONE]"},
+                ]),
             ) as send,
             redirect_stdout(StringIO()),
         ):
             result = history_cmd.run_send(args, client)
 
         self.assertEqual(result, 0)
+        list_messages.assert_called_once_with(
+            client,
+            18649,
+            external_user_id="user-1",
+        )
         send.assert_called_once_with(
             client,
             chat_id=18649,
             message="Use the recommended options",
             agent_id="agent-1",
             external_user_id="user-1",
-            stream=False,
+            stream=True,
             timeout=120.0,
         )
 

{codeer_cli-0.1.10 → codeer_cli-0.1.11}/uv.lock

@@ -26,7 +26,7 @@ wheels = [
 
 [[package]]
 name = "codeer-cli"
-version = "0.1.10"
+version = "0.1.11"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

codeer_cli-0.1.10/src/codeer_cli/chats.py

@@ -1,87 +0,0 @@
-"""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.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Iterator, List, Optional
-
-from .client import CodeerClient
-
-
-def create(
-    client: CodeerClient,
-    *,
-    agent_id: str,
-    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
-    if external_user_id is not None:
-        body["external_user_id"] = external_user_id
-    return client.post("/chats", json=body)
-
-
-def send_published_agent_message(
-    client: CodeerClient,
-    *,
-    chat_id: int,
-    message: str,
-    agent_id: str,
-    external_user_id: Optional[str] = None,
-    attachment_ids: Optional[List[str]] = None,
-    stream: bool = False,
-    timeout: Optional[float] = None,
-) -> Iterator[dict] | dict:
-    """Send a user message through the API-key external chat flow.
-
-    API-key chat endpoints use the agent's published version. They accept
-    ``agent_id`` rather than ``agent_history_id``.
-    """
-    body: dict[str, Any] = {"message": message, "agent_id": agent_id, "stream": stream}
-    if external_user_id is not None:
-        body["external_user_id"] = external_user_id
-    if attachment_ids:
-        body["attached_file_uuids"] = attachment_ids
-
-    path = f"/chats/{chat_id}/messages"
-    if stream:
-        return client.stream_sse("POST", path, json=body)
-    return client.post(path, json=body, timeout=timeout)
-
-
-def send_message(
-    client: CodeerClient,
-    *,
-    chat_id: int,
-    message: str,
-    agent_history_id: str,
-    attachment_ids: Optional[List[str]] = None,
-    stream: bool = True,
-) -> Iterator[dict] | dict:
-    """Send a user message; yield SSE events (if stream=True) or return the final payload.
-
-    ``agent_history_id`` is required — this is how you pin Live Test to a specific
-    (possibly unpublished) agent version without affecting production users.
-    """
-    body: dict[str, Any] = {"message": message, "agent_history_id": agent_history_id}
-    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)
-
-
-def list_messages(client: CodeerClient, chat_id: int) -> list[dict]:
-    return client.get(f"/chats/{chat_id}/messages")
-
-
-def list_chats(client: CodeerClient) -> list[dict]:
-    return client.get("/chats")