@scemoon/cdh 1.0.0

package/onecode/models/providers/anthropic_provider.py

@@ -0,0 +1,224 @@
+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 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:
+            return ModelResponse(
+                content="API key not configured. Set ANTHROPIC_API_KEY.",
+                model=model,
+            )
+        async with httpx.AsyncClient(timeout=120) as client:
+            resp = await client.post(
+                f"{self._endpoint}/messages",
+                headers={
+                    "x-api-key": key,
+                    "anthropic-version": "2023-06-01",
+                    "content-type": "application/json",
+                },
+                json={
+                    "model": model,
+                    "max_tokens": kwargs.get("max_tokens", 4096),
+                    "messages": self.prepare_messages(messages),
+                },
+            )
+            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:
+            yield "API key not configured."
+            return
+        async with httpx.AsyncClient(timeout=300) as client:
+            async with client.stream(
+                "POST",
+                f"{self._endpoint}/messages",
+                headers={
+                    "x-api-key": key,
+                    "anthropic-version": "2023-06-01",
+                    "content-type": "application/json",
+                },
+                json={
+                    "model": model,
+                    "max_tokens": kwargs.get("max_tokens", 4096),
+                    "messages": self.prepare_messages(messages),
+                    "stream": True,
+                },
+            ) as 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,
+        **kwargs,
+    ) -> ChatResponse:
+        from onecode.models.errors import (
+            ProviderError, TransientProviderError, retry_after_seconds,
+        )
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            raise ProviderError("API key not configured.")
+
+        content_parts: list[str] = []
+        tool_uses: list[dict] = []
+        usage: dict = {}
+        current_tool: Optional[dict] = None
+
+        try:
+            async with httpx.AsyncClient(timeout=300) as client:
+                body = {
+                    "model": model,
+                    "max_tokens": kwargs.get("max_tokens", 4096),
+                    "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", "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 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"]}
+                                    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 ProviderError:
+            raise
+        except httpx.ConnectError as e:
+            raise TransientProviderError(f"Connection error: {e}") from e
+        except Exception as e:
+            raise TransientProviderError(f"Error: {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,210 @@
+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 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"
+        self._stream_tool_calls: dict[int, dict] = {}
+
+    def is_anthropic_style(self) -> bool:
+        return False
+
+    def get_stream_tool_calls(self) -> list[dict]:
+        return list(self._stream_tool_calls.values())
+
+    async def chat(
+        self, messages: list[Message], model: str = "deepseek-chat", **kwargs
+    ) -> ModelResponse:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            return ModelResponse(
+                content="API key not configured. Set DEEPSEEK_API_KEY.",
+                model=model,
+            )
+        body = {
+            "model": model,
+            "messages": self.prepare_messages(messages),
+        }
+        tools = kwargs.get("tools")
+        if tools:
+            body["tools"] = tools
+        body.update({k: v for k, v in kwargs.items() if k != "tools"})
+
+        async with httpx.AsyncClient(timeout=120) as client:
+            resp = await client.post(
+                f"{self._endpoint}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {key}",
+                    "content-type": "application/json",
+                },
+                json=body,
+            )
+            data = resp.json()
+            choice = data.get("choices", [{}])[0]
+            msg = choice.get("message", {})
+
+            content_blocks = []
+            text = msg.get("content", "") or ""
+            if text:
+                content_blocks.append({"type": "text", "text": text})
+
+            tool_calls = msg.get("tool_calls", [])
+            for tc in tool_calls:
+                func = tc.get("function", {})
+                try:
+                    args = __import__("json").loads(func.get("arguments", "{}"))
+                except Exception:
+                    args = {"raw": func.get("arguments", "")}
+                content_blocks.append({
+                    "type": "tool_use",
+                    "id": tc.get("id", ""),
+                    "name": func.get("name", ""),
+                    "input": args,
+                })
+
+            return ModelResponse(
+                content=content_blocks,
+                model=model,
+                usage=data.get("usage", {}),
+                raw=data,
+            )
+
+    async def chat_stream(
+        self, messages: list[Message], model: str = "deepseek-chat", **kwargs
+    ) -> AsyncIterator[str]:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            yield "API key not configured."
+            return
+        self._stream_tool_calls = {}
+        body = {
+            "model": model,
+            "messages": self.prepare_messages(messages),
+            "stream": True,
+        }
+        tools = kwargs.get("tools")
+        if tools:
+            body["tools"] = tools
+        body.update({k: v for k, v in kwargs.items() if k not in ("tools", "stream")})
+
+        async with httpx.AsyncClient(timeout=300) as client:
+            async with client.stream(
+                "POST",
+                f"{self._endpoint}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {key}",
+                    "content-type": "application/json",
+                },
+                json=body,
+            ) as resp:
+                async for line in resp.aiter_lines():
+                    if line.startswith("data: ") and line[6:] != "[DONE]":
+                        import json
+                        chunk = json.loads(line[6:])
+                        delta = chunk.get("choices", [{}])[0].get("delta", {})
+                        yield delta.get("content", "")
+                        tc_deltas = delta.get("tool_calls", [])
+                        for tcd in tc_deltas:
+                            idx = tcd.get("index", 0)
+                            if idx not in self._stream_tool_calls:
+                                self._stream_tool_calls[idx] = {
+                                    "id": tcd.get("id", ""),
+                                    "name": tcd.get("function", {}).get("name", ""),
+                                    "arguments": "",
+                                }
+                            args_delta = tcd.get("function", {}).get("arguments", "")
+                            self._stream_tool_calls[idx]["arguments"] += args_delta
+                            if tcd.get("id"):
+                                self._stream_tool_calls[idx]["id"] = tcd["id"]
+                            if tcd.get("function", {}).get("name"):
+                                self._stream_tool_calls[idx]["name"] = tcd["function"]["name"]
+
+
+    async def chat_stream_response(
+        self,
+        messages: list[Message],
+        model: str,
+        on_text_chunk: Optional[Callable[[str], None]] = None,
+        on_tool_call_delta: Optional[Callable[[str, str, str], None]] = None,
+        **kwargs,
+    ) -> ChatResponse:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            return ChatResponse(content="API key not configured.")
+        self._stream_tool_calls = {}
+        body = {
+            "model": model,
+            "messages": self.prepare_messages(messages),
+            "stream": True,
+        }
+        tools = kwargs.get("tools")
+        if tools:
+            body["tools"] = tools
+        body.update({k: v for k, v in kwargs.items() if k not in ("tools", "stream")})
+
+        content_parts: list[str] = []
+
+        async with httpx.AsyncClient(timeout=300) as client:
+            async with client.stream(
+                "POST",
+                f"{self._endpoint}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {key}",
+                    "content-type": "application/json",
+                },
+                json=body,
+            ) as resp:
+                async for line in resp.aiter_lines():
+                    if line.startswith("data: ") and line[6:] != "[DONE]":
+                        chunk = json.loads(line[6:])
+                        delta = chunk.get("choices", [{}])[0].get("delta", {})
+                        text = delta.get("content", "")
+                        if text:
+                            content_parts.append(text)
+                            if on_text_chunk:
+                                on_text_chunk(text)
+                        tc_deltas = delta.get("tool_calls", [])
+                        for tcd in tc_deltas:
+                            idx = tcd.get("index", 0)
+                            if idx not in self._stream_tool_calls:
+                                self._stream_tool_calls[idx] = {
+                                    "id": tcd.get("id", ""),
+                                    "name": tcd.get("function", {}).get("name", ""),
+                                    "arguments": "",
+                                }
+                            args_delta = tcd.get("function", {}).get("arguments", "")
+                            self._stream_tool_calls[idx]["arguments"] += args_delta
+                            if tcd.get("id"):
+                                self._stream_tool_calls[idx]["id"] = tcd["id"]
+                            if tcd.get("function", {}).get("name"):
+                                self._stream_tool_calls[idx]["name"] = tcd["function"]["name"]
+                            if on_tool_call_delta:
+                                call_id = self._stream_tool_calls[idx].get("id", "")
+                                name = self._stream_tool_calls[idx].get("name", "")
+                                on_tool_call_delta(call_id, name, args_delta)
+
+        tool_uses = []
+        for nt in self._stream_tool_calls.values():
+            try:
+                inp = json.loads(nt.get("arguments", "{}"))
+            except (json.JSONDecodeError, TypeError):
+                inp = {"raw": nt.get("arguments", "")}
+            tool_uses.append({"id": nt["id"], "name": nt["name"], "input": inp})
+
+        return ChatResponse(
+            content="".join(content_parts),
+            tool_uses=tool_uses,
+        )
+
+
+ProviderRegistry.register("deepseek", DeepSeekProvider)

package/onecode/models/providers/glm_provider.py

@@ -0,0 +1,154 @@
+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 GLMProvider(Provider):
+    name = "glm"
+
+    def __init__(self, api_key: str = "", endpoint: str = "", **kwargs):
+        self.api_key = api_key
+        self._endpoint = endpoint or "https://open.bigmodel.cn/api/paas/v4"
+
+    def is_anthropic_style(self) -> bool:
+        return False
+
+    async def chat(
+        self, messages: list[Message], model: str = "glm-4-plus", **kwargs
+    ) -> ModelResponse:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            return ModelResponse(
+                content="API key not configured. Set GLM_API_KEY.",
+                model=model,
+            )
+        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={
+                    "model": model,
+                    "messages": self.prepare_messages(messages),
+                    **kwargs,
+                },
+            )
+            data = resp.json()
+            choice = data.get("choices", [{}])[0]
+            return ModelResponse(
+                content=[{"type": "text", "text": choice.get("message", {}).get("content", "")}],
+                model=model,
+                usage=data.get("usage", {}),
+                raw=data,
+            )
+
+    async def chat_stream(
+        self, messages: list[Message], model: str = "glm-4-plus", **kwargs
+    ) -> AsyncIterator[str]:
+        key = self.resolve_api_key(self.api_key)
+        if not key:
+            yield "API key not configured."
+            return
+        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={
+                    "model": model,
+                    "messages": self.prepare_messages(messages),
+                    "stream": True,
+                    **{k: v for k, v in kwargs.items() if k != "stream"},
+                },
+            ) 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", "")
+
+    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.")
+        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={
+                        "model": model,
+                        "messages": self.prepare_messages(messages),
+                        "stream": True,
+                        **kwargs,
+                    },
+                ) 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)
+                            for tcd in delta.get("tool_calls", []) or []:
+                                idx = tcd.get("index", 0)
+                                slot = stream_tool_calls.setdefault(
+                                    idx,
+                                    {"id": "", "name": "", "arguments": ""},
+                                )
+                                if tcd.get("id"):
+                                    slot["id"] = tcd["id"]
+                                fn = tcd.get("function", {}) or {}
+                                if fn.get("name"):
+                                    slot["name"] = fn["name"]
+                                args_delta = fn.get("arguments", "") or ""
+                                slot["arguments"] += args_delta
+                                if on_tool_call_delta:
+                                    on_tool_call_delta(slot.get("id", ""), slot.get("name", ""), args_delta)
+        except Exception as e:
+            return ChatResponse(content=f"Error: {e}")
+        tool_uses = []
+        for slot in stream_tool_calls.values():
+            name = slot.get("name") or ""
+            if not name:
+                continue
+            raw_args = slot.get("arguments") or ""
+            try:
+                inp: dict = json.loads(raw_args) if raw_args else {}
+            except (json.JSONDecodeError, TypeError):
+                inp = {"raw": raw_args}
+            if not isinstance(inp, dict):
+                inp = {"raw": inp}
+            tool_uses.append(
+                {"id": slot.get("id") or "", "name": name, "input": inp}
+            )
+        return ChatResponse(content="".join(content_parts), tool_uses=tool_uses)
+
+
+ProviderRegistry.register("glm", GLMProvider)