@scemoon/cdh 1.0.5 → 1.0.7

package/onecode/models/providers/openai_provider.py

@@ -1,237 +0,0 @@
-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", "")}
-                if not isinstance(args, dict):
-                    args = {"raw": args}
-                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", "")}
-            if not isinstance(inp, dict):
-                inp = {"raw": inp}
-            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

@@ -1,212 +0,0 @@
-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

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

package/onecode/server/app.py

@@ -1,224 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-from typing import 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

@@ -1,11 +0,0 @@
-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",
-]