codeer-cli 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

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/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/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/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/commands/_util.py

@@ -62,5 +62,7 @@ def print_json(value: Any) -> None:
 def write_json(path: str | None, value: Any) -> None:
     if not path:
         return
-    Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2, default=str) + "\n")
+    out = Path(path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(value, ensure_ascii=False, indent=2, default=str) + "\n")
     log(f"wrote full detail to {path}")

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.",
@@ -653,6 +647,64 @@ def _group_case_ids_by_evaluator(pairs: list[dict[str, str]]) -> dict[str, list[
     return dict(grouped)
 
 
+def _pairs_from_rubric_batches(
+    client,
+    *,
+    case_ids: list[str],
+    evaluator_ids: list[str],
+) -> list[dict[str, str]]:
+    pairs: list[dict[str, str]] = []
+    for evaluator_id in evaluator_ids:
+        for row in eval_mod.get_rubrics_batch(client, case_ids=case_ids, evaluator_id=evaluator_id):
+            if row.get("rubric"):
+                case_id = row.get("case_id") or row.get("evaluation_case_id")
+                if case_id:
+                    pairs.append({"case_id": str(case_id), "evaluator_id": evaluator_id})
+    return pairs
+
+
+def _pair_key(pair: dict[str, str]) -> tuple[str, str]:
+    return pair["case_id"], pair["evaluator_id"]
+
+
+def _skipped_pairs_from_trigger_response(response: Any) -> list[dict[str, str]]:
+    if not isinstance(response, dict):
+        return []
+    payload = response.get("data") if isinstance(response.get("data"), dict) else response
+    skipped = payload.get("skipped_pairs") if isinstance(payload, dict) else None
+    if not isinstance(skipped, list):
+        return []
+
+    out: list[dict[str, str]] = []
+    for row in skipped:
+        if not isinstance(row, dict):
+            continue
+        case_id = row.get("case_id")
+        evaluator_id = row.get("evaluator_id")
+        if not case_id or not evaluator_id:
+            continue
+        out.append({
+            "case_id": str(case_id),
+            "evaluator_id": str(evaluator_id),
+            "reason": str(row.get("reason") or "skipped"),
+        })
+    return out
+
+
+def _remove_non_runnable_skipped_pairs(
+    pairs: list[dict[str, str]],
+    skipped_pairs: list[dict[str, str]],
+) -> list[dict[str, str]]:
+    non_runnable = {
+        _pair_key(pair)
+        for pair in skipped_pairs
+        if pair.get("reason") == "not_assigned"
+    }
+    if not non_runnable:
+        return pairs
+    return [pair for pair in pairs if _pair_key(pair) not in non_runnable]
+
+
 def run_run(args, client) -> int:
     workspace_id, _ = client.resolve_scope()
     if args.latest or not args.history:
@@ -682,18 +734,22 @@ def run_run(args, client) -> int:
     evaluator_ids = [args.evaluator] if args.evaluator else (_ids(args.evaluators) or [])
     requested_evaluator_ids = evaluator_ids or None
 
-    assignment_rows = eval_mod.get_case_evaluator_infos(client, case_ids=case_ids)
-    assigned_by_case = _assigned_evaluators_by_case(assignment_rows)
-    pairs, skipped_unassigned = _planned_eval_pairs(
-        case_ids=case_ids,
-        assigned_by_case=assigned_by_case,
-        requested_evaluator_ids=requested_evaluator_ids,
-    )
+    skipped_unassigned: list[dict[str, str]] = []
+    if requested_evaluator_ids:
+        pairs = [
+            {"case_id": case_id, "evaluator_id": evaluator_id}
+            for evaluator_id in requested_evaluator_ids
+            for case_id in case_ids
+        ]
+    else:
+        evaluator_ids = [e["id"] for e in eval_mod.list_evaluators(client, workspace_id)]
+        pairs = _pairs_from_rubric_batches(
+            client,
+            case_ids=case_ids,
+            evaluator_ids=evaluator_ids,
+        )
     if not pairs:
-        if skipped_unassigned:
-            log("error: none of the requested case/evaluator pairs are assigned")
-        else:
-            log("error: no assigned case/evaluator pairs to run")
+        log("error: no case/evaluator pairs to run")
         print_json({
             "agent_id": args.agent,
             "history_id": args.history,
@@ -710,14 +766,47 @@ def run_run(args, client) -> int:
     case_label_by_id = {c["id"]: truncate(c.get("input") or "", 60) for c in case_objs}
     evaluator_name_by_id = {e["id"]: e.get("name", e["id"]) for e in evaluators}
 
+    requested_pairs = list(pairs)
+    requested_pair_count = len(requested_pairs)
+    log(f"triggering: {requested_pair_count} case/evaluator pairs on history {args.history}")
+    trigger_response: list[dict[str, Any]] = []
+    skipped_pairs: list[dict[str, str]] = []
+    for ev_id, ev_case_ids in _group_case_ids_by_evaluator(pairs).items():
+        response = eval_mod.trigger(
+            client,
+            case_ids=ev_case_ids,
+            evaluator_ids=[ev_id],
+            agent_history_id=args.history,
+        )
+        response_skipped = _skipped_pairs_from_trigger_response(response)
+        skipped_pairs.extend(response_skipped)
+        trigger_response.append({
+            "evaluator_id": ev_id,
+            "case_ids": ev_case_ids,
+            "response": response,
+            "skipped_pairs": response_skipped,
+        })
+
+    pairs = _remove_non_runnable_skipped_pairs(pairs, skipped_pairs)
+    skipped_unassigned = [pair for pair in skipped_pairs if pair.get("reason") == "not_assigned"]
     if skipped_unassigned:
-        log(f"skipping {len(skipped_unassigned)} unassigned requested pairs")
-    log(f"triggering: {len(pairs)} assigned case/evaluator pairs on history {args.history}")
-    trigger_response = eval_mod.trigger_pairs(
-        client,
-        case_evaluator_pairs=pairs,
-        agent_history_id=args.history,
-    )
+        log(f"skipping {len(skipped_unassigned)} not-assigned pairs from polling")
+    if not pairs:
+        log("error: no runnable case/evaluator pairs after trigger response")
+        print_json({
+            "agent_id": args.agent,
+            "history_id": args.history,
+            "requested_case_count": len(case_ids),
+            "requested_evaluator_count": len(requested_evaluator_ids or evaluator_ids),
+            "requested_pair_count": requested_pair_count,
+            "triggered_pair_count": 0,
+            "skipped_pair_count": len(skipped_pairs),
+            "skipped_unassigned_count": len(skipped_unassigned),
+            "trigger_response": trigger_response,
+            "skipped_pairs": skipped_pairs,
+            "skipped_unassigned": skipped_unassigned,
+        })
+        return 2
 
     deadline = time.time() + args.poll_timeout
     results_by_eval: dict[str, list[dict]] = {}
@@ -825,22 +914,27 @@ def run_run(args, client) -> int:
         "history_id": args.history,
         "requested_case_count": len(case_ids),
         "requested_evaluator_count": len(requested_evaluator_ids or evaluator_ids),
+        "requested_pair_count": requested_pair_count,
         "triggered_pair_count": len(pairs),
         "scored_pair_count": len(scored_pair_keys),
+        "skipped_pair_count": len(skipped_pairs),
         "skipped_unassigned_count": len(skipped_unassigned),
         "all_perfect": all_perfect,
         "result_count": len(result_summaries),
         "non_perfect_count": len(non_perfect),
         "wrote_full_detail": bool(args.out),
         "trigger_response": trigger_response,
+        "skipped_pairs": skipped_pairs,
         "skipped_unassigned": skipped_unassigned,
         "results": result_summaries,
     }
     full_out = {
         "agent_id": args.agent,
         "history_id": args.history,
+        "requested_pairs": requested_pairs,
         "triggered_pairs": pairs,
         "trigger_response": trigger_response,
+        "skipped_pairs": skipped_pairs,
         "skipped_unassigned": skipped_unassigned,
         "all_perfect": all_perfect,
         "results": flat,
@@ -1284,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 = [
@@ -1310,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))
 
@@ -1466,35 +1560,44 @@ def run_rubrics(args, client) -> int:
         log("error: no cases for this agent")
         return 2
 
-    assignment_rows = eval_mod.get_case_evaluator_infos(client, case_ids=case_ids)
-    assigned_by_case = _assigned_evaluators_by_case(assignment_rows)
-
     if args.evaluators:
         evaluator_ids = _ids(args.evaluators) or []
         evaluators = [eval_mod.get_evaluator(client, eid) for eid in evaluator_ids]
-    elif args.all_pairs:
+    else:
         evaluators = eval_mod.list_evaluators(client, workspace_id)
         evaluator_ids = [e["id"] for e in evaluators]
+
+    rubrics = eval_mod.get_case_rubrics(
+        client, agent_id=args.agent, workspace_id=workspace_id,
+        evaluator_ids=evaluator_ids, case_ids=case_ids,
+    )
+    assigned_by_case = {
+        cid: {
+            ev_id: {"evaluator_id": ev_id, "rubric": rubric_text}
+            for ev_id, rubric_text in (rubrics.get(cid) or {}).items()
+            if rubric_text
+        }
+        for cid in case_ids
+    }
+
+    if args.evaluators or args.all_pairs:
+        pass
     else:
         evaluator_ids = _dedupe_preserve_order([
             evaluator_id
             for case_id in case_ids
             for evaluator_id in assigned_by_case.get(case_id, {})
         ])
-        evaluators = [eval_mod.get_evaluator(client, eid) for eid in evaluator_ids]
+        evaluator_id_set = set(evaluator_ids)
+        evaluators = [e for e in evaluators if e["id"] in evaluator_id_set]
     evaluator_name = {e["id"]: e.get("name", e["id"]) for e in evaluators}
     if not evaluator_ids:
-        log("error: no assigned evaluators for these cases")
+        log("error: no evaluators with configured rubrics for these cases")
         return 2
 
-    mode = "all requested pairs" if args.evaluators or args.all_pairs else "assigned pairs"
+    mode = "all requested pairs" if args.evaluators or args.all_pairs else "pairs with configured rubrics"
     log(f"reading {mode}: {len(case_ids)} cases, {len(evaluator_ids)} evaluators...")
 
-    rubrics = eval_mod.get_case_rubrics(
-        client, agent_id=args.agent, workspace_id=workspace_id,
-        evaluator_ids=evaluator_ids, case_ids=case_ids,
-    )
-
     if args.full:
         for cid in case_ids:
             log("=" * 80)

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/eval_.py

@@ -54,8 +54,26 @@ def create_case(
     return client.post("/external/eval/cases", json=body)
 
 
+def _unwrap_list_response(value: Any, *keys: str) -> list[dict]:
+    """Normalize list endpoints that may return either a bare list or envelope."""
+    if isinstance(value, list):
+        return value
+    if isinstance(value, dict):
+        for key in keys:
+            rows = value.get(key)
+            if isinstance(rows, list):
+                return rows
+    return []
+
+
 def list_cases(client: CodeerClient, agent_id: str) -> list[dict]:
-    return client.get(f"/external/eval/agents/{agent_id}/cases")
+    return _unwrap_list_response(
+        client.get(f"/external/eval/agents/{agent_id}/cases"),
+        "cases",
+        "evaluation_cases",
+        "data",
+        "items",
+    )
 
 
 def get_case(client: CodeerClient, case_id: str) -> dict:
@@ -123,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(
@@ -152,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.7.dist-info → codeer_cli-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeer-cli
-Version: 0.1.7
+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.7.dist-info → codeer_cli-0.1.9.dist-info}/RECORD

@@ -1,23 +1,23 @@
-codeer_cli/__init__.py,sha256=-0gL8upoSsLAnXAfcRrwqZYJbwG0knzQoFf94O7Nc7c,1817
+codeer_cli/__init__.py,sha256=slzDQ-Le6vl5PrimV6ZKmcDcNsQ7my7yG-Is1JVlbi4,1851
 codeer_cli/_validate.py,sha256=pKUJa2TyTpERx5xmiYNZRn7tFqDxLZ2fF1rHAf1oz14,5415
 codeer_cli/agents.py,sha256=diodgiGhXlowEi8sbCzcSK1qSeCLF2fBe6QBs3Sq_x8,5617
-codeer_cli/chats.py,sha256=YVrZJhoa-d67o6tzX6riGXsbA-ehyhOxrZ8zRCcJNro,2675
-codeer_cli/cli.py,sha256=g-WR2D5MkaUdc13ZrpRCavXD1940CHE9eBELC034tic,4443
-codeer_cli/client.py,sha256=LpHVqf1IYNg1wFfIHnO9q4xg2h3IiGOitzCnvwB-Bcw,9809
+codeer_cli/chats.py,sha256=pww_AVByTh_AT2Td0gj2OomJrcw7D-cjDIpQ0ZQOlrM,2728
+codeer_cli/cli.py,sha256=tdHbAEqtfCWFVT1iecfWKh61P1IvjG59F9hfC4Srr0c,4455
+codeer_cli/client.py,sha256=x-5sx06dgS6P8siKOTCVNM8JlBST5e6PsOD83KKkpN8,12361
 codeer_cli/constants.py,sha256=D1pV3wCoqYybrKGKeoupYjjFWLfaFviKp1yL7oh6Qso,2323
-codeer_cli/eval_.py,sha256=XwmPxNOtxSyZq2EOae9FZe5NFp0YyVbIswTn22S8noc,17050
+codeer_cli/eval_.py,sha256=2Tz4qokctocZ0fqLYL8Sk9UV8yJ7p-9zYiUFljsRRCs,17478
 codeer_cli/histories.py,sha256=tk28git_peX4x703CIDU8u72JtlGaytyrtlHfxlK-7A,5979
 codeer_cli/kb.py,sha256=Ad4h65NByq5Rq5BTeMghLTKlWRhmOC2jxL0BaTGX3EM,10631
 codeer_cli/parse.py,sha256=qrjZn0MUTjGfucp4cwxy8Pt7WS-0x15kK5F7kWTY8Ps,21818
 codeer_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codeer_cli/commands/_util.py,sha256=VOB_HMWYzHFNY1ElLOED1HB6fpFpsniqH6Yx3VUlMrY,1644
+codeer_cli/commands/_util.py,sha256=X9-9cYgnBYz94hVG4Pe9SsI97DHNv3HE5_7GlPMn93I,1708
 codeer_cli/commands/agent.py,sha256=amvfVVrbPOkbYKCGvA6EJB30C-aY6WSdfR7u7FklXbs,14793
 codeer_cli/commands/check.py,sha256=lTxolx1mIJ8jldPhJ5FXqie9nbCLVOO-sDPOHTSy1-w,3817
-codeer_cli/commands/eval_cmd.py,sha256=fQu8ZRzGO7GWL_Og9NeZ0xYwHoN_iocmCnWw-kPNRkc,68599
-codeer_cli/commands/history.py,sha256=Jv7t0GhSZcbZ8OuIXZT34CixXt7ECEVP3nZ-WW_Ya9E,12026
+codeer_cli/commands/eval_cmd.py,sha256=Zlt_YIA3D5-Y8WL1HZ6PxZgL-TcwFTDoXvO2gv7yfOM,71989
+codeer_cli/commands/history.py,sha256=bVBlCMStTvTxG23bggASHkHKuI0RMPdiXjcrs3U04yw,16081
 codeer_cli/commands/kb.py,sha256=kVEinBVM6NN8_0djOqIQErh46dLmArwFngXMNzvGeAI,28345
 codeer_cli/commands/profile.py,sha256=IdlXC_6cqobsfN3JRrAnt-1OgBUsIFneS9QtR4Un6Kc,6521
-codeer_cli-0.1.7.dist-info/METADATA,sha256=z8yvV20PQ1ysK27LpsMuurXdAPWJ4Kz-o9-LuxrHczg,5999
-codeer_cli-0.1.7.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-codeer_cli-0.1.7.dist-info/entry_points.txt,sha256=-nXIrlm5SR5r7gg3y8AS0tN66MwmvNHsrlwLNQNGD50,47
-codeer_cli-0.1.7.dist-info/RECORD,,
+codeer_cli-0.1.9.dist-info/METADATA,sha256=XlAf4gazUUSZ8uk9YRBxOYCiJ-C13Tru02G548cqI5M,6605
+codeer_cli-0.1.9.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+codeer_cli-0.1.9.dist-info/entry_points.txt,sha256=-nXIrlm5SR5r7gg3y8AS0tN66MwmvNHsrlwLNQNGD50,47
+codeer_cli-0.1.9.dist-info/RECORD,,