pydantic-claude-code 0.1.0__py3-none-any.whl

pydantic_ai_claude_code/__init__.py

@@ -0,0 +1,35 @@
+"""Use your Claude Code subscription from a Pydantic AI Agent.
+
+Quick start:
+
+    from pydantic_ai import Agent
+    from pydantic_ai_claude_code import ClaudeCodeProvider
+
+    provider = ClaudeCodeProvider()
+    agent = Agent(provider.model('claude-sonnet-4-5'))
+"""
+
+from .credentials import ClaudeCodeCredentials
+from .flow import (
+    ClaudeCodeOAuthFlow,
+    exchange_code,
+    login,
+    parse_pasteback,
+    refresh_credentials,
+)
+from .model import ClaudeCodeModel
+from .provider import ClaudeCodeProvider
+from .storage import ClaudeCodeTokenStore, default_auth_path
+
+__all__ = [
+    "ClaudeCodeCredentials",
+    "ClaudeCodeModel",
+    "ClaudeCodeOAuthFlow",
+    "ClaudeCodeProvider",
+    "ClaudeCodeTokenStore",
+    "default_auth_path",
+    "exchange_code",
+    "login",
+    "parse_pasteback",
+    "refresh_credentials",
+]

pydantic_ai_claude_code/__main__.py

@@ -0,0 +1,19 @@
+"""Run `python -m pydantic_ai_claude_code login` to authenticate."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+
+from . import login
+
+
+def main() -> None:
+    if "login" not in sys.argv[1:]:
+        print("Usage: python -m pydantic_ai_claude_code login", file=sys.stderr)
+        sys.exit(2)
+    asyncio.run(login())
+
+
+if __name__ == "__main__":
+    main()

pydantic_ai_claude_code/auth.py

@@ -0,0 +1,83 @@
+"""httpx2 auth shim that authenticates Messages API calls with Claude Code tokens."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from collections.abc import AsyncGenerator, Awaitable, Callable
+
+import httpx2
+
+from pydantic_ai.exceptions import UserError
+
+from . import config
+from .credentials import ClaudeCodeCredentials
+from .flow import refresh_credentials
+
+CredentialsRefreshCallback = Callable[[ClaudeCodeCredentials], Awaitable[None]]
+
+
+class ClaudeCodeCredentialsPersistenceError(UserError):
+    """Raised after refreshed in-memory credentials could not be persisted."""
+
+
+def _expires_soon(credentials: ClaudeCodeCredentials) -> bool:
+    if credentials.expires_at is None:
+        return False
+    return time.time() + 30 >= credentials.expires_at.timestamp()
+
+
+class _ClaudeCodeAuth(httpx2.Auth):
+    requires_response_body = True
+
+    def __init__(self, credentials: ClaudeCodeCredentials, callback: CredentialsRefreshCallback | None = None) -> None:
+        self.credentials = credentials
+        self.callback = callback
+        self.revision = 0
+        self.lock = asyncio.Lock()
+        self.refresh_client = httpx2.AsyncClient()
+
+    async def _refresh(self, used_revision: int) -> None:
+        async with self.lock:
+            if self.revision != used_revision:
+                return
+            updated = await refresh_credentials(self.credentials, http_client=self.refresh_client)
+            self.credentials = updated
+            self.revision += 1
+            if self.callback is not None:
+                try:
+                    await self.callback(updated)
+                except Exception as exc:  # noqa: BLE001 - surface the persistence failure to the caller
+                    raise ClaudeCodeCredentialsPersistenceError(
+                        "Claude Code credentials refreshed in memory, but the persistence callback failed."
+                    ) from exc
+
+    def _apply(self, request: httpx2.Request) -> int:
+        # Subscription tokens are `Authorization: Bearer` credentials, not API keys.
+        # The SDK injects `x-api-key` from the placeholder `api_key`, so it must be
+        # removed or the server validates it first and rejects it as an API key.
+        if "x-api-key" in request.headers:
+            del request.headers["x-api-key"]
+        request.headers["Authorization"] = f"Bearer {self.credentials.token}"
+        request.headers["x-app"] = config.X_APP
+        request.headers["user-agent"] = config.USER_AGENT
+        # Anthropic's SDK manages its own betas; ours must be merged, not replaced.
+        existing_beta = request.headers.get("anthropic-beta")
+        if config.ANTHROPIC_BETA not in (existing_beta or ""):
+            request.headers["anthropic-beta"] = ", ".join(filter(None, [existing_beta, config.ANTHROPIC_BETA]))
+
+        return self.revision
+
+    async def async_auth_flow(self, request: httpx2.Request) -> AsyncGenerator[httpx2.Request, httpx2.Response]:
+        revision = self._apply(request)
+        if _expires_soon(self.credentials):
+            await self._refresh(revision)
+            revision = self._apply(request)
+        response = yield request
+        if response.status_code != 401:
+            return
+        await response.aread()
+        await response.aclose()
+        await self._refresh(revision)
+        self._apply(request)
+        yield request

pydantic_ai_claude_code/config.py

@@ -0,0 +1,44 @@
+"""OAuth endpoint and client configuration for Claude Code authentication.
+
+These constants were verified against the Claude Code CLI 2.1.263 binary
+(embedded config) and its published client metadata:
+
+- `https://claude.ai/oauth/claude-code-client-metadata` (dynamic client registration)
+- Authorization server: `https://claude.com/cai/oauth/authorize`
+- Token endpoint: `https://platform.claude.com/v1/oauth/token`
+
+The shared `9d1c250a...` client id is the public client the official CLI uses,
+so our flow presents the same credentials to Anthropic's authorization server.
+See `flow.py` for the authorization-code flow, and `provider.py` for the API client.
+"""
+
+# OAuth endpoints and the shared public client id used by the Claude Code CLI.
+AUTH_URL = "https://claude.ai/oauth/authorize"
+TOKEN_URL = "https://platform.claude.com/v1/oauth/token"
+CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
+# Same scope set the plugin in `code_puppy_core_plugins` uses. The binary's
+# `user:ccr_inference` scope is not recognized by the authorization server.
+SCOPES = "org:create_api_key user:profile user:inference"
+
+# The subscription tokens minted by this flow are valid against api.anthropic.com.
+API_BASE_URL = "https://api.anthropic.com"
+
+# Must open the system context when authenticating with Claude Code tokens. This
+# is the exact persona string the official CLI sends; the subscription backend
+# expects it at position 0.
+CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI for Claude."
+
+# Redirect handling. We host a short-lived callback server on localhost. The
+# authorization server accepts `http://localhost:<any port>/callback` but
+# rejects `127.0.0.1` variants, so the host must stay `localhost`.
+REDIRECT_HOST = "http://localhost"
+REDIRECT_PATH = "callback"
+CALLBACK_PORT_RANGE = (8765, 8795)
+CALLBACK_TIMEOUT = 180
+PASTEBACK_SCHEMES = ("claude://",)
+
+# Request headers that must accompany Claude Code subscription tokens. `anthropic-beta` is
+# appended (never replaced) by the auth layer so feature betas set by pydantic-ai survive.
+ANTHROPIC_BETA = "oauth-2025-04-20"
+USER_AGENT = "claude-cli/2.1.263 (external, cli)"
+X_APP = "cli"

pydantic_ai_claude_code/credentials.py

@@ -0,0 +1,72 @@
+"""Credentials for Claude Code subscription authentication."""
+
+from __future__ import annotations
+
+import time
+from datetime import UTC, datetime
+
+from pydantic import BaseModel, SecretStr
+
+from pydantic_ai.exceptions import UserError
+
+
+class ClaudeCodeCredentials(BaseModel):
+    """Credentials minted by the Claude Code OAuth flow.
+
+    `access_token` is the bearer token sent to the Messages API. `refresh_token`
+    is used by the auth layer to mint a new pair before expiry.
+    """
+
+    access_token: SecretStr
+    refresh_token: SecretStr
+    expires_at: datetime | None = None
+
+    @property
+    def token(self) -> str:
+        """The plaintext access token."""
+        return self.access_token.get_secret_value()
+
+    def to_wire_dict(self) -> dict[str, object]:
+        """A JSON-serializable, plain-string form of the credentials for storage.
+
+        Pydantic 2.13 masks `SecretStr` in some serialization modes, so the stored
+        form is spelled out here instead of trusting `model_dump`.
+        """
+        return {
+            "access_token": self.token,
+            "refresh_token": self.refresh_token.get_secret_value(),
+            "expires_at": self.expires_at.isoformat() if self.expires_at is not None else None,
+        }
+
+    @classmethod
+    def from_token_response(cls, data: object, previous: ClaudeCodeCredentials | None = None) -> ClaudeCodeCredentials:
+        """Build credentials from a token-endpoint response.
+
+        Args:
+            data: The parsed JSON body of a token response.
+            previous: Prior credentials whose refresh token is reused when the
+                issuer omits a new one, as Anthropic's refresh responses do.
+        """
+        root = data if isinstance(data, dict) else None
+        access_token = root.get("access_token") if root is not None else None
+        refresh_token = root.get("refresh_token") if root is not None else None
+        if not isinstance(access_token, str):
+            raise UserError("Claude Code token response did not contain a string `access_token`.")
+        if not isinstance(refresh_token, str):
+            if previous is None:
+                raise UserError("Claude Code token response did not contain a string `refresh_token`.")
+            refresh_token = previous.refresh_token.get_secret_value()
+        expires_at = None
+        if expires_in := root.get("expires_in"):
+            if isinstance(expires_in, (int, float)) and not isinstance(expires_in, bool):
+                expires_at = datetime.fromtimestamp(time.time() + float(expires_in), tz=UTC)
+        return cls(
+            access_token=SecretStr(access_token),
+            refresh_token=SecretStr(refresh_token),
+            expires_at=expires_at,
+        )
+
+    @classmethod
+    def from_token_file(cls, data: object) -> ClaudeCodeCredentials:
+        """Parse a stored token file (the saved output of a previous exchange)."""
+        return cls.model_validate(data)

pydantic_ai_claude_code/flow.py

@@ -0,0 +1,238 @@
+"""Authorization-code PKCE flow for Claude Code credentials.
+
+The browser flow hosts a short-lived localhost callback server, the same shape as
+the Codex provider's `_REDIRECT_URI`. Both the `claude://` pasteback scheme and a
+plain localhost redirect are supported.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import secrets
+import threading
+import webbrowser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any
+from urllib.parse import parse_qs, urlencode
+
+import httpx2
+
+from pydantic_ai.exceptions import UserError
+
+from . import config
+from .credentials import ClaudeCodeCredentials
+
+
+class ClaudeCodeOAuthFlow:
+    """A side-effect-free authorization-code PKCE flow context."""
+
+    def __init__(self, redirect_uri: str | None = None) -> None:
+        self.redirect_uri = redirect_uri
+        self.state = secrets.token_urlsafe(32)
+        self.code_verifier = secrets.token_urlsafe(64)
+        digest = hashlib.sha256(self.code_verifier.encode()).digest()
+        self.code_challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode()
+
+    def authorization_url(self) -> str:
+        query = urlencode(
+            {
+                "response_type": "code",
+                "client_id": config.CLIENT_ID,
+                "redirect_uri": self.redirect_uri or "",
+                "scope": config.SCOPES,
+                "state": self.state,
+                "code": "true",
+                "code_challenge": self.code_challenge,
+                "code_challenge_method": "S256",
+            }
+        )
+        return f"{config.AUTH_URL}?{query}"
+
+    async def exchange_code(self, code: str, *, http_client: httpx2.AsyncClient | None = None) -> ClaudeCodeCredentials:
+        """Exchange an authorization code for credentials."""
+        return await exchange_code(
+            code, self.code_verifier, self.redirect_uri, state=self.state, http_client=http_client
+        )
+
+
+async def exchange_code(
+    code: str,
+    code_verifier: str,
+    redirect_uri: str | None,
+    *,
+    state: str | None = None,
+    http_client: httpx2.AsyncClient | None = None,
+) -> ClaudeCodeCredentials:
+    """Exchange an authorization code for Claude Code credentials."""
+    async with _client_context(http_client) as client:
+        response = await client.post(
+            config.TOKEN_URL,
+            json={
+                "grant_type": "authorization_code",
+                "client_id": config.CLIENT_ID,
+                "code": code,
+                "redirect_uri": redirect_uri,
+                "code_verifier": code_verifier,
+                "state": state,
+            },
+            headers=_token_headers(),
+        )
+        _raise_for_token_error(response)
+        return ClaudeCodeCredentials.from_token_response(response.json())
+
+
+async def refresh_credentials(
+    credentials: ClaudeCodeCredentials, *, http_client: httpx2.AsyncClient | None = None
+) -> ClaudeCodeCredentials:
+    """Refresh Claude Code credentials without persisting them."""
+    async with _client_context(http_client) as client:
+        response = await client.post(
+            config.TOKEN_URL,
+            json={
+                "grant_type": "refresh_token",
+                "client_id": config.CLIENT_ID,
+                "refresh_token": credentials.refresh_token.get_secret_value(),
+            },
+            headers=_token_headers(),
+        )
+        _raise_for_token_error(response)
+        return ClaudeCodeCredentials.from_token_response(response.json(), previous=credentials)
+
+
+def _raise_for_token_error(response: httpx2.Response) -> None:
+    """Raise a `UserError` that includes the token server's error body.
+
+    The token endpoints return sparse HTTP codes, so the reason lives in the
+    JSON body; without it a 400 tells us nothing.
+    """
+    if response.status_code < 400:
+        return
+    body = response.text[:500]
+    raise UserError(f"Claude Code token endpoint returned {response.status_code}: {body}")
+
+
+def _token_headers() -> dict[str, str]:
+    return {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "anthropic-beta": config.ANTHROPIC_BETA,
+        "User-Agent": config.USER_AGENT,
+    }
+
+
+def parse_pasteback(raw: str) -> tuple[str, str] | None:
+    """Parse a `claude://oauth/callback?...` paste back into `(code, state)`.
+
+    Returns `None` when the input isn't a pasteback URL.
+    """
+    if not raw.startswith(config.PASTEBACK_SCHEMES):
+        return None
+    try:
+        query = raw.partition("?")[2]
+        params = parse_qs(query)
+    except ValueError:
+        return None
+    code = params.get("code", [""])[0]
+    state = params.get("state", [""])[0]
+    if not code:
+        return None
+    return code, state
+
+
+class _CallbackServer(ThreadingHTTPServer):
+    """Localhost server that captures the OAuth redirect query string."""
+
+    def __init__(self) -> None:
+        self.query: str | None = None
+        self.received = threading.Event()
+        super().__init__(("127.0.0.1", 0), _CallbackHandler)
+        self.daemon_threads = True
+
+
+class _CallbackHandler(BaseHTTPRequestHandler):
+    server: _CallbackServer
+
+    def do_GET(self) -> None:  # noqa: N802
+        if not self.server.received.is_set():
+            self.server.query = self.path
+            self.server.received.set()
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.end_headers()
+        self.wfile.write(
+            b"<html><body><h1>pydantic-ai-claude-code</h1><p>Auth successful. Return to your terminal.</p></body></html>"
+        )
+
+    def log_message(self, format: str, *args: object) -> None:  # noqa: A002 - stdlib signature
+        pass
+
+
+def start_login_callback_server() -> _CallbackServer:
+    """Start a callback server plus a daemon thread serving it."""
+    server = _CallbackServer()
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    return server
+
+
+async def login(*, store: Any = None) -> ClaudeCodeCredentials:
+    """Run the full OAuth flow and persist the minted credentials.
+
+    Args:
+        store: The token store to write to. Defaults to the standard store.
+
+    Returns:
+        The credentials that were persisted.
+    """
+    from .storage import ClaudeCodeTokenStore
+
+    if store is None:
+        store = ClaudeCodeTokenStore()
+    server = start_login_callback_server()
+    try:
+        redirect_uri = f"{config.REDIRECT_HOST}:{server.server_address[1]}/{config.REDIRECT_PATH}"
+        flow = ClaudeCodeOAuthFlow(redirect_uri=redirect_uri)
+        url = flow.authorization_url()
+        print(f"Open this URL in your browser if it did not open automatically:\n{url}")
+        # Launch the browser off the event path: on some macOS setups `webbrowser.open`
+        # hangs until the UI settles, which would starve the callback wait below.
+        threading.Thread(target=_open_browser, args=(url,), daemon=True).start()
+        if not server.received.wait(config.CALLBACK_TIMEOUT):
+            raise UserError("Claude Code OAuth callback timed out.")
+        code, state = _parse_callback_query(server.query)
+        if state and state != flow.state:
+            raise UserError("Claude Code OAuth state mismatch; the redirect may be a replay.")
+        if not code:
+            raise UserError(f"Claude Code OAuth redirect did not include a `code` parameter: {server.query!r}")
+        credentials = await flow.exchange_code(code)
+    finally:
+        server.shutdown()
+        server.server_close()
+    store.save(credentials)
+    return credentials
+
+
+def _open_browser(url: str) -> None:
+    try:
+        webbrowser.open(url)
+    except Exception:  # noqa: BLE001 - best-effort: the URL is printed for manual use
+        pass
+
+
+def _parse_callback_query(raw: str | None) -> tuple[str, str]:
+    """Extract `(code, state)` from a captured redirect path like `/callback?code=...`."""
+    params = parse_qs((raw or "").split("?", 1)[-1])
+    return params.get("code", [""])[0], params.get("state", [""])[0]
+
+
+class _client_context:
+    def __init__(self, client: httpx2.AsyncClient | None) -> None:
+        self.client = client or httpx2.AsyncClient()
+        self.owned = client is None
+
+    async def __aenter__(self) -> httpx2.AsyncClient:
+        return self.client
+
+    async def __aexit__(self, *_: object) -> None:
+        if self.owned:
+            await self.client.aclose()

pydantic_ai_claude_code/model.py

@@ -0,0 +1,40 @@
+"""The Claude Code model: an `AnthropicModel` with the Claude Code persona prepended."""
+
+from __future__ import annotations
+
+from pydantic_ai.messages import ModelMessage, ModelRequest, SystemPromptPart
+from pydantic_ai.models.anthropic import AnthropicModel
+
+from . import config
+
+
+class ClaudeCodeModel(AnthropicModel):
+    """AnthropicModel whose system prompt opens with the Claude Code persona.
+
+    The subscription backend expects the Claude Code persona at position 0 of
+    the system context. Prepending a `SystemPromptPart` here is idempotent:
+    once it's in history it stays, and repeated `prepare_messages` calls don't
+    duplicate it.
+    """
+
+    def prepare_messages(
+        self,
+        messages: list[ModelMessage],
+        model_request_parameters=None,
+    ) -> list[ModelMessage]:
+        return super().prepare_messages(_prepend_persona(messages), model_request_parameters)
+
+
+def _prepend_persona(messages: list[ModelMessage]) -> list[ModelMessage]:
+    """Return `messages` with the persona added first, unless it's already there."""
+    for index, message in enumerate(messages):
+        if not isinstance(message, ModelRequest):
+            continue
+        if any(
+            isinstance(part, SystemPromptPart) and part.content.strip().startswith(config.CLAUDE_CODE_SYSTEM_PROMPT)
+            for part in message.parts
+        ):
+            return messages
+        updated = ModelRequest([SystemPromptPart(config.CLAUDE_CODE_SYSTEM_PROMPT), *message.parts])
+        return [*messages[:index], updated, *messages[index + 1 :]]
+    return messages

pydantic_ai_claude_code/provider.py

@@ -0,0 +1,106 @@
+"""Pydantic AI provider backed by a Claude Code subscription."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx2
+
+from anthropic import AsyncAnthropic
+
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.providers.anthropic import AnthropicProvider
+
+from . import config
+from .model import ClaudeCodeModel
+from .auth import _ClaudeCodeAuth
+from .credentials import ClaudeCodeCredentials
+from .storage import ClaudeCodeTokenStore
+
+
+class ClaudeCodeProvider(AnthropicProvider):
+    """Anthropic provider that authenticates with Claude Code subscription tokens.
+
+    Mirrors the `OpenAICodexProvider` pattern from pydantic-ai: the provider owns
+    an httpx2 auth shim that injects the bearer token, refreshes it before expiry,
+    and retries once on 401.
+    """
+
+    @property
+    def name(self) -> str:
+        return "claude-code"
+
+    def __init__(
+        self,
+        credentials: ClaudeCodeCredentials | None = None,
+        *,
+        store: ClaudeCodeTokenStore | None = None,
+        on_credentials_refresh: Any = None,
+        http_client: httpx2.AsyncClient | None = None,
+        base_url: str | None = None,
+    ) -> None:
+        """Create a Claude Code provider.
+
+        Args:
+            credentials: Credentials to use. When omitted, they are loaded from
+                the store (which defaults to the standard token file).
+            store: Token store used to persist refreshed credentials. When
+                credentials are loaded from the store, refreshes are persisted
+                back to it automatically.
+            on_credentials_refresh: Optional callback in place of automatic
+                persistence. Takes precedence over `store` when both are given.
+            http_client: An existing httpx2 client to use; its `auth` is replaced.
+            base_url: Override for the Anthropic API base URL.
+        """
+        if credentials is None:
+            if store is None:
+                store = ClaudeCodeTokenStore()
+            creds = store.load()
+            if creds is None:
+                raise UserError(
+                    "No Claude Code credentials found. Run `asyncio.run(pydantic_ai_claude_code.login())` "
+                    "to authenticate, or pass credentials to the provider."
+                )
+            credentials = creds
+        if on_credentials_refresh is None and store is not None:
+
+            async def persist(updated: ClaudeCodeCredentials) -> None:
+                store.save(updated)
+
+            on_credentials_refresh = persist
+        auth = _ClaudeCodeAuth(credentials, on_credentials_refresh)
+        if http_client is None:
+            http_client = httpx2.AsyncClient(auth=auth)
+        else:
+            http_client.auth = auth  # type: ignore[assignment]
+        self._claude_code_auth = auth
+        self._client = AsyncAnthropic(
+            api_key="unused",  # the auth shim supplies the real credentials
+            base_url=base_url or config.API_BASE_URL,
+            http_client=http_client,
+        )
+
+    @property
+    def credentials(self) -> ClaudeCodeCredentials:
+        """The current credentials; refreshed in place by the auth shim."""
+        return self._claude_code_auth.credentials
+
+    def model(self, model_name: str) -> ClaudeCodeModel:
+        """Build a `ClaudeCodeModel` bound to this provider.
+
+        This is the object-only entry point agreed for the wheel: pass its result
+        to `Agent(model=...)` without modifying pydantic-ai. The persona is
+        prepended to the system context automatically.
+        """
+        return ClaudeCodeModel(model_name, provider=self)
+
+    @classmethod
+    def from_token_store(
+        cls,
+        *,
+        store: ClaudeCodeTokenStore | None = None,
+        http_client: httpx2.AsyncClient | None = None,
+        base_url: str | None = None,
+    ) -> "ClaudeCodeProvider":
+        """Build a provider from the stored token file."""
+        return cls(store=store, http_client=http_client, base_url=base_url)

pydantic_ai_claude_code/storage.py

@@ -0,0 +1,50 @@
+"""Persistent token storage for Claude Code credentials.
+
+The file lives under the user's data directory, is created with `0o600`
+permissions, and its path can be overridden with the `CLAUDE_CODE_AUTH_FILE`
+environment variable.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from pydantic_ai.exceptions import UserError
+
+from .credentials import ClaudeCodeCredentials
+
+
+def default_auth_path() -> Path:
+    """The token file path, honoring the `CLAUDE_CODE_AUTH_FILE` override."""
+    env_path = os.environ.get("CLAUDE_CODE_AUTH_FILE")
+    if env_path:
+        return Path(env_path).expanduser()
+    data_dir = Path(os.environ.get("XDG_DATA_HOME", "") or (Path.home() / ".local" / "share"))
+    return data_dir / "pydantic-ai-claude-code" / "auth.json"
+
+
+class ClaudeCodeTokenStore:
+    """Read and write `ClaudeCodeCredentials` to a single JSON file."""
+
+    def __init__(self, path: str | Path | None = None) -> None:
+        self.path = Path(path) if path is not None else default_auth_path()
+
+    def load(self) -> ClaudeCodeCredentials | None:
+        """Return stored credentials, or `None` when nothing is stored yet."""
+        try:
+            data = json.loads(self.path.read_text())
+        except FileNotFoundError:
+            return None
+        except (OSError, json.JSONDecodeError) as exc:
+            raise UserError(f"Unable to read Claude Code credentials from {str(self.path)!r}.") from exc
+        return ClaudeCodeCredentials.from_token_file(data)
+
+    def save(self, credentials: ClaudeCodeCredentials) -> None:
+        """Persist credentials atomically with restrictive permissions."""
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self.path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(credentials.to_wire_dict(), indent=2))
+        tmp.chmod(0o600)
+        os.replace(tmp, self.path)

pydantic_claude_code-0.1.0.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.5
+Name: pydantic-claude-code
+Version: 0.1.0
+Summary: Use your Claude Code subscription from a Pydantic AI Agent, with full tool support
+Project-URL: Repository, https://github.com/mpfaffenberger/pydantic-ai-claude-code
+Project-URL: Homepage, https://pypi.org/project/pydantic-claude-code/
+Author: Michael Pfaffenberger
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.15,>=3.11
+Requires-Dist: pydantic-ai-slim[anthropic]<3,>=2.31.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.1; extra == 'dev'
+Requires-Dist: pytest>=8.3.4; extra == 'dev'
+Requires-Dist: ruff<0.16,>=0.15; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pydantic-claude-code
+
+Use your Claude Code subscription from a plain pydantic-ai `Agent`, with full
+pydantic-ai tool support. No API key, no separate billing: if Claude Code works
+from your terminal, this wheel works too.
+
+The repo is `mpfaffenberger/pydantic-ai-claude-code` and the import is
+`pydantic_ai_claude_code`; the PyPI project is `pydantic-claude-code`
+(`pip install pydantic-claude-code`).
+
+## Why
+
+pydantic-ai gained a Codex OAuth path where `openai-codex:gpt-6-astra` just
+works against a ChatGPT subscription. This wheel brings the same experience to
+Claude: authenticate once, then run pydantic-ai agents against your Claude
+subscription, using `claude-sonnet-4-5`, `claude-opus-5`, or whatever model you
+subscribe to.
+
+Two deliberate design choices distinguish this from a fork of pydantic-ai:
+
+1. **pydantic-ai owns the loop.** We don't hand the whole agent loop to the
+   Claude Code CLI. pydantic-ai's own `Agent` machinery drives the conversation,
+   executes your tools, and validates structured output. The wheel is a model
+   + provider, not a second agent fighting for control.
+2. **Object-only resolution.** Instead of a `claude-code:` model-name string
+   (which would require patching pydantic-ai's internals), pass the model
+   object you build from the provider.
+
+## Quick start
+
+```python
+import asyncio
+
+from pydantic_ai import Agent
+
+from pydantic_ai_claude_code import ClaudeCodeProvider, login
+
+async def main() -> None:
+    # One-time: opens your browser, mints tokens, stores them
+    # (only needs to run again when tokens are revoked).
+    await login()
+
+    provider = ClaudeCodeProvider()  # loads the stored tokens
+    agent = Agent(provider.model('claude-sonnet-4-5'))
+
+    result = await agent.run('Say hi in three words.')
+    print(result.data)
+
+asyncio.run(main())
+```
+
+### With tools
+
+```python
+from pydantic_ai import Agent
+
+provider = ClaudeCodeProvider()
+agent = Agent(provider.model('claude-sonnet-4-5'))
+
+@agent.tool_plain
+def add(a: int, b: int) -> int:
+    """Add two numbers."""
+    return a + b
+```
+
+Tools defined on the agent are passed to the API as standard Anthropic tool
+definitions, and structured output works the same way as with the built-in
+`anthropic` provider. That's the whole point of the wheel.
+
+## How auth works
+
+The flow uses the same shared OAuth client the Claude Code CLI uses:
+
+- Authorization URL: `https://claude.ai/oauth/authorize`
+- Token URL: `https://platform.claude.com/v1/oauth/token`
+- Scopes: `org:create_api_key user:profile user:inference`
+
+Tokens are stored in (overridable via `CLAUDE_CODE_AUTH_FILE`):
+
+```
+~/.local/share/pydantic-ai-claude-code/auth.json
+```
+
+The file is written with `0o600` permissions and only ever contains what the
+issuer gave us. We never read the CLI's own credential files.
+
+Refreshes happen automatically in the background: the auth shim refreshes
+before expiry and retries once on a 401, exactly like the codex provider does.
+
+Requests identify as Claude Code: `"You are Claude Code, Anthropic's official
+CLI for Claude."` is prepended to the system context (position 0), the same
+persona the CLI sends. The subscription backend expects it and rate-gates
+premium models without it.
+
+## Security and scope
+
+This is a plain Anthropic Messages API client authenticated by your Claude
+subscription tokens. It does not run the Claude Code CLI in a subprocess, so it
+does not inherit Claude Code's sandboxing, permission prompts, or hooks. Treat
+it like any code-executing agent: only give it tools you trust.
+
+Projects using this are responsible for following Anthropic's rules for using
+Claude Code credentials in their own products.
+
+## Development
+
+```bash
+uv sync --extra dev  # or: source .venv/bin/activate && pip install -e ".[dev]"
+ruff check src tests
+pytest
+```
+
+## Prior art
+
+The OAuth mechanics (shared client id, PKCE, token storage and refresh) are
+lifted from the `claude_code_oauth` plugin in
+[`code_puppy_core_plugins`](https://github.com/mpfaffenberger/code_puppy_core_plugins),
+cleaned up and reshaped around the provider pattern in pydantic-ai.

pydantic_claude_code-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pydantic_ai_claude_code/__init__.py,sha256=oEoYiQ_uyGv4GTdwEgyO2oNAoeA12e7sakHJXIpwAA4,832
+pydantic_ai_claude_code/__main__.py,sha256=bFQey7CDpTvkqXpE_wWgf_kQlv977NFLo0t8SzTdw_I,377
+pydantic_ai_claude_code/auth.py,sha256=iv4LpXTU5MIJDCiDOYKce6BidqkEFANqzvnIH_QI4Gs,3373
+pydantic_ai_claude_code/config.py,sha256=MX2M9zc4Alv4c1KbvdjShsCpqwDNepc9wlrUhKEmpWY,2171
+pydantic_ai_claude_code/credentials.py,sha256=3-PVMx-H7SyXMzJNBITdMgMZjZ4k18KJiaft_7fa8Z0,2939
+pydantic_ai_claude_code/flow.py,sha256=XlLeGtUcdvNJP6bKXWZNE_nh18VOZahuLcly2-fq2BI,8424
+pydantic_ai_claude_code/model.py,sha256=jikHE7bY5YMVVfMqUTUPknQpRVFGOtckGaSWLVPe_Ik,1580
+pydantic_ai_claude_code/provider.py,sha256=kRtyUF_zevW90DIUcL9An1GLp-4KzlIwOmdvfMb8gRY,4012
+pydantic_ai_claude_code/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_ai_claude_code/storage.py,sha256=IB271p5VZtjXlch11p3i5LpXwJ5q1kO39hmTOeFxDuQ,1891
+pydantic_claude_code-0.1.0.dist-info/METADATA,sha256=IGx_no9XK0gvSd-w-jzUeaKde4xY0GnlilgTY0JaES8,5049
+pydantic_claude_code-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+pydantic_claude_code-0.1.0.dist-info/licenses/LICENSE,sha256=ANk1gpICbuBKisJscuk8cBJ6SQ6nA3yEi4soa2qSNT8,1078
+pydantic_claude_code-0.1.0.dist-info/RECORD,,

pydantic_claude_code-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pydantic_claude_code-0.1.0.dist-info/licenses/LICENSE

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