google-cloud-agentplatform 2.1.0__tar.gz → 2.3.0__tar.gz

{google_cloud_agentplatform-2.1.0/google_cloud_agentplatform.egg-info → google_cloud_agentplatform-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-cloud-agentplatform
-Version: 2.1.0
+Version: 2.3.0
 Summary: Google Cloud Agent Platform Client Library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0

{google_cloud_agentplatform-2.1.0 → google_cloud_agentplatform-2.3.0}/agentplatform/__init__.py

@@ -54,8 +54,17 @@ def __getattr__(name):  # type: ignore[no-untyped-def]
         global _genai_types
         if _genai_types is None:
             _genai_types = importlib.import_module("._genai.types", __name__)
-        if "vertexai.types" not in sys.modules:
-            sys.modules["vertexai.types"] = _genai_types
+        # `types` is an alias for `._genai.types` rather than a real submodule,
+        # so register it to keep
+        # `from agentplatform.types import TypeName`
+        # working without a prior attribute access. Spell it the google3 way:
+        # Copybara rewrites that prefix in both directions, and the external
+        # spelling fails its reversibility check. This key was `vertexai.types`,
+        # which both misnamed this package's own alias and shadowed the real
+        # `vertexai.types` module.
+        types_module_name = f"{__name__}.types"
+        if types_module_name not in sys.modules:
+            sys.modules[types_module_name] = _genai_types
         return _genai_types
 
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

{google_cloud_agentplatform-2.1.0 → google_cloud_agentplatform-2.3.0}/agentplatform/_genai/_evals_common.py

@@ -15,7 +15,6 @@
 """Common utilities for evals."""
 
 import asyncio
-import base64
 import collections
 import concurrent.futures
 import contextlib
@@ -38,6 +37,11 @@ from google.genai._gaos.types.interactions import functioncallstep
 from google.genai._gaos.types.interactions import functionresultstep
 from google.genai._gaos.types.interactions import modeloutputstep
 from google.genai._gaos.types.interactions import userinputstep
+
+try:
+    from google.genai._gaos.utils.serializers import ALLOW_UNKNOWN_UNION_VARIANTS
+except (ImportError, AttributeError):
+    ALLOW_UNKNOWN_UNION_VARIANTS = "speakeasy_allow_unknown_union_variants"
 from google.genai.models import Models
 import pandas as pd
 from tqdm import tqdm
@@ -776,7 +780,16 @@ def _interaction_dict_to_agent_data(
     Returns:
         An AgentData object with one or more ConversationTurns.
     """
-    typed_interaction = interaction_types.Interaction.model_validate(interaction)
+    # A server response, so unknown step types must degrade rather than raise.
+    # `Step` is an open discriminated union: parse_open_union only falls back to
+    # the Unknown variant when the validation context carries
+    # ALLOW_UNKNOWN_UNION_VARIANTS, and raises without it so that a
+    # user-constructed request payload surfaces its mistakes locally. This
+    # payload comes off the Interactions API, so it is on the tolerant side of
+    # that line. _interaction_steps_to_events already drops steps it cannot map.
+    typed_interaction = interaction_types.Interaction.model_validate(
+        interaction, context={ALLOW_UNKNOWN_UNION_VARIANTS: True}
+    )
     all_events = _interaction_steps_to_events(typed_interaction.steps or [])
 
     # Group events into turns. Each UserInputStep starts a new turn.
@@ -1690,8 +1703,12 @@ def _resolve_interactions_to_eval_cases(
                 break
             interaction_dict = json.loads(response.body)
             try:
+                # Also a server response -- see _interaction_dict_to_agent_data.
+                # Without the context a single step type this client does not
+                # know about raised, and the except below turned that into a
+                # `break`, silently truncating the interaction history.
                 typed_interaction = interaction_types.Interaction.model_validate(
-                    interaction_dict
+                    interaction_dict, context={ALLOW_UNKNOWN_UNION_VARIANTS: True}
                 )
             except Exception as e:
                 logger.warning("Failed to validate interaction model: %s", e)
@@ -4078,32 +4095,6 @@ async def _convert_evaluation_run_results_async(
     return eval_result, eval_item_map
 
 
-def _object_to_dict(obj: Any) -> Union[dict[str, Any], Any]:
-    """Converts an object to a dictionary."""
-    if obj is None:
-        return obj
-    if isinstance(obj, (int, float, str, bool)):
-        return obj
-    if isinstance(obj, datetime.datetime):
-        return obj.isoformat()
-    if isinstance(obj, bytes):
-        return base64.b64encode(obj).decode("utf-8")
-    if isinstance(obj, (list, tuple)):
-        return [_object_to_dict(item) for item in obj]
-    if isinstance(obj, dict):
-        return {k: _object_to_dict(v) for k, v in obj.items()}
-
-    if not hasattr(obj, "__dict__"):
-        return obj  # Not an object with attributes, return as is (e.g., set)
-
-    result: dict[str, Any] = {}
-    for key, value in obj.__dict__.items():
-        if value is None:
-            continue
-        result[key] = _object_to_dict(value)
-    return result
-
-
 def _get_content(row: dict[str, Any], column: str) -> Optional[genai_types.Content]:
     if isinstance(row[column], str):
         return genai_types.Content(
@@ -4248,7 +4239,9 @@ def _create_evaluation_set_from_dataframe(
     eval_items = []
     for eval_item_request in eval_item_requests:
         gcs_uri = gcs_utils.upload_json_to_prefix(
-            data=_object_to_dict(eval_item_request),
+            data=eval_item_request.model_dump(
+                mode="json", by_alias=True, exclude_none=True
+            ),
             gcs_dest_prefix=gcs_dest_prefix,
             filename_prefix="request",
         )

{google_cloud_agentplatform-2.1.0 → google_cloud_agentplatform-2.3.0}/agentplatform/_genai/_gcs_utils.py

@@ -17,13 +17,15 @@ from importlib.metadata import version as get_version
 import io
 import json
 import logging
-from typing import Any, Union
+from typing import Any, TYPE_CHECKING, Union
 import uuid
 
 from google.cloud import storage  # type: ignore[attr-defined]
 from google.genai._api_client import BaseApiClient
 from packaging.version import Version
-import pandas as pd
+
+if TYPE_CHECKING:
+    import pandas as pd
 
 
 logger = logging.getLogger(__name__)
@@ -211,6 +213,14 @@ class GcsUtils:
         self, gcs_filepath: str, file_type: str
     ) -> "pd.DataFrame":
         """Reads a file from Google Cloud Storage into a Pandas DataFrame."""
+        try:
+            import pandas as pd  # pylint: disable=g-import-not-at-top
+        except ImportError as e:
+            raise ImportError(
+                "Reading a Cloud Storage file into a DataFrame requires 'pandas'. "
+                "Please install it using pip install "
+                "google-cloud-aiplatform[evaluation]"
+            ) from e
         file_contents = self.read_file_contents(gcs_filepath)
         if file_type == "csv":
             return pd.read_csv(io.StringIO(file_contents), encoding="utf-8")

{google_cloud_agentplatform-2.1.0 → google_cloud_agentplatform-2.3.0}/agentplatform/_genai/client.py

@@ -62,6 +62,10 @@ if TYPE_CHECKING:
     from agentplatform._genai import (
         memory_banks as memory_banks_module,
     )
+    from agentplatform._genai import (
+        serving_profiles as serving_profiles_module,
+    )
+
 
 _GENAI_MODULES_TELEMETRY_HEADER = "vertex-genai-modules"
 
@@ -112,6 +116,7 @@ class AsyncClient:
         self._sessions: Optional[ModuleType] = None
         self._sandboxes: Optional[ModuleType] = None
         self._memory_banks: Optional[ModuleType] = None
+        self._serving_profiles: Optional[ModuleType] = None
 
     @property
     @_common.experimental_warning(
@@ -287,6 +292,17 @@ class AsyncClient:
             self._memory_banks = importlib.import_module(".memory_banks", __package__)
         return self._memory_banks.AsyncMemoryBanks(self._api_client)  # type: ignore[no-any-return]
 
+    @property
+    def serving_profiles(
+        self,
+    ) -> "serving_profiles_module.AsyncServingProfiles":
+        if self._serving_profiles is None:
+            self._serving_profiles = importlib.import_module(
+                ".serving_profiles",
+                __package__,
+            )
+        return self._serving_profiles.AsyncServingProfiles(self._api_client)  # type: ignore[no-any-return]
+
     async def aclose(self) -> None:
         """Closes the async client explicitly.
 
@@ -399,6 +415,7 @@ class Client:
         self._sessions: Optional[ModuleType] = None
         self._sandboxes: Optional[ModuleType] = None
         self._memory_banks: Optional[ModuleType] = None
+        self._serving_profiles: Optional[ModuleType] = None
 
     @property
     def evals(self) -> "evals_module.Evals":
@@ -598,3 +615,12 @@ class Client:
         if self._memory_banks is None:
             self._memory_banks = importlib.import_module(".memory_banks", __package__)
         return self._memory_banks.MemoryBanks(self._api_client)  # type: ignore[no-any-return]
+
+    @property
+    def serving_profiles(self) -> "serving_profiles_module.ServingProfiles":
+        if self._serving_profiles is None:
+            self._serving_profiles = importlib.import_module(
+                ".serving_profiles",
+                __package__,
+            )
+        return self._serving_profiles.ServingProfiles(self._api_client)  # type: ignore[no-any-return]

{google_cloud_agentplatform-2.1.0 → google_cloud_agentplatform-2.3.0}/agentplatform/_genai/evals.py

@@ -215,6 +215,13 @@ def _CustomCodeExecutionSpec_from_vertex(
             getv(from_object, ["evaluation_function"]),
         )
 
+    if getv(from_object, ["codeExecutionRegion"]) is not None:
+        setv(
+            to_object,
+            ["code_execution_region"],
+            getv(from_object, ["codeExecutionRegion"]),
+        )
+
     return to_object
 
 
@@ -237,6 +244,13 @@ def _CustomCodeExecutionSpec_to_vertex(
             getv(from_object, ["remote_custom_function"]),
         )
 
+    if getv(from_object, ["code_execution_region"]) is not None:
+        setv(
+            to_object,
+            ["codeExecutionRegion"],
+            getv(from_object, ["code_execution_region"]),
+        )
+
     return to_object
 
 

{google_cloud_agentplatform-2.1.0 → google_cloud_agentplatform-2.3.0}/agentplatform/_genai/memory_banks.py

@@ -504,6 +504,13 @@ def _ReasoningEngine_from_vertex(
     if getv(from_object, ["trafficConfig"]) is not None:
         setv(to_object, ["traffic_config"], getv(from_object, ["trafficConfig"]))
 
+    if getv(from_object, ["revisionGarbageCollectionStrategy"]) is not None:
+        setv(
+            to_object,
+            ["revision_garbage_collection_strategy"],
+            getv(from_object, ["revisionGarbageCollectionStrategy"]),
+        )
+
     return to_object
 
 

{google_cloud_agentplatform-2.1.0 → google_cloud_agentplatform-2.3.0}/agentplatform/_genai/runtimes.py

@@ -484,6 +484,13 @@ def _ReasoningEngine_from_vertex(
     if getv(from_object, ["trafficConfig"]) is not None:
         setv(to_object, ["traffic_config"], getv(from_object, ["trafficConfig"]))
 
+    if getv(from_object, ["revisionGarbageCollectionStrategy"]) is not None:
+        setv(
+            to_object,
+            ["revision_garbage_collection_strategy"],
+            getv(from_object, ["revisionGarbageCollectionStrategy"]),
+        )
+
     return to_object
 
 

{google_cloud_agentplatform-2.1.0 → google_cloud_agentplatform-2.3.0}/agentplatform/_genai/sandboxes.py

@@ -26,7 +26,6 @@ from typing import Any, Iterator, Optional, Union
 from urllib.parse import urlencode
 
 from google import auth as google_auth
-from google import genai
 from google.auth.transport import requests as google_auth_requests
 from google.genai import _api_module
 from google.genai import _common
@@ -34,6 +33,7 @@ from google.genai import types as genai_types
 from google.genai._common import get_value_by_path as getv
 from google.genai._common import set_value_by_path as setv
 from google.genai.pagers import Pager
+import requests
 
 from . import _runtimes_utils
 from . import types
@@ -1362,6 +1362,7 @@ class Sandboxes(_api_module.BaseModule):
         query_params: Optional[dict[str, object]] = None,
         headers: Optional[dict[str, str]] = None,
         request_dict: Optional[dict[str, object]] = None,
+        psc_endpoint: Optional[str] = None,
     ) -> genai_types.HttpResponse:
         """Sends a command to the sandbox.
 
@@ -1382,6 +1383,16 @@ class Sandboxes(_api_module.BaseModule):
                 Optional. The headers to include in the command.
             request_dict (dict[str, object]):
                 Optional. The request body to include in the command.
+            psc_endpoint (str):
+                Optional. Host (RFC1918 IP or resolvable internal hostname) of the
+                customer-side PSC endpoint forwarding rule that targets
+                ``connection_info.service_attachment``. Needed for VPC-SC sandboxes
+                (``ingressControlConfig.enablePrivateServiceConnect=true``) where
+                ``connection_info.load_balancer_hostname`` and ``load_balancer_ip``
+                are both unset because ingress goes through PSC in the customer's
+                VPC rather than a Google-managed load balancer. When provided, it
+                is used as the data-plane host in place of the load balancer
+                address.
 
         Returns:
             genai_types.HttpResponse: The response from the sandbox.
@@ -1391,12 +1402,21 @@ class Sandboxes(_api_module.BaseModule):
         connection_info = sandbox_environment.connection_info
         if not connection_info:
             raise ValueError("Connection info is not available.")
-        if connection_info.load_balancer_hostname:
+        if psc_endpoint:
+            # VPC-SC path: caller has provisioned a PSC endpoint against
+            # connection_info.service_attachment and passes its host here.
+            endpoint = "https://" + psc_endpoint
+        elif connection_info.load_balancer_hostname:
             endpoint = "https://" + connection_info.load_balancer_hostname
         elif connection_info.load_balancer_ip:
             endpoint = "http://" + connection_info.load_balancer_ip
         else:
-            raise ValueError("Load balancer hostname or ip is not available.")
+            raise ValueError(
+                "No data-plane endpoint available. Non-VPC-SC sandboxes populate"
+                " connection_info.load_balancer_hostname; VPC-SC sandboxes require"
+                " the caller to pass psc_endpoint (the host of the forwarding"
+                " rule targeting connection_info.service_attachment)."
+            )
 
         routing_token = connection_info.routing_token
         if not routing_token:
@@ -1408,15 +1428,27 @@ class Sandboxes(_api_module.BaseModule):
         headers["Authorization"] = f"Bearer {access_token}"
         headers["X-Sandbox-Routing-Token"] = routing_token
         headers["X-Sandbox-Port"] = port
-        endpoint = endpoint + path if path.startswith("/") else endpoint + "/" + path
-        http_options = genai_types.HttpOptions(headers=headers, base_url=endpoint)
-        http_client = genai.Client(vertexai=True, http_options=http_options)
-        # Full path is constructed in this function. The passed in path into request
-        # function will not be used.
-        response = http_client._api_client.request(http_method, path, request_dict)
+        url = endpoint + path if path.startswith("/") else endpoint + "/" + path
+        # The sandbox data plane authenticates via the Authorization,
+        # X-Sandbox-Routing-Token and X-Sandbox-Port headers set above, not via
+        # ADC. Routing this through genai.Client(vertexai=True) builds an
+        # authorized session with no credentials, whose request() then fails with
+        # "'NoneType' object has no attribute 'before_request'". Issue the request
+        # directly instead, mirroring generate_access_token above which also talks
+        # to a non-aiplatform endpoint with plain requests.
+        body = None
+        if request_dict:
+            body = json.dumps(request_dict)
+            headers.setdefault("Content-Type", "application/json")
+        response = requests.request(
+            http_method,
+            url,
+            headers=headers,
+            data=body,
+        )
         return genai_types.HttpResponse(
-            headers=response.headers,
-            body=response.body,
+            headers=dict(response.headers),
+            body=response.text,
         )
 
     def generate_browser_ws_headers(
@@ -1425,6 +1457,7 @@ class Sandboxes(_api_module.BaseModule):
         service_account_email: str,
         port: str = "8080",
         timeout: int = 3600,
+        psc_endpoint: Optional[str] = None,
     ) -> tuple[str, dict[str, str]]:
         """Generates the websocket upgrade headers for the browser.
 
@@ -1438,6 +1471,15 @@ class Sandboxes(_api_module.BaseModule):
                 Defaults to "8080". This should be one of the ports specified during template creation.
             timeout (int):
                 Optional. The timeout in seconds for the token. Defaults to 3600.
+            psc_endpoint (str):
+                Optional. Host (RFC1918 IP or resolvable internal hostname) of the
+                customer-side PSC endpoint forwarding rule that targets
+                ``connection_info.service_attachment``. Needed for VPC-SC
+                sandboxes; see ``send_command`` for details. When provided, it is
+                used as the websocket host in place of the load balancer address,
+                and is propagated to the internal ``send_command`` call that
+                fetches the CDP endpoint.
+
         Returns:
             tuple[str, dict[str, str]]: A tuple containing the websocket URL and
             the headers for websocket upgrade.
@@ -1446,12 +1488,19 @@ class Sandboxes(_api_module.BaseModule):
             raise ValueError("Connection info is not available.")
 
         connection_info = sandbox_environment.connection_info
-        if connection_info.load_balancer_hostname:
+        if psc_endpoint:
+            ws_base_url = "wss://" + psc_endpoint
+        elif connection_info.load_balancer_hostname:
             ws_base_url = "wss://" + connection_info.load_balancer_hostname
         elif connection_info.load_balancer_ip:
             ws_base_url = "ws://" + connection_info.load_balancer_ip
         else:
-            raise ValueError("Load balancer hostname or ip is not available.")
+            raise ValueError(
+                "No data-plane endpoint available. Non-VPC-SC sandboxes populate"
+                " connection_info.load_balancer_hostname; VPC-SC sandboxes require"
+                " the caller to pass psc_endpoint (the host of the forwarding"
+                " rule targeting connection_info.service_attachment)."
+            )
 
         http_access_token = self.generate_access_token(service_account_email, timeout)
         response = self.send_command(
@@ -1460,6 +1509,7 @@ class Sandboxes(_api_module.BaseModule):
             sandbox_environment=sandbox_environment,
             port=port,
             path="/cdp_ws_endpoint",
+            psc_endpoint=psc_endpoint,
         )
         if not response:
             raise ValueError("Failed to get the websocket endpoint.")