claude-all-hands 1.0.0

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/genai/client.py

@@ -0,0 +1,403 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import asyncio
+import os
+from types import TracebackType
+from typing import Optional, Union
+
+import google.auth
+import pydantic
+
+from ._api_client import BaseApiClient
+from ._base_url import get_base_url
+from ._replay_api_client import ReplayApiClient
+from .batches import AsyncBatches, Batches
+from .caches import AsyncCaches, Caches
+from .chats import AsyncChats, Chats
+from .files import AsyncFiles, Files
+from .live import AsyncLive
+from .models import AsyncModels, Models
+from .operations import AsyncOperations, Operations
+from .tokens import AsyncTokens, Tokens
+from .tunings import AsyncTunings, Tunings
+from .types import HttpOptions, HttpOptionsDict, HttpRetryOptions
+
+
+class AsyncClient:
+  """Client for making asynchronous (non-blocking) requests."""
+
+  def __init__(self, api_client: BaseApiClient):
+
+    self._api_client = api_client
+    self._models = AsyncModels(self._api_client)
+    self._tunings = AsyncTunings(self._api_client)
+    self._caches = AsyncCaches(self._api_client)
+    self._batches = AsyncBatches(self._api_client)
+    self._files = AsyncFiles(self._api_client)
+    self._live = AsyncLive(self._api_client)
+    self._tokens = AsyncTokens(self._api_client)
+    self._operations = AsyncOperations(self._api_client)
+
+  @property
+  def models(self) -> AsyncModels:
+    return self._models
+
+  @property
+  def tunings(self) -> AsyncTunings:
+    return self._tunings
+
+  @property
+  def caches(self) -> AsyncCaches:
+    return self._caches
+
+  @property
+  def batches(self) -> AsyncBatches:
+    return self._batches
+
+  @property
+  def chats(self) -> AsyncChats:
+    return AsyncChats(modules=self.models)
+
+  @property
+  def files(self) -> AsyncFiles:
+    return self._files
+
+  @property
+  def live(self) -> AsyncLive:
+    return self._live
+
+  @property
+  def auth_tokens(self) -> AsyncTokens:
+    return self._tokens
+
+  @property
+  def operations(self) -> AsyncOperations:
+    return self._operations
+
+  async def aclose(self) -> None:
+    """Closes the async client explicitly.
+
+    However, it doesn't close the sync client, which can be closed using the
+    Client.close() method or using the context manager.
+
+    Usage:
+    .. code-block:: python
+
+      from google.genai import Client
+
+      async_client = Client(
+          vertexai=True, project='my-project-id', location='us-central1'
+      ).aio
+      response_1 = await async_client.models.generate_content(
+          model='gemini-2.0-flash',
+          contents='Hello World',
+      )
+      response_2 = await async_client.models.generate_content(
+          model='gemini-2.0-flash',
+          contents='Hello World',
+      )
+      # Close the client to release resources.
+      await async_client.aclose()
+    """
+    await self._api_client.aclose()
+
+  async def __aenter__(self) -> 'AsyncClient':
+    return self
+
+  async def __aexit__(
+      self,
+      exc_type: Optional[Exception],
+      exc_value: Optional[Exception],
+      traceback: Optional[TracebackType],
+  ) -> None:
+    await self.aclose()
+
+  def __del__(self) -> None:
+    try:
+      asyncio.get_running_loop().create_task(self.aclose())
+    except Exception:
+      pass
+
+
+class DebugConfig(pydantic.BaseModel):
+  """Configuration options that change client network behavior when testing."""
+
+  client_mode: Optional[str] = pydantic.Field(
+      default_factory=lambda: os.getenv('GOOGLE_GENAI_CLIENT_MODE', None)
+  )
+
+  replays_directory: Optional[str] = pydantic.Field(
+      default_factory=lambda: os.getenv('GOOGLE_GENAI_REPLAYS_DIRECTORY', None)
+  )
+
+  replay_id: Optional[str] = pydantic.Field(
+      default_factory=lambda: os.getenv('GOOGLE_GENAI_REPLAY_ID', None)
+  )
+
+
+class Client:
+  """Client for making synchronous requests.
+
+  Use this client to make a request to the Gemini Developer API or Vertex AI
+  API and then wait for the response.
+
+  To initialize the client, provide the required arguments either directly
+  or by using environment variables. Gemini API users and Vertex AI users in
+  express mode can provide API key by providing input argument
+  `api_key="your-api-key"` or by defining `GOOGLE_API_KEY="your-api-key"` as an
+  environment variable
+
+  Vertex AI API users can provide inputs argument as `vertexai=True,
+  project="your-project-id", location="us-central1"` or by defining
+  `GOOGLE_GENAI_USE_VERTEXAI=true`, `GOOGLE_CLOUD_PROJECT` and
+  `GOOGLE_CLOUD_LOCATION` environment variables.
+
+  Attributes:
+    api_key: The `API key <https://ai.google.dev/gemini-api/docs/api-key>`_ to
+      use for authentication. Applies to the Gemini Developer API only.
+    vertexai: Indicates whether the client should use the Vertex AI API
+      endpoints. Defaults to False (uses Gemini Developer API endpoints).
+      Applies to the Vertex AI API only.
+    credentials: The credentials to use for authentication when calling the
+      Vertex AI APIs. Credentials can be obtained from environment variables and
+      default credentials. For more information, see `Set up Application Default
+      Credentials
+      <https://cloud.google.com/docs/authentication/provide-credentials-adc>`_.
+      Applies to the Vertex AI API only.
+    project: The `Google Cloud project ID
+      <https://cloud.google.com/vertex-ai/docs/start/cloud-environment>`_ to use
+      for quota. Can be obtained from environment variables (for example,
+      ``GOOGLE_CLOUD_PROJECT``). Applies to the Vertex AI API only.
+      Find your `Google Cloud project ID <https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects>`_.
+    location: The `location
+      <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations>`_
+      to send API requests to (for example, ``us-central1``). Can be obtained
+      from environment variables. Applies to the Vertex AI API only.
+    debug_config: Config settings that control network behavior of the client.
+      This is typically used when running test code.
+    http_options: Http options to use for the client. These options will be
+      applied to all requests made by the client. Example usage: `client =
+      genai.Client(http_options=types.HttpOptions(api_version='v1'))`.
+
+  Usage for the Gemini Developer API:
+
+  .. code-block:: python
+
+    from google import genai
+
+    client = genai.Client(api_key='my-api-key')
+
+  Usage for the Vertex AI API:
+
+  .. code-block:: python
+
+    from google import genai
+
+    client = genai.Client(
+        vertexai=True, project='my-project-id', location='us-central1'
+    )
+  """
+
+  def __init__(
+      self,
+      *,
+      vertexai: Optional[bool] = None,
+      api_key: Optional[str] = None,
+      credentials: Optional[google.auth.credentials.Credentials] = None,
+      project: Optional[str] = None,
+      location: Optional[str] = None,
+      debug_config: Optional[DebugConfig] = None,
+      http_options: Optional[Union[HttpOptions, HttpOptionsDict]] = None,
+  ):
+    """Initializes the client.
+
+    Args:
+       vertexai (bool): Indicates whether the client should use the Vertex AI
+         API endpoints. Defaults to False (uses Gemini Developer API endpoints).
+         Applies to the Vertex AI API only.
+       api_key (str): The `API key
+         <https://ai.google.dev/gemini-api/docs/api-key>`_ to use for
+         authentication. Applies to the Gemini Developer API only.
+       credentials (google.auth.credentials.Credentials): The credentials to use
+         for authentication when calling the Vertex AI APIs. Credentials can be
+         obtained from environment variables and default credentials. For more
+         information, see `Set up Application Default Credentials
+         <https://cloud.google.com/docs/authentication/provide-credentials-adc>`_.
+         Applies to the Vertex AI API only.
+       project (str): The `Google Cloud project ID
+         <https://cloud.google.com/vertex-ai/docs/start/cloud-environment>`_ to
+         use for quota. Can be obtained from environment variables (for example,
+         ``GOOGLE_CLOUD_PROJECT``). Applies to the Vertex AI API only.
+       location (str): The `location
+         <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations>`_
+         to send API requests to (for example, ``us-central1``). Can be obtained
+         from environment variables. Applies to the Vertex AI API only.
+       debug_config (DebugConfig): Config settings that control network behavior
+         of the client. This is typically used when running test code.
+       http_options (Union[HttpOptions, HttpOptionsDict]): Http options to use
+         for the client.
+    """
+
+    self._debug_config = debug_config or DebugConfig()
+    if isinstance(http_options, dict):
+      http_options = HttpOptions(**http_options)
+
+    base_url = get_base_url(vertexai or False, http_options)
+    if base_url:
+      if http_options:
+        http_options.base_url = base_url
+      else:
+        http_options = HttpOptions(base_url=base_url)
+
+    self._api_client = self._get_api_client(
+        vertexai=vertexai,
+        api_key=api_key,
+        credentials=credentials,
+        project=project,
+        location=location,
+        debug_config=self._debug_config,
+        http_options=http_options,
+    )
+
+    self._aio = AsyncClient(self._api_client)
+    self._models = Models(self._api_client)
+    self._tunings = Tunings(self._api_client)
+    self._caches = Caches(self._api_client)
+    self._batches = Batches(self._api_client)
+    self._files = Files(self._api_client)
+    self._tokens = Tokens(self._api_client)
+    self._operations = Operations(self._api_client)
+
+  @staticmethod
+  def _get_api_client(
+      vertexai: Optional[bool] = None,
+      api_key: Optional[str] = None,
+      credentials: Optional[google.auth.credentials.Credentials] = None,
+      project: Optional[str] = None,
+      location: Optional[str] = None,
+      debug_config: Optional[DebugConfig] = None,
+      http_options: Optional[HttpOptions] = None,
+  ) -> BaseApiClient:
+    if debug_config and debug_config.client_mode in [
+        'record',
+        'replay',
+        'auto',
+    ]:
+      return ReplayApiClient(
+          mode=debug_config.client_mode,  # type: ignore[arg-type]
+          replay_id=debug_config.replay_id,  # type: ignore[arg-type]
+          replays_directory=debug_config.replays_directory,
+          vertexai=vertexai,  # type: ignore[arg-type]
+          api_key=api_key,
+          credentials=credentials,
+          project=project,
+          location=location,
+          http_options=http_options,
+      )
+
+    return BaseApiClient(
+        vertexai=vertexai,
+        api_key=api_key,
+        credentials=credentials,
+        project=project,
+        location=location,
+        http_options=http_options,
+    )
+
+  @property
+  def chats(self) -> Chats:
+    return Chats(modules=self.models)
+
+  @property
+  def aio(self) -> AsyncClient:
+    return self._aio
+
+  @property
+  def models(self) -> Models:
+    return self._models
+
+  @property
+  def tunings(self) -> Tunings:
+    return self._tunings
+
+  @property
+  def caches(self) -> Caches:
+    return self._caches
+
+  @property
+  def batches(self) -> Batches:
+    return self._batches
+
+  @property
+  def files(self) -> Files:
+    return self._files
+
+  @property
+  def auth_tokens(self) -> Tokens:
+    return self._tokens
+
+  @property
+  def operations(self) -> Operations:
+    return self._operations
+
+  @property
+  def vertexai(self) -> bool:
+    """Returns whether the client is using the Vertex AI API."""
+    return self._api_client.vertexai or False
+
+  def close(self) -> None:
+    """Closes the synchronous client explicitly.
+
+    However, it doesn't close the async client, which can be closed using the
+    Client.aio.aclose() method or using the async context manager.
+
+    Usage:
+    .. code-block:: python
+
+      from google.genai import Client
+
+      client = Client(
+          vertexai=True, project='my-project-id', location='us-central1'
+      )
+      response_1 = client.models.generate_content(
+          model='gemini-2.0-flash',
+          contents='Hello World',
+      )
+      response_2 = client.models.generate_content(
+          model='gemini-2.0-flash',
+          contents='Hello World',
+      )
+      # Close the client to release resources.
+      client.close()
+    """
+    self._api_client.close()
+
+  def __enter__(self) -> 'Client':
+    return self
+
+  def __exit__(
+      self,
+      exc_type: Optional[Exception],
+      exc_value: Optional[Exception],
+      traceback: Optional[TracebackType],
+  ) -> None:
+    self.close()
+
+  def __del__(self) -> None:
+    try:
+      self.close()
+    except Exception:
+      pass

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/genai/errors.py

@@ -0,0 +1,202 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Error classes for the GenAI SDK."""
+
+from typing import Any, Optional, TYPE_CHECKING, Union
+import httpx
+import json
+from . import _common
+
+
+if TYPE_CHECKING:
+  from .replay_api_client import ReplayResponse
+  import aiohttp
+
+
+class APIError(Exception):
+  """General errors raised by the GenAI API."""
+  code: int
+  response: Union['ReplayResponse', httpx.Response]
+
+  status: Optional[str] = None
+  message: Optional[str] = None
+
+  def __init__(
+      self,
+      code: int,
+      response_json: Any,
+      response: Optional[
+          Union['ReplayResponse', httpx.Response, 'aiohttp.ClientResponse']
+      ] = None,
+  ):
+    if isinstance(response_json, list) and len(response_json) == 1:
+      response_json = response_json[0]
+
+    self.response = response
+    self.details = response_json
+    self.message = self._get_message(response_json)
+    self.status = self._get_status(response_json)
+    self.code = code if code else self._get_code(response_json)
+
+    super().__init__(f'{self.code} {self.status}. {self.details}')
+
+  def _get_status(self, response_json: Any) -> Any:
+    return response_json.get(
+        'status', response_json.get('error', {}).get('status', None)
+    )
+
+  def _get_message(self, response_json: Any) -> Any:
+    return response_json.get(
+        'message', response_json.get('error', {}).get('message', None)
+    )
+
+  def _get_code(self, response_json: Any) -> Any:
+    return response_json.get(
+        'code', response_json.get('error', {}).get('code', None)
+    )
+
+  def _to_replay_record(self) -> _common.StringDict:
+    """Returns a dictionary representation of the error for replay recording.
+
+    details is not included since it may expose internal information in the
+    replay file.
+    """
+    return {
+        'error': {
+            'code': self.code,
+            'message': self.message,
+            'status': self.status,
+        }
+    }
+
+  @classmethod
+  def raise_for_response(
+      cls, response: Union['ReplayResponse', httpx.Response]
+  ) -> None:
+    """Raises an error with detailed error message if the response has an error status."""
+    if response.status_code == 200:
+      return
+
+    if isinstance(response, httpx.Response):
+      try:
+        response.read()
+        response_json = response.json()
+      except json.decoder.JSONDecodeError:
+        message = response.text
+        response_json = {
+            'message': message,
+            'status': response.reason_phrase,
+        }
+    else:
+      response_json = response.body_segments[0].get('error', {})
+
+    status_code = response.status_code
+    if 400 <= status_code < 500:
+      raise ClientError(status_code, response_json, response)
+    elif 500 <= status_code < 600:
+      raise ServerError(status_code, response_json, response)
+    else:
+      raise cls(status_code, response_json, response)
+
+  @classmethod
+  async def raise_for_async_response(
+      cls,
+      response: Union[
+          'ReplayResponse', httpx.Response, 'aiohttp.ClientResponse'
+      ],
+  ) -> None:
+    """Raises an error with detailed error message if the response has an error status."""
+    status_code = 0
+    response_json = None
+    if isinstance(response, httpx.Response):
+      if response.status_code == 200:
+        return
+      try:
+        await response.aread()
+        response_json = response.json()
+      except json.decoder.JSONDecodeError:
+        message = response.text
+        response_json = {
+            'message': message,
+            'status': response.reason_phrase,
+        }
+      status_code = response.status_code
+    elif hasattr(response, 'body_segments') and hasattr(
+        response, 'status_code'
+    ):
+      if response.status_code == 200:
+        return
+      response_json = response.body_segments[0].get('error', {})
+      status_code = response.status_code
+    else:
+      try:
+        import aiohttp  # pylint: disable=g-import-not-at-top
+
+        if isinstance(response, aiohttp.ClientResponse):
+          if response.status == 200:
+            return
+          try:
+            response_json = await response.json()
+          except aiohttp.client_exceptions.ContentTypeError:
+            message = await response.text()
+            response_json = {
+                'message': message,
+                'status': response.reason,
+            }
+          status_code = response.status
+        else:
+          raise ValueError(f'Unsupported response type: {type(response)}')
+      except ImportError:
+        raise ValueError(f'Unsupported response type: {type(response)}')
+
+    if 400 <= status_code < 500:
+      raise ClientError(status_code, response_json, response)
+    elif 500 <= status_code < 600:
+      raise ServerError(status_code, response_json, response)
+    else:
+      raise cls(status_code, response_json, response)
+
+
+class ClientError(APIError):
+  """Client error raised by the GenAI API."""
+  pass
+
+
+class ServerError(APIError):
+  """Server error raised by the GenAI API."""
+  pass
+
+
+class UnknownFunctionCallArgumentError(ValueError):
+  """Raised when the function call argument cannot be converted to the parameter annotation."""
+  pass
+
+
+class UnsupportedFunctionError(ValueError):
+  """Raised when the function is not supported."""
+  pass
+
+
+class FunctionInvocationError(ValueError):
+  """Raised when the function cannot be invoked with the given arguments."""
+  pass
+
+
+class UnknownApiResponseError(ValueError):
+  """Raised when the response from the API cannot be parsed as JSON."""
+  pass
+
+ExperimentalWarning = _common.ExperimentalWarning