Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python
5.1 KB
Raw Blame
"""Google Vertex AI provider using the OpenAI-compatible Chat Completions API."""

from dataclasses import replace
from typing import Any

import httpx

from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.providers.admission import (
    ProviderAdmissionController,
    ProviderOperationKind,
)
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.google_openai import (
    GoogleOpenAIProvider,
    VertexReasoningEncoder,
    validate_google_extra_body,
)
from free_claude_code.providers.http import maybe_await_aclose
from free_claude_code.providers.model_listing import (
    ModelListResponseError,
    model_infos_from_ids,
)
from free_claude_code.providers.openai_chat import (
    OpenAIChatProfile,
    OpenAIChatRequestPolicy,
)

from .auth import GoogleAccessTokenProvider
from .endpoint import vertex_openai_base_url, vertex_publisher_models_url
from .models import extract_vertex_model_page

_REQUEST_POLICY = OpenAIChatRequestPolicy(
    provider_name="VERTEX",
    reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,
    include_extra_body=True,
    extra_body_validator=validate_google_extra_body,
)
_PROFILE = OpenAIChatProfile(_REQUEST_POLICY, VertexReasoningEncoder())


class VertexProvider(GoogleOpenAIProvider):
    """Vertex AI Gemini models with renewable ADC and native model discovery."""

    def __init__(
        self,
        config: ProviderConfig,
        *,
        project_id: str,
        location: str,
        admission: ProviderAdmissionController,
        access_token_provider: GoogleAccessTokenProvider | None = None,
    ) -> None:
        self._project_id = project_id.strip()
        self._location = location.strip().lower()
        base_url = vertex_openai_base_url(self._project_id, self._location)
        self._models_url = vertex_publisher_models_url(self._location)
        self._access_token_provider = (
            access_token_provider or GoogleAccessTokenProvider(proxy=config.proxy)
        )
        self._model_list_client = httpx.AsyncClient(
            proxy=config.proxy,
            timeout=httpx.Timeout(
                config.http_read_timeout,
                connect=config.http_connect_timeout,
                read=config.http_read_timeout,
                write=config.http_write_timeout,
            ),
        )
        super().__init__(
            replace(config, base_url=base_url),
            profile=_PROFILE,
            admission=admission,
            api_key_provider=self._access_token_provider,
            default_headers={"x-goog-user-project": self._project_id},
        )

    async def cleanup(self) -> None:
        """Release both OpenAI-compatible and native model-list clients."""
        try:
            await super().cleanup()
        finally:
            await self._model_list_client.aclose()

    async def list_model_infos(self) -> frozenset[ProviderModelInfo]:
        """List Vertex publisher models and translate their resource names."""
        model_ids: set[str] = set()
        page_token: str | None = None
        seen_page_tokens: set[str] = set()
        while True:
            payload = await self._list_model_page(page_token)
            page_ids, page_token = extract_vertex_model_page(payload)
            model_ids.update(page_ids)
            if page_token is None:
                break
            if page_token in seen_page_tokens:
                raise ModelListResponseError(
                    "VERTEX model-list response is malformed: repeated nextPageToken"
                )
            seen_page_tokens.add(page_token)
        if not model_ids:
            raise ModelListResponseError(
                "VERTEX model-list response is malformed: response did not include "
                "any model ids"
            )
        return model_infos_from_ids(model_ids)

    async def _list_model_page(self, page_token: str | None) -> Any:
        async def request() -> httpx.Response:
            token = await self._access_token_provider()
            response = await self._model_list_client.get(
                self._models_url,
                params={"pageToken": page_token} if page_token else None,
                headers={
                    "Authorization": f"Bearer {token}",
                    "x-goog-user-project": self._project_id,
                },
            )
            try:
                response.raise_for_status()
            except Exception:
                await maybe_await_aclose(response)
                raise
            return response

        execution = self._admission.start_execution()
        response = await execution.run_call(
            request,
            operation_kind=ProviderOperationKind.MODEL_DISCOVERY,
        )
        try:
            try:
                return response.json()
            except ValueError as exc:
                raise ModelListResponseError(
                    "VERTEX model-list response is malformed: invalid JSON"
                ) from exc
        finally:
            await maybe_await_aclose(response)