@scemoon/cdh 1.0.0

package/onecode/models/providers/openai_provider.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import json
+from typing import AsyncIterator, Callable, Optional
+
+import httpx
+
+from onecode.models.provider import ChatResponse, Message, ModelResponse, Provider, ProviderRegistry
+
+
+class OpenAIProvider(Provider):
+    name = "openai"
+
+    def __init__(self, api_key: str = "", endpoint: str = "", **kwargs):
+        self.api_key = api_key
+        self._endpoint = endpoint or "https://api.openai.com/v1"
+        self._stream_tool_calls: dict[int, dict] = {}
+
+    def is_anthropic_style(self) -> bool:
+        return False
+
+    def prepare_messages(self, messages: list[Message]) -> list[dict]:
+        """Prepare messages for OpenAI API, supporting multimodal (text + image) content."""
+        system_parts = []
+        non_system = []
+
+        for m in messages:
+            if m.role == "system":
+                system_parts.append(m.to_api_content())
+            else:
+                non_system.append(m.to_multimodal_dict())
+
+        if len(system_parts) > 1:
+            combined_system = "\n\n".join(system_parts)
+        elif system_parts:
+            combined_system = system_parts[0]
+        else:
+            combined_system = ""
+
+        if combined_system:
+            non_system.insert(0, {"role": "system", "content": combined_system})
+
+        return non_system
+
+    def get_stream_tool_calls(self) -> list[dict]:
+        return list(self._stream_tool_calls.values())
+
+    async def chat(
+        self, messages: list[Message], model: str = "gpt-4-turbo", **kwargs
+    ) -> ModelResponse:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            return ModelResponse(
+                content="API key not configured. Set OPENAI_API_KEY.",
+                model=model,
+            )
+        body = {
+            "model": model,
+            "messages": self.prepare_messages(messages),
+        }
+        tools = kwargs.get("tools")
+        if tools:
+            body["tools"] = tools
+        body.update({k: v for k, v in kwargs.items() if k != "tools"})
+
+        async with httpx.AsyncClient(timeout=120) as client:
+            resp = await client.post(
+                f"{self._endpoint}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {key}",
+                    "content-type": "application/json",
+                },
+                json=body,
+            )
+            data = resp.json()
+            choice = data.get("choices", [{}])[0]
+            msg = choice.get("message", {})
+
+            content_blocks = []
+            text = msg.get("content", "") or ""
+            if text:
+                content_blocks.append({"type": "text", "text": text})
+
+            tool_calls = msg.get("tool_calls", [])
+            for tc in tool_calls:
+                func = tc.get("function", {})
+                try:
+                    args = __import__("json").loads(func.get("arguments", "{}"))
+                except Exception:
+                    args = {"raw": func.get("arguments", "")}
+                content_blocks.append({
+                    "type": "tool_use",
+                    "id": tc.get("id", ""),
+                    "name": func.get("name", ""),
+                    "input": args,
+                })
+
+            return ModelResponse(
+                content=content_blocks,
+                model=model,
+                usage=data.get("usage", {}),
+                raw=data,
+            )
+
+    async def chat_stream(
+        self, messages: list[Message], model: str = "gpt-4-turbo", **kwargs
+    ) -> AsyncIterator[str]:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            yield "API key not configured."
+            return
+        self._stream_tool_calls = {}
+        body = {
+            "model": model,
+            "messages": self.prepare_messages(messages),
+            "stream": True,
+        }
+        tools = kwargs.get("tools")
+        if tools:
+            body["tools"] = tools
+        body.update({k: v for k, v in kwargs.items() if k not in ("tools", "stream")})
+
+        async with httpx.AsyncClient(timeout=300) as client:
+            async with client.stream(
+                "POST",
+                f"{self._endpoint}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {key}",
+                    "content-type": "application/json",
+                },
+                json=body,
+            ) as resp:
+                async for line in resp.aiter_lines():
+                    if line.startswith("data: ") and line[6:] != "[DONE]":
+                        import json
+                        chunk = json.loads(line[6:])
+                        delta = chunk.get("choices", [{}])[0].get("delta", {})
+                        yield delta.get("content", "")
+                        tc_deltas = delta.get("tool_calls", [])
+                        for tcd in tc_deltas:
+                            idx = tcd.get("index", 0)
+                            if idx not in self._stream_tool_calls:
+                                self._stream_tool_calls[idx] = {
+                                    "id": tcd.get("id", ""),
+                                    "name": tcd.get("function", {}).get("name", ""),
+                                    "arguments": "",
+                                }
+                            args_delta = tcd.get("function", {}).get("arguments", "")
+                            self._stream_tool_calls[idx]["arguments"] += args_delta
+                            if tcd.get("id"):
+                                self._stream_tool_calls[idx]["id"] = tcd["id"]
+                            if tcd.get("function", {}).get("name"):
+                                self._stream_tool_calls[idx]["name"] = tcd["function"]["name"]
+
+
+    async def chat_stream_response(
+        self,
+        messages: list[Message],
+        model: str,
+        on_text_chunk: Optional[Callable[[str], None]] = None,
+        on_tool_call_delta: Optional[Callable[[str, str, str], None]] = None,
+        **kwargs,
+    ) -> ChatResponse:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            return ChatResponse(content="API key not configured.")
+        self._stream_tool_calls = {}
+        body = {
+            "model": model,
+            "messages": self.prepare_messages(messages),
+            "stream": True,
+        }
+        tools = kwargs.get("tools")
+        if tools:
+            body["tools"] = tools
+        body.update({k: v for k, v in kwargs.items() if k not in ("tools", "stream")})
+
+        content_parts: list[str] = []
+
+        async with httpx.AsyncClient(timeout=300) as client:
+            async with client.stream(
+                "POST",
+                f"{self._endpoint}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {key}",
+                    "content-type": "application/json",
+                },
+                json=body,
+            ) as resp:
+                async for line in resp.aiter_lines():
+                    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:
+                            content_parts.append(text)
+                            if on_text_chunk:
+                                on_text_chunk(text)
+                        tc_deltas = delta.get("tool_calls", [])
+                        for tcd in tc_deltas:
+                            idx = tcd.get("index", 0)
+                            if idx not in self._stream_tool_calls:
+                                self._stream_tool_calls[idx] = {
+                                    "id": tcd.get("id", ""),
+                                    "name": tcd.get("function", {}).get("name", ""),
+                                    "arguments": "",
+                                }
+                            args_delta = tcd.get("function", {}).get("arguments", "")
+                            self._stream_tool_calls[idx]["arguments"] += args_delta
+                            if tcd.get("id"):
+                                self._stream_tool_calls[idx]["id"] = tcd["id"]
+                            if tcd.get("function", {}).get("name"):
+                                self._stream_tool_calls[idx]["name"] = tcd["function"]["name"]
+                            if on_tool_call_delta:
+                                call_id = self._stream_tool_calls[idx].get("id", "")
+                                name = self._stream_tool_calls[idx].get("name", "")
+                                on_tool_call_delta(call_id, name, args_delta)
+
+        tool_uses = []
+        for nt in self._stream_tool_calls.values():
+            try:
+                inp = json.loads(nt.get("arguments", "{}"))
+            except (json.JSONDecodeError, TypeError):
+                inp = {"raw": nt.get("arguments", "")}
+            tool_uses.append({"id": nt["id"], "name": nt["name"], "input": inp})
+
+        return ChatResponse(
+            content="".join(content_parts),
+            tool_uses=tool_uses,
+        )
+
+
+ProviderRegistry.register("openai", OpenAIProvider)

package/onecode/models/registry.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ModelInfo:
+    id: str
+    provider: str
+    context_window: int = 0
+    max_output: int = 4096
+    cost_per_1k_input: float = 0.0
+    cost_per_1k_output: float = 0.0
+    capabilities: list[str] = field(default_factory=list)
+    description: str = ""
+
+
+REFERENCE_MODELS: list[ModelInfo] = [
+    # ── Anthropic (Claude) ──
+    ModelInfo(
+        id="claude-3-opus-20240229",
+        provider="anthropic",
+        context_window=200000,
+        max_output=4096,
+        cost_per_1k_input=0.015,
+        cost_per_1k_output=0.075,
+        capabilities=["reasoning", "coding", "analysis", "complex"],
+        description="Most capable Anthropic model for complex tasks",
+    ),
+    ModelInfo(
+        id="claude-3-sonnet-20240229",
+        provider="anthropic",
+        context_window=200000,
+        max_output=4096,
+        cost_per_1k_input=0.003,
+        cost_per_1k_output=0.015,
+        capabilities=["coding", "design", "medium"],
+        description="Balanced Anthropic model for everyday tasks",
+    ),
+    ModelInfo(
+        id="claude-3-haiku-20240307",
+        provider="anthropic",
+        context_window=200000,
+        max_output=4096,
+        cost_per_1k_input=0.00025,
+        cost_per_1k_output=0.00125,
+        capabilities=["quick", "simple", "summarization"],
+        description="Fastest Anthropic model for simple tasks",
+    ),
+    # ── OpenAI ──
+    ModelInfo(
+        id="gpt-4o",
+        provider="openai",
+        context_window=128000,
+        max_output=16384,
+        cost_per_1k_input=0.005,
+        cost_per_1k_output=0.015,
+        capabilities=["reasoning", "coding", "vision", "complex"],
+        description="OpenAI multimodal flagship model",
+    ),
+    ModelInfo(
+        id="gpt-4-turbo",
+        provider="openai",
+        context_window=128000,
+        max_output=4096,
+        cost_per_1k_input=0.01,
+        cost_per_1k_output=0.03,
+        capabilities=["reasoning", "coding", "complex"],
+        description="OpenAI GPT-4 Turbo, fast and capable",
+    ),
+    # ── DeepSeek ──
+    ModelInfo(
+        id="deepseek-chat",
+        provider="deepseek",
+        context_window=128000,
+        max_output=8192,
+        cost_per_1k_input=0.00014,
+        cost_per_1k_output=0.00028,
+        capabilities=["reasoning", "coding", "general"],
+        description="DeepSeek general-purpose chat model",
+    ),
+    ModelInfo(
+        id="deepseek-reasoner",
+        provider="deepseek",
+        context_window=128000,
+        max_output=8192,
+        cost_per_1k_input=0.00055,
+        cost_per_1k_output=0.00219,
+        capabilities=["reasoning", "analysis", "complex"],
+        description="DeepSeek reasoning model for complex tasks",
+    ),
+    # ── MiniMax ──
+    ModelInfo(
+        id="minimax-m1",
+        provider="minimax",
+        context_window=1000000,
+        max_output=16384,
+        cost_per_1k_input=0.001,
+        cost_per_1k_output=0.003,
+        capabilities=["reasoning", "coding", "long-context", "complex"],
+        description="MiniMax M1 flagship model with 1M context",
+    ),
+    ModelInfo(
+        id="minimax-m1-light",
+        provider="minimax",
+        context_window=128000,
+        max_output=8192,
+        cost_per_1k_input=0.0002,
+        cost_per_1k_output=0.0006,
+        capabilities=["coding", "general", "cost-efficient"],
+        description="MiniMax M1 Light, faster and cost-effective",
+    ),
+    # ── Zhipu GLM ──
+    ModelInfo(
+        id="glm-4-plus",
+        provider="glm",
+        context_window=128000,
+        max_output=8192,
+        cost_per_1k_input=0.007,
+        cost_per_1k_output=0.007,
+        capabilities=["reasoning", "coding", "analysis"],
+        description="GLM-4 Plus, Zhipu's most advanced model",
+    ),
+    ModelInfo(
+        id="glm-4-flash",
+        provider="glm",
+        context_window=128000,
+        max_output=4096,
+        cost_per_1k_input=0.0001,
+        cost_per_1k_output=0.0001,
+        capabilities=["quick", "general", "cost-efficient"],
+        description="GLM-4 Flash, fast and affordable",
+    ),
+    # ── Ollama (local) ──
+    ModelInfo(
+        id="llama2",
+        provider="ollama",
+        context_window=4096,
+        max_output=2048,
+        cost_per_1k_input=0.0,
+        cost_per_1k_output=0.0,
+        capabilities=["local", "simple"],
+        description="Local Llama 2 model via Ollama",
+    ),
+    ModelInfo(
+        id="codellama",
+        provider="ollama",
+        context_window=16384,
+        max_output=4096,
+        cost_per_1k_input=0.0,
+        cost_per_1k_output=0.0,
+        capabilities=["local", "coding"],
+        description="Local CodeLlama model via Ollama",
+    ),
+]
+
+
+class ModelRegistry:
+    _models: dict[str, ModelInfo] = {}
+
+    @classmethod
+    def initialize(cls):
+        from onecode.config import load_config
+        cfg = load_config()
+        cls._models.clear()
+        for provider, prov_cfg in cfg.providers.items():
+            for model_id in prov_cfg.models:
+                cls._models[model_id] = ModelInfo(
+                    id=model_id,
+                    provider=provider,
+                    context_window=0,
+                    max_output=4096,
+                    cost_per_1k_input=0.0,
+                    cost_per_1k_output=0.0,
+                    capabilities=[],
+                    description="",
+                )
+
+    @classmethod
+    def get(cls, model_id: str) -> Optional[ModelInfo]:
+        return cls._models.get(model_id)
+
+    @classmethod
+    def list_all(cls) -> list[ModelInfo]:
+        return list(cls._models.values())
+
+    @classmethod
+    def list_by_provider(cls, provider: str) -> list[ModelInfo]:
+        return [m for m in cls._models.values() if m.provider == provider]
+
+    @classmethod
+    def reference_table(cls) -> str:
+        from rich.table import Table
+
+        table = Table(title="Model Reference")
+        table.add_column("Model", style="cyan")
+        table.add_column("Provider", style="green")
+        table.add_column("Context", justify="right")
+        table.add_column("Input Cost", justify="right")
+        table.add_column("Output Cost", justify="right")
+        table.add_column("Capabilities")
+        for m in cls._models.values():
+            table.add_row(
+                m.id,
+                m.provider,
+                f"{m.context_window:,}",
+                f"${m.cost_per_1k_input:.5f}",
+                f"${m.cost_per_1k_output:.5f}",
+                ", ".join(m.capabilities),
+            )
+        return table

package/onecode/server/__init__.py

@@ -0,0 +1,3 @@
+from onecode.server.app import AgentServer
+
+__all__ = ["AgentServer"]

package/onecode/server/app.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any, Optional
+
+from starlette.applications import Starlette
+from starlette.responses import JSONResponse, Response
+from starlette.routing import Route
+
+from onecode.agent.engine import AgentEngine
+
+logger = logging.getLogger("onecode.server")
+
+
+async def _sse_publisher(engine: AgentEngine, response: Response):
+    """Stream agent output as SSE events."""
+    send = response.__dict__.get("send")
+
+    async def _on_text(text: str):
+        if send:
+            try:
+                await send({
+                    "type": "http.response.body",
+                    "body": f"data: {json.dumps({'type': 'text', 'content': text})}\n\n".encode(),
+                    "more_body": True,
+                })
+            except Exception:
+                pass
+
+    engine.on_text_chunk = _on_text
+    return send
+
+
+class AgentServer:
+    """HTTP/SSE server for remote agent access (Clawd-Code pattern)."""
+
+    def __init__(self, engine: AgentEngine, host: str = "127.0.0.1", port: int = 8765):
+        self._engine = engine
+        self._host = host
+        self._port = port
+        self._app = self._build_app()
+        self._server: Optional[asyncio.AbstractServer] = None
+
+    def _build_app(self) -> Starlette:
+        routes = [
+            Route("/health", endpoint=self._handle_health, methods=["GET"]),
+            Route("/status", endpoint=self._handle_status, methods=["GET"]),
+            Route("/chat", endpoint=self._handle_chat, methods=["POST"]),
+            Route("/events", endpoint=self._handle_events, methods=["GET"]),
+        ]
+        return Starlette(routes=routes, on_shutdown=[self._shutdown])
+
+    async def _handle_health(self, request):
+        return JSONResponse({"status": "ok"})
+
+    async def _handle_status(self, request):
+        return JSONResponse({
+            "iterations": self._engine.iterations,
+            "total_tokens": self._engine.total_tokens,
+            "provider": getattr(self._engine.app, "current_provider", None),
+            "model": getattr(self._engine.app, "current_model", None),
+        })
+
+    async def _handle_chat(self, request):
+        try:
+            body = await request.json()
+        except Exception:
+            return JSONResponse({"error": "invalid JSON body"}, status_code=400)
+
+        user_input = body.get("message", "")
+        if not user_input:
+            return JSONResponse({"error": "message is required"}, status_code=400)
+
+        response_text = await self._engine.chat(user_input)
+        return JSONResponse({"response": response_text})
+
+    async def _handle_events(self, request):
+        async def _send_events(send):
+            await send({
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [
+                    (b"content-type", b"text/event-stream"),
+                    (b"cache-control", b"no-cache"),
+                    (b"connection", b"keep-alive"),
+                    (b"access-control-allow-origin", b"*"),
+                ],
+            })
+
+            user_input = request.query_params.get("message", "")
+            if not user_input:
+                await send({
+                    "type": "http.response.body",
+                    "body": b"data: {\"error\": \"message query param required\"}\n\n",
+                    "more_body": False,
+                })
+                return
+
+            from onecode.models.messages import StreamEvent, StreamEventType
+
+            _tc_args: dict[str, str] = {}
+
+            def _on_tool_call_delta(call_id: str, name: str, args_delta: str) -> None:
+                if not args_delta:
+                    return
+                _tc_args[call_id] = _tc_args.get(call_id, "") + args_delta
+                payload = json.dumps({
+                    "type": "tool_call_args",
+                    "toolCallId": call_id,
+                    "name": name,
+                    "args": _tc_args[call_id],
+                })
+                asyncio.ensure_future(send({
+                    "type": "http.response.body",
+                    "body": f"data: {payload}\n\n".encode(),
+                    "more_body": True,
+                }))
+
+            self._engine.on_tool_call_delta = _on_tool_call_delta
+
+            text_buffer = []
+            async for event in self._engine.chat_stream(user_input):
+                if isinstance(event, StreamEvent):
+                    if event.type == StreamEventType.TEXT_DELTA and event.text:
+                        text_buffer.append(event.text)
+                        payload = json.dumps({"type": "delta", "text": event.text})
+                        await send({
+                            "type": "http.response.body",
+                            "body": f"data: {payload}\n\n".encode(),
+                            "more_body": True,
+                        })
+                    elif event.type == StreamEventType.THINKING and event.thinking:
+                        payload = json.dumps({"type": "thinking", "content": event.thinking})
+                        await send({
+                            "type": "http.response.body",
+                            "body": f"data: {payload}\n\n".encode(),
+                            "more_body": True,
+                        })
+                    elif event.type == StreamEventType.TOOL_CALL_START:
+                        payload = json.dumps({
+                            "type": "tool_call_start",
+                            "toolCallId": event.tool_id,
+                            "name": event.tool_name,
+                        })
+                        await send({
+                            "type": "http.response.body",
+                            "body": f"data: {payload}\n\n".encode(),
+                            "more_body": True,
+                        })
+                    elif event.type == StreamEventType.TOOL_CALL_COMPLETE:
+                        payload = json.dumps({
+                            "type": "tool_call_complete",
+                            "toolCallId": event.tool_id,
+                            "name": event.tool_name,
+                            "args": event.tool_args,
+                        })
+                        await send({
+                            "type": "http.response.body",
+                            "body": f"data: {payload}\n\n".encode(),
+                            "more_body": True,
+                        })
+                    elif event.type == StreamEventType.TOOL_RESULT:
+                        payload = json.dumps({
+                            "type": "tool_result",
+                            "toolCallId": event.tool_id,
+                            "content": event.result_content,
+                            "isError": event.result_is_error,
+                        })
+                        await send({
+                            "type": "http.response.body",
+                            "body": f"data: {payload}\n\n".encode(),
+                            "more_body": True,
+                        })
+                    elif event.type == StreamEventType.ERROR:
+                        payload = json.dumps({"type": "error", "message": event.error_message})
+                        await send({
+                            "type": "http.response.body",
+                            "body": f"data: {payload}\n\n".encode(),
+                            "more_body": True,
+                        })
+                else:
+                    text_buffer.append(str(event))
+
+            full_text = "".join(text_buffer)
+            payload = json.dumps({"type": "done", "text": full_text})
+            await send({
+                "type": "http.response.body",
+                "body": f"data: {payload}\n\n".encode(),
+                "more_body": False,
+            })
+
+        return Response(
+            content=None,
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+            },
+        )
+
+    async def _shutdown(self):
+        logger.info("Server shutting down")
+
+    async def start(self):
+        import uvicorn
+        cfg = uvicorn.Config(
+            self._app,
+            host=self._host,
+            port=self._port,
+            log_level="info",
+            lifespan="on",
+        )
+        server = uvicorn.Server(cfg)
+        logger.info(f"Agent server starting on http://{self._host}:{self._port}")
+        await server.serve()
+
+    def start_background(self) -> None:
+        """Start server in background thread."""
+        import threading
+        t = threading.Thread(target=lambda: asyncio.run(self.start()), daemon=True)
+        t.start()

package/onecode/skills/__init__.py

@@ -0,0 +1,11 @@
+from onecode.skills.model import Skill
+from onecode.skills.loader import SkillLoader
+from onecode.skills.frontmatter import parse_frontmatter
+from onecode.skills.argument_substitution import substitute_arguments
+from onecode.skills.create import create_skill_scaffold
+
+__all__ = [
+    "Skill", "SkillLoader",
+    "parse_frontmatter", "substitute_arguments",
+    "create_skill_scaffold",
+]