codeer-cli 0.1.8__tar.gz → 0.1.9__tar.gz

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/API_REFERENCE.md

@@ -149,10 +149,10 @@ for the apply → test → publish workflow. Pass the draft `AgentHistory.id` fr
 
 | Method & path | Purpose |
 | --- | --- |
-| `GET /eval/workspaces/{workspace_id}/case-labels` | List reusable eval case labels |
-| `POST /eval/workspaces/{workspace_id}/case-labels` | Create reusable eval case label (`name`, `color?`) |
-| `PUT /eval/case-labels/{label_id}` | Update eval case label name/color |
-| `DELETE /eval/case-labels/{label_id}` | Delete eval case label and clear associations |
+| `GET /external/eval/case-labels` | List reusable eval case labels in the API key workspace |
+| `POST /external/eval/case-labels` | Create reusable eval case label (`name`, `color?`) in the API key workspace |
+| `PUT /external/eval/case-labels/{label_id}` | Update an eval case label in the API key workspace |
+| `DELETE /external/eval/case-labels/{label_id}` | Delete an eval case label and clear associations |
 | `POST /eval/cases` | Create case (`input`, `expected_output?`, `rubric?`, `label_ids?`); rubric = user-docs "Standard" |
 | `GET /eval/agents/{agent_id}/cases` | List cases for an agent |
 | `GET /eval/cases/{case_id}` | Read one |
@@ -171,8 +171,11 @@ for the apply → test → publish workflow. Pass the draft `AgentHistory.id` fr
 | `POST /eval/rubric` | Set/override the rubric for one (case, evaluator); also creates assignment |
 | `POST /eval/rubrics/batch` | **Read** rubrics for a batch of (case, evaluator) pairs |
 
-Eval case labels are workspace-scoped reusable objects. The case create/update
-payload uses `label_ids` (stringified label IDs), not freeform label names:
+Eval case labels are workspace-scoped reusable objects. The external label
+endpoints infer the workspace from the API key and do not accept a workspace
+override; switch CLI profiles to operate on another workspace. The case
+create/update payload uses `label_ids` (stringified label IDs), not freeform
+label names:
 
 ```json
 {
@@ -247,12 +250,19 @@ 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 |
 | `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 |
 | `POST /histories/{hid}/conversations/{cid}/feedbacks` | Leave freeform improvement feedback |
 | `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.
+
 `feedback_filter` accepts the `FeedbackFilterType` enum values:
 `no_feedback`, `with_feedback`, `helpful_feedback`, `improve_feedback`.
 

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeer-cli
-Version: 0.1.8
+Version: 0.1.9
 Summary: Command line tools for managing Codeer agents over the Codeer API.
 Project-URL: Homepage, https://www.codeer.ai
 Author: Codeer.AI
@@ -143,9 +143,20 @@ 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 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.
+
+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
+workspace.
+
 Flags:
 
 - `--full` prints bounded extra detail for human inspection. It is still

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/README.md

@@ -125,9 +125,20 @@ 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 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.
+
+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
+workspace.
+
 Flags:
 
 - `--full` prints bounded extra detail for human inspection. It is still

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/pyproject.toml

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

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/src/codeer_cli/__init__.py

@@ -19,7 +19,7 @@ workspace-local dotenv files or credential files.
 """
 
 from ._validate import ToolValidationError
-from .client import AuthError, CodeerClient, CodeerError
+from .client import AuthError, CodeerClient, CodeerError, TransportError
 from .parse import (
     AgentSummary,
     ConversationTurn,
@@ -43,7 +43,7 @@ from .parse import (
 )
 
 __all__ = [
-    "CodeerClient", "CodeerError", "AuthError", "ToolValidationError",
+    "CodeerClient", "CodeerError", "TransportError", "AuthError", "ToolValidationError",
     # parsers
     "AgentSummary", "ConversationTurn", "EvalResultSummary", "HistorySummary",
     "KBNode", "ToolCall", "EvalToolCall",

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/src/codeer_cli/chats.py

@@ -36,6 +36,7 @@ def send_published_agent_message(
     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.
 
@@ -51,7 +52,7 @@ 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)
+    return client.post(path, json=body, timeout=timeout)
 
 
 def send_message(
@@ -84,4 +85,3 @@ def list_messages(client: CodeerClient, chat_id: int) -> list[dict]:
 
 def list_chats(client: CodeerClient) -> list[dict]:
     return client.get("/chats")
-

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/src/codeer_cli/cli.py

@@ -4,7 +4,7 @@
     codeer agent list|get|apply|diff|versions
     codeer kb list|files|upload|node-rename|node-delete|faq-list|faq-get|faq-create|faq-update|faq-delete
     codeer eval list|label-list|label-create|label-update|label-delete|case-update|case-delete|evaluators|evaluator-create|evaluator-update|run|export|reconcile|cases-apply|rubrics|rubrics-apply
-    codeer history list|get|conversations|negative-feedback
+    codeer history list|get|conversations|negative-feedback|create|send
 """
 
 from __future__ import annotations

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/src/codeer_cli/client.py

@@ -37,6 +37,16 @@ class ScopeResolutionError(CodeerError):
     """Raised when workspace or organization scope cannot be inferred."""
 
 
+class TransportError(CodeerError):
+    """Raised when an HTTP request fails before a response is available."""
+
+    def __init__(self, message: str, body: Any = None):
+        RuntimeError.__init__(self, message)
+        self.status = 0
+        self.message = message
+        self.body = body
+
+
 @dataclass
 class CodeerClient:
     """Thin wrapper around httpx.Client with Codeer API-key auth.
@@ -148,9 +158,32 @@ class CodeerClient:
         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}"
-        r = self._client.request(method, url, params=params, json=json, files=files, data=data)
+        request_kwargs: dict[str, Any] = {}
+        if timeout is not None:
+            request_kwargs["timeout"] = timeout
+        method_upper = method.upper()
+        try:
+            r = self._client.request(
+                method_upper,
+                url,
+                params=params,
+                json=json,
+                files=files,
+                data=data,
+                **request_kwargs,
+            )
+        except httpx.TimeoutException as exc:
+            raise self._transport_error(
+                method_upper,
+                path,
+                exc,
+                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
         return self._parse(r)
 
     def get(self, path: str, **kwargs: Any) -> Any:
@@ -181,29 +214,68 @@ class CodeerClient:
         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}"
-        with self._client.stream(method, url, params=params, json=json) as r:
-            if r.status_code >= 400:
-                body = r.read().decode("utf-8", "replace")
-                self._raise_for_error(r.status_code, body)
-            event = "message"
-            buf: list[str] = []
-            for line in r.iter_lines():
-                if line == "":
-                    if buf:
-                        raw = "\n".join(buf)
-                        yield {"event": event, "data": _maybe_json(raw)}
-                        buf = []
-                        event = "message"
-                    continue
-                if line.startswith(":"):
-                    continue
-                if line.startswith("event:"):
-                    event = line[len("event:"):].strip()
-                    continue
-                if line.startswith("data:"):
-                    buf.append(line[len("data:"):].lstrip())
-            if buf:
-                yield {"event": event, "data": _maybe_json("\n".join(buf))}
+        method_upper = method.upper()
+        try:
+            with self._client.stream(method_upper, url, params=params, json=json) as r:
+                if r.status_code >= 400:
+                    body = r.read().decode("utf-8", "replace")
+                    self._raise_for_error(r.status_code, body)
+                event = "message"
+                buf: list[str] = []
+                for line in r.iter_lines():
+                    if line == "":
+                        if buf:
+                            raw = "\n".join(buf)
+                            yield {"event": event, "data": _maybe_json(raw)}
+                            buf = []
+                            event = "message"
+                        continue
+                    if line.startswith(":"):
+                        continue
+                    if line.startswith("event:"):
+                        event = line[len("event:"):].strip()
+                        continue
+                    if line.startswith("data:"):
+                        buf.append(line[len("data:"):].lstrip())
+                if buf:
+                    yield {"event": event, "data": _maybe_json("\n".join(buf))}
+        except httpx.TimeoutException as exc:
+            raise self._transport_error(
+                method_upper,
+                path,
+                exc,
+                timeout_seconds=self.timeout,
+            ) from exc
+        except httpx.RequestError as exc:
+            raise self._transport_error(method_upper, path, exc) from exc
+
+    def _transport_error(
+        self,
+        method: str,
+        path: str,
+        exc: httpx.RequestError,
+        *,
+        timeout_seconds: float | None = None,
+    ) -> TransportError:
+        outcome_uncertain = (
+            method not in {"GET", "HEAD", "OPTIONS"}
+            and not isinstance(exc, httpx.ConnectError)
+        )
+        if isinstance(exc, httpx.TimeoutException):
+            timeout_value = timeout_seconds if timeout_seconds is not None else self.timeout
+            message = f"Request timed out after {timeout_value:g}s: {method} {path}."
+            if outcome_uncertain:
+                message += " The server may have completed the request; inspect current state before retrying."
+        else:
+            message = f"Request failed: {method} {path}: {exc}"
+        return TransportError(
+            message,
+            {
+                "method": method,
+                "path": path,
+                "outcome_uncertain": outcome_uncertain,
+            },
+        )
 
     def _parse(self, r: httpx.Response) -> Any:
         text = r.text

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/src/codeer_cli/commands/eval_cmd.py

@@ -48,14 +48,12 @@ def register(subparsers):
 
     # codeer eval label-list/create/update/delete
     p = sub.add_parser("label-list", help="List eval case labels in the workspace")
-    p.add_argument("--workspace", default=None, help="Workspace UUID (default: active API-key workspace)")
     p.add_argument("--out", default=None)
     p.set_defaults(func=run_label_list)
 
     p = sub.add_parser("label-create", help="Create an eval case label; run --dry-run first")
     p.add_argument("--name", required=True)
     p.add_argument("--color", default=None, help="Hex color like #0969da (default: server default)")
-    p.add_argument("--workspace", default=None, help="Workspace UUID (default: active API-key workspace)")
     p.add_argument("--dry-run", action="store_true")
     p.add_argument("--out", default=None)
     p.set_defaults(func=run_label_create)
@@ -288,9 +286,7 @@ def run_list(args, client) -> int:
 # eval case labels
 # ---------------------------------------------------------------------------
 
-def _workspace_arg_or_default(client, workspace_id: str | None) -> str:
-    if workspace_id:
-        return workspace_id
+def _active_workspace(client) -> str:
     ws, _ = client.resolve_scope()
     return ws
 
@@ -305,8 +301,8 @@ def _label_summary(label: dict) -> dict:
 
 
 def run_label_list(args, client) -> int:
-    workspace_id = _workspace_arg_or_default(client, args.workspace)
-    labels = eval_mod.list_case_labels(client, workspace_id=workspace_id)
+    workspace_id = _active_workspace(client)
+    labels = eval_mod.list_case_labels(client)
     out = {
         "workspace_id": workspace_id,
         "label_count": len(labels),
@@ -318,13 +314,13 @@ def run_label_list(args, client) -> int:
 
 
 def run_label_create(args, client) -> int:
-    workspace_id = _workspace_arg_or_default(client, args.workspace)
+    workspace_id = _active_workspace(client)
     if args.dry_run:
         out = {
             "dry_run": True,
             "operation": "label_create",
             "method": "POST",
-            "path": f"/eval/workspaces/{workspace_id}/case-labels",
+            "path": "/external/eval/case-labels",
             "workspace_id": workspace_id,
             "name": args.name,
             "color": args.color,
@@ -335,9 +331,7 @@ def run_label_create(args, client) -> int:
         write_json(args.out, out)
         return 0
 
-    label = eval_mod.create_case_label(
-        client, workspace_id=workspace_id, name=args.name, color=args.color
-    )
+    label = eval_mod.create_case_label(client, name=args.name, color=args.color)
     out = _label_summary(strip_noisy_fields(label))
     print_json(out)
     write_json(args.out, out)
@@ -354,7 +348,7 @@ def run_label_update(args, client) -> int:
             "dry_run": True,
             "operation": "label_update",
             "method": "PUT",
-            "path": f"/eval/case-labels/{args.label_id}",
+            "path": f"/external/eval/case-labels/{args.label_id}",
             "label_id": args.label_id,
             "updates": {"name": args.name, "color": args.color},
             "would_write_server_state": True,
@@ -379,7 +373,7 @@ def run_label_delete(args, client) -> int:
             "dry_run": True,
             "operation": "label_delete",
             "method": "DELETE",
-            "path": f"/eval/case-labels/{args.label_id}",
+            "path": f"/external/eval/case-labels/{args.label_id}",
             "label_id": args.label_id,
             "would_write_server_state": True,
             "next_step": "Review this summary, then rerun without --dry-run after approval.",
@@ -1384,7 +1378,7 @@ def run_cases_apply(args, client) -> int:
     if manifest_label_names:
         labels_by_name = {
             (label.get("name") or "").casefold(): label
-            for label in eval_mod.list_case_labels(client, workspace_id=workspace_id)
+            for label in eval_mod.list_case_labels(client)
             if label.get("name")
         }
         missing_label_names = [
@@ -1410,7 +1404,7 @@ def run_cases_apply(args, client) -> int:
         else:
             for name in missing_label_names:
                 log(f"creating label: {name}")
-                label = eval_mod.create_case_label(client, workspace_id=workspace_id, name=name)
+                label = eval_mod.create_case_label(client, name=name)
                 labels_by_name[name.casefold()] = label
                 created_labels.append(_label_summary(label))
 

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/src/codeer_cli/commands/history.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+import math
 import os
 
 from .. import agents as agents_mod
 from .. import chats as chats_mod
 from .. import histories as hist_mod
+from ..client import TransportError
 from ._util import log, print_json, strip_noisy_fields, truncate, write_json
 
 
@@ -74,10 +76,27 @@ 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("--out", default=None,
                    help="Write complete create response/conversation artifact to this file; stdout stays compact.")
     p.set_defaults(func=run_create)
 
+    # codeer history send <id> --message ...
+    p = sub.add_parser("send", help="Continue an existing persisted conversation history")
+    p.add_argument("history_id", type=int)
+    p.add_argument("--agent", default=None,
+                   help="Agent ID override (defaults to the history's agent or CODEER_AGENT_ID)")
+    p.add_argument("--user", default=None,
+                   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("--out", default=None,
+                   help="Write complete send response/conversation artifact to this file; stdout stays compact.")
+    p.set_defaults(func=run_send)
+
 
 def _parse_exclude(raw: str | None) -> list[str]:
     if not raw:
@@ -253,11 +272,51 @@ def _history_url(client, workspace_id: str, history_id: int) -> str:
     return f"{base}/workspaces/{workspace_id}/histories/{history_id}"
 
 
+def _send_messages(
+    client,
+    *,
+    history_id: int,
+    agent_id: str,
+    external_user_id: str | None,
+    messages: list[str],
+    timeout: float,
+) -> list[dict]:
+    results = []
+    for idx, message in enumerate(messages, 1):
+        log(f"sending turn {idx}/{len(messages)}")
+        try:
+            result = 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,
+                timeout=timeout,
+            )
+        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)})
+            raise TransportError(
+                f"Failed while sending turn {idx}/{len(messages)} to history {history_id}: {exc.message}",
+                body,
+            ) from exc
+        results.append(result)
+    return results
+
+
+def _valid_timeout(timeout: float) -> bool:
+    return math.isfinite(timeout) and timeout > 0
+
+
 def run_create(args, client) -> int:
     agent_id = args.agent or os.environ.get("CODEER_AGENT_ID")
     if not agent_id:
         log("error: --agent is required or set CODEER_AGENT_ID")
         return 2
+    if not _valid_timeout(args.timeout):
+        log("error: --timeout must be a finite number greater than zero")
+        return 2
 
     workspace_id, _ = client.resolve_scope()
     title = args.title or (args.message[0].strip()[:80] if args.message else "CLI conversation")
@@ -269,19 +328,14 @@ def run_create(args, client) -> int:
         external_user_id=args.user,
     )
     history_id = chat["id"]
-    message_results = []
-
-    for idx, message in enumerate(args.message, 1):
-        log(f"sending turn {idx}/{len(args.message)}")
-        result = chats_mod.send_published_agent_message(
-            client,
-            chat_id=history_id,
-            message=message,
-            agent_id=agent_id,
-            external_user_id=args.user,
-            stream=False,
-        )
-        message_results.append(result)
+    message_results = _send_messages(
+        client,
+        history_id=history_id,
+        agent_id=agent_id,
+        external_user_id=args.user,
+        messages=args.message,
+        timeout=args.timeout,
+    )
 
     conversations = hist_mod.get_conversations(client, history_id)
     out = {
@@ -303,3 +357,61 @@ def run_create(args, client) -> int:
         "wrote_full_detail": bool(args.out),
     })
     return 0
+
+
+def run_send(args, client) -> int:
+    if not _valid_timeout(args.timeout):
+        log("error: --timeout must be a finite number greater than zero")
+        return 2
+
+    history = hist_mod.get(client, args.history_id)
+    history_agent = history.get("agent") or {}
+    history_meta = history.get("meta") or {}
+    agent_id = (
+        args.agent
+        or history.get("agent_id")
+        or history_agent.get("id")
+        or history_meta.get("conversation_agent_id")
+        or os.environ.get("CODEER_AGENT_ID")
+    )
+    if not agent_id:
+        log("error: could not resolve agent from history; pass --agent or set CODEER_AGENT_ID")
+        return 2
+
+    external_user_id = (
+        args.user
+        if args.user is not None
+        else (
+            history.get("external_user_id")
+            or history_meta.get("external_user_id")
+        )
+    )
+    workspace_id, _ = client.resolve_scope()
+    message_results = _send_messages(
+        client,
+        history_id=args.history_id,
+        agent_id=agent_id,
+        external_user_id=external_user_id,
+        messages=args.message,
+        timeout=args.timeout,
+    )
+    conversations = hist_mod.get_conversations(client, args.history_id)
+    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,
+    }
+    write_json(args.out, strip_noisy_fields(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),
+        "wrote_full_detail": bool(args.out),
+    })
+    return 0

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/src/codeer_cli/eval_.py

@@ -141,21 +141,20 @@ def replace_case_evaluator_infos(
 
 # --- case labels -----------------------------------------------------------
 
-def list_case_labels(client: CodeerClient, *, workspace_id: str) -> list[dict]:
-    return client.get(f"/eval/workspaces/{workspace_id}/case-labels")
+def list_case_labels(client: CodeerClient) -> list[dict]:
+    return client.get("/external/eval/case-labels")
 
 
 def create_case_label(
     client: CodeerClient,
     *,
-    workspace_id: str,
     name: str,
     color: Optional[str] = None,
 ) -> dict:
     body: dict[str, Any] = {"name": name}
     if color is not None:
         body["color"] = color
-    return client.post(f"/eval/workspaces/{workspace_id}/case-labels", json=body)
+    return client.post("/external/eval/case-labels", json=body)
 
 
 def update_case_label(
@@ -170,11 +169,11 @@ def update_case_label(
         body["name"] = name
     if color is not None:
         body["color"] = color
-    return client.put(f"/eval/case-labels/{label_id}", json=body)
+    return client.put(f"/external/eval/case-labels/{label_id}", json=body)
 
 
 def delete_case_label(client: CodeerClient, *, label_id: str) -> dict:
-    return client.delete(f"/eval/case-labels/{label_id}")
+    return client.delete(f"/external/eval/case-labels/{label_id}")
 
 
 

codeer_cli-0.1.9/tests/test_client_transport.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import unittest
+
+import httpx
+
+from codeer_cli.client import CodeerClient, TransportError
+
+
+class ClientTransportTests(unittest.TestCase):
+    def test_request_forwards_per_request_timeout(self) -> None:
+        requests: list[httpx.Request] = []
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            requests.append(request)
+            return httpx.Response(200, json={"ok": True})
+
+        client = self._client(handler)
+        try:
+            result = client.post("/chats/1/messages", json={"message": "Hi"}, timeout=120.0)
+        finally:
+            client.close()
+
+        self.assertEqual(result, {"ok": True})
+        self.assertEqual(requests[0].extensions["timeout"]["read"], 120.0)
+
+    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)
+
+        client = self._client(handler)
+        try:
+            with self.assertRaises(TransportError) as raised:
+                client.post("/chats/1/messages", json={"message": "Hi"}, timeout=120.0)
+        finally:
+            client.close()
+
+        self.assertIn("timed out after 120s", raised.exception.message)
+        self.assertIn("inspect current state before retrying", raised.exception.message)
+        self.assertEqual(raised.exception.status, 0)
+        self.assertTrue(raised.exception.body["outcome_uncertain"])
+
+    def test_connection_error_becomes_transport_error(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            raise httpx.ConnectError("connection refused", request=request)
+
+        client = self._client(handler)
+        try:
+            with self.assertRaises(TransportError) as raised:
+                client.get("/external/me")
+        finally:
+            client.close()
+
+        self.assertIn("Request failed: GET /external/me", raised.exception.message)
+        self.assertFalse(raised.exception.body["outcome_uncertain"])
+
+    def test_stream_connection_error_becomes_transport_error(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            raise httpx.ConnectError("connection refused", request=request)
+
+        client = self._client(handler)
+        try:
+            with self.assertRaises(TransportError) as raised:
+                list(client.stream_sse("POST", "/chats/1/messages", json={"message": "Hi"}))
+        finally:
+            client.close()
+
+        self.assertIn("Request failed: POST /chats/1/messages", raised.exception.message)
+        self.assertFalse(raised.exception.body["outcome_uncertain"])
+
+    @staticmethod
+    def _client(handler) -> CodeerClient:
+        client = CodeerClient(base_url="https://api.codeer.ai", api_key="test-key")
+        client._client.close()
+        client._client = httpx.Client(
+            base_url=client.base_url,
+            timeout=client.timeout,
+            transport=httpx.MockTransport(handler),
+        )
+        return client
+
+
+if __name__ == "__main__":
+    unittest.main()

codeer_cli-0.1.9/tests/test_eval_labels.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import io
+import json
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from codeer_cli import eval_ as eval_mod
+from codeer_cli.commands.eval_cmd import (
+    _resolve_case_label_ids,
+    run_cases_apply,
+    run_label_create,
+)
+
+
+class FakeClient:
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, str, dict]] = []
+
+    def get(self, path: str):
+        self.calls.append(("GET", path, {}))
+        return []
+
+    def post(self, path: str, **kwargs):
+        self.calls.append(("POST", path, kwargs))
+        return {"id": "created"}
+
+    def put(self, path: str, **kwargs):
+        self.calls.append(("PUT", path, kwargs))
+        return {"id": "updated"}
+
+    def delete(self, path: str, **kwargs):
+        self.calls.append(("DELETE", path, kwargs))
+        return {"ok": True}
+
+    def resolve_scope(self):
+        return "ws-1", "org-1"
+
+
+class CasesApplyFakeClient(FakeClient):
+    def resolve_scope(self):
+        return "ws-1", None
+
+    def get(self, path: str):
+        self.calls.append(("GET", path, {}))
+        if path == "/external/eval/case-labels":
+            return []
+        if path == "/external/eval/agents/agent-1/cases":
+            return {
+                "cases": [
+                    {"id": "case-1", "input": "First question", "note": "Keep me"},
+                    {"id": "case-2", "input": "Second question", "meta": {"keep": True}},
+                ]
+            }
+        return []
+
+    def post(self, path: str, **kwargs):
+        self.calls.append(("POST", path, kwargs))
+        if path == "/external/eval/case-labels":
+            return {"id": "label-1", "name": kwargs["json"]["name"], "color": "#0969da"}
+        return {"id": "unexpected-case"}
+
+
+class EvalLabelClientTests(unittest.TestCase):
+    def test_create_case_sends_label_ids(self) -> None:
+        client = FakeClient()
+
+        eval_mod.create_case(
+            client,  # type: ignore[arg-type]
+            agent_id="agent-1",
+            input="How much?",
+            label_ids=["10", "11"],
+        )
+
+        self.assertEqual(client.calls[0][0], "POST")
+        self.assertEqual(client.calls[0][1], "/external/eval/cases")
+        self.assertEqual(client.calls[0][2]["json"]["label_ids"], ["10", "11"])
+
+    def test_update_case_sends_empty_label_ids_to_clear(self) -> None:
+        client = FakeClient()
+
+        eval_mod.update_case(
+            client,  # type: ignore[arg-type]
+            "case-1",
+            label_ids=[],
+        )
+
+        self.assertEqual(client.calls[0][0], "PUT")
+        self.assertEqual(client.calls[0][1], "/external/eval/cases/case-1")
+        self.assertEqual(client.calls[0][2]["json"]["label_ids"], [])
+
+    def test_case_label_crud_paths(self) -> None:
+        client = FakeClient()
+
+        eval_mod.list_case_labels(client)  # type: ignore[arg-type]
+        eval_mod.create_case_label(client, name="Routing")  # type: ignore[arg-type]
+        eval_mod.update_case_label(client, label_id="5", color="#0969da")  # type: ignore[arg-type]
+        eval_mod.delete_case_label(client, label_id="5")  # type: ignore[arg-type]
+
+        self.assertEqual(client.calls[0], ("GET", "/external/eval/case-labels", {}))
+        self.assertEqual(client.calls[1][0:2], ("POST", "/external/eval/case-labels"))
+        self.assertEqual(client.calls[1][2]["json"], {"name": "Routing"})
+        self.assertEqual(client.calls[2][0:2], ("PUT", "/external/eval/case-labels/5"))
+        self.assertEqual(client.calls[2][2]["json"], {"color": "#0969da"})
+        self.assertEqual(client.calls[3][0:2], ("DELETE", "/external/eval/case-labels/5"))
+
+    def test_label_create_dry_run_reports_active_api_key_workspace(self) -> None:
+        client = FakeClient()
+        args = SimpleNamespace(
+            name="Routing",
+            color="#0969da",
+            dry_run=True,
+            out=None,
+        )
+
+        stdout = io.StringIO()
+        with redirect_stdout(stdout):
+            result = run_label_create(args, client)  # type: ignore[arg-type]
+
+        report = json.loads(stdout.getvalue())
+        self.assertEqual(result, 0)
+        self.assertEqual(report["workspace_id"], "ws-1")
+        self.assertEqual(report["path"], "/external/eval/case-labels")
+        self.assertEqual(client.calls, [])
+
+
+class EvalLabelManifestTests(unittest.TestCase):
+    def test_resolve_case_label_ids_from_ids_and_names(self) -> None:
+        label_ids, label_names = _resolve_case_label_ids(
+            {"label_ids": ["7"], "labels": ["Routing", "Billing"]},
+            {
+                "routing": {"id": "8", "name": "Routing"},
+                "billing": {"id": "9", "name": "Billing"},
+            },
+        )
+
+        self.assertEqual(label_ids, ["7", "8", "9"])
+        self.assertEqual(label_names, ["Routing", "Billing"])
+
+    def test_resolve_case_label_ids_dedupes_preserving_order(self) -> None:
+        label_ids, _ = _resolve_case_label_ids(
+            {"label_ids": ["7", "8"], "labels": ["Routing"]},
+            {"routing": {"id": "8", "name": "Routing"}},
+        )
+
+        self.assertEqual(label_ids, ["7", "8"])
+
+    def test_unknown_label_name_is_error(self) -> None:
+        with self.assertRaises(ValueError):
+            _resolve_case_label_ids({"labels": ["Missing"]}, {})
+
+    def test_cases_apply_create_labels_dry_run_reports_without_writing(self) -> None:
+        client = CasesApplyFakeClient()
+        args = self._cases_apply_args(dry_run=True)
+
+        with patch.object(Path, "read_text", return_value=json.dumps(self._manifest())):
+            stdout = io.StringIO()
+            with redirect_stdout(stdout):
+                result = run_cases_apply(args, client)  # type: ignore[arg-type]
+
+        report = json.loads(stdout.getvalue())
+        self.assertEqual(result, 0)
+        self.assertEqual(report["would_create_case_labels"], ["Missing"])
+        self.assertEqual([update["case_id"] for update in report["updates"]], ["case-1", "case-2"])
+        self.assertTrue(all(update["label_ids"] == ["(new:Missing)"] for update in report["updates"]))
+        self.assertTrue(all(call[0] == "GET" for call in client.calls))
+
+    def test_cases_apply_creates_one_label_and_only_updates_existing_cases(self) -> None:
+        client = CasesApplyFakeClient()
+        args = self._cases_apply_args(dry_run=False)
+
+        with patch.object(Path, "read_text", return_value=json.dumps(self._manifest())):
+            stdout = io.StringIO()
+            with redirect_stdout(stdout):
+                result = run_cases_apply(args, client)  # type: ignore[arg-type]
+
+        report = json.loads(stdout.getvalue())
+        label_creates = [
+            call for call in client.calls
+            if call[0:2] == ("POST", "/external/eval/case-labels")
+        ]
+        case_creates = [
+            call for call in client.calls
+            if call[0:2] == ("POST", "/external/eval/cases")
+        ]
+        case_updates = [
+            call for call in client.calls
+            if call[0] == "PUT" and call[1] in {
+                "/external/eval/cases/case-1",
+                "/external/eval/cases/case-2",
+            }
+        ]
+
+        self.assertEqual(result, 0)
+        self.assertEqual(len(label_creates), 1)
+        self.assertEqual(case_creates, [])
+        self.assertEqual(len(case_updates), 2)
+        self.assertTrue(all(call[2]["json"] == {"label_ids": ["label-1"]} for call in case_updates))
+        self.assertEqual([row["case_id"] for row in report["reused"]], ["case-1", "case-2"])
+        self.assertEqual(report["created_case_labels"][0]["name"], "Missing")
+
+    @staticmethod
+    def _cases_apply_args(*, dry_run: bool) -> SimpleNamespace:
+        return SimpleNamespace(
+            cases="manifest.json",
+            agent="agent-1",
+            attachments_dir=None,
+            allow_duplicates=False,
+            create_labels=True,
+            dry_run=dry_run,
+            out=None,
+        )
+
+    @staticmethod
+    def _manifest() -> dict:
+        return {
+            "cases": [
+                {
+                    "label": "First",
+                    "input": "First question",
+                    "labels": ["Missing"],
+                    "rubrics": {"eval-1": "Must pass"},
+                },
+                {
+                    "label": "Second",
+                    "input": "Second question",
+                    "labels": ["Missing"],
+                    "rubrics": {"eval-1": "Must pass"},
+                },
+            ]
+        }
+
+
+if __name__ == "__main__":
+    unittest.main()

codeer_cli-0.1.9/tests/test_history_send.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import unittest
+from contextlib import redirect_stdout
+from io import StringIO
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from codeer_cli import chats as chats_mod
+from codeer_cli.client import TransportError
+from codeer_cli.commands import history as history_cmd
+
+
+class FakeClient:
+    base_url = "https://api.codeer.ai"
+
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, dict]] = []
+
+    def resolve_scope(self) -> tuple[str, str]:
+        return "workspace-1", "organization-1"
+
+    def post(self, path: str, **kwargs):
+        self.calls.append((path, kwargs))
+        return {"ok": True}
+
+
+class HistorySendTests(unittest.TestCase):
+    def test_chat_send_forwards_response_timeout(self) -> None:
+        client = FakeClient()
+
+        chats_mod.send_published_agent_message(
+            client,  # type: ignore[arg-type]
+            chat_id=18649,
+            message="Continue",
+            agent_id="agent-1",
+            timeout=120.0,
+        )
+
+        self.assertEqual(client.calls[0][0], "/chats/18649/messages")
+        self.assertEqual(client.calls[0][1]["timeout"], 120.0)
+
+    def test_run_send_resolves_agent_and_appends_to_existing_history(self) -> None:
+        client = FakeClient()
+        args = SimpleNamespace(
+            history_id=18649,
+            agent=None,
+            user=None,
+            message=["Use the recommended options"],
+            timeout=120.0,
+            out=None,
+        )
+
+        with (
+            patch.object(
+                history_cmd.hist_mod,
+                "get",
+                return_value={
+                    "id": 18649,
+                    "agent_id": None,
+                    "external_user_id": None,
+                    "meta": {
+                        "conversation_agent_id": "agent-1",
+                        "external_user_id": "user-1",
+                    },
+                },
+            ),
+            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"},
+                ],
+            ),
+            patch.object(
+                history_cmd.chats_mod,
+                "send_published_agent_message",
+                return_value={"conversation_id": 4},
+            ) as send,
+            redirect_stdout(StringIO()),
+        ):
+            result = history_cmd.run_send(args, client)
+
+        self.assertEqual(result, 0)
+        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,
+            timeout=120.0,
+        )
+
+    def test_run_send_rejects_non_positive_timeout(self) -> None:
+        client = FakeClient()
+        args = SimpleNamespace(
+            history_id=18649,
+            agent=None,
+            user=None,
+            message=["Continue"],
+            timeout=0,
+            out=None,
+        )
+
+        with redirect_stdout(StringIO()):
+            result = history_cmd.run_send(args, client)
+
+        self.assertEqual(result, 2)
+
+    def test_run_create_rejects_non_finite_timeout(self) -> None:
+        client = FakeClient()
+        args = SimpleNamespace(
+            agent="agent-1",
+            title=None,
+            user=None,
+            message=["Start"],
+            timeout=float("nan"),
+            out=None,
+        )
+
+        with redirect_stdout(StringIO()):
+            result = history_cmd.run_create(args, client)
+
+        self.assertEqual(result, 2)
+        self.assertEqual(client.calls, [])
+
+    def test_send_transport_error_includes_history_and_turn_context(self) -> None:
+        client = FakeClient()
+
+        with patch.object(
+            history_cmd.chats_mod,
+            "send_published_agent_message",
+            side_effect=TransportError(
+                "Request timed out",
+                {"outcome_uncertain": True},
+            ),
+        ):
+            with self.assertRaises(TransportError) as raised:
+                history_cmd._send_messages(
+                    client,
+                    history_id=18649,
+                    agent_id="agent-1",
+                    external_user_id="user-1",
+                    messages=["First", "Second"],
+                    timeout=120.0,
+                )
+
+        self.assertIn("turn 1/2", raised.exception.message)
+        self.assertEqual(raised.exception.body["history_id"], 18649)
+        self.assertEqual(raised.exception.body["turn"], 1)
+        self.assertTrue(raised.exception.body["outcome_uncertain"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{codeer_cli-0.1.8 → codeer_cli-0.1.9}/uv.lock

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

codeer_cli-0.1.8/tests/test_eval_labels.py

@@ -1,101 +0,0 @@
-from __future__ import annotations
-
-import unittest
-
-from codeer_cli import eval_ as eval_mod
-from codeer_cli.commands.eval_cmd import _resolve_case_label_ids
-
-
-class FakeClient:
-    def __init__(self) -> None:
-        self.calls: list[tuple[str, str, dict]] = []
-
-    def get(self, path: str):
-        self.calls.append(("GET", path, {}))
-        return []
-
-    def post(self, path: str, **kwargs):
-        self.calls.append(("POST", path, kwargs))
-        return {"id": "created"}
-
-    def put(self, path: str, **kwargs):
-        self.calls.append(("PUT", path, kwargs))
-        return {"id": "updated"}
-
-    def delete(self, path: str, **kwargs):
-        self.calls.append(("DELETE", path, kwargs))
-        return {"ok": True}
-
-
-class EvalLabelClientTests(unittest.TestCase):
-    def test_create_case_sends_label_ids(self) -> None:
-        client = FakeClient()
-
-        eval_mod.create_case(
-            client,  # type: ignore[arg-type]
-            agent_id="agent-1",
-            input="How much?",
-            label_ids=["10", "11"],
-        )
-
-        self.assertEqual(client.calls[0][0], "POST")
-        self.assertEqual(client.calls[0][1], "/external/eval/cases")
-        self.assertEqual(client.calls[0][2]["json"]["label_ids"], ["10", "11"])
-
-    def test_update_case_sends_empty_label_ids_to_clear(self) -> None:
-        client = FakeClient()
-
-        eval_mod.update_case(
-            client,  # type: ignore[arg-type]
-            "case-1",
-            label_ids=[],
-        )
-
-        self.assertEqual(client.calls[0][0], "PUT")
-        self.assertEqual(client.calls[0][1], "/external/eval/cases/case-1")
-        self.assertEqual(client.calls[0][2]["json"]["label_ids"], [])
-
-    def test_case_label_crud_paths(self) -> None:
-        client = FakeClient()
-
-        eval_mod.list_case_labels(client, workspace_id="ws-1")  # type: ignore[arg-type]
-        eval_mod.create_case_label(client, workspace_id="ws-1", name="Routing")  # type: ignore[arg-type]
-        eval_mod.update_case_label(client, label_id="5", color="#0969da")  # type: ignore[arg-type]
-        eval_mod.delete_case_label(client, label_id="5")  # type: ignore[arg-type]
-
-        self.assertEqual(client.calls[0], ("GET", "/eval/workspaces/ws-1/case-labels", {}))
-        self.assertEqual(client.calls[1][0:2], ("POST", "/eval/workspaces/ws-1/case-labels"))
-        self.assertEqual(client.calls[1][2]["json"], {"name": "Routing"})
-        self.assertEqual(client.calls[2][0:2], ("PUT", "/eval/case-labels/5"))
-        self.assertEqual(client.calls[2][2]["json"], {"color": "#0969da"})
-        self.assertEqual(client.calls[3][0:2], ("DELETE", "/eval/case-labels/5"))
-
-
-class EvalLabelManifestTests(unittest.TestCase):
-    def test_resolve_case_label_ids_from_ids_and_names(self) -> None:
-        label_ids, label_names = _resolve_case_label_ids(
-            {"label_ids": ["7"], "labels": ["Routing", "Billing"]},
-            {
-                "routing": {"id": "8", "name": "Routing"},
-                "billing": {"id": "9", "name": "Billing"},
-            },
-        )
-
-        self.assertEqual(label_ids, ["7", "8", "9"])
-        self.assertEqual(label_names, ["Routing", "Billing"])
-
-    def test_resolve_case_label_ids_dedupes_preserving_order(self) -> None:
-        label_ids, _ = _resolve_case_label_ids(
-            {"label_ids": ["7", "8"], "labels": ["Routing"]},
-            {"routing": {"id": "8", "name": "Routing"}},
-        )
-
-        self.assertEqual(label_ids, ["7", "8"])
-
-    def test_unknown_label_name_is_error(self) -> None:
-        with self.assertRaises(ValueError):
-            _resolve_case_label_ids({"labels": ["Missing"]}, {})
-
-
-if __name__ == "__main__":
-    unittest.main()