pydantic-ai-opencode 0.1.0__tar.gz

pydantic_ai_opencode-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+.coverage
+htmlcov/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+
+# Virtual environments
+.venv
+
+# OS files
+.DS_Store

pydantic_ai_opencode-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joey Chilson
+
+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.

pydantic_ai_opencode-0.1.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: pydantic-ai-opencode
+Version: 0.1.0
+Summary: Pydantic AI providers and model factory for OpenCode Zen and OpenCode Go.
+Project-URL: Homepage, https://github.com/joeychilson/pydantic_ai_opencode
+Project-URL: Repository, https://github.com/joeychilson/pydantic_ai_opencode
+Project-URL: Issues, https://github.com/joeychilson/pydantic_ai_opencode/issues
+Author-email: Joey Chilson <joeychilson@outlook.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,llm,opencode,providers,pydantic-ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: pydantic-ai-slim[anthropic,google,openai]<2.0.0,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.14.0; extra == 'dev'
+Requires-Dist: ty>=0.0.34; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pydantic-ai-opencode
+
+Pydantic AI providers and a model factory for [OpenCode Zen](https://opencode.ai/docs/zen/) and [OpenCode Go](https://opencode.ai/docs/go/).
+
+OpenCode exposes multiple model families through one gateway per service, but those families use different wire formats. This package chooses the right Pydantic AI model class and provider for each OpenCode model id.
+
+## Install
+
+```bash
+pip install pydantic-ai-opencode
+```
+
+or from this checkout:
+
+```bash
+uv sync
+```
+
+## Authentication
+
+Set an API key:
+
+```bash
+export OPENCODE_API_KEY="..."
+```
+
+or log in with the OpenCode CLI:
+
+```bash
+opencode auth login
+```
+
+The library checks `OPENCODE_API_KEY` first, then the matching entry in
+`~/.local/share/opencode/auth.json`, for example:
+
+```json
+{
+  "opencode-go": {
+    "type": "api",
+    "key": "..."
+  }
+}
+```
+
+## Quick Start
+
+```python
+from pydantic_ai import Agent
+from pydantic_ai_opencode import opencode_model
+
+agent = Agent(
+    opencode_model("opencode-go/glm-5.1"),
+    instructions="You are concise and helpful.",
+)
+
+result = agent.run_sync("Explain Pydantic AI in one sentence.")
+print(result.output)
+```
+
+## Model Factory
+
+Use `opencode_model()` with OpenCode model ids:
+
+```python
+from pydantic_ai_opencode import opencode_model
+
+model = opencode_model("opencode/gpt-5.5")
+model = opencode_model("opencode/claude-opus-4-7")
+model = opencode_model("opencode/gemini-3.1-pro")
+model = opencode_model("opencode-go/glm-5.1")
+model = opencode_model("opencode-go/minimax-m2.7")
+```
+
+You can pass an explicit API key, a custom OpenCode auth file, Pydantic AI model settings, a profile override, or a shared `httpx.AsyncClient`:
+
+```python
+from httpx import AsyncClient
+from pydantic_ai_opencode import opencode_model
+
+client = AsyncClient(timeout=30)
+model = opencode_model(
+    "opencode-go/qwen3.6-plus",
+    api_key="...",
+    http_client=client,
+)
+```
+
+## Direct Providers
+
+Use provider classes directly when you need to build the Pydantic AI model yourself or provide a custom SDK client:
+
+```python
+from pydantic_ai import Agent
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai_opencode import OpenCodeGoProvider
+
+model = OpenAIChatModel(
+    "glm-5.1",
+    provider=OpenCodeGoProvider(api_key="..."),
+)
+agent = Agent(model)
+```
+
+Public providers:
+
+- `OpenCodeZenProvider`: Zen OpenAI client for GPT Responses and chat models
+- `OpenCodeZenAnthropicProvider`: Zen Anthropic client for Claude models
+- `OpenCodeZenGoogleProvider`: Zen Google client for Gemini models
+- `OpenCodeGoProvider`: Go OpenAI client for chat models
+- `OpenCodeGoAnthropicProvider`: Go Anthropic client for MiniMax messages models
+
+## Routing
+
+The factory routes models according to OpenCode service and wire format:
+
+- `opencode/gpt-*`: `OpenAIResponsesModel`
+- `opencode/claude-*`: `AnthropicModel`
+- `opencode/gemini-*`: `GoogleModel`
+- `opencode/<chat-model>`: `OpenAIChatModel`
+- `opencode-go/<chat-model>`: `OpenAIChatModel`
+- `opencode-go/minimax-*`: `AnthropicModel`
+
+List known models:
+
+```python
+from pydantic_ai_opencode import list_models
+
+print(list_models("opencode-go"))
+```
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run --extra dev pytest
+uv run --extra dev ruff check .
+uv build
+```

pydantic_ai_opencode-0.1.0/README.md

@@ -0,0 +1,138 @@
+# pydantic-ai-opencode
+
+Pydantic AI providers and a model factory for [OpenCode Zen](https://opencode.ai/docs/zen/) and [OpenCode Go](https://opencode.ai/docs/go/).
+
+OpenCode exposes multiple model families through one gateway per service, but those families use different wire formats. This package chooses the right Pydantic AI model class and provider for each OpenCode model id.
+
+## Install
+
+```bash
+pip install pydantic-ai-opencode
+```
+
+or from this checkout:
+
+```bash
+uv sync
+```
+
+## Authentication
+
+Set an API key:
+
+```bash
+export OPENCODE_API_KEY="..."
+```
+
+or log in with the OpenCode CLI:
+
+```bash
+opencode auth login
+```
+
+The library checks `OPENCODE_API_KEY` first, then the matching entry in
+`~/.local/share/opencode/auth.json`, for example:
+
+```json
+{
+  "opencode-go": {
+    "type": "api",
+    "key": "..."
+  }
+}
+```
+
+## Quick Start
+
+```python
+from pydantic_ai import Agent
+from pydantic_ai_opencode import opencode_model
+
+agent = Agent(
+    opencode_model("opencode-go/glm-5.1"),
+    instructions="You are concise and helpful.",
+)
+
+result = agent.run_sync("Explain Pydantic AI in one sentence.")
+print(result.output)
+```
+
+## Model Factory
+
+Use `opencode_model()` with OpenCode model ids:
+
+```python
+from pydantic_ai_opencode import opencode_model
+
+model = opencode_model("opencode/gpt-5.5")
+model = opencode_model("opencode/claude-opus-4-7")
+model = opencode_model("opencode/gemini-3.1-pro")
+model = opencode_model("opencode-go/glm-5.1")
+model = opencode_model("opencode-go/minimax-m2.7")
+```
+
+You can pass an explicit API key, a custom OpenCode auth file, Pydantic AI model settings, a profile override, or a shared `httpx.AsyncClient`:
+
+```python
+from httpx import AsyncClient
+from pydantic_ai_opencode import opencode_model
+
+client = AsyncClient(timeout=30)
+model = opencode_model(
+    "opencode-go/qwen3.6-plus",
+    api_key="...",
+    http_client=client,
+)
+```
+
+## Direct Providers
+
+Use provider classes directly when you need to build the Pydantic AI model yourself or provide a custom SDK client:
+
+```python
+from pydantic_ai import Agent
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai_opencode import OpenCodeGoProvider
+
+model = OpenAIChatModel(
+    "glm-5.1",
+    provider=OpenCodeGoProvider(api_key="..."),
+)
+agent = Agent(model)
+```
+
+Public providers:
+
+- `OpenCodeZenProvider`: Zen OpenAI client for GPT Responses and chat models
+- `OpenCodeZenAnthropicProvider`: Zen Anthropic client for Claude models
+- `OpenCodeZenGoogleProvider`: Zen Google client for Gemini models
+- `OpenCodeGoProvider`: Go OpenAI client for chat models
+- `OpenCodeGoAnthropicProvider`: Go Anthropic client for MiniMax messages models
+
+## Routing
+
+The factory routes models according to OpenCode service and wire format:
+
+- `opencode/gpt-*`: `OpenAIResponsesModel`
+- `opencode/claude-*`: `AnthropicModel`
+- `opencode/gemini-*`: `GoogleModel`
+- `opencode/<chat-model>`: `OpenAIChatModel`
+- `opencode-go/<chat-model>`: `OpenAIChatModel`
+- `opencode-go/minimax-*`: `AnthropicModel`
+
+List known models:
+
+```python
+from pydantic_ai_opencode import list_models
+
+print(list_models("opencode-go"))
+```
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run --extra dev pytest
+uv run --extra dev ruff check .
+uv build
+```

pydantic_ai_opencode-0.1.0/examples/basic_agent.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from pydantic_ai import Agent
+
+from pydantic_ai_opencode import opencode_model
+
+agent = Agent(
+    opencode_model("opencode-go/kimi-k2.6"),
+    instructions="You are concise and helpful.",
+)
+
+result = agent.run_sync("Explain Pydantic AI in one sentence.")
+print(result.output)

pydantic_ai_opencode-0.1.0/pydantic_ai_opencode/__init__.py

@@ -0,0 +1,55 @@
+"""Pydantic AI integration for OpenCode Zen and OpenCode Go."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .auth import OpenCodeAuthError, get_opencode_api_key
+from .models import opencode_model
+from .providers import (
+    GO_BASE_URL,
+    ZEN_BASE_URL,
+    OpenCodeGoAnthropicProvider,
+    OpenCodeGoProvider,
+    OpenCodeZenAnthropicProvider,
+    OpenCodeZenGoogleProvider,
+    OpenCodeZenProvider,
+)
+from .registry import (
+    GO_MODELS,
+    ZEN_MODELS,
+    ModelInfo,
+    ServiceName,
+    WireFormat,
+    list_model_info,
+    list_models,
+    model_info,
+)
+
+try:
+    __version__ = version("pydantic-ai-opencode")
+except PackageNotFoundError:  # pragma: no cover - only used from an unpackaged tree
+    __version__ = "0.1.0"
+
+
+__all__ = [
+    "GO_BASE_URL",
+    "GO_MODELS",
+    "OpenCodeAuthError",
+    "OpenCodeGoAnthropicProvider",
+    "OpenCodeGoProvider",
+    "OpenCodeZenAnthropicProvider",
+    "OpenCodeZenGoogleProvider",
+    "OpenCodeZenProvider",
+    "ModelInfo",
+    "ServiceName",
+    "WireFormat",
+    "ZEN_BASE_URL",
+    "ZEN_MODELS",
+    "__version__",
+    "get_opencode_api_key",
+    "list_model_info",
+    "list_models",
+    "model_info",
+    "opencode_model",
+]

pydantic_ai_opencode-0.1.0/pydantic_ai_opencode/auth.py

@@ -0,0 +1,84 @@
+"""Authentication helpers for OpenCode API keys."""
+
+from __future__ import annotations
+
+import json
+import os
+from os import PathLike
+from pathlib import Path
+from typing import Any
+
+DEFAULT_OPENCODE_API_KEY_ENV_VAR = "OPENCODE_API_KEY"
+OPENCODE_AUTH_FILE = Path.home() / ".local" / "share" / "opencode" / "auth.json"
+OPENCODE_SERVICES = ("opencode", "opencode-go")
+
+
+class OpenCodeAuthError(RuntimeError):
+    """Raised when no OpenCode API key can be found."""
+
+
+def read_opencode_auth_file(
+    auth_file: str | PathLike[str] | None = None,
+) -> dict[str, Any]:
+    """Read the OpenCode CLI auth file.
+
+    Invalid or missing auth files are treated as absent so callers can fall back
+    to other auth sources without handling filesystem details.
+    """
+    path = Path(auth_file) if auth_file is not None else OPENCODE_AUTH_FILE
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return {}
+
+    return data if isinstance(data, dict) else {}
+
+
+def get_opencode_api_key(
+    api_key: str | None = None,
+    *,
+    service: str = "opencode",
+    env_var: str = DEFAULT_OPENCODE_API_KEY_ENV_VAR,
+    auth_file: str | PathLike[str] | None = None,
+) -> str:
+    """Return an OpenCode API key from an explicit value, env var, or CLI auth.
+
+    Args:
+        api_key: Explicit API key. Takes precedence when provided.
+        service: OpenCode service auth entry to read from the CLI auth file.
+        env_var: Environment variable to check after `api_key`.
+        auth_file: Optional path to an OpenCode CLI auth file. Defaults to the
+            standard OpenCode auth location.
+
+    Raises:
+        OpenCodeAuthError: If no non-empty API key is available.
+    """
+    if api_key:
+        return api_key
+
+    if value := os.environ.get(env_var):
+        return value
+
+    auth_data = read_opencode_auth_file(auth_file)
+    auth_services = (service, "opencode") if service == "opencode-go" else (service,)
+    for auth_service in auth_services:
+        entry = auth_data.get(auth_service)
+        if isinstance(entry, dict):
+            key = entry.get("key")
+            if isinstance(key, str) and key:
+                return key
+
+    raise OpenCodeAuthError(
+        f"No OpenCode API key found for {service!r}. Set ${env_var} or run "
+        "`opencode auth login`."
+    )
+
+
+__all__ = [
+    "DEFAULT_OPENCODE_API_KEY_ENV_VAR",
+    "OPENCODE_AUTH_FILE",
+    "OPENCODE_SERVICES",
+    "OpenCodeAuthError",
+    "get_opencode_api_key",
+    "read_opencode_auth_file",
+]

pydantic_ai_opencode-0.1.0/pydantic_ai_opencode/models.py

@@ -0,0 +1,131 @@
+"""Model factory for OpenCode model ids."""
+
+from __future__ import annotations
+
+from os import PathLike
+from typing import TYPE_CHECKING
+
+from pydantic_ai.models import Model
+from pydantic_ai.models.anthropic import AnthropicModel
+from pydantic_ai.models.google import GoogleModel
+from pydantic_ai.models.openai import OpenAIChatModel, OpenAIResponsesModel
+from pydantic_ai.profiles import ModelProfileSpec
+from pydantic_ai.settings import ModelSettings
+
+from .auth import get_opencode_api_key
+from .providers import (
+    OpenCodeGoAnthropicProvider,
+    OpenCodeGoProvider,
+    OpenCodeZenAnthropicProvider,
+    OpenCodeZenGoogleProvider,
+    OpenCodeZenProvider,
+)
+from .registry import ModelInfo, model_info
+
+if TYPE_CHECKING:
+    import httpx
+
+
+def _build_model(
+    info: ModelInfo,
+    *,
+    api_key: str,
+    http_client: httpx.AsyncClient | None = None,
+    profile: ModelProfileSpec | None = None,
+    settings: ModelSettings | None = None,
+) -> Model:
+    if info.service == "opencode":
+        if info.wire == "responses":
+            return OpenAIResponsesModel(
+                info.name,
+                provider=OpenCodeZenProvider(api_key=api_key, http_client=http_client),
+                profile=profile,
+                settings=settings,
+            )
+        if info.wire == "chat":
+            return OpenAIChatModel(
+                info.name,
+                provider=OpenCodeZenProvider(api_key=api_key, http_client=http_client),
+                profile=profile,
+                settings=settings,
+            )
+        if info.wire == "messages":
+            return AnthropicModel(
+                info.name,
+                provider=OpenCodeZenAnthropicProvider(
+                    api_key=api_key,
+                    http_client=http_client,
+                ),
+                profile=profile,
+                settings=settings,
+            )
+        if info.wire == "google":
+            return GoogleModel(
+                info.name,
+                provider=OpenCodeZenGoogleProvider(
+                    api_key=api_key,
+                    http_client=http_client,
+                ),
+                profile=profile,
+                settings=settings,
+            )
+
+    if info.service == "opencode-go":
+        if info.wire == "chat":
+            return OpenAIChatModel(
+                info.name,
+                provider=OpenCodeGoProvider(api_key=api_key, http_client=http_client),
+                profile=profile,
+                settings=settings,
+            )
+        if info.wire == "messages":
+            return AnthropicModel(
+                info.name,
+                provider=OpenCodeGoAnthropicProvider(
+                    api_key=api_key,
+                    http_client=http_client,
+                ),
+                profile=profile,
+                settings=settings,
+            )
+
+    raise ValueError(f"Unsupported OpenCode model route: {info!r}")
+
+
+def opencode_model(
+    model_id: str,
+    *,
+    api_key: str | None = None,
+    auth_file: str | PathLike[str] | None = None,
+    http_client: httpx.AsyncClient | None = None,
+    profile: ModelProfileSpec | None = None,
+    settings: ModelSettings | None = None,
+) -> Model:
+    """Build a Pydantic AI model from an OpenCode model id.
+
+    Args:
+        model_id: OpenCode model id, for example `opencode/gpt-5.5` or
+            `opencode-go/glm-5.1`.
+        api_key: Optional OpenCode API key. If omitted, `$OPENCODE_API_KEY` and
+            the OpenCode CLI auth file are checked.
+        auth_file: Optional OpenCode CLI auth file path.
+        http_client: Optional shared `httpx.AsyncClient` for requests.
+        profile: Optional Pydantic AI model profile override.
+        settings: Optional default Pydantic AI model settings.
+    """
+    info = model_info(model_id)
+    resolved_api_key = get_opencode_api_key(
+        api_key,
+        service=info.service,
+        auth_file=auth_file,
+    )
+    return _build_model(
+        info,
+        api_key=resolved_api_key,
+        http_client=http_client,
+        profile=profile,
+        settings=settings,
+    )
+
+
+__all__ = ["opencode_model"]