polyllm-openai-compatible 0.1.0__tar.gz

polyllm_openai_compatible-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PolyLLM contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

polyllm_openai_compatible-0.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: polyllm-openai-compatible
+Version: 0.1.0
+Summary: OpenAI-compatible endpoint plugin for PolyLLM.
+Author: PolyLLM contributors
+License-Expression: MIT
+Project-URL: Homepage, https://polyllm.raingpt.top
+Project-URL: Repository, https://github.com/you-want/PolyLLM
+Project-URL: Issues, https://github.com/you-want/PolyLLM/issues
+Keywords: llm,polyllm,openai-compatible,gateway
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: polyllm-core>=0.1.0
+Dynamic: license-file
+
+# PolyLLM OpenAI-Compatible Plugin for Python
+
+适用于 Qwen、Moonshot、OpenRouter、Groq、vLLM、Ollama 等所有兼容 OpenAI Chat Completions 协议的服务。
+
+```python
+from polyllm_core import create_llm
+from polyllm_openai_compatible import OpenAICompatiblePlugin
+
+plugin = OpenAICompatiblePlugin()
+llm = create_llm(
+    plugins=[plugin],
+    providers={"openai-compatible": {"api_key": "...", "base_url": "https://your-endpoint/v1"}},
+    allow_unlisted_models=True,
+)
+response = await llm.chat("openai-compatible:your-model", messages=[{"role": "user", "content": "你好"}])
+```

polyllm_openai_compatible-0.1.0/README.md

@@ -0,0 +1,16 @@
+# PolyLLM OpenAI-Compatible Plugin for Python
+
+适用于 Qwen、Moonshot、OpenRouter、Groq、vLLM、Ollama 等所有兼容 OpenAI Chat Completions 协议的服务。
+
+```python
+from polyllm_core import create_llm
+from polyllm_openai_compatible import OpenAICompatiblePlugin
+
+plugin = OpenAICompatiblePlugin()
+llm = create_llm(
+    plugins=[plugin],
+    providers={"openai-compatible": {"api_key": "...", "base_url": "https://your-endpoint/v1"}},
+    allow_unlisted_models=True,
+)
+response = await llm.chat("openai-compatible:your-model", messages=[{"role": "user", "content": "你好"}])
+```

polyllm_openai_compatible-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "polyllm-openai-compatible"
+version = "0.1.0"
+description = "OpenAI-compatible endpoint plugin for PolyLLM."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["polyllm-core>=0.1.0"]
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "PolyLLM contributors" }]
+keywords = ["llm", "polyllm", "openai-compatible", "gateway"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://polyllm.raingpt.top"
+Repository = "https://github.com/you-want/PolyLLM"
+Issues = "https://github.com/you-want/PolyLLM/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+polyllm_openai_compatible = ["py.typed"]

polyllm_openai_compatible-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

polyllm_openai_compatible-0.1.0/src/polyllm_openai_compatible/__init__.py

@@ -0,0 +1,3 @@
+from .plugin import OpenAICompatiblePlugin, parse_sse, urllib_transport
+
+__all__ = ["OpenAICompatiblePlugin", "parse_sse", "urllib_transport"]

polyllm_openai_compatible-0.1.0/src/polyllm_openai_compatible/plugin.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, AsyncIterator, Callable, cast
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+from polyllm_core.config import resolve_provider_runtime
+from polyllm_core.errors import PolyLLMError
+from polyllm_core.types import (
+    ChatContext,
+    LLMPlugin,
+    ModelCapabilities,
+    ModelSpec,
+    ProviderConfig,
+    ProviderModelInfo,
+    UnifiedChoice,
+    UnifiedMessage,
+    UnifiedRequest,
+    UnifiedResponse,
+    UnifiedStreamChunk,
+    UnifiedToolCall,
+    UnifiedUsage,
+)
+
+Transport = Callable[[str, str, dict[str, str], dict[str, Any] | None, int], tuple[int, str]]
+
+
+class OpenAICompatiblePlugin(LLMPlugin):
+    provider = "openai-compatible"
+    models: tuple[ModelSpec, ...] = ()
+
+    def __init__(self, transport: Transport | None = None, provider: str = "openai-compatible"):
+        self.provider = provider
+        self._transport = transport or urllib_transport
+
+    async def chat(
+        self,
+        request: UnifiedRequest,
+        config: ProviderConfig,
+        context: ChatContext,
+    ) -> UnifiedResponse:
+        status, body = await self._request("POST", "/chat/completions", self._build_body(request), config, context)
+        data = self._parse_json(status, body)
+        choice = data["choices"][0]
+        message = choice["message"]
+        return UnifiedResponse(
+            id=data["id"],
+            model=data["model"],
+            choices=[
+                UnifiedChoice(
+                    index=choice["index"],
+                    message=UnifiedMessage(
+                        role="assistant",
+                        content=message.get("content") or "",
+                        tool_calls=tuple(
+                            UnifiedToolCall(
+                                id=call["id"],
+                                type="function",
+                                function=dict(call["function"]),
+                            )
+                            for call in message.get("tool_calls", [])
+                        ),
+                    ),
+                    finish_reason=choice.get("finish_reason", "other"),
+                )
+            ],
+            usage=self._parse_usage(data.get("usage", {})),
+            provider_metadata=data.get("metadata"),
+        )
+
+    async def chat_stream(
+        self,
+        request: UnifiedRequest,
+        config: ProviderConfig,
+        context: ChatContext,
+    ) -> AsyncIterator[UnifiedStreamChunk]:
+        body = self._build_body(request)
+        body["stream"] = True
+        status, text = await self._request("POST", "/chat/completions", body, config, context)
+        if status < 200 or status >= 300:
+            raise PolyLLMError(
+                "PROVIDER_ERROR",
+                f"OpenAI-compatible API 错误: {status} {text}",
+                {"status": status},
+            )
+        for event in parse_sse(text):
+            yield UnifiedStreamChunk(
+                id=event["id"],
+                model=event["model"],
+                delta=dict(event.get("delta", {})),
+                finish_reason=event.get("finish_reason"),
+            )
+
+    async def list_models(self, config: ProviderConfig) -> list[ProviderModelInfo]:
+        status, body = await self._request("GET", "/models", None, config, None)
+        data = self._parse_json(status, body)
+        return [
+            ProviderModelInfo(
+                id=item["id"],
+                display_name=item.get("display_name") or item.get("name"),
+                owned_by=item.get("owned_by"),
+                created_at=item.get("created"),
+                metadata=item.get("metadata"),
+            )
+            for item in data.get("data", [])
+        ]
+
+    def create_model_spec(self, model_id: str) -> ModelSpec:
+        return ModelSpec(
+            id=model_id,
+            provider=self.provider,
+            capabilities=ModelCapabilities(
+                streaming=True,
+                vision=True,
+                function_calling=True,
+                json_mode=True,
+                system_prompt=True,
+            ),
+            context_window=128000,
+            max_output=16384,
+        )
+
+    def _build_body(self, request: UnifiedRequest) -> dict[str, Any]:
+        body: dict[str, Any] = {
+            "model": request.model,
+            "messages": [
+                {
+                    "role": message.role,
+                    "content": message.content,
+                    **({"name": message.name} if message.name else {}),
+                    **({"tool_call_id": message.tool_call_id} if message.tool_call_id else {}),
+                    **(
+                        {"tool_calls": [dict(call.__dict__) for call in message.tool_calls]}
+                        if message.tool_calls
+                        else {}
+                    ),
+                }
+                for message in request.messages
+            ],
+        }
+        if request.temperature is not None:
+            body["temperature"] = request.temperature
+        if request.max_tokens is not None:
+            body["max_tokens"] = request.max_tokens
+        if request.top_p is not None:
+            body["top_p"] = request.top_p
+        if request.json_mode:
+            body["response_format"] = {"type": "json_object"}
+        if request.tools:
+            body["tools"] = [{"type": "function", "function": dict(tool.function)} for tool in request.tools]
+        return body
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        payload: dict[str, Any] | None,
+        config: ProviderConfig,
+        context: ChatContext | None,
+    ) -> tuple[int, str]:
+        runtime = resolve_provider_runtime(self.provider, config)
+        if not runtime.base_url:
+            raise PolyLLMError(
+                "INVALID_CONFIG",
+                "OpenAI-compatible 供应商必须配置 providers[].base_url",
+                {"provider": self.provider},
+            )
+        base_url = runtime.base_url.rstrip("/")
+        headers = {"Authorization": f"Bearer {runtime.api_key}", **runtime.headers}
+        if payload is not None:
+            headers["Content-Type"] = "application/json"
+        timeout_ms = context.timeout_ms if context is not None and context.timeout_ms is not None else 120000
+        return await asyncio.to_thread(
+            self._transport, method, f"{base_url}{path}", headers, payload, timeout_ms
+        )
+
+    @staticmethod
+    def _parse_usage(data: dict[str, Any]) -> UnifiedUsage:
+        return UnifiedUsage(
+            prompt_tokens=data.get("prompt_tokens", 0),
+            completion_tokens=data.get("completion_tokens", 0),
+            total_tokens=data.get("total_tokens", 0),
+        )
+
+    @staticmethod
+    def _parse_json(status: int, body: str) -> dict[str, Any]:
+        try:
+            data = cast(dict[str, Any], json.loads(body))
+        except json.JSONDecodeError as error:
+            raise PolyLLMError("PROVIDER_ERROR", f"服务返回无效 JSON: {body[:200]}", {"status": status}) from error
+        if status < 200 or status >= 300:
+            raise PolyLLMError(
+                "PROVIDER_ERROR",
+                f"OpenAI-compatible API 错误: {status} {body}",
+                {"status": status, "body": data},
+            )
+        return data
+
+
+def urllib_transport(
+    method: str,
+    url: str,
+    headers: dict[str, str],
+    payload: dict[str, Any] | None,
+    timeout_ms: int,
+) -> tuple[int, str]:
+    data = json.dumps(payload).encode("utf-8") if payload is not None else None
+    request = Request(url, data=data, headers=headers, method=method)
+    try:
+        with urlopen(request, timeout=timeout_ms / 1000) as response:
+            return response.status, response.read().decode("utf-8")
+    except HTTPError as error:
+        return error.code, error.read().decode("utf-8")
+
+
+def parse_sse(text: str) -> list[dict[str, Any]]:
+    events: list[dict[str, Any]] = []
+    for line in text.splitlines():
+        if not line.startswith("data:"):
+            continue
+        value = line.removeprefix("data:").strip()
+        if not value or value == "[DONE]":
+            continue
+        events.append(json.loads(value))
+    return events

polyllm_openai_compatible-0.1.0/src/polyllm_openai_compatible.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: polyllm-openai-compatible
+Version: 0.1.0
+Summary: OpenAI-compatible endpoint plugin for PolyLLM.
+Author: PolyLLM contributors
+License-Expression: MIT
+Project-URL: Homepage, https://polyllm.raingpt.top
+Project-URL: Repository, https://github.com/you-want/PolyLLM
+Project-URL: Issues, https://github.com/you-want/PolyLLM/issues
+Keywords: llm,polyllm,openai-compatible,gateway
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: polyllm-core>=0.1.0
+Dynamic: license-file
+
+# PolyLLM OpenAI-Compatible Plugin for Python
+
+适用于 Qwen、Moonshot、OpenRouter、Groq、vLLM、Ollama 等所有兼容 OpenAI Chat Completions 协议的服务。
+
+```python
+from polyllm_core import create_llm
+from polyllm_openai_compatible import OpenAICompatiblePlugin
+
+plugin = OpenAICompatiblePlugin()
+llm = create_llm(
+    plugins=[plugin],
+    providers={"openai-compatible": {"api_key": "...", "base_url": "https://your-endpoint/v1"}},
+    allow_unlisted_models=True,
+)
+response = await llm.chat("openai-compatible:your-model", messages=[{"role": "user", "content": "你好"}])
+```

polyllm_openai_compatible-0.1.0/src/polyllm_openai_compatible.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/polyllm_openai_compatible/__init__.py
+src/polyllm_openai_compatible/plugin.py
+src/polyllm_openai_compatible/py.typed
+src/polyllm_openai_compatible.egg-info/PKG-INFO
+src/polyllm_openai_compatible.egg-info/SOURCES.txt
+src/polyllm_openai_compatible.egg-info/dependency_links.txt
+src/polyllm_openai_compatible.egg-info/requires.txt
+src/polyllm_openai_compatible.egg-info/top_level.txt
+tests/test_openai_compatible.py

polyllm_openai_compatible-0.1.0/src/polyllm_openai_compatible.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

polyllm_openai_compatible-0.1.0/src/polyllm_openai_compatible.egg-info/requires.txt

@@ -0,0 +1 @@
+polyllm-core>=0.1.0

polyllm_openai_compatible-0.1.0/src/polyllm_openai_compatible.egg-info/top_level.txt

@@ -0,0 +1 @@
+polyllm_openai_compatible

polyllm_openai_compatible-0.1.0/tests/test_openai_compatible.py

@@ -0,0 +1,47 @@
+import asyncio
+import json
+import unittest
+
+from polyllm_core.types import ProviderConfig, UnifiedMessage, UnifiedRequest
+from polyllm_openai_compatible import OpenAICompatiblePlugin
+
+
+class OpenAICompatibleTests(unittest.TestCase):
+    def test_requires_base_url(self):
+        plugin = OpenAICompatiblePlugin()
+        with self.assertRaises(Exception):
+            asyncio.run(plugin.chat(UnifiedRequest(model="m", messages=[]), ProviderConfig(api_key="k"), None))
+
+    def test_chat_uses_provider_base_url(self):
+        urls = []
+
+        def transport(method, url, headers, payload, timeout):
+            urls.append(url)
+            return 200, json.dumps(
+                {
+                    "id": "r",
+                    "model": "m",
+                    "choices": [{"index": 0, "message": {"role": "assistant", "content": "ok"}, "finish_reason": "stop"}],
+                    "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2},
+                }
+            )
+
+        response = asyncio.run(
+            OpenAICompatiblePlugin(transport).chat(
+                UnifiedRequest(model="m", messages=[UnifiedMessage(role="user", content="hi")]),
+                ProviderConfig(api_key="k", base_url="https://example.com/v1/"),
+                None,
+            )
+        )
+        self.assertEqual(response.model, "m")
+        self.assertEqual(urls[0], "https://example.com/v1/chat/completions")
+
+    def test_dynamic_model(self):
+        plugin = OpenAICompatiblePlugin()
+        spec = plugin.create_model_spec("qwen-max")
+        self.assertEqual(spec.provider, "openai-compatible")
+        self.assertEqual(spec.id, "qwen-max")
+
+
+if __name__ == "__main__":
+    unittest.main()