polyllm-gemini 0.3.0__tar.gz

polyllm_gemini-0.3.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_gemini-0.3.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: polyllm-gemini
+Version: 0.3.0
+Summary: Google Gemini 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,gemini,google
+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.3.0
+Dynamic: license-file
+
+# PolyLLM OpenAI Plugin for Python
+
+```python
+from polyllm_core import create_llm
+from polyllm_openai import OpenAIPlugin
+
+llm = create_llm(plugins=[OpenAIPlugin()], providers={"openai": {"api_key": "..."}})
+response = await llm.chat("openai:gpt-4o-mini", messages=[{"role": "user", "content": "你好"}])
+```

polyllm_gemini-0.3.0/README.md

@@ -0,0 +1,9 @@
+# PolyLLM OpenAI Plugin for Python
+
+```python
+from polyllm_core import create_llm
+from polyllm_openai import OpenAIPlugin
+
+llm = create_llm(plugins=[OpenAIPlugin()], providers={"openai": {"api_key": "..."}})
+response = await llm.chat("openai:gpt-4o-mini", messages=[{"role": "user", "content": "你好"}])
+```

polyllm_gemini-0.3.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "polyllm-gemini"
+version = "0.3.0"
+description = "Google Gemini plugin for PolyLLM."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["polyllm-core>=0.3.0"]
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "PolyLLM contributors" }]
+keywords = ["llm", "polyllm", "gemini", "google"]
+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_gemini = ["py.typed"]

polyllm_gemini-0.3.0/setup.cfg

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

polyllm_gemini-0.3.0/src/polyllm_gemini/__init__.py

@@ -0,0 +1,4 @@
+from .plugin import GeminiPlugin, normalize_gemini_model_id, parse_sse_events
+from .specs import models
+
+__all__ = ["GeminiPlugin", "models", "normalize_gemini_model_id", "parse_sse_events"]

polyllm_gemini-0.3.0/src/polyllm_gemini/plugin.py

@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, AsyncIterator, Callable, Literal, 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,
+)
+
+from .specs import models
+
+Transport = Callable[[str, str, dict[str, str], dict[str, Any] | None, int], tuple[int, str]]
+FinishReason = Literal["stop", "length", "tool_calls", "content_filter", "other"]
+
+DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
+
+
+def normalize_gemini_model_id(model_id: str) -> str:
+    """Gemini 资源名形如 `models/gemini-2.5-flash`，统一去掉 `models/` 前缀。"""
+    prefix = "models/"
+    return model_id[len(prefix):] if model_id.startswith(prefix) else model_id
+
+
+class GeminiPlugin(LLMPlugin):
+    provider = "gemini"
+    models = models
+
+    def __init__(self, transport: Transport | None = None):
+        self._transport = transport or urllib_transport
+
+    async def chat(
+        self,
+        request: UnifiedRequest,
+        config: ProviderConfig,
+        context: ChatContext,
+    ) -> UnifiedResponse:
+        runtime = resolve_provider_runtime(self.provider, config)
+        base_url = (runtime.base_url or DEFAULT_BASE_URL).rstrip("/")
+        url = f"{base_url}/models/{normalize_gemini_model_id(context.model.id)}:generateContent"
+        status, body = await self._request("POST", url, self._build_body(request), runtime, context)
+        data = self._parse_json(status, body)
+        candidate = (data.get("candidates") or [{}])[0]
+        parts = candidate.get("content", {}).get("parts", [])
+        text = "".join(part.get("text", "") for part in parts if "text" in part)
+        tool_calls = tuple(
+            UnifiedToolCall(
+                id=f"call_{index}",
+                type="function",
+                function={"name": part.get("functionCall", {}).get("name", ""), "arguments": json.dumps(part.get("functionCall", {}).get("args", {}))},
+            )
+            for index, part in enumerate(parts)
+            if "functionCall" in part
+        )
+        usage = data.get("usageMetadata") or {}
+        prompt_tokens = usage.get("promptTokenCount", 0)
+        completion_tokens = usage.get("candidatesTokenCount", 0)
+        finish_reason = self._map_finish_reason(candidate.get("finishReason"))
+        return UnifiedResponse(
+            id="",
+            model=context.model.id,
+            choices=[
+                UnifiedChoice(
+                    index=0,
+                    message=UnifiedMessage(
+                        role="assistant",
+                        content=text,
+                        tool_calls=tool_calls,
+                    ),
+                    finish_reason=finish_reason,
+                )
+            ],
+            usage=UnifiedUsage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=usage.get("totalTokenCount") or prompt_tokens + completion_tokens,
+            ),
+            provider_metadata=data,
+        )
+
+    async def chat_stream(
+        self,
+        request: UnifiedRequest,
+        config: ProviderConfig,
+        context: ChatContext,
+    ) -> AsyncIterator[UnifiedStreamChunk]:
+        runtime = resolve_provider_runtime(self.provider, config)
+        base_url = (runtime.base_url or DEFAULT_BASE_URL).rstrip("/")
+        url = f"{base_url}/models/{normalize_gemini_model_id(context.model.id)}:streamGenerateContent?alt=sse"
+        body = self._build_body(request)
+        status, text = await self._request("POST", url, body, runtime, context)
+        if status < 200 or status >= 300:
+            raise PolyLLMError("PROVIDER_ERROR", f"Gemini API 错误: {status} {text}", {"status": status})
+        for event_payload in parse_sse_events(text):
+            event = json.loads(event_payload)
+            candidate = (event.get("candidates") or [{}])[0]
+            parts = candidate.get("content", {}).get("parts", [])
+            for part in parts:
+                if "text" in part:
+                    yield UnifiedStreamChunk(id="", model=context.model.id, delta={"content": part.get("text", "")})
+                elif "functionCall" in part:
+                    yield UnifiedStreamChunk(
+                        id="",
+                        model=context.model.id,
+                        delta={
+                            "tool_calls": [
+                                {
+                                    "id": f"call_{len(parts) - 1}",
+                                    "type": "function",
+                                    "function": {
+                                        "name": part.get("functionCall", {}).get("name", ""),
+                                        "arguments": json.dumps(part.get("functionCall", {}).get("args", {})),
+                                    },
+                                }
+                            ]
+                        },
+                    )
+            usage = event.get("usageMetadata")
+            if usage:
+                prompt_tokens = usage.get("promptTokenCount", 0)
+                completion_tokens = usage.get("candidatesTokenCount", 0)
+                yield UnifiedStreamChunk(
+                    id="",
+                    model=context.model.id,
+                    delta={},
+                    usage=UnifiedUsage(
+                        prompt_tokens=prompt_tokens,
+                        completion_tokens=completion_tokens,
+                        total_tokens=usage.get("totalTokenCount") or prompt_tokens + completion_tokens,
+                    ),
+                )
+            if candidate.get("finishReason"):
+                yield UnifiedStreamChunk(
+                    id="",
+                    model=context.model.id,
+                    delta={},
+                    finish_reason=self._map_finish_reason(candidate.get("finishReason")),
+                )
+
+    async def list_models(self, config: ProviderConfig) -> list[ProviderModelInfo]:
+        runtime = resolve_provider_runtime(self.provider, config)
+        base_url = (runtime.base_url or DEFAULT_BASE_URL).rstrip("/")
+        url = f"{base_url}/models"
+        status, body = await self._request("GET", url, None, runtime, None)
+        data = self._parse_json(status, body)
+        return [
+            ProviderModelInfo(
+                id=normalize_gemini_model_id(item.get("name") or ""),
+                display_name=item.get("displayName"),
+            )
+            for item in data.get("models", [])
+        ]
+
+    def create_model_spec(self, model_id: str) -> ModelSpec:
+        return ModelSpec(
+            id=model_id,
+            provider=self.provider,
+            capabilities=ModelCapabilities(
+                streaming=True,
+                vision=False,
+                function_calling=True,
+                json_mode=False,
+                system_prompt=True,
+            ),
+            context_window=1048576,
+            max_output=8192,
+        )
+
+    def _build_body(self, request: UnifiedRequest) -> dict[str, Any]:
+        system_parts: list[dict[str, Any]] = []
+        contents: list[dict[str, Any]] = []
+        for message in request.messages:
+            if message.role == "system":
+                system_parts.append({"text": message.content if isinstance(message.content, str) else ""})
+                continue
+            if message.role == "tool":
+                contents.append(
+                    {
+                        "role": "user",
+                        "parts": [
+                            {
+                                "functionResponse": {
+                                    "name": message.name or "",
+                                    "response": json.loads(message.content or "{}")
+                                    if isinstance(message.content, str)
+                                    else {},
+                                }
+                            }
+                        ],
+                    }
+                )
+                continue
+            parts: list[dict[str, Any]] = []
+            if isinstance(message.content, str):
+                if message.content:
+                    parts.append({"text": message.content})
+            else:
+                for part in message.content:
+                    if part.type == "text":
+                        parts.append({"text": part.text or ""})
+                    elif part.type == "image_url":
+                        raise PolyLLMError(
+                            "UNSUPPORTED_PARAMETER",
+                            "Gemini 插件暂不支持远程图片 URL，请直接提供 base64 内容或改用其他供应商",
+                            {"provider": self.provider},
+                        )
+            if message.tool_calls:
+                for call in message.tool_calls:
+                    parts.append(
+                        {"functionCall": {"name": call.function.get("name", ""), "args": json.loads(call.function.get("arguments", "{}"))}}
+                    )
+            if not parts:
+                parts.append({"text": ""})
+            contents.append({"role": "model" if message.role == "assistant" else "user", "parts": parts})
+
+        body: dict[str, Any] = {"contents": contents}
+        if system_parts:
+            body["systemInstruction"] = {"parts": system_parts}
+        if request.temperature is not None:
+            body["temperature"] = request.temperature
+        if request.top_p is not None:
+            body["topP"] = request.top_p
+        if request.max_tokens is not None:
+            body["maxOutputTokens"] = request.max_tokens
+        if request.tools:
+            body["tools"] = [
+                {
+                    "functionDeclarations": [
+                        {
+                            "name": tool.function.get("name", ""),
+                            "description": tool.function.get("description"),
+                            "parameters": tool.function.get("parameters", {}),
+                        }
+                        for tool in request.tools
+                    ]
+                }
+            ]
+        return body
+
+    @staticmethod
+    def _map_finish_reason(reason: Any) -> FinishReason:
+        if reason == "MAX_TOKENS":
+            return "length"
+        if reason in {"SAFETY", "PROHIBITED_CONTENT"}:
+            return "content_filter"
+        return "stop"
+
+    @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"Gemini 返回无效 JSON: {body[:200]}", {"status": status}) from error
+        if status < 200 or status >= 300:
+            raise PolyLLMError(
+                "PROVIDER_ERROR",
+                f"Gemini API 错误: {status} {body}",
+                {"status": status, "body": data},
+            )
+        return data
+
+    async def _request(
+        self,
+        method: str,
+        url: str,
+        payload: dict[str, Any] | None,
+        runtime: Any,
+        context: ChatContext | None,
+    ) -> tuple[int, str]:
+        headers = {"x-goog-api-key": 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, url, headers, payload, timeout_ms)
+
+
+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_events(text: str) -> list[str]:
+    """解析 Gemini `?alt=sse` 的 Server-Sent Events 响应体。
+
+    支持 `data:` 前缀、CRLF/LF、以及末尾没有换行的残留事件；
+    空事件（SSE 规范里的 `\\n\\n` 分隔）返回空列表项，由调用方跳过。
+    """
+    events: list[str] = []
+    for raw_line in text.replace("\r\n", "\n").split("\n"):
+        line = raw_line.strip()
+        if not line.startswith("data:"):
+            continue
+        value = line.removeprefix("data:").strip()
+        if value:
+            events.append(value)
+    return events

polyllm_gemini-0.3.0/src/polyllm_gemini/specs.py

@@ -0,0 +1,42 @@
+from polyllm_core.types import ModelCapabilities, ModelSpec, NumericParamRange
+
+capabilities = ModelCapabilities(
+    streaming=True,
+    vision=False,
+    function_calling=True,
+    json_mode=False,
+    system_prompt=True,
+)
+
+models = (
+    ModelSpec(
+        id="gemini-2.5-flash",
+        provider="gemini",
+        aliases=("gemini-flash", "flash"),
+        snapshot="gemini-2.5-flash",
+        is_latest=True,
+        capabilities=capabilities,
+        params={
+            "temperature": NumericParamRange(0, 2, 1),
+            "max_tokens": NumericParamRange(1, 65536, 8192, field="maxOutputTokens"),
+            "top_p": NumericParamRange(0, 1, 1),
+        },
+        context_window=1048576,
+        max_output=65536,
+    ),
+    ModelSpec(
+        id="gemini-2.5-pro",
+        provider="gemini",
+        aliases=("gemini-pro", "pro"),
+        snapshot="gemini-2.5-pro",
+        is_latest=True,
+        capabilities=capabilities,
+        params={
+            "temperature": NumericParamRange(0, 2, 1),
+            "max_tokens": NumericParamRange(1, 65536, 8192, field="maxOutputTokens"),
+            "top_p": NumericParamRange(0, 1, 1),
+        },
+        context_window=1048576,
+        max_output=65536,
+    ),
+)

polyllm_gemini-0.3.0/src/polyllm_gemini.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: polyllm-gemini
+Version: 0.3.0
+Summary: Google Gemini 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,gemini,google
+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.3.0
+Dynamic: license-file
+
+# PolyLLM OpenAI Plugin for Python
+
+```python
+from polyllm_core import create_llm
+from polyllm_openai import OpenAIPlugin
+
+llm = create_llm(plugins=[OpenAIPlugin()], providers={"openai": {"api_key": "..."}})
+response = await llm.chat("openai:gpt-4o-mini", messages=[{"role": "user", "content": "你好"}])
+```

polyllm_gemini-0.3.0/src/polyllm_gemini.egg-info/SOURCES.txt

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

polyllm_gemini-0.3.0/src/polyllm_gemini.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

polyllm_gemini-0.3.0/src/polyllm_gemini.egg-info/requires.txt

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

polyllm_gemini-0.3.0/src/polyllm_gemini.egg-info/top_level.txt

@@ -0,0 +1 @@
+polyllm_gemini

polyllm_gemini-0.3.0/tests/test_gemini.py

@@ -0,0 +1,116 @@
+import asyncio
+import json
+import unittest
+
+from polyllm_core.types import ChatContext, ProviderConfig, UnifiedContentPart, UnifiedMessage, UnifiedRequest
+from polyllm_gemini import GeminiPlugin
+
+
+class GeminiTests(unittest.TestCase):
+    def test_chat_wire_and_response(self):
+        calls = []
+
+        def transport(method, url, headers, payload, timeout):
+            calls.append((method, url, headers, payload, timeout))
+            return 200, json.dumps(
+                {
+                    "candidates": [
+                        {
+                            "content": {"parts": [{"text": "你好！"}]},
+                            "finishReason": "STOP",
+                        }
+                    ],
+                    "usageMetadata": {
+                        "promptTokenCount": 3,
+                        "candidatesTokenCount": 4,
+                        "totalTokenCount": 7,
+                    },
+                }
+            )
+
+        plugin = GeminiPlugin(transport)
+        context = ChatContext(model=plugin.models[0])
+        response = asyncio.run(
+            plugin.chat(
+                UnifiedRequest(
+                    model="gemini-2.5-flash",
+                    messages=[
+                        UnifiedMessage(role="system", content="你是助手"),
+                        UnifiedMessage(role="user", content="你好"),
+                    ],
+                    temperature=0.5,
+                    max_tokens=512,
+                ),
+                ProviderConfig(api_key="k"),
+                context,
+            )
+        )
+        self.assertEqual(response.choices[0].message.content, "你好！")
+        self.assertEqual(response.usage.total_tokens, 7)
+        self.assertEqual(response.choices[0].finish_reason, "stop")
+        self.assertEqual(calls[0][0], "POST")
+        body = calls[0][3]
+        self.assertEqual(body["systemInstruction"], {"parts": [{"text": "你是助手"}]})
+        self.assertEqual(body["maxOutputTokens"], 512)
+        self.assertTrue(calls[0][1].endswith(":generateContent"))
+
+    def test_list_models_uses_get_and_strips_resource_prefix(self):
+        def transport(method, url, headers, payload, timeout):
+            self.assertEqual(method, "GET")
+            self.assertTrue(url.endswith("/models"))
+            return 200, json.dumps({"models": [{"name": "models/gemini-2.5-flash", "displayName": "Gemini 2.5 Flash"}]})
+
+        models = asyncio.run(GeminiPlugin(transport).list_models(ProviderConfig(api_key="k")))
+        self.assertEqual(models[0].id, "gemini-2.5-flash")
+
+    def test_chat_rejects_remote_image_url(self):
+        def transport(method, url, headers, payload, timeout):
+            return 200, "{}"
+
+        plugin = GeminiPlugin(transport)
+        request = UnifiedRequest(
+            model="gemini-2.5-flash",
+            messages=[
+                UnifiedMessage(
+                    role="user",
+                    content=[UnifiedContentPart(type="image_url", image_url={"url": "https://example.com/a.png"})],
+                ),
+            ],
+        )
+        with self.assertRaises(Exception) as caught:
+            asyncio.run(
+                plugin.chat(request, ProviderConfig(api_key="k"), ChatContext(model=plugin.models[0]))
+            )
+        self.assertIn("UNSUPPORTED_PARAMETER", getattr(caught.exception, "code", str(caught.exception)))
+
+    def test_dynamic_model_disables_vision_until_supported(self):
+        spec = GeminiPlugin().create_model_spec("custom-gemini")
+        self.assertFalse(spec.capabilities.vision)
+
+    def test_stream_parses_sse(self):
+        first = json.dumps({"candidates": [{"content": {"parts": [{"text": "好"}]}}]})
+        last = json.dumps({
+            "candidates": [{"content": {"parts": [{"text": "！"}]}, "finishReason": "STOP"}],
+            "usageMetadata": {"promptTokenCount": 1, "candidatesTokenCount": 2, "totalTokenCount": 3},
+        })
+        sse = f"data: {first}\n\ndata: {last}\n\n"
+
+        async def run():
+            chunks = []
+            plugin = GeminiPlugin(lambda *args: (200, sse))
+            async for chunk in plugin.chat_stream(
+                UnifiedRequest(model="gemini-2.5-flash", messages=[UnifiedMessage(role="user", content="hi")], stream=True),
+                ProviderConfig(api_key="k"),
+                ChatContext(model=plugin.models[0]),
+            ):
+                chunks.append(chunk)
+            return chunks
+
+        chunks = asyncio.run(run())
+        self.assertEqual([chunk.delta.get("content") for chunk in chunks if chunk.delta.get("content") is not None], ["好", "！"])
+        self.assertEqual(chunks[-1].finish_reason, "stop")
+        self.assertTrue(any(chunk.usage is not None for chunk in chunks))
+
+
+if __name__ == "__main__":
+    unittest.main()