@scemoon/cdh 1.0.7 → 1.0.9-beta.1

package/onecode/models/providers/openai_provider.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import AsyncIterator, Callable, Optional
+
+import httpx
+
+from onecode.models.errors import (
+    ProviderError, TransientProviderError, retry_after_seconds, safe_error_msg,
+)
+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"
+
+    def is_anthropic_style(self) -> bool:
+        return False
+
+    def _non_system_to_dict(self, msg: Message) -> dict:
+        return msg.to_multimodal_dict()
+
+    def prepare_messages(self, messages: list[Message]) -> list[dict]:
+        """Prepare messages for OpenAI API, supporting multimodal content.
+
+        Delegates to the base hardening pipeline which handles empty-tool
+        dropping, user coalescing, orphan-tool stripping, dangling
+        tool_call cleanup, and system-prompt capping.
+        """
+        return super().prepare_messages(messages)
+
+    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:
+            raise ProviderError("API key not configured. Set OPENAI_API_KEY.")
+        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 not in ("tools", "stream")})
+
+        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,
+            )
+            if resp.status_code != 200:
+                raise Provider.classify_http_error(
+                    resp.status_code, resp.text,
+                    retry_after=retry_after_seconds(resp),
+                )
+            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 = 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:
+            raise ProviderError("API key not configured.")
+        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:
+                if resp.status_code != 200:
+                    error_body = await resp.aread()
+                    raise Provider.classify_http_error(
+                        resp.status_code, error_body.decode("utf-8", errors="replace"),
+                        retry_after=retry_after_seconds(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", {})
+                        yield delta.get("content", "")
+
+    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,
+        cancel_check: Optional[Callable[[], bool]] = None,
+        **kwargs,
+    ) -> ChatResponse:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            raise ProviderError("API key not configured.")
+        if cancel_check and cancel_check():
+            raise asyncio.CancelledError("cancelled before chat_stream_response")
+
+        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] = []
+        stream_tool_calls: dict[int, dict] = {}
+
+        try:
+            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:
+                    if resp.status_code != 200:
+                        error_body = await resp.aread()
+                        raise Provider.classify_http_error(
+                            resp.status_code, error_body.decode("utf-8", errors="replace"),
+                            retry_after=retry_after_seconds(resp),
+                        )
+                    async for line in resp.aiter_lines():
+                        if cancel_check and cancel_check():
+                            raise asyncio.CancelledError("cancelled during streaming")
+                        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 stream_tool_calls:
+                                    stream_tool_calls[idx] = {
+                                        "id": tcd.get("id", ""),
+                                        "name": tcd.get("function", {}).get("name", ""),
+                                        "arguments": "",
+                                    }
+                                args_delta = tcd.get("function", {}).get("arguments", "")
+                                stream_tool_calls[idx]["arguments"] += args_delta
+                                if tcd.get("id"):
+                                    stream_tool_calls[idx]["id"] = tcd["id"]
+                                if tcd.get("function", {}).get("name"):
+                                    stream_tool_calls[idx]["name"] = tcd["function"]["name"]
+                                if on_tool_call_delta:
+                                    call_id = stream_tool_calls[idx].get("id", "")
+                                    name = stream_tool_calls[idx].get("name", "")
+                                    on_tool_call_delta(call_id, name, args_delta)
+        except asyncio.CancelledError:
+            raise
+        except ProviderError:
+            raise
+        except Exception as e:
+            raise TransientProviderError(f"Error: {safe_error_msg(e)}") from e
+
+        tool_uses = []
+        for nt in 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

@@ -0,0 +1,349 @@
+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-opus-4.7",
+        provider="anthropic",
+        context_window=200000,
+        max_output=8192,
+        cost_per_1k_input=0.015,
+        cost_per_1k_output=0.075,
+        capabilities=["reasoning", "coding", "analysis", "complex"],
+        description="Claude Opus 4.7, Anthropic's most capable model",
+    ),
+    ModelInfo(
+        id="claude-opus-4.7-fast",
+        provider="anthropic",
+        context_window=200000,
+        max_output=8192,
+        cost_per_1k_input=0.015,
+        cost_per_1k_output=0.075,
+        capabilities=["reasoning", "coding", "fast"],
+        description="Claude Opus 4.7 Fast, faster inference variant",
+    ),
+    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",
+    ),
+    ModelInfo(
+        id="gpt-5.5-pro",
+        provider="openai",
+        context_window=128000,
+        max_output=16384,
+        cost_per_1k_input=0.01,
+        cost_per_1k_output=0.04,
+        capabilities=["reasoning", "coding", "complex"],
+        description="OpenAI GPT-5.5 Pro, most capable model",
+    ),
+    ModelInfo(
+        id="gpt-5.5",
+        provider="openai",
+        context_window=128000,
+        max_output=16384,
+        cost_per_1k_input=0.005,
+        cost_per_1k_output=0.015,
+        capabilities=["reasoning", "coding", "general"],
+        description="OpenAI GPT-5.5, balanced general-purpose model",
+    ),
+    # ── DeepSeek ──
+    ModelInfo(
+        id="deepseek-v4-pro",
+        provider="deepseek",
+        context_window=128000,
+        max_output=8192,
+        cost_per_1k_input=0.00055,
+        cost_per_1k_output=0.00219,
+        capabilities=["reasoning", "coding", "analysis", "complex"],
+        description="DeepSeek V4 Pro, advanced reasoning model",
+    ),
+    ModelInfo(
+        id="deepseek-v4-flash",
+        provider="deepseek",
+        context_window=128000,
+        max_output=8192,
+        cost_per_1k_input=0.00014,
+        cost_per_1k_output=0.00028,
+        capabilities=["coding", "general", "fast"],
+        description="DeepSeek V4 Flash, fast cost-efficient model",
+    ),
+    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",
+    ),
+    ModelInfo(
+        id="MiniMax-M3",
+        provider="minimaxi",
+        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 M3 flagship model with 1M context",
+    ),
+    ModelInfo(
+        id="MiniMax-M2.7",
+        provider="minimaxi",
+        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 M2.7, balanced and capable",
+    ),
+    ModelInfo(
+        id="MiniMax-M2.5",
+        provider="minimaxi",
+        context_window=64000,
+        max_output=4096,
+        cost_per_1k_input=0.0001,
+        cost_per_1k_output=0.0003,
+        capabilities=["quick", "general", "cost-efficient"],
+        description="MiniMax M2.5, fast and affordable",
+    ),
+    # ── Zhipu GLM ──
+    ModelInfo(
+        id="glm-5.1",
+        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-5.1, Zhipu's flagship model",
+    ),
+    ModelInfo(
+        id="glm-5",
+        provider="glm",
+        context_window=128000,
+        max_output=8192,
+        cost_per_1k_input=0.004,
+        cost_per_1k_output=0.004,
+        capabilities=["coding", "general", "balanced"],
+        description="GLM-5, balanced and capable",
+    ),
+    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",
+    ),
+    ModelInfo(
+        id="qwen3.5-2b",
+        provider="ollama",
+        context_window=32000,
+        max_output=4096,
+        cost_per_1k_input=0.0,
+        cost_per_1k_output=0.0,
+        capabilities=["local", "coding", "reasoning"],
+        description="Qwen3.5 2B - 轻量推荐（需 8GB+ 内存）",
+    ),
+    ModelInfo(
+        id="qwen3.5-4b",
+        provider="ollama",
+        context_window=32000,
+        max_output=4096,
+        cost_per_1k_input=0.0,
+        cost_per_1k_output=0.0,
+        capabilities=["local", "coding", "reasoning"],
+        description="Qwen3.5 4B - 高质量（需 16GB+ 内存）",
+    ),
+]
+
+
+class ModelRegistry:
+    _models: dict[str, ModelInfo] = {}
+
+    _reference: dict[str, ModelInfo] = {m.id: m for m in REFERENCE_MODELS}
+
+    @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:
+                ref = cls._reference.get(model_id)
+                cls._models[model_id] = ModelInfo(
+                    id=model_id,
+                    provider=provider,
+                    context_window=ref.context_window if ref else 0,
+                    max_output=ref.max_output if ref else 4096,
+                    cost_per_1k_input=ref.cost_per_1k_input if ref else 0.0,
+                    cost_per_1k_output=ref.cost_per_1k_output if ref else 0.0,
+                    capabilities=list(ref.capabilities) if ref else [],
+                    description=ref.description if ref else "",
+                )
+        # Also register any reference models not in config
+        for m in REFERENCE_MODELS:
+            if m.id not in cls._models:
+                cls._models[m.id] = m
+
+    @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"]