@scemoon/cdh 1.0.8 → 1.0.9-beta.1

package/onecode/models/providers/__init__.py

@@ -0,0 +1,17 @@
+from onecode.models.providers.anthropic_provider import AnthropicProvider
+from onecode.models.providers.openai_provider import OpenAIProvider
+from onecode.models.providers.ollama_provider import OllamaProvider
+from onecode.models.providers.deepseek_provider import DeepSeekProvider
+from onecode.models.providers.minimax_provider import MiniMaxProvider
+from onecode.models.providers.minimaxi_provider import MiniMaxiProvider
+from onecode.models.providers.glm_provider import GLMProvider
+
+__all__ = [
+    "AnthropicProvider",
+    "OpenAIProvider",
+    "OllamaProvider",
+    "DeepSeekProvider",
+    "MiniMaxProvider",
+    "MiniMaxiProvider",
+    "GLMProvider",
+]

package/onecode/models/providers/anthropic_provider.py

@@ -0,0 +1,286 @@
+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 AnthropicProvider(Provider):
+    name = "anthropic"
+
+    def __init__(self, api_key: str = "", endpoint: str = "", **kwargs):
+        self.api_key = api_key
+        self._endpoint = endpoint or "https://api.anthropic.com/v1"
+
+    def is_anthropic_style(self) -> bool:
+        return True
+
+    def prepare_messages(self, messages: list[Message]) -> list[dict]:
+        """Prepare messages for Anthropic API.
+
+        Converts OpenAI-format image blocks (image_url) to Anthropic's
+        native image format (image + source).
+        """
+        prepared = super().prepare_messages(messages)
+        for msg in prepared:
+            content = msg.get("content")
+            if isinstance(content, list):
+                new_content = []
+                for part in content:
+                    if isinstance(part, dict) and part.get("type") == "image_url":
+                        url = part["image_url"]["url"]
+                        if url.startswith("data:"):
+                            header, _, encoded = url[5:].partition(",")
+                            mime = header.split(";")[0] if ";" in header else "image/png"
+                            new_content.append({
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": mime,
+                                    "data": encoded,
+                                },
+                            })
+                    else:
+                        new_content.append(part)
+                msg["content"] = new_content
+        return prepared
+
+    async def chat(
+        self, messages: list[Message], model: str = "claude-3-opus-20240229", **kwargs
+    ) -> ModelResponse:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            raise ProviderError("API key not configured. Set ANTHROPIC_API_KEY.")
+        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={
+                    "x-api-key": key,
+                    "anthropic-version": "2023-06-01",
+                    "content-type": "application/json",
+                },
+                json=api_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()
+            return ModelResponse(
+                content=[{"type": "text", "text": data.get("content", [{}])[0].get("text", "")}],
+                model=model,
+                usage=data.get("usage", {}),
+                raw=data,
+            )
+
+    async def chat_stream(
+        self, messages: list[Message], model: str = "claude-3-opus-20240229", **kwargs
+    ) -> AsyncIterator[str]:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            raise ProviderError("API key not configured.")
+        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",
+                headers={
+                    "x-api-key": key,
+                    "anthropic-version": "2023-06-01",
+                    "content-type": "application/json",
+                },
+                json=body_cs,
+            ) 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:])
+                        if chunk.get("type") == "content_block_delta":
+                            delta = chunk.get("delta", {})
+                            yield delta.get("text", "")
+
+    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")
+
+        content_parts: list[str] = []
+        tool_uses: list[dict] = []
+        usage: dict = {}
+        current_tool: Optional[dict] = None
+
+        try:
+            async with httpx.AsyncClient(timeout=300) 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)
+
+                body = {
+                    "model": model,
+                    "max_tokens": kwargs.get("max_tokens", 4096),
+                    "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
+                body.update({k: v for k, v in kwargs.items() if k not in ("tools", "stream", "max_tokens")})
+
+                async with client.stream(
+                    "POST",
+                    f"{self._endpoint}/messages",
+                    headers={
+                        "x-api-key": key,
+                        "anthropic-version": "2023-06-01",
+                        "content-type": "application/json",
+                    },
+                    json=body,
+                ) as resp:
+                    if resp.status_code != 200:
+                        error_body = await resp.aread()
+                        error_text = error_body.decode("utf-8", errors="replace")
+                        raise Provider.classify_http_error(
+                            resp.status_code, error_text, 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:])
+                            chunk_type = chunk.get("type", "")
+
+                            if chunk_type == "content_block_start":
+                                block = chunk.get("content_block", {})
+                                if block.get("type") == "tool_use":
+                                    current_tool = {
+                                        "id": block.get("id", ""),
+                                        "name": block.get("name", ""),
+                                        "input": {},
+                                        "input_json": "",
+                                    }
+
+                            elif chunk_type == "content_block_delta":
+                                delta = chunk.get("delta", {})
+                                delta_type = delta.get("type", "")
+                                if delta_type == "text_delta":
+                                    text = delta.get("text", "")
+                                    if text:
+                                        content_parts.append(text)
+                                        if on_text_chunk:
+                                            on_text_chunk(text)
+                                elif delta_type == "input_json_delta":
+                                    if current_tool is not None:
+                                        current_tool["input_json"] += delta.get("partial_json", "")
+                                        if on_tool_call_delta:
+                                            partial = delta.get("partial_json", "") or ""
+                                            call_id = current_tool.get("id", "")
+                                            name = current_tool.get("name", "")
+                                            on_tool_call_delta(call_id, name, partial)
+
+                            elif chunk_type == "content_block_stop":
+                                if current_tool is not None:
+                                    try:
+                                        current_tool["input"] = json.loads(current_tool["input_json"])
+                                    except (json.JSONDecodeError, TypeError):
+                                        current_tool["input"] = {"raw": current_tool["input_json"]}
+                                    if not isinstance(current_tool["input"], dict):
+                                        current_tool["input"] = {"raw": current_tool["input"]}
+                                    tool_uses.append({
+                                        "id": current_tool["id"],
+                                        "name": current_tool["name"],
+                                        "input": current_tool["input"],
+                                    })
+                                    current_tool = None
+
+                            elif chunk_type == "message_delta":
+                                usage = chunk.get("usage", {})
+        except asyncio.CancelledError:
+            raise
+        except ProviderError:
+            raise
+        except httpx.ConnectError as e:
+            raise TransientProviderError(f"Connection error: {e}") from e
+        except Exception as e:
+            raise TransientProviderError(f"Error: {safe_error_msg(e)}") from e
+
+        return ChatResponse(
+            content="".join(content_parts),
+            tool_uses=tool_uses,
+            usage=usage,
+        )
+
+
+ProviderRegistry.register("anthropic", AnthropicProvider)

package/onecode/models/providers/deepseek_provider.py

@@ -0,0 +1,221 @@
+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 DeepSeekProvider(Provider):
+    name = "deepseek"
+
+    def __init__(self, api_key: str = "", endpoint: str = "", **kwargs):
+        self.api_key = api_key
+        self._endpoint = endpoint or "https://api.deepseek.com/v1"
+
+    def is_anthropic_style(self) -> bool:
+        return False
+
+    async def chat(
+        self, messages: list[Message], model: str = "deepseek-chat", **kwargs
+    ) -> ModelResponse:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            raise ProviderError("API key not configured. Set DEEPSEEK_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 = "deepseek-chat", **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", "")}
+            tool_uses.append({"id": nt["id"], "name": nt["name"], "input": inp})
+
+        return ChatResponse(
+            content="".join(content_parts),
+            tool_uses=tool_uses,
+        )
+
+
+ProviderRegistry.register("deepseek", DeepSeekProvider)