@scemoon/cdh 1.0.0 → 1.0.4

package/onecode/models/providers/minimaxi_provider.py

@@ -10,13 +10,13 @@ from typing import AsyncIterator, Callable, Optional
 import httpx
 
 from onecode.models.errors import (
-    ProviderError, TransientProviderError, retry_after_seconds,
+    ProviderError, TransientProviderError, retry_after_seconds, safe_error_msg,
 )
 from onecode.models.provider import ChatResponse, Message, ModelResponse, Provider, ProviderRegistry
 
 logger = logging.getLogger("onecode.provider.minimaxi")
 
-LOG_DIR = Path.home() / ".onecode" / "logs"
+LOG_DIR = Path.home() / ".cdh" / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 
 
@@ -111,12 +111,27 @@ class MiniMaxiProvider(Provider):
         self._endpoint = endpoint or "https://api.minimaxi.com/v1"
         self._request_count = 0
 
+    def _pick_default_model(self, requested: str) -> str:
+        """Resolve the effective default model.
+
+        ``cn-cp-`` prefixed keys belong to the ``minimax-cn-coding-plan``
+        tier and must use ``MiniMax-M3``.  Any other key keeps the
+        requested model (or the historical ``MiniMax-M2.7`` fallback).
+        """
+        if requested and requested != "MiniMax-M2.7":
+            return requested
+        key = (self.api_key or "").strip()
+        if key.startswith("cn-cp-"):
+            return "MiniMax-M3"
+        return requested or "MiniMax-M2.7"
+
     def is_anthropic_style(self) -> bool:
         return False
 
     async def chat(
-        self, messages: list[Message], model: str = "MiniMax-M2.7", **kwargs
+        self, messages: list[Message], model: str = "", **kwargs
     ) -> ModelResponse:
+        model = self._pick_default_model(model)
         self._request_count += 1
         req_id = f"req_{self._request_count}_{int(time.time())}"
         logger.info(f"[{req_id}] chat() called with model={model}, messages={len(messages)}")
@@ -133,17 +148,27 @@ class MiniMaxiProvider(Provider):
         try:
             async with httpx.AsyncClient(timeout=120) as client:
                 logger.info(f"[{req_id}] Sending request to {self._endpoint}/chat/completions")
+                outgoing_payload = {
+                    "model": model,
+                    "messages": self.prepare_messages(messages),
+                    **kwargs,
+                }
+                # Debug-only: log the post-`prepare_messages` wire payload
+                # so we can see exactly which messages reach the gateway
+                # when the upstream returns (2013) or any other 400.
+                # Disabled at INFO/WARN — set log_level: debug to enable.
+                logger.debug(
+                    "[%s] OUTGOING PAYLOAD (chat):\n%s",
+                    req_id,
+                    json.dumps(outgoing_payload, ensure_ascii=False, indent=2),
+                )
                 resp = await client.post(
                     f"{self._endpoint}/chat/completions",
                     headers={
                         "Authorization": f"Bearer {key}",
                         "content-type": "application/json",
                     },
-                    json={
-                        "model": model,
-                        "messages": self.prepare_messages(messages),
-                        **kwargs,
-                    },
+                    json=outgoing_payload,
                 )
                 elapsed = time.time() - start_time
                 logger.info(f"[{req_id}] Response status: {resp.status_code}, elapsed: {elapsed:.2f}s")
@@ -152,10 +177,14 @@ class MiniMaxiProvider(Provider):
                     error_text = resp.text
                     logger.error(f"[{req_id}] Non-2xx HTTP {resp.status_code}: {error_text[:500]}")
                     _log_request(model, messages, error=f"HTTP {resp.status_code}: {error_text[:500]}")
-                    raise Provider.classify_http_error(
+                    classified = Provider.classify_http_error(
                         resp.status_code, error_text,
                         retry_after=retry_after_seconds(resp),
                     )
+                    body_excerpt = (error_text or "").strip()[:200]
+                    if body_excerpt and classified.__class__.__name__ == "ProviderError":
+                        classified.args = (f"{classified.args[0]}: {body_excerpt}",)
+                    raise classified
 
                 data = resp.json()
                 choice = data.get("choices", [{}])[0]
@@ -178,7 +207,7 @@ class MiniMaxiProvider(Provider):
             _log_request(model, messages, error=error_msg)
             raise TransientProviderError(error_msg) from e
         except Exception as e:
-            error_msg = f"Error: {e}"
+            error_msg = f"Error: {safe_error_msg(e)}"
             logger.exception(f"[{req_id}] {error_msg}")
             _log_request(model, messages, error=error_msg)
             raise TransientProviderError(error_msg) from e
@@ -209,6 +238,21 @@ class MiniMaxiProvider(Provider):
 
         try:
             async with httpx.AsyncClient(timeout=300) as client:
+                outgoing_payload = {
+                    "model": model,
+                    "messages": self.prepare_messages(messages),
+                    "stream": True,
+                    **kwargs,
+                }
+                # Debug-only: log the post-`prepare_messages` wire payload
+                # so we can see exactly which messages reach the gateway
+                # when the upstream returns (2013) or any other 400.
+                # Disabled at INFO/WARN — set log_level: debug to enable.
+                logger.debug(
+                    "[%s] OUTGOING PAYLOAD (chat_stream_response):\n%s",
+                    req_id,
+                    json.dumps(outgoing_payload, ensure_ascii=False, indent=2),
+                )
                 async with client.stream(
                     "POST",
                     f"{self._endpoint}/chat/completions",
@@ -216,12 +260,7 @@ class MiniMaxiProvider(Provider):
                         "Authorization": f"Bearer {key}",
                         "Content-Type": "application/json",
                     },
-                    json={
-                        "model": model,
-                        "messages": self.prepare_messages(messages),
-                        "stream": True,
-                        **kwargs,
-                    },
+                    json=outgoing_payload,
                 ) as resp:
                     if resp.status_code >= 400:
                         error_body = (await resp.aread()).decode("utf-8", errors="replace")
@@ -269,7 +308,7 @@ class MiniMaxiProvider(Provider):
             _log_request(model, messages, error=error_msg)
             raise TransientProviderError(error_msg) from e
         except Exception as e:
-            error_msg = f"Error: {e}"
+            error_msg = f"Error: {safe_error_msg(e)}"
             logger.exception(f"[{req_id}] {error_msg}")
             _log_request(model, messages, error=error_msg)
             raise TransientProviderError(error_msg) from e
@@ -280,8 +319,9 @@ class MiniMaxiProvider(Provider):
         return ChatResponse(content="".join(content_parts), tool_uses=tool_uses)
 
     async def chat_stream(
-        self, messages: list[Message], model: str = "MiniMax-M2.7", **kwargs
+        self, messages: list[Message], model: str = "", **kwargs
     ) -> AsyncIterator[str]:
+        model = self._pick_default_model(model)
         self._request_count += 1
         req_id = f"req_{self._request_count}_{int(time.time())}"
         logger.info(f"[{req_id}] chat_stream() called with model={model}, messages={len(messages)}")
@@ -303,6 +343,17 @@ class MiniMaxiProvider(Provider):
                 logger.info(f"[{req_id}] Sending stream request to {self._endpoint}/chat/completions")
                 logger.info(f"[{req_id}] Request: model={model}, messages_count={len(messages)}")
 
+                outgoing_payload = {
+                    "model": model,
+                    "messages": self.prepare_messages(messages),
+                    "stream": True,
+                }
+                # Debug-only: same wire-payload log as chat() — see comment above.
+                logger.debug(
+                    "[%s] OUTGOING PAYLOAD (chat_stream):\n%s",
+                    req_id,
+                    json.dumps(outgoing_payload, ensure_ascii=False, indent=2),
+                )
                 async with client.stream(
                     "POST",
                     f"{self._endpoint}/chat/completions",
@@ -310,11 +361,7 @@ class MiniMaxiProvider(Provider):
                         "Authorization": f"Bearer {key}",
                         "Content-Type": "application/json",
                     },
-                    json={
-                        "model": model,
-                        "messages": self.prepare_messages(messages),
-                        "stream": True,
-                    },
+                    json=outgoing_payload,
                 ) as resp:
                     logger.info(f"[{req_id}] Stream response status: {resp.status_code}")
                     if resp.status_code != 200:
@@ -322,10 +369,14 @@ class MiniMaxiProvider(Provider):
                         error_text = error_body.decode("utf-8", errors="replace")
                         logger.error(f"[{req_id}] Stream error HTTP {resp.status_code}: {error_text[:1000]}")
                         _log_request(model, messages, error=f"HTTP {resp.status_code}: {error_text[:500]}")
-                        raise Provider.classify_http_error(
+                        classified = Provider.classify_http_error(
                             resp.status_code, error_text,
                             retry_after=retry_after_seconds(resp),
                         )
+                        body_excerpt = error_text.strip()[:200]
+                        if body_excerpt and classified.__class__.__name__ == "ProviderError":
+                            classified.args = (f"{classified.args[0]}: {body_excerpt}",)
+                        raise classified
 
                     async for line in resp.aiter_lines():
                         if line.startswith("data: ") and line[6:] != "[DONE]":
@@ -352,7 +403,7 @@ class MiniMaxiProvider(Provider):
             _log_request(model, messages, error=error_msg)
             raise TransientProviderError(error_msg) from e
         except Exception as e:
-            error_msg = f"Error: {e}"
+            error_msg = f"Error: {safe_error_msg(e)}"
             logger.exception(f"[{req_id}] {error_msg}")
             _log_request(model, messages, error=error_msg)
             raise TransientProviderError(error_msg) from e

package/onecode/models/providers/ollama_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
 
 
@@ -89,7 +90,7 @@ class OllamaProvider(Provider):
                             if chunk.get("done"):
                                 break
         except Exception as e:
-            return ChatResponse(content=f"Error: {e}")
+            return ChatResponse(content=f"Error: {safe_error_msg(e)}")
         return ChatResponse(content="".join(content_parts))
 
 

package/onecode/models/providers/openai_provider.py

@@ -88,6 +88,8 @@ class OpenAIProvider(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", ""),
@@ -222,6 +224,8 @@ class OpenAIProvider(Provider):
                 inp = json.loads(nt.get("arguments", "{}"))
             except (json.JSONDecodeError, TypeError):
                 inp = {"raw": nt.get("arguments", "")}
+            if not isinstance(inp, dict):
+                inp = {"raw": inp}
             tool_uses.append({"id": nt["id"], "name": nt["name"], "input": inp})
 
         return ChatResponse(

package/onecode/tasks/manager.py

@@ -53,7 +53,7 @@ class TaskManager:
         self._tasks: dict[str, TaskRecord] = {}
         self._queue: asyncio.Queue[ExecutionTask] = asyncio.Queue()
         self._running: dict[str, asyncio.Task] = {}
-        self._storage_path = storage_path or Path.home() / ".onecode" / "tasks"
+        self._storage_path = storage_path or Path.home() / ".cdh" / "tasks"
         self._executor: Optional[TaskExecutor] = None
         self._worker_task: Optional[asyncio.Task] = None
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scemoon/cdh",
-  "version": "1.0.0",
+  "version": "1.0.4",
   "description": "Cloud Dev Harness - cloud-native development Agent framework",
   "keywords": ["ai", "agent", "cloud", "development", "cli", "tui"],
   "license": "MIT",

package/pyproject.toml

@@ -47,6 +47,16 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.packages.find]
 include = ["onecode*", "cdh*", "tui*"]
 
+[tool.setuptools.package-data]
+tui = [
+    "tui.tcss",
+    "screens/*.tcss",
+    "data/**/*",
+]
+onecode = [
+    "builtin_skills/**/*",
+]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 

package/run.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 const { spawn, execSync } = require('child_process');
 const path = require('path');
+const pkg = require('./package.json');
 
 function exec(cmd, opts = {}) {
   try {
@@ -33,9 +34,15 @@ function checkCdhInstalled(pythonCmd) {
 
 function run(pythonModule) {
   const PKG_DIR = __dirname;
-  const PYTHON_ENV_DIR = path.join(require('os').homedir(), '.onecode', 'python');
+  const PYTHON_ENV_DIR = path.join(require('os').homedir(), '.cdh', 'python');
 
-  const isPostinstall = process.argv.length <= 2;
+  const args = process.argv.slice(2);
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(pkg.version);
+    process.exit(0);
+  }
+
+  const isPostinstall = process.env.npm_lifecycle_event === 'postinstall' || process.env.npm_command === 'install';
   const py = checkPython();
 
   if (!py.ok) {
@@ -46,9 +53,13 @@ function run(pythonModule) {
       exec(`uv venv "${PYTHON_ENV_DIR}"`);
       const venvPython = path.join(PYTHON_ENV_DIR, 'bin', 'python');
       console.log('cdh: Installing cloud-dev-harness...');
-      exec(`"${venvPython}" -m pip install -e "${PKG_DIR}"`);
+      const r = exec(`uv pip install "${PKG_DIR}" --python "${venvPython}"`);
+      if (!r.ok) {
+        console.error('cdh: Install failed:', r.out);
+        process.exit(1);
+      }
       if (isPostinstall) {
-        console.log('cdh: Installed. Add to PATH: export PATH="$HOME/.onecode/python/bin:$PATH"');
+        console.log('cdh: Installed. Add to PATH: export PATH="$HOME/.cdh/python/bin:$PATH"');
         process.exit(0);
       }
       spawn(venvPython, ['-m', pythonModule, ...process.argv.slice(2)], { stdio: 'inherit' })
@@ -62,7 +73,13 @@ function run(pythonModule) {
 
   if (!checkCdhInstalled(py.pythonCmd)) {
     console.log('cdh: Installing cloud-dev-harness...');
-    exec(`${py.pythonCmd} -m pip install "${PKG_DIR}"`);
+    const r = checkUv()
+      ? exec(`uv pip install "${PKG_DIR}" --python "${py.pythonCmd}"`)
+      : exec(`${py.pythonCmd} -m pip install "${PKG_DIR}"`);
+    if (!r.ok) {
+      console.error('cdh: Install failed:', r.out);
+      process.exit(1);
+    }
   }
 
   if (isPostinstall) {
@@ -70,8 +87,8 @@ function run(pythonModule) {
     process.exit(0);
   }
 
-  const args = process.argv.slice(2).filter(a => !a.startsWith('--'));
-  const cmd = spawn(py.pythonCmd, ['-m', pythonModule, ...args], {
+  const passthroughArgs = process.argv.slice(2).filter(a => a !== '--version' && a !== '-v');
+  const cmd = spawn(py.pythonCmd, ['-m', pythonModule, ...passthroughArgs], {
     stdio: 'inherit',
     cwd: PKG_DIR,
   });

package/tui/acp/agent.py

@@ -277,8 +277,12 @@ class Agent(AgentBase):
                 "sessionUpdate": "subagent_start",
                 "subagentId": subagent_id,
                 "agentType": agent_type,
+                **rest,
             }:
-                self.post_message(messages.SubAgentStart(subagent_id, agent_type))
+                self.post_message(messages.SubAgentStart(
+                    subagent_id, agent_type,
+                    prompt=rest.get("prompt", ""),
+                ))
 
             case {
                 "sessionUpdate": "subagent_chunk",
@@ -287,12 +291,24 @@ class Agent(AgentBase):
             }:
                 self.post_message(messages.SubAgentChunk(subagent_id, text))
 
+            case {
+                "sessionUpdate": "subagent_thinking",
+                "subagentId": subagent_id,
+                "text": text,
+            }:
+                self.post_message(messages.SubAgentThinking(subagent_id, text))
+
             case {
                 "sessionUpdate": "subagent_end",
                 "subagentId": subagent_id,
                 "agentType": agent_type,
+                **rest,
             }:
-                self.post_message(messages.SubAgentEnd(subagent_id, agent_type))
+                self.post_message(messages.SubAgentEnd(
+                    subagent_id, agent_type,
+                    status=rest.get("status", "completed"),
+                    error=rest.get("error", ""),
+                ))
 
         if status_line is not None:
             self.post_message(messages.UpdateStatusLine(status_line))
@@ -600,6 +616,15 @@ class Agent(AgentBase):
             db = DB()
             await db.session_update_last_used(self.session_pk)
 
+        # Save session before terminating
+        if self.session_id is not None:
+            try:
+                with self.request():
+                    response = api.session_save(self.session_id)
+                await asyncio.wait_for(response.wait(), timeout=3)
+            except Exception:
+                pass
+
         if self._process is not None:
             try:
                 self._process.terminate()
@@ -670,7 +695,7 @@ class Agent(AgentBase):
         await self._save_last_session_to_cdh()
 
     async def _save_last_session_to_cdh(self) -> None:
-        if self.session_pk is None:
+        if self.session_id is None:
             return
         try:
             from onecode.agent.cdh_loader import CdhProjectLoader
@@ -678,14 +703,13 @@ class Agent(AgentBase):
             cdh_dir = CdhProjectLoader.find_cdh_dir(self.project_root_path)
             if cdh_dir is None:
                 return
-            CdhProjectLoader.save_last_session(
-                cdh_dir,
-                {
-                    "agent_session_id": self.session_id,
-                    "session_pk": self.session_pk,
-                    "agent_identity": self._agent_data["identity"],
-                },
-            )
+            data: dict = {
+                "agent_session_id": self.session_id,
+                "agent_identity": self._agent_data["identity"],
+            }
+            if self.session_pk is not None:
+                data["session_pk"] = self.session_pk
+            CdhProjectLoader.save_last_session(cdh_dir, data)
         except Exception:
             pass
 
@@ -781,6 +805,11 @@ class Agent(AgentBase):
                         cwd = session_cwd
                     if agent_data := meta.get("agent_data"):
                         self._agent_data = agent_data
+        else:
+            db = DB()
+            if (session := await db.session_get_by_agent_session_id(self.session_id)) is not None:
+                self.session_pk = session["id"]
+                session_title = session.get("title") or "Untitled"
 
         with self.request():
             session_load_response = api.session_load(cwd, [], self.session_id)
@@ -801,6 +830,20 @@ class Agent(AgentBase):
             }
             self.post_message(messages.SetModes(current_mode, modes_update))
 
+        if self.session_pk is None:
+            self._pending_session_data = {
+                "session_name": session_title or "Untitled",
+                "agent_name": self._agent_data["name"],
+                "agent_identity": self._agent_data["identity"],
+                "session_id": self.session_id,
+                "protocol": "acp",
+                "meta": {
+                    "cwd": str(self.project_root_path),
+                    "agent_data": self._agent_data,
+                },
+            }
+            await self._ensure_db_session()
+
         if session_title:
             self.post_message(tui_messages.SessionUpdate(name=session_title))
 
@@ -870,6 +913,12 @@ class Agent(AgentBase):
             return
         db = DB()
         await db.session_update_title(self.session_pk, name)
+        if self.session_id:
+            from onecode.agent.session import AgentSession
+            session = AgentSession(self.session_id)
+            if session.load():
+                session.name = name
+                session.save()
         self.post_message(tui_messages.SessionUpdate(name=name))
 
     async def acp_session_cancel(self) -> bool:

package/tui/acp/api.py

@@ -53,3 +53,9 @@ def session_prompt(
 def session_set_mode(sessionId: str, modeId: str) -> protocol.SetSessionModeResponse:
     """https://agentclientprotocol.com/protocol/session-modes#from-the-client"""
     ...
+
+
+@API.method(name="session/save")
+def session_save(sessionId: str) -> dict:
+    """Save the session state."""
+    ...

package/tui/acp/messages.py

@@ -172,6 +172,7 @@ class SubAgentStart(AgentMessage):
 
     subagent_id: str
     agent_type: str
+    prompt: str = ""
 
 
 @dataclass
@@ -182,9 +183,19 @@ class SubAgentChunk(AgentMessage):
     text: str
 
 
+@dataclass
+class SubAgentThinking(AgentMessage):
+    """Sub-agent thinking block."""
+
+    subagent_id: str
+    text: str
+
+
 @dataclass
 class SubAgentEnd(AgentMessage):
     """Sub-agent task completed."""
 
     subagent_id: str
     agent_type: str
+    status: str = "completed"
+    error: str = ""

package/tui/acp/prompt.py

@@ -24,7 +24,7 @@ def cloud_spec_skill_loaded() -> bool:
 def ensure_cloud_spec_skill_installed() -> str | None:
     """Ensure cloud-spec-skill is accessible to agents.
 
-    Checks if SKILL.md exists in repo and copies it to ~/.onecode/skills/ if needed,
+    Checks if SKILL.md exists in repo and copies it to ~/.cdh/skills/ if needed,
     or updates if the repo version is newer.
     Returns error message if installation fails, None on success.
     """

package/tui/acp/protocol.py

@@ -321,6 +321,33 @@ class UsageUpdate(SchemaDict, total=False, extra_items=object):
     cost: Cost
 
 
+class SubAgentStart(SchemaDict, total=False, extra_items=Any):
+    sessionUpdate: Required[Literal["subagent_start"]]
+    subagentId: Required[str]
+    agentType: Required[str]
+    prompt: str
+
+
+class SubAgentChunk(SchemaDict, total=False, extra_items=Any):
+    sessionUpdate: Required[Literal["subagent_chunk"]]
+    subagentId: Required[str]
+    text: Required[str]
+
+
+class SubAgentThinking(SchemaDict, total=False, extra_items=Any):
+    sessionUpdate: Required[Literal["subagent_thinking"]]
+    subagentId: Required[str]
+    text: Required[str]
+
+
+class SubAgentEnd(SchemaDict, total=False, extra_items=Any):
+    sessionUpdate: Required[Literal["subagent_end"]]
+    subagentId: Required[str]
+    agentType: Required[str]
+    status: str
+    error: str
+
+
 type SessionUpdate = (
     UserMessageChunk
     | AgentMessageChunk
@@ -331,6 +358,10 @@ type SessionUpdate = (
     | AvailableCommandsUpdate
     | CurrentModeUpdate
     | UsageUpdate
+    | SubAgentStart
+    | SubAgentChunk
+    | SubAgentThinking
+    | SubAgentEnd
 )
 
 

package/tui/agents.py

@@ -28,14 +28,15 @@ async def read_agents() -> dict[str, Agent]:
             List of agent dicts.
         """
         agents: list[Agent] = []
-        try:
-            for file in files("tui.data").joinpath("agents").iterdir():
+        for file in files("tui.data").joinpath("agents").iterdir():
+            if file.name.startswith("."):
+                continue
+            try:
                 agent: Agent = tomllib.load(file.open("rb"))
-                if agent.get("active", True):
-                    agents.append(agent)
-
-        except Exception as error:
-            raise AgentReadError(f"Failed to read agents; {error}")
+            except Exception:
+                continue
+            if agent.get("active", True):
+                agents.append(agent)
 
         return agents