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

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

@@ -27,6 +27,9 @@ need a default agent.
 - `/histories` uses **`limit` + `offset`** (NOT `page` / `page_size`).
   Default in `histories.list()` is `limit=500`. Backend hard-cap may be
   lower — check the response length.
+- `/api/v2/chats/{id}/messages` also uses `limit` + `offset`.
+  `chats.list_messages()` follows pages until exhaustion; its `limit` argument
+  is a page size, not a total-result cap.
 - `/agents/{id}/histories`, `/eval/agents/{id}/cases`, `/eval/evaluators` all
   return everything in one shot today (no pagination).
 - `order_by` defaults to `"desc"` (most recent first) on endpoints that
@@ -275,7 +278,7 @@ the public CLI.
 | `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 |
+| `GET /histories/{id}/conversations` | Legacy compact conversation rows; not complete tool I/O |
 | `POST /histories/{hid}/conversations/{cid}/feedbacks` | Leave freeform improvement feedback |
 | `POST /histories/{hid}/conversations/{cid}/score` | Numeric score |
 
@@ -467,7 +470,7 @@ For bulk creation, `codeer eval cases-apply --attachments-dir <dir>` reads
 each case's `attachment_files: ["x.jpg"]` array, uploads, and attaches in one
 pass. Workspace scope is inferred from the API-key virtual user profile.
 
-### 11. Tool args + outputs are NOT persisted in history reads
+### 11. Tool args + outputs are not available in legacy V1 history reads
 
 Legacy V1 `History` conversation rows have only three roles
 (`OpenAIChatRole = system | user | assistant`) — there is no `tool` role row.
@@ -492,8 +495,8 @@ 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.
+paginated V2 message read for persisted after-the-fact tool I/O. The legacy V1
+history read remains useful for compact turn-level compatibility only.
 
 ### 10. A KB has exactly ONE level of folders — no nesting
 

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: codeer-cli
-Version: 0.1.11
+Version: 0.1.13
 Summary: Command line tools for managing Codeer agents over the Codeer API.
 Project-URL: Homepage, https://www.codeer.ai
 Author: Codeer.AI
@@ -172,6 +172,7 @@ Use this pattern during agent lifecycle work:
 ```bash
 codeer agent list
 codeer history list --agent <agent-id> --limit 50
+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
@@ -196,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.11 → codeer_cli-0.1.13}/README.md

@@ -154,6 +154,7 @@ Use this pattern during agent lifecycle work:
 ```bash
 codeer agent list
 codeer history list --agent <agent-id> --limit 50
+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
@@ -178,6 +179,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.11 → codeer_cli-0.1.13}/pyproject.toml

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

{codeer_cli-0.1.11 → codeer_cli-0.1.13}/src/codeer_cli/agents.py

@@ -20,6 +20,7 @@ def create(
     unified_tools: Optional[List[dict]] = None,
     use_search: bool = False,
     llm_model: Optional[str] = None,
+    llm_model_settings: Optional[dict[str, dict[str, Any]]] = None,
     description: Optional[str] = None,
     suggested_questions: Optional[List[str]] = None,
     primary_object_ids: Optional[List[int]] = None,
@@ -41,6 +42,8 @@ def create(
         body["description"] = description
     if llm_model is not None:
         body["llm_model"] = llm_model
+    if llm_model_settings is not None:
+        body["llm_model_settings"] = llm_model_settings
     if validated_handoff is not None:
         body["human_handoff"] = validated_handoff
     return client.post("/external/agents", json=body)
@@ -57,6 +60,7 @@ def update(
     version_note: str = "",
     description: Optional[str] = None,
     llm_model: Optional[str] = None,
+    llm_model_settings: Optional[dict[str, dict[str, Any]]] = None,
     suggested_questions: Optional[List[str]] = None,
     primary_object_ids: Optional[List[int]] = None,
     attachment_ids: Optional[List[str]] = None,
@@ -79,6 +83,8 @@ def update(
         body["description"] = description
     if llm_model is not None:
         body["llm_model"] = llm_model
+    if llm_model_settings is not None:
+        body["llm_model_settings"] = llm_model_settings
     if validated_handoff is not None:
         body["human_handoff"] = validated_handoff
     return client.patch(f"/external/agents/{agent_id}", json=body)

{codeer_cli-0.1.11 → codeer_cli-0.1.13}/src/codeer_cli/chats.py

@@ -186,14 +186,50 @@ def list_messages(
     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,
-    )
+    """Return every client-visible Chat V2 part for a persisted chat.
+
+    ``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]:

{codeer_cli-0.1.11 → codeer_cli-0.1.13}/src/codeer_cli/commands/agent.py

@@ -89,7 +89,9 @@ def register(subparsers):
 def _tool_summary(tools: list[dict] | None) -> list[dict]:
     out = []
     for t in tools or []:
-        form = t.get("custom_form_schema") if isinstance(t.get("custom_form_schema"), dict) else {}
+        form = t.get("custom_form_schema")
+        if not isinstance(form, dict):
+            form = {}
         out.append({
             "id": t.get("id"),
             "type": t.get("type"),
@@ -169,6 +171,8 @@ def run_apply(args, client) -> int:
         log(f"error: invalid agent payload: {exc}")
         return 2
 
+    llm_model_settings_provided = "llm_model_settings" in body
+
     if args.dry_run:
         operation = "update" if args.agent_id else "create"
         result = {
@@ -181,6 +185,8 @@ def run_apply(args, client) -> int:
             "tool_count": len(validated_tools),
             "use_search": body.get("use_search", False),
             "llm_model": body.get("llm_model"),
+            "llm_model_settings_provided": llm_model_settings_provided,
+            "llm_model_settings": body.get("llm_model_settings"),
             "human_handoff": {
                 "enabled": bool((validated_handoff or {}).get("enabled")),
                 "idle_timeout_minutes": (validated_handoff or {}).get("idle_timeout_minutes"),
@@ -193,6 +199,12 @@ def run_apply(args, client) -> int:
         print_json(result)
         return 0
 
+    model_settings_kwargs = (
+        {"llm_model_settings": body["llm_model_settings"]}
+        if llm_model_settings_provided
+        else {}
+    )
+
     if args.agent_id:
         body.pop("workspace_id", None)
         agents_mod.update(
@@ -208,6 +220,7 @@ def run_apply(args, client) -> int:
             primary_object_ids=body.get("primary_object_ids") or [],
             attachment_ids=body.get("attachment_ids") or [],
             human_handoff=validated_handoff,
+            **model_settings_kwargs,
         )
         agent_id = args.agent_id
         log(f"PUT /agents/{agent_id} ok")
@@ -227,6 +240,7 @@ def run_apply(args, client) -> int:
             primary_object_ids=body.get("primary_object_ids") or [],
             attachment_ids=body.get("attachment_ids") or [],
             human_handoff=validated_handoff,
+            **model_settings_kwargs,
         )
         agent_id = agent["id"]
         log(f"POST /agents ok, id={agent_id}")

{codeer_cli-0.1.11 → codeer_cli-0.1.13}/src/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
@@ -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
 
@@ -355,7 +379,7 @@ def run_create(args, client) -> int:
         "messages": message_results,
         "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,
@@ -418,7 +442,7 @@ def run_send(args, client) -> int:
         "messages": message_results,
         "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,

{codeer_cli-0.1.11 → codeer_cli-0.1.13}/src/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-0.1.13/tests/test_agent_model_settings.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import contextlib
+import io
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from codeer_cli import agents
+from codeer_cli.commands import agent as agent_cmd
+
+
+MODEL_ID = "openai/gpt-5.6-luna"
+MODEL_SETTINGS = {MODEL_ID: {"thinking": "xhigh"}}
+
+
+class FakeClient:
+    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": "agent-1"}
+
+    def patch(self, path: str, **kwargs):
+        self.calls.append(("PATCH", path, kwargs))
+        return {"id": "agent-1"}
+
+
+class AgentModelSettingsPayloadTests(unittest.TestCase):
+    def test_create_forwards_model_settings(self) -> None:
+        client = FakeClient()
+
+        agents.create(
+            client,  # type: ignore[arg-type]
+            workspace_id="workspace-1",
+            name="Agent",
+            system_prompt="Help safely.",
+            llm_model=MODEL_ID,
+            llm_model_settings=MODEL_SETTINGS,
+        )
+
+        self.assertEqual(client.calls[0][0:2], ("POST", "/external/agents"))
+        self.assertEqual(
+            client.calls[0][2]["json"]["llm_model_settings"],
+            MODEL_SETTINGS,
+        )
+
+    def test_update_forwards_model_settings(self) -> None:
+        client = FakeClient()
+
+        agents.update(
+            client,  # type: ignore[arg-type]
+            "agent-1",
+            name="Agent",
+            system_prompt="Help safely.",
+            unified_tools=[],
+            use_search=False,
+            llm_model=MODEL_ID,
+            llm_model_settings=MODEL_SETTINGS,
+        )
+
+        self.assertEqual(
+            client.calls[0][0:2],
+            ("PATCH", "/external/agents/agent-1"),
+        )
+        self.assertEqual(
+            client.calls[0][2]["json"]["llm_model_settings"],
+            MODEL_SETTINGS,
+        )
+
+    def test_update_forwards_empty_map_to_clear_settings(self) -> None:
+        client = FakeClient()
+
+        agents.update(
+            client,  # type: ignore[arg-type]
+            "agent-1",
+            name="Agent",
+            system_prompt="Help safely.",
+            unified_tools=[],
+            use_search=False,
+            llm_model_settings={},
+        )
+
+        self.assertEqual(client.calls[0][2]["json"]["llm_model_settings"], {})
+
+    def test_update_omits_model_settings_when_unspecified(self) -> None:
+        client = FakeClient()
+
+        agents.update(
+            client,  # type: ignore[arg-type]
+            "agent-1",
+            name="Agent",
+            system_prompt="Help safely.",
+            unified_tools=[],
+            use_search=False,
+        )
+
+        self.assertNotIn("llm_model_settings", client.calls[0][2]["json"])
+
+
+class AgentModelSettingsCommandTests(unittest.TestCase):
+    def _run_apply(
+        self,
+        payload: dict,
+        *,
+        agent_id: str | None = None,
+        dry_run: bool = False,
+    ) -> tuple[int, dict]:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            payload_path = Path(tmpdir) / "agent.json"
+            payload_path.write_text(json.dumps(payload))
+            args = SimpleNamespace(
+                payload=str(payload_path),
+                agent_id=agent_id,
+                dry_run=dry_run,
+                note="settings regression",
+                out=None,
+            )
+            stdout = io.StringIO()
+            with contextlib.redirect_stdout(stdout):
+                status = agent_cmd.run_apply(args, object())
+        return status, json.loads(stdout.getvalue()) if stdout.getvalue() else {}
+
+    def test_apply_create_forwards_model_settings(self) -> None:
+        payload = {
+            "workspace_id": "workspace-1",
+            "name": "Agent",
+            "system_prompt": "Help safely.",
+            "llm_model": MODEL_ID,
+            "llm_model_settings": MODEL_SETTINGS,
+        }
+        history = [{"id": "history-1", "version_number": 1, "status": "draft"}]
+
+        with (
+            patch.object(
+                agent_cmd.agents_mod,
+                "create",
+                return_value={"id": "agent-1"},
+            ) as create,
+            patch.object(agent_cmd.agents_mod, "list_versions", return_value=history),
+        ):
+            status, _ = self._run_apply(payload)
+
+        self.assertEqual(status, 0)
+        self.assertEqual(
+            create.call_args.kwargs["llm_model_settings"],
+            MODEL_SETTINGS,
+        )
+
+    def test_apply_update_preserves_present_and_empty_settings(self) -> None:
+        history = [{"id": "history-2", "version_number": 2, "status": "draft"}]
+
+        for model_settings in (MODEL_SETTINGS, {}):
+            with self.subTest(model_settings=model_settings):
+                payload = {
+                    "name": "Agent",
+                    "system_prompt": "Help safely.",
+                    "llm_model_settings": model_settings,
+                }
+                with (
+                    patch.object(agent_cmd.agents_mod, "update") as update,
+                    patch.object(
+                        agent_cmd.agents_mod,
+                        "list_versions",
+                        return_value=history,
+                    ),
+                ):
+                    status, _ = self._run_apply(payload, agent_id="agent-1")
+
+                self.assertEqual(status, 0)
+                self.assertEqual(
+                    update.call_args.kwargs["llm_model_settings"],
+                    model_settings,
+                )
+
+    def test_apply_update_does_not_supply_omitted_settings(self) -> None:
+        payload = {
+            "name": "Agent",
+            "system_prompt": "Help safely.",
+        }
+        history = [{"id": "history-2", "version_number": 2, "status": "draft"}]
+
+        with (
+            patch.object(agent_cmd.agents_mod, "update") as update,
+            patch.object(agent_cmd.agents_mod, "list_versions", return_value=history),
+        ):
+            status, _ = self._run_apply(payload, agent_id="agent-1")
+
+        self.assertEqual(status, 0)
+        self.assertNotIn("llm_model_settings", update.call_args.kwargs)
+
+    def test_apply_dry_run_distinguishes_settings_states(self) -> None:
+        cases = (
+            (MODEL_SETTINGS, True, MODEL_SETTINGS),
+            ({}, True, {}),
+            (None, False, None),
+        )
+
+        for model_settings, expected_provided, expected_settings in cases:
+            with self.subTest(model_settings=model_settings):
+                payload: dict[str, object] = {
+                    "name": "Agent",
+                    "system_prompt": "Help safely.",
+                }
+                if expected_provided:
+                    payload["llm_model_settings"] = model_settings
+
+                status, result = self._run_apply(
+                    payload,
+                    agent_id="agent-1",
+                    dry_run=True,
+                )
+
+                self.assertEqual(status, 0)
+                self.assertEqual(
+                    result["llm_model_settings_provided"],
+                    expected_provided,
+                )
+                self.assertEqual(
+                    result["llm_model_settings"],
+                    expected_settings,
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()

{codeer_cli-0.1.11 → codeer_cli-0.1.13}/tests/test_chats_v2.py

@@ -19,6 +19,23 @@ class RecordingClient:
         return {"chat_id": 123, "messages": []}
 
 
+class PaginatedClient(RecordingClient):
+    def __init__(self, messages: list[dict]) -> None:
+        super().__init__()
+        self.messages = messages
+
+    def get(self, path: str, **kwargs):
+        self.calls.append(("GET", path, kwargs))
+        params = kwargs["params"]
+        offset = params["offset"]
+        limit = params["limit"]
+        return {
+            "chat_id": 123,
+            "reply_context_anchor": {"part_id": 99, "sequence": 99},
+            "messages": self.messages[offset:offset + limit],
+        }
+
+
 class ChatV2RequestTests(unittest.TestCase):
     def test_create_uses_v2_and_always_sends_name(self) -> None:
         client = RecordingClient()
@@ -59,6 +76,42 @@ class ChatV2RequestTests(unittest.TestCase):
             },
         ))
 
+    def test_list_messages_fetches_every_page_without_mutating_parts(self) -> None:
+        messages = [
+            {
+                "id": idx,
+                "part_kind": "tool-return",
+                "content": {"content": {"owner": f"owner-{idx}"}},
+                "metadata": {"agent_history_id": f"version-{idx}"},
+            }
+            for idx in range(5)
+        ]
+        client = PaginatedClient(messages)
+
+        result = chats.list_messages(client, 123, limit=2)  # type: ignore[arg-type]
+
+        self.assertEqual(result["messages"], messages)
+        self.assertEqual(result["reply_context_anchor"], {"part_id": 99, "sequence": 99})
+        self.assertEqual(
+            [call[2]["params"]["offset"] for call in client.calls],
+            [0, 2, 4],
+        )
+
+    def test_list_messages_checks_one_empty_page_for_exact_page_multiple(self) -> None:
+        client = PaginatedClient([{"id": idx} for idx in range(4)])
+
+        result = chats.list_messages(client, 123, limit=2)  # type: ignore[arg-type]
+
+        self.assertEqual([message["id"] for message in result["messages"]], [0, 1, 2, 3])
+        self.assertEqual(
+            [call[2]["params"]["offset"] for call in client.calls],
+            [0, 2, 4],
+        )
+
+    def test_list_messages_rejects_non_positive_page_size(self) -> None:
+        with self.assertRaisesRegex(ValueError, "limit must be greater than zero"):
+            chats.list_messages(RecordingClient(), 123, limit=0)  # type: ignore[arg-type]
+
 
 class ChatV2StreamTests(unittest.TestCase):
     def test_collects_structured_events_and_final_text(self) -> None:

codeer_cli-0.1.13/tests/test_history_read.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import json
+import unittest
+from contextlib import redirect_stdout
+from io import StringIO
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from codeer_cli import histories
+from codeer_cli.commands import history as history_cmd
+
+
+class FakeClient:
+    def resolve_scope(self) -> tuple[str, str]:
+        return "workspace-1", "organization-1"
+
+
+class HistoryReadTests(unittest.TestCase):
+    def test_run_conversations_uses_v2_and_writes_unmodified_parts(self) -> None:
+        client = FakeClient()
+        response = {
+            "chat_id": 18649,
+            "messages": [
+                {
+                    "id": 10,
+                    "conversation_group_id": "group-1",
+                    "sequence": 1,
+                    "part_kind": "user-prompt",
+                    "content": {"content": "Question"},
+                    "metadata": {"agent_history_id": "version-1"},
+                    "source": "stack",
+                    "attached_files": [],
+                    "feedbacks": [],
+                },
+                {
+                    "id": 11,
+                    "conversation_group_id": "group-1",
+                    "sequence": 2,
+                    "part_kind": "tool-return",
+                    "content": {"content": {"owner": "Ada", "members": ["Grace"]}},
+                    "metadata": {"reasoning_step_type": "consultant_http_request"},
+                    "source": "stack",
+                    "attached_files": [],
+                    "feedbacks": [],
+                },
+            ],
+        }
+        args = SimpleNamespace(history_id=18649, full=False, out=None)
+
+        with TemporaryDirectory() as tmpdir:
+            out_path = Path(tmpdir) / "history.json"
+            args.out = str(out_path)
+            stdout = StringIO()
+            with (
+                patch.object(history_cmd.chats_mod, "list_messages", return_value=response) as list_messages,
+                redirect_stdout(stdout),
+            ):
+                result = history_cmd.run_conversations(args, client)
+
+            artifact = json.loads(out_path.read_text())
+
+        self.assertEqual(result, 0)
+        list_messages.assert_called_once_with(client, 18649)
+        self.assertEqual(artifact, response)
+        self.assertEqual(artifact["messages"][1]["content"]["content"]["owner"], "Ada")
+        summary = json.loads(stdout.getvalue())
+        self.assertEqual(summary["turn_count"], 1)
+        self.assertEqual(summary["part_count"], 2)
+        self.assertTrue(summary["stdout_is_summary"])
+        self.assertEqual(summary["parts"][1]["part_kind"], "tool-return")
+
+    def test_negative_feedback_uses_v2_part_feedback_and_grouped_user_prompt(self) -> None:
+        client = FakeClient()
+        history_rows = [{
+            "id": 18649,
+            "name": "Support chat",
+            "external_user_id": "user-1",
+            "created_at": "2026-08-10T00:00:00Z",
+        }]
+        parts = {
+            "chat_id": 18649,
+            "messages": [
+                {
+                    "id": 1,
+                    "conversation_group_id": "group-1",
+                    "part_kind": "user-prompt",
+                    "content": {"content": "Why did this fail?"},
+                },
+                {
+                    "id": 2,
+                    "conversation_group_id": "group-1",
+                    "part_kind": "tool-call",
+                    "content": {"tool_name": "http_request", "args": {"path": "/status"}},
+                },
+                {
+                    "id": 3,
+                    "conversation_group_id": "group-1",
+                    "part_kind": "text",
+                    "content": {"content": "The service is healthy."},
+                    "feedbacks": [{"type": "sys_improve", "content": "Incorrect"}],
+                },
+            ],
+        }
+
+        with (
+            patch.object(histories, "list", return_value=history_rows),
+            patch("codeer_cli.chats.list_messages", return_value=parts) as list_messages,
+        ):
+            rows = histories.list_negative_feedback_turns(client, agent_id="agent-1")
+
+        list_messages.assert_called_once_with(client, 18649)
+        self.assertEqual(rows, [{
+            "history_id": 18649,
+            "history_title": "Support chat",
+            "external_user_id": "user-1",
+            "created_at": "2026-08-10T00:00:00Z",
+            "turn_idx": 0,
+            "part_idx": 2,
+            "conversation_group_id": "group-1",
+            "conversation_part_id": 3,
+            "feedback_type": "sys_improve",
+            "feedback_text": "Incorrect",
+            "user_message": "Why did this fail?",
+            "assistant_excerpt": "The service is healthy.",
+        }])
+
+
+if __name__ == "__main__":
+    unittest.main()

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

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