google-genai 1.3.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
@@ -34,7 +34,7 @@ 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)
@@ -239,7 +239,7 @@ class Client:
           http_options=http_options,
       )
 
-    return ApiClient(
+    return BaseApiClient(
         vertexai=vertexai,
         api_key=api_key,
         credentials=credentials,

google/genai/errors.py

@@ -28,11 +28,10 @@ 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,