@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/onecode/models/providers/__init__.py

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

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

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