google-genai 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

google/genai/chats.py

@@ -21,14 +21,10 @@ from .models import AsyncModels, Models
 from .types import Content, ContentDict, GenerateContentConfigOrDict, GenerateContentResponse, Part, PartUnionDict
 
 
-def _validate_response(response: GenerateContentResponse) -> bool:
-  if not response.candidates:
-    return False
-  if not response.candidates[0].content:
-    return False
-  if not response.candidates[0].content.parts:
+def _validate_content(content: Content) -> bool:
+  if not content.parts:
     return False
-  for part in response.candidates[0].content.parts:
+  for part in content.parts:
     if part == Part():
       return False
     if part.text is not None and part.text == "":
@@ -36,6 +32,76 @@ def _validate_response(response: GenerateContentResponse) -> bool:
   return True
 
 
+def _validate_contents(contents: list[Content]) -> bool:
+  if not contents:
+    return False
+  for content in contents:
+    if not _validate_content(content):
+      return False
+  return True
+
+
+def _validate_response(response: GenerateContentResponse) -> bool:
+  if not response.candidates:
+    return False
+  if not response.candidates[0].content:
+    return False
+  return _validate_content(response.candidates[0].content)
+
+
+def _extract_curated_history(
+    comprehensive_history: list[Content],
+) -> list[Content]:
+  """Extracts the curated (valid) history from a comprehensive history.
+
+  The comprehensive history contains all turns (user input and model responses),
+  including any invalid or rejected model outputs.  This function filters
+  that history to return only the valid turns.
+
+  A "turn" starts with one user input (a single content) and then follows by
+  corresponding model response (which may consist of multiple contents).
+  Turns are assumed to alternate: user input, model output, user input, model
+  output, etc.
+
+  Args:
+      comprehensive_history: A list representing the complete chat history.
+        Including invalid turns.
+
+  Returns:
+      curated history, which is a list of valid turns.
+  """
+  if not comprehensive_history:
+    return []
+  curated_history = []
+  length = len(comprehensive_history)
+  i = 0
+  current_input = comprehensive_history[i]
+  if current_input.role != "user":
+    raise ValueError("History must start with a user turn.")
+  while i < length:
+    if comprehensive_history[i].role not in ["user", "model"]:
+      raise ValueError(
+          "Role must be user or model, but got"
+          f" {comprehensive_history[i].role}"
+      )
+
+    if comprehensive_history[i].role == "user":
+      current_input = comprehensive_history[i]
+      i += 1
+    else:
+      current_output = []
+      is_valid = True
+      while i < length and comprehensive_history[i].role == "model":
+        current_output.append(comprehensive_history[i])
+        if is_valid and not _validate_content(comprehensive_history[i]):
+          is_valid = False
+        i += 1
+      if is_valid:
+        curated_history.append(current_input)
+        curated_history.extend(current_output)
+  return curated_history
+
+
 class _BaseChat:
   """Base chat session."""
 
@@ -44,13 +110,70 @@ class _BaseChat:
       *,
       modules: Union[Models, AsyncModels],
       model: str,
-      config: GenerateContentConfigOrDict = None,
+      config: Optional[GenerateContentConfigOrDict] = None,
       history: list[Content],
   ):
     self._modules = modules
     self._model = model
     self._config = config
-    self._curated_history = history
+    self._comprehensive_history = history
+    """Comprehensive history is the full history of the chat, including turns of the invalid contents from the model and their associated inputs.
+    """
+    self._curated_history = _extract_curated_history(history)
+    """Curated history is the set of valid turns that will be used in the subsequent send requests.
+    """
+
+
+  def record_history(self, user_input: Content,
+                     model_output: list[Content],
+                     automatic_function_calling_history: list[Content],
+                     is_valid: bool):
+    """Records the chat history.
+
+    Maintaining both comprehensive and curated histories.
+
+    Args:
+      user_input: The user's input content.
+      model_output: A list of `Content` from the model's response.
+        This can be an empty list if the model produced no output.
+      automatic_function_calling_history: A list of `Content` representing
+        the history of automatic function calls, including the user input as
+        the first entry.
+      is_valid: A boolean flag indicating whether the current model output is
+        considered valid.
+    """
+    input_contents = (
+        automatic_function_calling_history
+        if automatic_function_calling_history
+        else [user_input]
+    )
+    # Appends an empty content when model returns empty response, so that the
+    # history is always alternating between user and model.
+    output_contents = (
+        model_output if model_output else [Content(role="model", parts=[])]
+    )
+    self._comprehensive_history.extend(input_contents)
+    self._comprehensive_history.extend(output_contents)
+    if is_valid:
+      self._curated_history.extend(input_contents)
+      self._curated_history.extend(output_contents)
+
+
+  def get_history(self, curated: bool = False) -> list[Content]:
+    """Returns the chat history.
+
+    Args:
+        curated: A boolean flag indicating whether to return the curated
+            (valid) history or the comprehensive (all turns) history.
+            Defaults to False (returns the comprehensive history).
+
+    Returns:
+        A list of `Content` objects representing the chat history.
+    """
+    if curated:
+      return self._curated_history
+    else:
+      return self._comprehensive_history
 
 
 class Chat(_BaseChat):
@@ -85,14 +208,17 @@ class Chat(_BaseChat):
         contents=self._curated_history + [input_content],
         config=config if config else self._config,
     )
-    if _validate_response(response):
-      if response.automatic_function_calling_history:
-        self._curated_history.extend(
-            response.automatic_function_calling_history
-        )
-      else:
-        self._curated_history.append(input_content)
-      self._curated_history.append(response.candidates[0].content)
+    model_output = (
+        [response.candidates[0].content]
+        if response.candidates and response.candidates[0].content
+        else []
+    )
+    self.record_history(
+        user_input=input_content,
+        model_output=model_output,
+        automatic_function_calling_history=response.automatic_function_calling_history,
+        is_valid=_validate_response(response),
+    )
     return response
 
   def send_message_stream(
@@ -122,19 +248,26 @@ class Chat(_BaseChat):
     input_content = t.t_content(self._modules._api_client, message)
     output_contents = []
     finish_reason = None
+    is_valid = True
+    chunk = None
     for chunk in self._modules.generate_content_stream(
         model=self._model,
         contents=self._curated_history + [input_content],
         config=config if config else self._config,
     ):
-      if _validate_response(chunk):
+      if not _validate_response(chunk):
+        is_valid = False
+      if chunk.candidates and chunk.candidates[0].content:
         output_contents.append(chunk.candidates[0].content)
       if chunk.candidates and chunk.candidates[0].finish_reason:
         finish_reason = chunk.candidates[0].finish_reason
       yield chunk
-    if output_contents and finish_reason:
-      self._curated_history.append(input_content)
-      self._curated_history.extend(output_contents)
+    self.record_history(
+        user_input=input_content,
+        model_output=output_contents,
+        automatic_function_calling_history=chunk.automatic_function_calling_history,
+        is_valid=is_valid and output_contents and finish_reason,
+    )
 
 
 class Chats:
@@ -147,7 +280,7 @@ class Chats:
       self,
       *,
       model: str,
-      config: GenerateContentConfigOrDict = None,
+      config: Optional[GenerateContentConfigOrDict] = None,
       history: Optional[list[Content]] = None,
   ) -> Chat:
     """Creates a new chat session.
@@ -200,14 +333,17 @@ class AsyncChat(_BaseChat):
         contents=self._curated_history + [input_content],
         config=config if config else self._config,
     )
-    if _validate_response(response):
-      if response.automatic_function_calling_history:
-        self._curated_history.extend(
-            response.automatic_function_calling_history
-        )
-      else:
-        self._curated_history.append(input_content)
-      self._curated_history.append(response.candidates[0].content)
+    model_output = (
+        [response.candidates[0].content]
+        if response.candidates and response.candidates[0].content
+        else []
+    )
+    self.record_history(
+        user_input=input_content,
+        model_output=model_output,
+        automatic_function_calling_history=response.automatic_function_calling_history,
+        is_valid=_validate_response(response),
+    )
     return response
 
   async def send_message_stream(
@@ -238,20 +374,28 @@ class AsyncChat(_BaseChat):
     async def async_generator():
       output_contents = []
       finish_reason = None
+      is_valid = True
+      chunk = None
       async for chunk in await self._modules.generate_content_stream(
           model=self._model,
           contents=self._curated_history + [input_content],
           config=config if config else self._config,
       ):
-        if _validate_response(chunk):
+        if not _validate_response(chunk):
+          is_valid = False
+        if chunk.candidates and chunk.candidates[0].content:
           output_contents.append(chunk.candidates[0].content)
         if chunk.candidates and chunk.candidates[0].finish_reason:
           finish_reason = chunk.candidates[0].finish_reason
         yield chunk
 
-      if output_contents and finish_reason:
-        self._curated_history.append(input_content)
-        self._curated_history.extend(output_contents)
+      self.record_history(
+          user_input=input_content,
+          model_output=output_contents,
+          automatic_function_calling_history=chunk.automatic_function_calling_history,
+          is_valid=is_valid and output_contents and finish_reason,
+
+      )
     return async_generator()
 
 
@@ -265,7 +409,7 @@ class AsyncChats:
       self,
       *,
       model: str,
-      config: GenerateContentConfigOrDict = None,
+      config: Optional[GenerateContentConfigOrDict] = None,
       history: Optional[list[Content]] = None,
   ) -> AsyncChat:
     """Creates a new chat session.

google/genai/client.py

@@ -19,7 +19,7 @@ from typing import Optional, Union
 import google.auth
 import pydantic
 
-from ._api_client import ApiClient, HttpOptions, HttpOptionsDict
+from ._api_client import BaseApiClient, HttpOptions, HttpOptionsDict
 from ._replay_api_client import ReplayApiClient
 from .batches import AsyncBatches, Batches
 from .caches import AsyncCaches, Caches
@@ -27,13 +27,14 @@ 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 .tunings import AsyncTunings, Tunings
 
 
 class AsyncClient:
   """Client for making asynchronous (non-blocking) requests."""
 
-  def __init__(self, api_client: ApiClient):
+  def __init__(self, api_client: BaseApiClient):
 
     self._api_client = api_client
     self._models = AsyncModels(self._api_client)
@@ -42,6 +43,7 @@ class AsyncClient:
     self._batches = AsyncBatches(self._api_client)
     self._files = AsyncFiles(self._api_client)
     self._live = AsyncLive(self._api_client)
+    self._operations = AsyncOperations(self._api_client)
 
   @property
   def models(self) -> AsyncModels:
@@ -71,6 +73,9 @@ class AsyncClient:
   def live(self) -> AsyncLive:
     return self._live
 
+  @property
+  def operations(self) -> AsyncOperations:
+    return self._operations
 
 class DebugConfig(pydantic.BaseModel):
   """Configuration options that change client network behavior when testing."""
@@ -100,9 +105,9 @@ class Client:
   `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=false,
+  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=false`, `GOOGLE_CLOUD_PROJECT` and
+  `GOOGLE_GENAI_USE_VERTEXAI=true`, `GOOGLE_CLOUD_PROJECT` and
   `GOOGLE_CLOUD_LOCATION` environment variables.
 
   Attributes:
@@ -205,6 +210,7 @@ class Client:
     self._caches = Caches(self._api_client)
     self._batches = Batches(self._api_client)
     self._files = Files(self._api_client)
+    self._operations = Operations(self._api_client)
 
   @staticmethod
   def _get_api_client(
@@ -233,7 +239,7 @@ class Client:
           http_options=http_options,
       )
 
-    return ApiClient(
+    return BaseApiClient(
         vertexai=vertexai,
         api_key=api_key,
         credentials=credentials,
@@ -270,7 +276,11 @@ class Client:
   def files(self) -> Files:
     return self._files
 
+  @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
+    return self._api_client.vertexai or False

google/genai/errors.py

@@ -16,7 +16,8 @@
 """Error classes for the GenAI SDK."""
 
 from typing import Any, Optional, TYPE_CHECKING, Union
-
+import httpx
+import json
 import requests
 
 
@@ -27,14 +28,15 @@ if TYPE_CHECKING:
 class APIError(Exception):
   """General errors raised by the GenAI API."""
   code: int
-  response: requests.Response
+  response: Union[requests.Response, 'ReplayResponse', httpx.Response]
 
   status: Optional[str] = None
   message: Optional[str] = None
-  response: Optional[Any] = None
 
   def __init__(
-      self, code: int, response: Union[requests.Response, 'ReplayResponse']
+      self,
+      code: int,
+      response: Union[requests.Response, 'ReplayResponse', httpx.Response],
   ):
     self.response = response
 
@@ -48,6 +50,18 @@ class APIError(Exception):
             'message': response.text,
             'status': response.reason,
         }
+    elif isinstance(response, httpx.Response):
+      try:
+        response_json = response.json()
+      except (json.decoder.JSONDecodeError, httpx.ResponseNotRead):
+        try:
+          message = response.text
+        except httpx.ResponseNotRead:
+          message = None
+        response_json = {
+            'message': message,
+            'status': response.reason_phrase,
+        }
     else:
       response_json = response.body_segments[0].get('error', {})
 
@@ -89,7 +103,7 @@ class APIError(Exception):
 
   @classmethod
   def raise_for_response(
-      cls, response: Union[requests.Response, 'ReplayResponse']
+      cls, response: Union[requests.Response, 'ReplayResponse', httpx.Response]
   ):
     """Raises an error with detailed error message if the response has an error status."""
     if response.status_code == 200: