@scemoon/cdh 1.0.4 → 1.0.6

package/onecode/models/messages.py

@@ -105,6 +105,7 @@ TOOL_CATEGORY_MAP: dict[str, ToolCategory] = {
     "TodoUpdate": ToolCategory.TODO_MGMT,
     "TodoOutput": ToolCategory.TODO_MGMT,
     "TodoStop": ToolCategory.TODO_MGMT,
+    "TodoClear": ToolCategory.TODO_MGMT,
     "AskUser": ToolCategory.INTERACTION,
 }
 
@@ -280,6 +281,11 @@ class StreamEventType(str, Enum):
     SUBAGENT_CHUNK = "subagent_chunk"
     SUBAGENT_THINKING = "subagent_thinking"
     SUBAGENT_END = "subagent_end"
+    # A tool invoked *inside* a subagent, forwarded to the parent so the TUI
+    # can render it as a real ToolCall card inside the SubAgent widget (same
+    # style as main-conversation tools) instead of a plain "[Tool: X]" line.
+    SUBAGENT_TOOL_CALL = "subagent_tool_call"
+    SUBAGENT_TOOL_RESULT = "subagent_tool_result"
 
 
 @dataclass
@@ -327,6 +333,10 @@ class StreamEvent:
     subagent_thinking_text: str = ""
     subagent_status: str = ""
     subagent_error: str = ""
+    # SUBAGENT_TOOL_CALL fields ("start" | "complete"; reuses tool_id/name/
+    # category/args). SUBAGENT_TOOL_RESULT reuses tool_id/result_* and needs
+    # tool_name for display when no prior TOOL_CALL_COMPLETE was captured.
+    subagent_tool_phase: str = ""
 
     @classmethod
     def text_delta(cls, text: str) -> "StreamEvent":
@@ -448,6 +458,54 @@ class StreamEvent:
             subagent_error=error,
         )
 
+    @classmethod
+    def subagent_tool_call(
+        cls,
+        subagent_id: str,
+        phase: str,
+        tool_id: str,
+        tool_name: str,
+        tool_category: ToolCategory = ToolCategory.UNKNOWN,
+        tool_args: dict[str, Any] | None = None,
+    ) -> "StreamEvent":
+        """A tool invocation *inside* a subagent.
+
+        ``phase`` is ``"start"`` (model began the call) or ``"complete"``
+        (args fully streamed). Carries the parent Spawn ``subagent_id`` so
+        the ACP can tag the emitted ``tool_call`` sessionUpdate and the TUI
+        can mount the card inside the owning SubAgent widget.
+        """
+        return cls(
+            type=StreamEventType.SUBAGENT_TOOL_CALL,
+            subagent_id=subagent_id,
+            subagent_tool_phase=phase,
+            tool_id=tool_id,
+            tool_name=tool_name,
+            tool_category=tool_category,
+            tool_args=tool_args or {},
+        )
+
+    @classmethod
+    def subagent_tool_result(
+        cls,
+        subagent_id: str,
+        tool_id: str,
+        tool_name: str,
+        result_content: str,
+        is_error: bool = False,
+        category: ToolCategory = ToolCategory.UNKNOWN,
+    ) -> "StreamEvent":
+        """Result of a tool invoked *inside* a subagent."""
+        return cls(
+            type=StreamEventType.SUBAGENT_TOOL_RESULT,
+            subagent_id=subagent_id,
+            tool_id=tool_id,
+            tool_name=tool_name,
+            result_content=result_content,
+            result_is_error=is_error,
+            result_category=category,
+        )
+
     @staticmethod
     def is_text(event: "StreamEvent") -> bool:
         return event.type in (StreamEventType.TEXT_DELTA, StreamEventType.THINKING)

package/onecode/models/provider.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
@@ -592,6 +593,15 @@ class Provider(ABC):
         """Whether this provider uses Anthropic-style 'system' kwarg."""
         return False
 
+    def supports_native_tools(self) -> bool:
+        """Whether this provider accepts structured tools param in API calls.
+
+        When True, TOOL_DESCRIPTIONS prose in the system prompt is skipped
+        because the provider's native tool schema (passed via the ``tools``
+        kwarg to ``chat_stream_response``) provides equivalent information.
+        """
+        return True
+
     async def chat_stream_response(
         self,
         messages: list[Message],
@@ -605,7 +615,15 @@ class Provider(ABC):
         Default implementation: falls back to chat() for providers that
         don't implement structured streaming.
         """
-        response = await self.chat(messages, model=model, **kwargs)
+        logging.getLogger("onecode.models.provider").warning(
+            "[PROVIDER-STREAM] %s does not override chat_stream_response — "
+            "falling back to non-streaming chat() (on_text_chunk will NOT fire)",
+            type(self).__name__,
+        )
+        response = await asyncio.wait_for(
+            self.chat(messages, model=model, **kwargs),
+            timeout=300,
+        )
         return ChatResponse(
             content=response.get_text(),
             tool_uses=[
@@ -625,7 +643,7 @@ class Provider(ABC):
         body: str,
         *,
         retry_after: Optional[float] = None,
-    ) -> "ProviderError":
+    ) -> "ProviderError":  # noqa: F821
         """Convert an upstream HTTP error into the most specific
         :class:`ProviderError` subclass.
 

package/onecode/models/providers/anthropic_provider.py

@@ -58,6 +58,25 @@ class AnthropicProvider(Provider):
                 model=model,
             )
         async with httpx.AsyncClient(timeout=120) as client:
+            prepared = self.prepare_messages(messages)
+            system_content = None
+            filtered_messages = []
+            for msg in prepared:
+                if msg.get("role") == "system":
+                    system_content = msg["content"]
+                else:
+                    filtered_messages.append(msg)
+            api_body = {
+                "model": model,
+                "max_tokens": kwargs.get("max_tokens", 4096),
+                "messages": filtered_messages,
+            }
+            if system_content:
+                api_body["system"] = [{
+                    "type": "text",
+                    "text": system_content,
+                    "cache_control": {"type": "ephemeral"},
+                }]
             resp = await client.post(
                 f"{self._endpoint}/messages",
                 headers={
@@ -65,11 +84,7 @@ class AnthropicProvider(Provider):
                     "anthropic-version": "2023-06-01",
                     "content-type": "application/json",
                 },
-                json={
-                    "model": model,
-                    "max_tokens": kwargs.get("max_tokens", 4096),
-                    "messages": self.prepare_messages(messages),
-                },
+                json=api_body,
             )
             data = resp.json()
             return ModelResponse(
@@ -87,6 +102,26 @@ class AnthropicProvider(Provider):
             yield "API key not configured."
             return
         async with httpx.AsyncClient(timeout=300) as client:
+            prepared_cs = self.prepare_messages(messages)
+            system_content_cs = None
+            filtered_cs = []
+            for msg in prepared_cs:
+                if msg.get("role") == "system":
+                    system_content_cs = msg["content"]
+                else:
+                    filtered_cs.append(msg)
+            body_cs = {
+                "model": model,
+                "max_tokens": kwargs.get("max_tokens", 4096),
+                "messages": filtered_cs,
+                "stream": True,
+            }
+            if system_content_cs:
+                body_cs["system"] = [{
+                    "type": "text",
+                    "text": system_content_cs,
+                    "cache_control": {"type": "ephemeral"},
+                }]
             async with client.stream(
                 "POST",
                 f"{self._endpoint}/messages",
@@ -95,12 +130,7 @@ class AnthropicProvider(Provider):
                     "anthropic-version": "2023-06-01",
                     "content-type": "application/json",
                 },
-                json={
-                    "model": model,
-                    "max_tokens": kwargs.get("max_tokens", 4096),
-                    "messages": self.prepare_messages(messages),
-                    "stream": True,
-                },
+                json=body_cs,
             ) as resp:
                 async for line in resp.aiter_lines():
                     if line.startswith("data: ") and line[6:] != "[DONE]":
@@ -131,12 +161,29 @@ class AnthropicProvider(Provider):
 
         try:
             async with httpx.AsyncClient(timeout=300) as client:
+                # Extract system message for Anthropic's separate ``system``
+                # parameter (enables prompt caching).
+                prepared = self.prepare_messages(messages)
+                system_content = None
+                filtered_messages = []
+                for msg in prepared:
+                    if msg.get("role") == "system":
+                        system_content = msg["content"]
+                    else:
+                        filtered_messages.append(msg)
+
                 body = {
                     "model": model,
                     "max_tokens": kwargs.get("max_tokens", 4096),
-                    "messages": self.prepare_messages(messages),
+                    "messages": filtered_messages,
                     "stream": True,
                 }
+                if system_content:
+                    body["system"] = [{
+                        "type": "text",
+                        "text": system_content,
+                        "cache_control": {"type": "ephemeral"},
+                    }]
                 tools = kwargs.get("tools")
                 if tools:
                     body["tools"] = tools

package/onecode/models/providers/glm_provider.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import json
+import logging
+import time
 from typing import AsyncIterator, Callable, Optional
 
 import httpx
@@ -8,6 +10,8 @@ import httpx
 from onecode.models.errors import safe_error_msg
 from onecode.models.provider import ChatResponse, Message, ModelResponse, Provider, ProviderRegistry
 
+logger = logging.getLogger("onecode.models.providers.glm")
+
 
 class GLMProvider(Provider):
     name = "glm"
@@ -92,6 +96,17 @@ class GLMProvider(Provider):
             return ChatResponse(content="API key not configured.")
         content_parts: list[str] = []
         stream_tool_calls: dict[int, dict] = {}
+        _n_msgs = len(messages)
+        _t0 = time.monotonic()
+        _first_byte_t: float | None = None
+        _chunk_n = 0
+        _text_n = 0
+        _bytes = 0
+        _on_text_cb = bool(on_text_chunk)
+        logger.debug(
+            "[GLM-STREAM] open model=%s msgs=%d on_text_chunk_cb=%s",
+            model, _n_msgs, _on_text_cb,
+        )
         try:
             async with httpx.AsyncClient(timeout=300) as client:
                 async with client.stream(
@@ -108,12 +123,27 @@ class GLMProvider(Provider):
                         **kwargs,
                     },
                 ) as resp:
+                    logger.debug(
+                        "[GLM-STREAM] stream opened status=%d t=%.2fs",
+                        resp.status_code, time.monotonic() - _t0,
+                    )
                     async for line in resp.aiter_lines():
+                        if not line:
+                            continue
+                        _chunk_n += 1
                         if line.startswith("data: ") and line[6:] != "[DONE]":
                             chunk = json.loads(line[6:])
                             delta = chunk.get("choices", [{}])[0].get("delta", {})
                             text = delta.get("content", "")
                             if text:
+                                if _first_byte_t is None:
+                                    _first_byte_t = time.monotonic() - _t0
+                                    logger.debug(
+                                        "[GLM-STREAM] first-byte t=%.2fs chunk#%d",
+                                        _first_byte_t, _chunk_n,
+                                    )
+                                _text_n += 1
+                                _bytes += len(text)
                                 content_parts.append(text)
                                 if on_text_chunk:
                                     on_text_chunk(text)
@@ -132,7 +162,17 @@ class GLMProvider(Provider):
                                 slot["arguments"] += args_delta
                                 if on_tool_call_delta:
                                     on_tool_call_delta(slot.get("id", ""), slot.get("name", ""), args_delta)
+                    logger.debug(
+                        "[GLM-STREAM] stream done chunks=%d text_chunks=%d "
+                        "bytes=%d on_text_cb=%s t=%.2fs",
+                        _chunk_n, _text_n, _bytes, _on_text_cb,
+                        time.monotonic() - _t0,
+                    )
         except Exception as e:
+            logger.exception(
+                "[GLM-STREAM] EXCEPTION t=%.2fs chunks=%d text_chunks=%d: %s",
+                time.monotonic() - _t0, _chunk_n, _text_n, e,
+            )
             return ChatResponse(content=f"Error: {safe_error_msg(e)}")
         tool_uses = []
         for slot in stream_tool_calls.values():

package/onecode/models/providers/minimax_provider.py

@@ -19,6 +19,9 @@ class MiniMaxProvider(Provider):
     def is_anthropic_style(self) -> bool:
         return False
 
+    def supports_native_tools(self) -> bool:
+        return False
+
     async def chat(
         self, messages: list[Message], model: str = "MiniMax-M2.7", **kwargs
     ) -> ModelResponse:

package/onecode/models/providers/minimaxi_provider.py

@@ -128,6 +128,9 @@ class MiniMaxiProvider(Provider):
     def is_anthropic_style(self) -> bool:
         return False
 
+    def supports_native_tools(self) -> bool:
+        return False
+
     async def chat(
         self, messages: list[Message], model: str = "", **kwargs
     ) -> ModelResponse:

package/onecode/models/providers/ollama_provider.py

@@ -18,6 +18,9 @@ class OllamaProvider(Provider):
     def is_anthropic_style(self) -> bool:
         return False
 
+    def supports_native_tools(self) -> bool:
+        return False
+
     async def chat(
         self, messages: list[Message], model: str = "llama2", **kwargs
     ) -> ModelResponse:

package/onecode/server/app.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
-from typing import Any, Optional
+from typing import Optional
 
 from starlette.applications import Starlette
 from starlette.responses import JSONResponse, Response

package/onecode/skills/argument_substitution.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import re
-from typing import Any
 
 
 _PATH_RE = re.compile(r'\$path')

package/onecode/skills/bootstrap.py

@@ -0,0 +1,124 @@
+"""onecode bootstrap — ensures ai-dlc-skill is installed in the cdh platform pool.
+
+Called at onecode startup (or cdh launch) to sync the ai-dlc-skill version
+from the repository source (ai-dlc-skill/) to ~/.cdh/skills/ai-dlc-skill/.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from cdh.cdh_skill_manager import CdhSkillManager
+
+logger = logging.getLogger("onecode.skills.bootstrap")
+
+SKILL_SOURCE_NAME = "ai-dlc-skill"
+DEFAULT_VERSION = "4.0.0"
+
+
+def get_source_skill_dir(workspace_root: Path) -> Optional[Path]:
+    """Walk up from workspace_root to find ai-dlc-skill/ directory."""
+    current = workspace_root.resolve()
+    # Check current directory
+    candidate = current / SKILL_SOURCE_NAME
+    if candidate.is_dir() and (candidate / "skill.yaml").exists():
+        return candidate
+    # Check parent (if in a subdirectory)
+    candidate = current.parent / SKILL_SOURCE_NAME
+    if candidate.is_dir() and (candidate / "skill.yaml").exists():
+        return candidate
+    # Check git root
+    try:
+        git_root = next(
+            p for p in current.parents if (p / ".git").exists()
+        )
+        candidate = git_root / SKILL_SOURCE_NAME
+        if candidate.is_dir() and (candidate / "skill.yaml").exists():
+            return candidate
+    except StopIteration:
+        pass
+    return None
+
+
+def get_source_version(source_dir: Path) -> str:
+    """Read metadata.version from source skill.yaml."""
+    try:
+        skill_yaml = source_dir / "skill.yaml"
+        data = yaml.safe_load(skill_yaml.read_text(encoding="utf-8")) or {}
+        return data.get("metadata", {}).get("version", DEFAULT_VERSION)
+    except Exception:
+        return DEFAULT_VERSION
+
+
+def ensure_onecode_default_skills() -> None:
+    """Install built-in skills (git, shell) to ~/.onecode/skills/ on first run."""
+    from onecode.config import ONECODE_DIR
+
+    target_dir = ONECODE_DIR / "skills"
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    builtin_root = Path(__file__).resolve().parent.parent / "builtin_skills"
+    if not builtin_root.exists():
+        return
+
+    mgr = CdhSkillManager(skills_dir=target_dir)
+
+    for d in sorted(builtin_root.iterdir()):
+        if not d.is_dir():
+            continue
+        if not (d / "skill.yaml").exists():
+            continue
+        name = d.name
+        if mgr.get_installed_version(name) is not None:
+            continue
+        err = mgr.install(d)
+        if err:
+            logger.warning("default skill %s install failed: %s", name, err)
+        else:
+            logger.info("default skill %s installed \u2192 %s/%s", name, target_dir, name)
+
+
+def ensure_ai_dlc_skill(workspace_root: Path | None = None) -> None:
+    """Bootstrap ai-dlc-skill into cdh platform pool.
+
+    Compares source version with installed version. If missing or outdated,
+    installs via CdhSkillManager. Return value: None (logs warnings on failure).
+    """
+    root = workspace_root or Path.cwd()
+    mgr = CdhSkillManager()
+
+    # Check if already installed and up-to-date
+    installed_version = mgr.get_installed_version(SKILL_SOURCE_NAME)
+
+    # Find source directory
+    source_dir = get_source_skill_dir(root)
+    if source_dir is None:
+        if installed_version is None:
+            logger.warning(
+                "ai-dlc-skill source not found at %s/ai-dlc-skill/ and not installed; "
+                "install from repository root to enable AI-DLC methodology.",
+                root,
+            )
+        return
+
+    source_version = get_source_version(source_dir)
+
+    if installed_version == source_version:
+        logger.debug("ai-dlc-skill v%s is current, skipping install.", source_version)
+        return
+
+    # Install or update
+    err = mgr.install(source_dir)
+    if err:
+        logger.warning("ai-dlc-skill install failed: %s", err)
+    else:
+        logger.info(
+            "ai-dlc-skill installed v%s → %s/%s",
+            source_version,
+            mgr.skills_dir,
+            SKILL_SOURCE_NAME,
+        )

package/onecode/skills/loader.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import re
 from pathlib import Path
 from typing import Optional
 
@@ -9,18 +8,10 @@ import yaml
 from onecode.skills.frontmatter import parse_frontmatter
 from onecode.skills.model import Skill
 
-from onecode.config import CLOUD_DEV_HARNESS_DIR
+from onecode.config import ONECODE_DIR
 
 
-USER_SKILLS_DIR = CLOUD_DEV_HARNESS_DIR / "skills"
-
-
-SKILL_LOCATIONS = [
-    ("user", USER_SKILLS_DIR),
-    (".opencode", ".opencode/skills"),
-    (".claude", ".claude/skills"),
-    (".agents", ".agents/skills"),
-]
+USER_SKILLS_DIR = ONECODE_DIR / "skills"
 
 
 class SkillLoader:
@@ -31,50 +22,9 @@ class SkillLoader:
     def _get_search_dirs(self) -> list[tuple[str, Path]]:
         dirs = []
         if USER_SKILLS_DIR.exists():
-            dirs.append(("user", USER_SKILLS_DIR))
-
-        # Built-in skills packaged with onecode
-        builtin_dir = Path(__file__).resolve().parent.parent / "builtin_skills"
-        if builtin_dir.exists():
-            dirs.append(("builtin", builtin_dir))
-
-        # Project root-level directories containing SKILL.md
-        try:
-            for d in sorted(self._workspace_root.iterdir()):
-                if d.is_dir() and (d / "SKILL.md").exists():
-                    dirs.append(("project", self._workspace_root))
-                    break
-        except Exception:
-            pass
-
-        search_paths = [
-            (".opencode", ".claude", ".agents"),
-        ]
-        for group in search_paths:
-            for name in group:
-                pattern = f"{name}/skills"
-                for parent in self._walk_up_parents():
-                    candidate = parent / pattern
-                    if candidate.exists():
-                        dirs.append((f"{name}/skills", candidate))
-                        break
-
+            dirs.append(("onecode", USER_SKILLS_DIR))
         return dirs
 
-    def _walk_up_parents(self):
-        current = self._workspace_root.resolve()
-        yield current
-        try:
-            git_root = next(
-                (p for p in current.parents if (p / ".git").exists() or (p / ".hg").exists()),
-                None,
-            )
-            if git_root:
-                yield git_root
-        except StopIteration:
-            pass
-        yield Path.home()
-
     def _discover(self) -> dict[str, Skill]:
         if self._cache is not None:
             return self._cache
@@ -153,5 +103,37 @@ class SkillLoader:
             if s.path and str(s.path).startswith(source_prefix)
         ]
 
+    def search(self, keyword: str) -> list[Skill]:
+        kw = keyword.lower()
+        results: list[tuple[Skill, int]] = []
+
+        for skill in self._discover().values():
+            score = 0
+            name_lower = skill.name.lower()
+            desc_lower = skill.description.lower()
+
+            if kw == name_lower:
+                score += 100
+            elif kw in name_lower:
+                score += 50
+            if kw in desc_lower:
+                score += 30
+                if desc_lower.startswith(kw):
+                    score += 10
+            for trigger in skill.triggers:
+                if kw in trigger.lower():
+                    score += 20
+                    break
+            for phase in skill.phases:
+                if kw in phase.lower():
+                    score += 10
+                    break
+
+            if score > 0:
+                results.append((skill, score))
+
+        results.sort(key=lambda x: x[1], reverse=True)
+        return [s for s, _ in results]
+
     def invalidate_cache(self) -> None:
         self._cache = None

package/onecode/skills/manager.py

@@ -5,12 +5,12 @@ from typing import Optional
 
 import yaml
 
-from onecode.config import CLOUD_DEV_HARNESS_DIR
+from onecode.config import ONECODE_DIR
 
 
 class SkillManager:
     def __init__(self):
-        self.skills_dir = CLOUD_DEV_HARNESS_DIR / "skills"
+        self.skills_dir = ONECODE_DIR / "skills"
         self.skills_dir.mkdir(parents=True, exist_ok=True)
         self._skills: dict[str, dict] = {}