@scemoon/cdh 1.0.0 → 1.0.4

package/onecode/config.py

@@ -6,7 +6,7 @@ from typing import Any, Optional
 import yaml
 
 
-CLOUD_DEV_HARNESS_DIR = Path.home() / ".onecode"
+CLOUD_DEV_HARNESS_DIR = Path.home() / ".cdh"
 GLOBAL_CONFIG_PATH = CLOUD_DEV_HARNESS_DIR / "onecode.config.yaml"
 
 
@@ -22,7 +22,7 @@ class ObservabilityConfig:
     trace_enabled: bool = True
     trace_exporter: str = "file"
     otlp_endpoint: str = "http://localhost:4317"
-    trace_dir: str = "~/.onecode/traces"
+    trace_dir: str = "~/.cdh/traces"
 
 
 @dataclass
@@ -201,7 +201,7 @@ def _write_default_config():
             "trace_enabled": True,
             "trace_exporter": "file",
             "otlp_endpoint": "http://localhost:4317",
-            "trace_dir": "~/.onecode/traces",
+            "trace_dir": "~/.cdh/traces",
         },
         "attachments": {
             "max_size_mb": 10,

package/onecode/config_screen.py

@@ -160,7 +160,8 @@ class EditFieldScreen(ModalScreen[str]):
 
     @on(Button.Pressed, "#edit-save")
     def on_save(self) -> None:
-        self.dismiss(self.query_one("#edit-input", Input).value)
+        value = self.query_one("#edit-input", Input).value.strip()
+        self.dismiss(value or None)
 
     @on(Button.Pressed, "#edit-cancel")
     def on_cancel(self) -> None:
@@ -168,7 +169,8 @@ class EditFieldScreen(ModalScreen[str]):
 
     @on(Input.Submitted)
     def on_input_submitted(self) -> None:
-        self.dismiss(self.query_one("#edit-input", Input).value)
+        value = self.query_one("#edit-input", Input).value.strip()
+        self.dismiss(value or None)
 
     def action_dismiss_modal(self) -> None:
         self.dismiss(None)

package/onecode/models/errors.py

@@ -23,6 +23,16 @@ if TYPE_CHECKING:
     import httpx
 
 
+def safe_error_msg(e: BaseException) -> str:
+    """Return a non-empty error message from an exception.
+
+    Python's ``str(Exception())`` returns ``""``, which leads to
+    confusing ``"Error: "`` messages in the UI.  This helper falls
+    back to the exception type name when the message is empty.
+    """
+    return str(e) or type(e).__name__
+
+
 def retry_after_seconds(resp: "httpx.Response") -> Optional[float]:
     """Parse the ``Retry-After`` header from an HTTP response.
 
@@ -70,7 +80,7 @@ class ProviderError(Exception):
 
     def to_user_message(self) -> str:
         """Build a short, user-friendly message for the TUI."""
-        head = f"Error: {self.args[0]}" if self.args else "Error: provider failure"
+        head = f"Error: {safe_error_msg(self)}" if self.args else "Error: provider failure"
         if self.status_code is not None:
             head += f" (HTTP {self.status_code})"
         if self.retry_after is not None:

package/onecode/models/messages.py

@@ -78,7 +78,7 @@ class ToolCategory(str, Enum):
     WEB_FETCH = "web_fetch"
     WEB_SEARCH = "web_search"
     TASK = "task"              # sub-agent
-    TASK_MGMT = "task_mgmt"    # task/todo CRUD
+    TODO_MGMT = "todo_mgmt"    # todo CRUD
     INTERACTION = "interaction"  # user approval / AskUser
     UNKNOWN = "unknown"
 
@@ -95,19 +95,16 @@ TOOL_CATEGORY_MAP: dict[str, ToolCategory] = {
     "Bash": ToolCategory.BASH,
     "WebFetch": ToolCategory.WEB_FETCH,
     "WebSearch": ToolCategory.WEB_SEARCH,
-    "Task": ToolCategory.TASK,
+    "Spawn": ToolCategory.TASK,
     "SendMessage": ToolCategory.INTERACTION,
     "Agent": ToolCategory.TASK,
-    "ToolSearch": ToolCategory.TASK_MGMT,
-    "TaskCreate": ToolCategory.TASK_MGMT,
-    "TaskGet": ToolCategory.TASK_MGMT,
-    "TaskList": ToolCategory.TASK_MGMT,
-    "TaskUpdate": ToolCategory.TASK_MGMT,
-    "TaskOutput": ToolCategory.TASK_MGMT,
-    "TaskStop": ToolCategory.TASK_MGMT,
-    "TodoCreate": ToolCategory.TASK_MGMT,
-    "TodoList": ToolCategory.TASK_MGMT,
-    "TodoComplete": ToolCategory.TASK_MGMT,
+    "ToolSearch": ToolCategory.TODO_MGMT,
+    "TodoCreate": ToolCategory.TODO_MGMT,
+    "TodoGet": ToolCategory.TODO_MGMT,
+    "TodoList": ToolCategory.TODO_MGMT,
+    "TodoUpdate": ToolCategory.TODO_MGMT,
+    "TodoOutput": ToolCategory.TODO_MGMT,
+    "TodoStop": ToolCategory.TODO_MGMT,
     "AskUser": ToolCategory.INTERACTION,
 }
 
@@ -281,6 +278,7 @@ class StreamEventType(str, Enum):
     PLAN = "plan"
     SUBAGENT_START = "subagent_start"
     SUBAGENT_CHUNK = "subagent_chunk"
+    SUBAGENT_THINKING = "subagent_thinking"
     SUBAGENT_END = "subagent_end"
 
 
@@ -325,6 +323,10 @@ class StreamEvent:
     subagent_id: str = ""
     subagent_type: str = ""
     subagent_text: str = ""
+    subagent_prompt: str = ""
+    subagent_thinking_text: str = ""
+    subagent_status: str = ""
+    subagent_error: str = ""
 
     @classmethod
     def text_delta(cls, text: str) -> "StreamEvent":
@@ -403,18 +405,19 @@ class StreamEvent:
 
         Args:
             entries: List of plan entries, each with:
-                - content: str - The task description
+                - content: str - The todo description
                 - status: str - "pending" | "in_progress" | "completed"
                 - priority: str - "high" | "medium" | "low"
         """
         return cls(type=StreamEventType.PLAN, plan_entries=entries)
 
     @classmethod
-    def subagent_start(cls, agent_type: str, call_id: str) -> "StreamEvent":
+    def subagent_start(cls, agent_type: str, call_id: str, prompt: str = "") -> "StreamEvent":
         return cls(
             type=StreamEventType.SUBAGENT_START,
             subagent_id=call_id,
             subagent_type=agent_type,
+            subagent_prompt=prompt,
         )
 
     @classmethod
@@ -426,8 +429,24 @@ class StreamEvent:
         )
 
     @classmethod
-    def subagent_end(cls, call_id: str) -> "StreamEvent":
-        return cls(type=StreamEventType.SUBAGENT_END, subagent_id=call_id)
+    def subagent_thinking(cls, call_id: str, text: str) -> "StreamEvent":
+        return cls(
+            type=StreamEventType.SUBAGENT_THINKING,
+            subagent_id=call_id,
+            subagent_thinking_text=text,
+        )
+
+    @classmethod
+    def subagent_end(
+        cls, call_id: str, agent_type: str = "", status: str = "completed", error: str = ""
+    ) -> "StreamEvent":
+        return cls(
+            type=StreamEventType.SUBAGENT_END,
+            subagent_id=call_id,
+            subagent_type=agent_type,
+            subagent_status=status,
+            subagent_error=error,
+        )
 
     @staticmethod
     def is_text(event: "StreamEvent") -> bool:

package/onecode/models/provider.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from __future__ import annotations
 
+import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from enum import Enum
@@ -296,6 +297,8 @@ class ModelResponse:
 class Provider(ABC):
     name: str = ""
 
+    _prep_logger = logging.getLogger("onecode.provider.prepare")
+
     @abstractmethod
     async def chat(
         self, messages: list[Message], model: str, **kwargs
@@ -317,22 +320,245 @@ class Provider(ABC):
         return key or ""
 
     def prepare_messages(self, messages: list["Message"]) -> list[dict]:
-        """Prepare messages for API call. Handles tool, tool_use, tool_result blocks properly."""
-        system_parts = []
-        non_system = []
+        """Prepare messages for API call. Handles tool, tool_use, tool_result blocks properly.
+
+        Hardening applied before serialization:
+        1. Drop ``tool`` messages with empty content and no ``tool_call_id``
+           (the OpenAI-compatible API rejects these with HTTP 400).
+        2. Coalesce runs of consecutive identical ``user`` content into one
+           message (some MiniMax gateways reject back-to-back duplicates).
+        3. Cap the combined system-prompt length at 32 KiB, keeping the
+           highest-priority blocks (``AGENT_CONFIG`` → ``REACT_PHASE`` →
+           newest skills) and dropping older skill bodies first.
+        4. Drop ``tool`` messages whose ``tool_call_id`` is not present in
+           the immediately preceding assistant message's ``tool_calls`` —
+           the MiniMax gateway returns ``(2013) tool call result does not
+           follow tool call`` otherwise.
+        5. When a tool message is dropped (empty or orphan), also strip
+           the matching ``tool_call`` entry from the *owning* assistant
+           message — i.e. the assistant that originally emitted that
+           ``tool_call.id``.  Without this, the request still contains
+           an ``assistant.tool_calls`` reference with no following
+           ``tool`` result, which MiniMax rejects with the same (2013)
+           error (``tool call and result not match`` in the stricter
+           validator).  Tracking is per-id, not per-last-assistant, so
+           drops that span multiple turns (e.g. an empty result from
+           turn 1 and a legitimate one from turn 2) are each routed
+           back to the right assistant.
+        """
+        _SYSTEM_CAP_BYTES = 32 * 1024
+        log = Provider._prep_logger
+        dropped_empty_tools = 0
+        dropped_orphan_tools = 0
+        coalesced_user_msgs = 0
+
+        system_parts: list[tuple[str, str]] = []  # (marker, body)
+        non_system: list[dict] = []
 
         for m in messages:
             if m.role == "system":
-                system_parts.append(m.to_api_content())
+                body = m.to_api_content()
+                marker = ""
+                if "<!-- AGENT_CONFIG -->" in body:
+                    marker = "AGENT_CONFIG"
+                elif "<!-- REACT_PHASE -->" in body:
+                    marker = "REACT_PHASE"
+                elif "<!-- SKILL:" in body:
+                    marker = "SKILL"
+                elif "<!-- CDH_PROJECT -->" in body:
+                    marker = "CDH_PROJECT"
+                if body:
+                    system_parts.append((marker, body))
+            elif m.role == "tool":
+                api = m.to_api_dict()
+                has_id = bool(api.get("tool_call_id"))
+                has_content = bool((api.get("content") or "").strip())
+                if not has_id or not has_content:
+                    dropped_empty_tools += 1
+                    log.debug(
+                        "prepare_messages: dropped empty tool message (id=%r content_len=%d)",
+                        api.get("tool_call_id"),
+                        len(api.get("content") or ""),
+                    )
+                    continue
+                non_system.append(api)
             else:
                 non_system.append(m.to_api_dict())
 
-        if len(system_parts) > 1:
-            combined_system = "\n\n".join(system_parts)
-        elif system_parts:
-            combined_system = system_parts[0]
-        else:
-            combined_system = ""
+        coalesced: list[dict] = []
+        for msg in non_system:
+            if (
+                msg.get("role") == "user"
+                and coalesced
+                and coalesced[-1].get("role") == "user"
+                and (msg.get("content") or "") == (coalesced[-1].get("content") or "")
+                and not msg.get("tool_calls")
+                and not coalesced[-1].get("tool_calls")
+            ):
+                coalesced_user_msgs += 1
+                continue
+            coalesced.append(msg)
+        non_system = coalesced
+
+        # First pass: walk messages, drop orphan tool messages, and build
+        # a per-id map of ``tc_id -> owning assistant index`` so we know
+        # exactly which assistant emitted each ``tool_call`` entry.
+        linked: list[dict] = []
+        last_assistant_tc_ids: set[str] = set()
+        # Maps tool_call.id -> index in ``linked`` of the assistant that
+        # currently owns it.  Rebuilt whenever a new assistant message
+        # is appended (matches the same reset semantics as
+        # ``last_assistant_tc_ids``).
+        tc_owner: dict[str, int] = {}
+        for msg in non_system:
+            if msg.get("role") == "tool":
+                tcid = msg.get("tool_call_id") or ""
+                if tcid not in last_assistant_tc_ids:
+                    dropped_orphan_tools += 1
+                    log.debug(
+                        "prepare_messages: dropped orphan tool message "
+                        "(tool_call_id=%r not in preceding assistant.tool_calls)",
+                        tcid,
+                    )
+                    continue
+                linked.append(msg)
+                continue
+            new_index = len(linked)
+            linked.append(msg)
+            if msg.get("role") == "assistant":
+                last_assistant_tc_ids = {
+                    tc.get("id") for tc in (msg.get("tool_calls") or []) if tc.get("id")
+                }
+                for tc in msg.get("tool_calls") or []:
+                    tcid = tc.get("id")
+                    if tcid:
+                        tc_owner[tcid] = new_index
+            else:
+                last_assistant_tc_ids = set()
+        non_system = linked
+
+        # Second pass: any tool_call whose matching tool message was
+        # dropped (empty content caught above, or otherwise missing)
+        # must be removed from the *owning* assistant message — not just
+        # the last assistant.  We do this in two steps:
+        #   1. Walk the full list and collect every tool_call_id that
+        #      appears in any tool message — these are the "seen" ids.
+        #   2. Walk again and, for each assistant message, find any
+        #      tool_call.id that is NOT in the seen set.  Those are
+        #      dangling entries that must be stripped.
+        seen_tool_ids: set[str] = set()
+        for msg in non_system:
+            if msg.get("role") == "tool":
+                tcid = msg.get("tool_call_id") or ""
+                if tcid:
+                    seen_tool_ids.add(tcid)
+
+        dangling: dict[int, set[str]] = {}
+        for msg in non_system:
+            if msg.get("role") != "assistant":
+                continue
+            tcs = msg.get("tool_calls") or []
+            if not tcs:
+                continue
+            for tc in tcs:
+                tcid = tc.get("id") or ""
+                if tcid and tcid not in seen_tool_ids:
+                    owner_idx = tc_owner.get(tcid)
+                    if owner_idx is not None:
+                        dangling.setdefault(owner_idx, set()).add(tcid)
+        # Also strip tool_call entries with an empty id — those can
+        # never be matched to a tool result and would be silently
+        # dangling.  This mirrors the upstream filter in the first-pass
+        # tool tracking (``if tc.get("id")`` / ``if tcid``).
+        for msg in non_system:
+            if msg.get("role") != "assistant":
+                continue
+            tcs = msg.get("tool_calls") or []
+            if not tcs:
+                continue
+            kept = [tc for tc in tcs if tc.get("id")]
+            if len(kept) < len(tcs):
+                log.debug(
+                    "prepare_messages: stripped %d empty-id tool_call entr%s "
+                    "from assistant message",
+                    len(tcs) - len(kept),
+                    "y" if len(tcs) - len(kept) == 1 else "ies",
+                )
+                if kept:
+                    msg["tool_calls"] = kept
+                else:
+                    msg.pop("tool_calls", None)
+
+        # Apply the cleanup: strip dangling tool_call entries.  Empty
+        # ``tool_calls`` lists are removed entirely.
+        if dangling:
+            total_stripped = 0
+            for idx, ids in dangling.items():
+                assistant_msg = non_system[idx]
+                tcs = assistant_msg.get("tool_calls") or []
+                kept = [tc for tc in tcs if (tc.get("id") or "") not in ids]
+                stripped = len(tcs) - len(kept)
+                if stripped:
+                    total_stripped += stripped
+                    log.debug(
+                        "prepare_messages: stripped %d dangling tool_call entr%s "
+                        "from assistant message idx=%d (ids=%r)",
+                        stripped,
+                        "y" if stripped == 1 else "ies",
+                        idx,
+                        sorted(ids),
+                    )
+                    if kept:
+                        assistant_msg["tool_calls"] = kept
+                    else:
+                        assistant_msg.pop("tool_calls", None)
+            if total_stripped:
+                log.info(
+                    "prepare_messages(%s): stripped %d dangling tool_call entr%s across %d assistant message(s)",
+                    self.name or "?",
+                    total_stripped,
+                    "y" if total_stripped == 1 else "ies",
+                    len(dangling),
+                )
+
+        if dropped_empty_tools or dropped_orphan_tools or coalesced_user_msgs:
+            log.info(
+                "prepare_messages(%s): dropped empty_tools=%d orphan_tools=%d "
+                "coalesced_user=%d (input=%d output=%d)",
+                self.name or "?",
+                dropped_empty_tools,
+                dropped_orphan_tools,
+                coalesced_user_msgs,
+                len(messages),
+                len(non_system) + (1 if system_parts else 0),
+            )
+
+        combined_system = ""
+        if system_parts:
+            combined_parts = [body for _, body in system_parts]
+            combined_system = "\n\n".join(combined_parts)
+            if len(combined_system.encode("utf-8")) > _SYSTEM_CAP_BYTES:
+                priority = {"AGENT_CONFIG": 0, "REACT_PHASE": 1, "CDH_PROJECT": 2, "SKILL": 3}
+                ordered = sorted(
+                    range(len(system_parts)),
+                    key=lambda i: (priority.get(system_parts[i][0], 9), -i),
+                )
+                kept_indices: set[int] = set()
+                running = 0
+                for idx in ordered:
+                    marker, body = system_parts[idx]
+                    size = len(body.encode("utf-8")) + 2
+                    if marker == "AGENT_CONFIG":
+                        kept_indices.add(idx)
+                        running = max(running, size)
+                        continue
+                    if running + size <= _SYSTEM_CAP_BYTES:
+                        kept_indices.add(idx)
+                        running += size
+                kept = [body for i, body in enumerate(combined_parts) if i in kept_indices]
+                if not any("<!-- AGENT_CONFIG -->" in b for b in kept) and system_parts:
+                    kept.insert(0, system_parts[0][1])
+                combined_system = "\n\n".join(kept).encode("utf-8")[:_SYSTEM_CAP_BYTES].decode("utf-8", errors="ignore")
 
         if combined_system:
             non_system.insert(0, {"role": "system", "content": combined_system})
@@ -351,6 +577,8 @@ class Provider(ABC):
                 args = __import__("json").loads(func.get("arguments", "{}"))
             except Exception:
                 args = {"raw": func.get("arguments", "")}
+            if not isinstance(args, dict):
+                args = {"raw": args}
             result.append({
                 "id": tc.get("id", ""),
                 "name": func.get("name", ""),
@@ -412,6 +640,7 @@ class Provider(ABC):
             TransientProviderError,
         )
         snippet = (body or "").strip()
+        body_excerpt = snippet[:200] if snippet else ""
         if status_code == 429:
             return RateLimitError(
                 "rate limit exceeded", status_code=status_code,
@@ -426,11 +655,13 @@ class Provider(ABC):
                 "context length exceeded", status_code=status_code, body=snippet,
             )
         if 500 <= status_code < 600:
+            msg = f"upstream {status_code}: {body_excerpt}" if body_excerpt else f"upstream {status_code}"
             return TransientProviderError(
-                f"upstream {status_code}", status_code=status_code, body=snippet,
+                msg, status_code=status_code, body=snippet,
             )
+        msg = f"upstream error {status_code}: {body_excerpt}" if body_excerpt else f"upstream error {status_code}"
         return ProviderError(
-            f"upstream error {status_code}", status_code=status_code, body=snippet,
+            msg, status_code=status_code, body=snippet,
         )
 
 

package/onecode/models/providers/anthropic_provider.py

@@ -118,7 +118,7 @@ class AnthropicProvider(Provider):
         **kwargs,
     ) -> ChatResponse:
         from onecode.models.errors import (
-            ProviderError, TransientProviderError, retry_after_seconds,
+            ProviderError, TransientProviderError, retry_after_seconds, safe_error_msg,
         )
         key = self.resolve_api_key(self.api_key)
         if not key:
@@ -198,6 +198,8 @@ class AnthropicProvider(Provider):
                                         current_tool["input"] = json.loads(current_tool["input_json"])
                                     except (json.JSONDecodeError, TypeError):
                                         current_tool["input"] = {"raw": current_tool["input_json"]}
+                                    if not isinstance(current_tool["input"], dict):
+                                        current_tool["input"] = {"raw": current_tool["input"]}
                                     tool_uses.append({
                                         "id": current_tool["id"],
                                         "name": current_tool["name"],
@@ -212,7 +214,7 @@ class AnthropicProvider(Provider):
         except httpx.ConnectError as e:
             raise TransientProviderError(f"Connection error: {e}") from e
         except Exception as e:
-            raise TransientProviderError(f"Error: {e}") from e
+            raise TransientProviderError(f"Error: {safe_error_msg(e)}") from e
 
         return ChatResponse(
             content="".join(content_parts),

package/onecode/models/providers/deepseek_provider.py

@@ -65,6 +65,8 @@ class DeepSeekProvider(Provider):
                     args = __import__("json").loads(func.get("arguments", "{}"))
                 except Exception:
                     args = {"raw": func.get("arguments", "")}
+                if not isinstance(args, dict):
+                    args = {"raw": args}
                 content_blocks.append({
                     "type": "tool_use",
                     "id": tc.get("id", ""),

package/onecode/models/providers/glm_provider.py

@@ -5,6 +5,7 @@ from typing import AsyncIterator, Callable, Optional
 
 import httpx
 
+from onecode.models.errors import safe_error_msg
 from onecode.models.provider import ChatResponse, Message, ModelResponse, Provider, ProviderRegistry
 
 
@@ -132,7 +133,7 @@ class GLMProvider(Provider):
                                 if on_tool_call_delta:
                                     on_tool_call_delta(slot.get("id", ""), slot.get("name", ""), args_delta)
         except Exception as e:
-            return ChatResponse(content=f"Error: {e}")
+            return ChatResponse(content=f"Error: {safe_error_msg(e)}")
         tool_uses = []
         for slot in stream_tool_calls.values():
             name = slot.get("name") or ""

package/onecode/models/providers/minimax_provider.py

@@ -5,6 +5,7 @@ from typing import AsyncIterator, Callable, Optional
 
 import httpx
 
+from onecode.models.errors import safe_error_msg
 from onecode.models.provider import ChatResponse, Message, ModelResponse, Provider, ProviderRegistry
 
 
@@ -132,7 +133,7 @@ class MiniMaxProvider(Provider):
                                 if on_tool_call_delta:
                                     on_tool_call_delta(slot.get("id", ""), slot.get("name", ""), args_delta)
         except Exception as e:
-            return ChatResponse(content=f"Error: {e}")
+            return ChatResponse(content=f"Error: {safe_error_msg(e)}")
         tool_uses = []
         for slot in stream_tool_calls.values():
             name = slot.get("name") or ""