google-cloud-agentplatform 2.0.1__tar.gz → 2.1.3__tar.gz

{google_cloud_agentplatform-2.0.1/google_cloud_agentplatform.egg-info → google_cloud_agentplatform-2.1.3}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: google-cloud-agentplatform
-Version: 2.0.1
+Version: 2.1.3
 Summary: Google Cloud Agent Platform Client Library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: google-auth
@@ -74,9 +74,9 @@ Provides-Extra: all
 Requires-Dist: google-cloud-agentplatform[a2a,adk,ag2,agent_engines,bigquery,evaluation,langchain,live,llama_index]; extra == "all"
 Dynamic: license-file
 
-# Google Cloud Agent Platform
+# Gemini Enterprise Agent Platform
 
-This is the packaging directory for `google-cloud-agentplatform`.
+Gemini Enterprise Agent Platform Client Library.
 
 ## Installation
 
@@ -85,9 +85,13 @@ This is the packaging directory for `google-cloud-agentplatform`.
 pip install google-cloud-agentplatform
 
 # With specific extras
+pip install google-cloud-agentplatform[agent_engines]
+pip install google-cloud-agentplatform[a2a]
 pip install google-cloud-agentplatform[adk]
 pip install google-cloud-agentplatform[langchain]
+pip install google-cloud-agentplatform[ag2]
+pip install google-cloud-agentplatform[llama_index]
 pip install google-cloud-agentplatform[evaluation]
 pip install google-cloud-agentplatform[bigquery]
+pip install google-cloud-agentplatform[live]
 pip install google-cloud-agentplatform[all]
-```

google_cloud_agentplatform-2.1.3/README.md

@@ -0,0 +1,21 @@
+# Gemini Enterprise Agent Platform
+
+Gemini Enterprise Agent Platform Client Library.
+
+## Installation
+
+```bash
+# Core installation
+pip install google-cloud-agentplatform
+
+# With specific extras
+pip install google-cloud-agentplatform[agent_engines]
+pip install google-cloud-agentplatform[a2a]
+pip install google-cloud-agentplatform[adk]
+pip install google-cloud-agentplatform[langchain]
+pip install google-cloud-agentplatform[ag2]
+pip install google-cloud-agentplatform[llama_index]
+pip install google-cloud-agentplatform[evaluation]
+pip install google-cloud-agentplatform[bigquery]
+pip install google-cloud-agentplatform[live]
+pip install google-cloud-agentplatform[all]

{google_cloud_agentplatform-2.0.1 → google_cloud_agentplatform-2.1.3}/agentplatform/_genai/_evals_common.py

@@ -15,7 +15,6 @@
 """Common utilities for evals."""
 
 import asyncio
-import base64
 import collections
 import concurrent.futures
 import contextlib
@@ -4078,32 +4077,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 +4221,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.0.1 → google_cloud_agentplatform-2.1.3}/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.0.1 → google_cloud_agentplatform-2.1.3}/agentplatform/_genai/sandbox_templates.py

@@ -62,6 +62,13 @@ def _CreateSandboxEnvironmentTemplateConfig_to_vertex(
             getv(from_object, ["egress_control_config"]),
         )
 
+    if getv(from_object, ["ingress_control_config"]) is not None:
+        setv(
+            parent_object,
+            ["ingressControlConfig"],
+            getv(from_object, ["ingress_control_config"]),
+        )
+
     return to_object
 
 

{google_cloud_agentplatform-2.0.1 → google_cloud_agentplatform-2.1.3}/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
@@ -1038,7 +1038,14 @@ class Sandboxes(_api_module.BaseModule):
                     get_operation_fn=self._get_sandbox_operation,
                     poll_interval_seconds=poll_interval_seconds,
                 )
-            if operation.response:
+            # Only refresh via get() when the LRO response carries a resource
+            # name. The pause LRO's response_type is declared as SandboxEnvironment
+            # in the proto but the backend may return an empty payload for some
+            # code paths, in which case operation.response.name is empty and a
+            # get() call would produce a 404 with an unsubstituted {name} in the
+            # request URL. Callers who want the post-pause state can call
+            # sandboxes.get(name=name) explicitly.
+            if operation.response and getattr(operation.response, "name", None):
                 operation.response = self.get(name=operation.response.name)
         return operation
 
@@ -1084,7 +1091,11 @@ class Sandboxes(_api_module.BaseModule):
                     get_operation_fn=self._get_sandbox_operation,
                     poll_interval_seconds=poll_interval_seconds,
                 )
-            if operation.response:
+            # Only refresh via get() when the LRO response carries a resource
+            # name. Symmetric guard with pause() above: protects against a backend
+            # response payload without a name field, which would otherwise produce
+            # a 404 with an unsubstituted {name} in the request URL.
+            if operation.response and getattr(operation.response, "name", None):
                 operation.response = self.get(name=operation.response.name)
         return operation
 
@@ -1157,6 +1168,85 @@ class Sandboxes(_api_module.BaseModule):
 
         return response
 
+    def execute_bash(
+        self,
+        *,
+        name: str,
+        command: str,
+        cwd: Optional[str] = None,
+        timeout: Optional[int] = None,
+        port: str = "8080",
+        config: Optional[types.ExecuteCodeRuntimeSandboxConfigOrDict] = None,
+    ) -> dict[str, Any]:
+        """Runs a bash command in a shell sandbox.
+
+        The sandbox must have been created with a shell environment, either by
+        passing `spec={"shell_environment": {}}` to `create()` or by referencing a
+        template whose `default_container_category` is
+        `DEFAULT_CONTAINER_CATEGORY_SHELL_SANDBOX`.
+
+        Unlike `send_command`, this authenticates with the caller's own credentials,
+        so it needs no service account and no signed JWT.
+
+        Args:
+            name (str):
+                Required. The name of the agent engine sandbox to run the command
+                in, of the form
+                projects/*/locations/*/reasoningEngines/*/sandboxEnvironments/*.
+            command (str):
+                Required. The bash command to run.
+            cwd (str):
+                Optional. The working directory to run the command in. Defaults to
+                the sandbox's workspace directory.
+            timeout (int):
+                Optional. Seconds to allow the command to run before the sandbox
+                kills it. Defaults to the sandbox's own limit.
+            port (str):
+                Optional. The port the shell server listens on. Defaults to "8080".
+            config (ExecuteCodeRuntimeSandboxConfigOrDict):
+                Optional. The configuration for the request.
+
+        Returns:
+            dict[str, Any]: The result of the command, with keys `stdout`,
+            `stderr`, `returncode` and `duration_ms`. A command that exits
+            non-zero is reported here rather than raised.
+
+        Raises:
+            ValueError: If the sandbox returns no output.
+        """
+        request: dict[str, Any] = {"command": command}
+        if cwd is not None:
+            request["cwd"] = cwd
+        if timeout is not None:
+            request["timeout"] = timeout
+
+        # The sandbox proxy addresses the container by URI and port, and forwards
+        # the JSON chunk as the POST body.
+        response = self._execute_code(
+            name=name,
+            inputs=[
+                types.Chunk(
+                    mime_type="application/x.sandbox-request-uri",
+                    data=b"/exec",
+                ),
+                types.Chunk(
+                    mime_type="application/x.sandbox-request-port",
+                    data=port.encode("utf-8"),
+                ),
+                types.Chunk(
+                    mime_type="application/json",
+                    data=json.dumps(request).encode("utf-8"),
+                ),
+            ],
+            config=config,
+        )
+
+        for output in response.outputs or []:
+            if output.data:
+                return json.loads(output.data.decode("utf-8"))
+
+        raise ValueError(f"The sandbox {name} returned no output for the command.")
+
     def get(
         self,
         *,
@@ -1272,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.
 
@@ -1292,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.
@@ -1301,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:
@@ -1318,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(
@@ -1335,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.
 
@@ -1348,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.
@@ -1356,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(
@@ -1370,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.")

{google_cloud_agentplatform-2.0.1 → google_cloud_agentplatform-2.1.3}/agentplatform/_genai/types/__init__.py

@@ -1968,6 +1968,7 @@ from .common import SandboxEnvironmentTemplateOrDict
 from .common import SandboxEnvironmentTemplateResourceRequirements
 from .common import SandboxEnvironmentTemplateResourceRequirementsDict
 from .common import SandboxEnvironmentTemplateResourceRequirementsOrDict
+from .common import SandboxEnvironmentTemplateState
 from .common import SandboxState
 from .common import SavedQuery
 from .common import SavedQueryDict
@@ -3457,15 +3458,15 @@ __all__ = [
     "SandboxEnvironmentTemplateEgressControlConfig",
     "SandboxEnvironmentTemplateEgressControlConfigDict",
     "SandboxEnvironmentTemplateEgressControlConfigOrDict",
-    "CreateSandboxEnvironmentTemplateConfig",
-    "CreateSandboxEnvironmentTemplateConfigDict",
-    "CreateSandboxEnvironmentTemplateConfigOrDict",
     "PSCAutomationConfig",
     "PSCAutomationConfigDict",
     "PSCAutomationConfigOrDict",
     "PrivateServiceConnectConfig",
     "PrivateServiceConnectConfigDict",
     "PrivateServiceConnectConfigOrDict",
+    "CreateSandboxEnvironmentTemplateConfig",
+    "CreateSandboxEnvironmentTemplateConfigDict",
+    "CreateSandboxEnvironmentTemplateConfigOrDict",
     "SandboxEnvironmentTemplate",
     "SandboxEnvironmentTemplateDict",
     "SandboxEnvironmentTemplateOrDict",
@@ -4309,6 +4310,7 @@ __all__ = [
     "Protocol",
     "DefaultContainerCategory",
     "PscAutomationState",
+    "SandboxEnvironmentTemplateState",
     "PostSnapshotAction",
     "Framework",
     "SkillSource",

{google_cloud_agentplatform-2.0.1 → google_cloud_agentplatform-2.1.3}/agentplatform/_genai/types/common.py

@@ -322,6 +322,12 @@ class SandboxState(_common.CaseInSensitiveEnum):
     """Sandbox has terminated with underlying runtime failure."""
     STATE_DELETED = "STATE_DELETED"
     """Sandbox runtime has been deleted."""
+    STATE_PAUSED = "STATE_PAUSED"
+    """Sandbox runtime is paused."""
+    STATE_PAUSING = "STATE_PAUSING"
+    """Sandbox runtime is pausing."""
+    STATE_RESUMING = "STATE_RESUMING"
+    """Sandbox runtime is resuming."""
 
 
 class Protocol(_common.CaseInSensitiveEnum):
@@ -359,6 +365,23 @@ class PscAutomationState(_common.CaseInSensitiveEnum):
     """The PSC service automation has failed."""
 
 
+class SandboxEnvironmentTemplateState(_common.CaseInSensitiveEnum):
+    """Output only. The state of the sandbox environment template."""
+
+    UNSPECIFIED = "UNSPECIFIED"
+    """The default value. This value is unused."""
+    PROVISIONING = "PROVISIONING"
+    """Runtime resources are being allocated for the sandbox environment."""
+    ACTIVE = "ACTIVE"
+    """Sandbox runtime is ready for serving."""
+    DEPROVISIONING = "DEPROVISIONING"
+    """Sandbox runtime is halted, performing tear down tasks."""
+    DELETED = "DELETED"
+    """Sandbox has terminated with underlying runtime failure."""
+    FAILED = "FAILED"
+    """Sandbox has failed to provision."""
+
+
 class PostSnapshotAction(_common.CaseInSensitiveEnum):
     """Input only. Action to take on the source SandboxEnvironment after the snapshot is taken. This field is only used in CreateSandboxEnvironmentSnapshotRequest and it is not stored in the resource."""
 
@@ -17603,98 +17626,6 @@ SandboxEnvironmentTemplateEgressControlConfigOrDict = Union[
 ]
 
 
-class CreateSandboxEnvironmentTemplateConfig(_common.BaseModel):
-    """Config for creating a Sandbox Template."""
-
-    http_options: Optional[genai_types.HttpOptions] = Field(
-        default=None, description="""Used to override HTTP request options."""
-    )
-    wait_for_completion: Optional[bool] = Field(
-        default=True,
-        description="""Waits for the operation to complete before returning.""",
-    )
-    custom_container_environment: Optional[
-        SandboxEnvironmentTemplateCustomContainerEnvironment
-    ] = Field(
-        default=None,
-        description="""The custom container environment for the sandbox template.""",
-    )
-    default_container_environment: Optional[
-        SandboxEnvironmentTemplateDefaultContainerEnvironment
-    ] = Field(
-        default=None,
-        description="""The default container environment for the sandbox template.""",
-    )
-    egress_control_config: Optional[SandboxEnvironmentTemplateEgressControlConfig] = (
-        Field(
-            default=None,
-            description="""The egress control config for the sandbox template.""",
-        )
-    )
-
-
-class CreateSandboxEnvironmentTemplateConfigDict(TypedDict, total=False):
-    """Config for creating a Sandbox Template."""
-
-    http_options: Optional[genai_types.HttpOptions]
-    """Used to override HTTP request options."""
-
-    wait_for_completion: Optional[bool]
-    """Waits for the operation to complete before returning."""
-
-    custom_container_environment: Optional[
-        SandboxEnvironmentTemplateCustomContainerEnvironmentDict
-    ]
-    """The custom container environment for the sandbox template."""
-
-    default_container_environment: Optional[
-        SandboxEnvironmentTemplateDefaultContainerEnvironmentDict
-    ]
-    """The default container environment for the sandbox template."""
-
-    egress_control_config: Optional[SandboxEnvironmentTemplateEgressControlConfigDict]
-    """The egress control config for the sandbox template."""
-
-
-CreateSandboxEnvironmentTemplateConfigOrDict = Union[
-    CreateSandboxEnvironmentTemplateConfig, CreateSandboxEnvironmentTemplateConfigDict
-]
-
-
-class _CreateSandboxEnvironmentTemplateRequestParameters(_common.BaseModel):
-    """Parameters for creating Sandbox Environment Templates."""
-
-    name: Optional[str] = Field(
-        default=None,
-        description="""Name of the agent runtime to create the template under.""",
-    )
-    display_name: Optional[str] = Field(
-        default=None, description="""The display name of the sandbox template."""
-    )
-    config: Optional[CreateSandboxEnvironmentTemplateConfig] = Field(
-        default=None, description=""""""
-    )
-
-
-class _CreateSandboxEnvironmentTemplateRequestParametersDict(TypedDict, total=False):
-    """Parameters for creating Sandbox Environment Templates."""
-
-    name: Optional[str]
-    """Name of the agent runtime to create the template under."""
-
-    display_name: Optional[str]
-    """The display name of the sandbox template."""
-
-    config: Optional[CreateSandboxEnvironmentTemplateConfigDict]
-    """"""
-
-
-_CreateSandboxEnvironmentTemplateRequestParametersOrDict = Union[
-    _CreateSandboxEnvironmentTemplateRequestParameters,
-    _CreateSandboxEnvironmentTemplateRequestParametersDict,
-]
-
-
 class PSCAutomationConfig(_common.BaseModel):
     """PSC config that is used to automatically create PSC endpoints in the user projects."""
 
@@ -17798,6 +17729,105 @@ PrivateServiceConnectConfigOrDict = Union[
 ]
 
 
+class CreateSandboxEnvironmentTemplateConfig(_common.BaseModel):
+    """Config for creating a Sandbox Template."""
+
+    http_options: Optional[genai_types.HttpOptions] = Field(
+        default=None, description="""Used to override HTTP request options."""
+    )
+    wait_for_completion: Optional[bool] = Field(
+        default=True,
+        description="""Waits for the operation to complete before returning.""",
+    )
+    custom_container_environment: Optional[
+        SandboxEnvironmentTemplateCustomContainerEnvironment
+    ] = Field(
+        default=None,
+        description="""The custom container environment for the sandbox template.""",
+    )
+    default_container_environment: Optional[
+        SandboxEnvironmentTemplateDefaultContainerEnvironment
+    ] = Field(
+        default=None,
+        description="""The default container environment for the sandbox template.""",
+    )
+    egress_control_config: Optional[SandboxEnvironmentTemplateEgressControlConfig] = (
+        Field(
+            default=None,
+            description="""The egress control config for the sandbox template.""",
+        )
+    )
+    ingress_control_config: Optional[PrivateServiceConnectConfig] = Field(
+        default=None,
+        description="""The ingress control config for the sandbox template.""",
+    )
+
+
+class CreateSandboxEnvironmentTemplateConfigDict(TypedDict, total=False):
+    """Config for creating a Sandbox Template."""
+
+    http_options: Optional[genai_types.HttpOptions]
+    """Used to override HTTP request options."""
+
+    wait_for_completion: Optional[bool]
+    """Waits for the operation to complete before returning."""
+
+    custom_container_environment: Optional[
+        SandboxEnvironmentTemplateCustomContainerEnvironmentDict
+    ]
+    """The custom container environment for the sandbox template."""
+
+    default_container_environment: Optional[
+        SandboxEnvironmentTemplateDefaultContainerEnvironmentDict
+    ]
+    """The default container environment for the sandbox template."""
+
+    egress_control_config: Optional[SandboxEnvironmentTemplateEgressControlConfigDict]
+    """The egress control config for the sandbox template."""
+
+    ingress_control_config: Optional[PrivateServiceConnectConfigDict]
+    """The ingress control config for the sandbox template."""
+
+
+CreateSandboxEnvironmentTemplateConfigOrDict = Union[
+    CreateSandboxEnvironmentTemplateConfig, CreateSandboxEnvironmentTemplateConfigDict
+]
+
+
+class _CreateSandboxEnvironmentTemplateRequestParameters(_common.BaseModel):
+    """Parameters for creating Sandbox Environment Templates."""
+
+    name: Optional[str] = Field(
+        default=None,
+        description="""Name of the agent runtime to create the template under.""",
+    )
+    display_name: Optional[str] = Field(
+        default=None, description="""The display name of the sandbox template."""
+    )
+    config: Optional[CreateSandboxEnvironmentTemplateConfig] = Field(
+        default=None, description=""""""
+    )
+
+
+class _CreateSandboxEnvironmentTemplateRequestParametersDict(TypedDict, total=False):
+    """Parameters for creating Sandbox Environment Templates."""
+
+    name: Optional[str]
+    """Name of the agent runtime to create the template under."""
+
+    display_name: Optional[str]
+    """The display name of the sandbox template."""
+
+    config: Optional[CreateSandboxEnvironmentTemplateConfigDict]
+    """"""
+
+
+_CreateSandboxEnvironmentTemplateRequestParametersOrDict = Union[
+    _CreateSandboxEnvironmentTemplateRequestParameters,
+    _CreateSandboxEnvironmentTemplateRequestParametersDict,
+]
+
+
 class SandboxEnvironmentTemplate(_common.BaseModel):
     """A sandbox environment template."""
 
@@ -17831,16 +17861,7 @@ class SandboxEnvironmentTemplate(_common.BaseModel):
         default=None,
         description="""Identifier. The resource name of the SandboxEnvironmentTemplate. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sandboxEnvironmentTemplates/{sandbox_environment_template}`""",
     )
-    state: Optional[
-        Literal[
-            "UNSPECIFIED",
-            "PROVISIONING",
-            "ACTIVE",
-            "DEPROVISIONING",
-            "DELETED",
-            "FAILED",
-        ]
-    ] = Field(
+    state: Optional[SandboxEnvironmentTemplateState] = Field(
         default=None,
         description="""Output only. The state of the sandbox environment template.""",
     )
@@ -17879,16 +17900,7 @@ class SandboxEnvironmentTemplateDict(TypedDict, total=False):
     name: Optional[str]
     """Identifier. The resource name of the SandboxEnvironmentTemplate. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sandboxEnvironmentTemplates/{sandbox_environment_template}`"""
 
-    state: Optional[
-        Literal[
-            "UNSPECIFIED",
-            "PROVISIONING",
-            "ACTIVE",
-            "DEPROVISIONING",
-            "DELETED",
-            "FAILED",
-        ]
-    ]
+    state: Optional[SandboxEnvironmentTemplateState]
     """Output only. The state of the sandbox environment template."""
 
     update_time: Optional[datetime.datetime]

{google_cloud_agentplatform-2.0.1 → google_cloud_agentplatform-2.1.3}/agentplatform/version.py

@@ -14,4 +14,4 @@
 #
 """Version file for agentplatform."""
 
-__version__ = "2.0.1"
+__version__ = "2.1.3"

{google_cloud_agentplatform-2.0.1 → google_cloud_agentplatform-2.1.3/google_cloud_agentplatform.egg-info}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: google-cloud-agentplatform
-Version: 2.0.1
+Version: 2.1.3
 Summary: Google Cloud Agent Platform Client Library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: google-auth
@@ -74,9 +74,9 @@ Provides-Extra: all
 Requires-Dist: google-cloud-agentplatform[a2a,adk,ag2,agent_engines,bigquery,evaluation,langchain,live,llama_index]; extra == "all"
 Dynamic: license-file
 
-# Google Cloud Agent Platform
+# Gemini Enterprise Agent Platform
 
-This is the packaging directory for `google-cloud-agentplatform`.
+Gemini Enterprise Agent Platform Client Library.
 
 ## Installation
 
@@ -85,9 +85,13 @@ This is the packaging directory for `google-cloud-agentplatform`.
 pip install google-cloud-agentplatform
 
 # With specific extras
+pip install google-cloud-agentplatform[agent_engines]
+pip install google-cloud-agentplatform[a2a]
 pip install google-cloud-agentplatform[adk]
 pip install google-cloud-agentplatform[langchain]
+pip install google-cloud-agentplatform[ag2]
+pip install google-cloud-agentplatform[llama_index]
 pip install google-cloud-agentplatform[evaluation]
 pip install google-cloud-agentplatform[bigquery]
+pip install google-cloud-agentplatform[live]
 pip install google-cloud-agentplatform[all]
-```

{google_cloud_agentplatform-2.0.1 → google_cloud_agentplatform-2.1.3}/pyproject.toml

@@ -10,18 +10,18 @@ authors = [
     {name = "Google LLC", email = "googleapis-packages@google.com"}
 ]
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license = {text = "Apache-2.0"}
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
     "google-auth",

google_cloud_agentplatform-2.0.1/README.md

@@ -1,17 +0,0 @@
-# Google Cloud Agent Platform
-
-This is the packaging directory for `google-cloud-agentplatform`.
-
-## Installation
-
-```bash
-# Core installation
-pip install google-cloud-agentplatform
-
-# With specific extras
-pip install google-cloud-agentplatform[adk]
-pip install google-cloud-agentplatform[langchain]
-pip install google-cloud-agentplatform[evaluation]
-pip install google-cloud-agentplatform[bigquery]
-pip install google-cloud-agentplatform[all]
-```