google-cloud-agentplatform 2.5.0__tar.gz → 2.6.0__tar.gz

{google_cloud_agentplatform-2.5.0/google_cloud_agentplatform.egg-info → google_cloud_agentplatform-2.6.0}/PKG-INFO

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

{google_cloud_agentplatform-2.5.0 → google_cloud_agentplatform-2.6.0}/agentplatform/_genai/_evals_common.py

@@ -296,9 +296,8 @@ def _build_generate_content_config(
     for key in [
         "system_instruction",
         "tools",
-        "tools_config",
+        "tool_config",
         "safety_settings",
-        "labels",
     ]:
         if key in request_dict:
             merged_config_dict[key] = request_dict[key]
@@ -3735,7 +3734,10 @@ def _convert_gcs_to_evaluation_item_result(
         return types.EvaluationItemResult(**eval_item_data)
     except Exception as e:
         logger.error(
-            "Failed to load evaluation result from GCS: %s. Error: %s", gcs_uri, e
+            "Failed to load evaluation result from GCS: %s. Error: %s",
+            gcs_uri,
+            e,
+            exc_info=True,
         )
     return types.EvaluationItemResult()
 
@@ -3752,7 +3754,10 @@ def _convert_gcs_to_evaluation_item_request(
         return types.EvaluationItemRequest(**eval_item_data)
     except Exception as e:
         logger.error(
-            "Failed to load evaluation request from GCS: %s. Error: %s", gcs_uri, e
+            "Failed to load evaluation request from GCS: %s. Error: %s",
+            gcs_uri,
+            e,
+            exc_info=True,
         )
     return types.EvaluationItemRequest()
 
@@ -3926,16 +3931,16 @@ def _get_eval_cases_eval_dfs_from_eval_items(
           item.
         - eval_dfs: A list of EvaluationDatasets, one for each candidate.
     """
-    dataset_rows = []
+    dataset_rows: list[dict[str, Any]] = []
     eval_case_results = []
-    for index, eval_item in enumerate(eval_items):
+    for eval_item in eval_items:
         if (
             eval_item
             and eval_item.evaluation_response
             and eval_item.evaluation_response.request
         ):
             eval_case_results.append(
-                _get_eval_case_result_from_eval_item(index, eval_item)
+                _get_eval_case_result_from_eval_item(len(dataset_rows), eval_item)
             )
             dataset_rows.append(
                 _convert_request_to_dataset_row(eval_item.evaluation_response.request)
@@ -4120,6 +4125,36 @@ def _get_content(row: dict[str, Any], column: str) -> Optional[genai_types.Conte
         )
 
 
+# Columns mapped to EvaluationItemRequest fields; all others go to extra_context.
+_EVALUATION_SET_STANDARD_COLUMNS = _evals_constant.COMMON_DATASET_COLUMNS | {
+    _evals_constant.RESPONSE,
+    "interaction",
+    "gemini_agent",
+}
+
+
+def _to_extra_context_content(value: Any) -> Optional[genai_types.Content]:
+    if isinstance(value, str):
+        return genai_types.Content(parts=[genai_types.Part(text=value)])
+    if isinstance(value, genai_types.Content):
+        return value
+    parts = []
+    for content in _evals_metric_handlers._value_to_content_list(value):
+        parts.extend(content.parts or [])
+    return genai_types.Content(parts=parts) if parts else None
+
+
+def _get_extra_context(row: "pd.Series") -> Optional[dict[str, genai_types.Content]]:
+    extra_context = {}
+    for column, value in row.items():
+        if column in _EVALUATION_SET_STANDARD_COLUMNS or _is_missing(value):
+            continue
+        content = _to_extra_context_content(value)
+        if content:
+            extra_context[str(column)] = content
+    return extra_context or None
+
+
 def _create_evaluation_set_from_dataframe(
     api_client: BaseApiClient,
     gcs_dest_prefix: str,
@@ -4244,6 +4279,7 @@ def _create_evaluation_set_from_dataframe(
                 candidate_responses=(
                     candidate_responses if candidate_responses else None
                 ),
+                extra_context=_get_extra_context(row),
             )
         )
     logger.info("Writing evaluation item requests to GCS.")

{google_cloud_agentplatform-2.5.0 → google_cloud_agentplatform-2.6.0}/agentplatform/_genai/_evals_data_converters.py

@@ -230,6 +230,18 @@ class _FlattenEvalDataConverter(_evals_utils.EvalDataConverter):
                     "Invalid prompt type for case %s: %s" % (i, type(prompt_data))
                 )
 
+            if (
+                isinstance(conversation_history_data, str)
+                and conversation_history_data.strip()
+            ):
+                try:
+                    conversation_history_data = json.loads(conversation_history_data)
+                except json.JSONDecodeError:
+                    logger.warning(
+                        "Could not decode conversation_history JSON string for case %s.",
+                        eval_case_id,
+                    )
+
             conversation_history: Optional[list[types.evals.Message]] = None
             if isinstance(conversation_history_data, list):
                 conversation_history = []
@@ -242,6 +254,11 @@ class _FlattenEvalDataConverter(_evals_utils.EvalDataConverter):
                             )
                         )
                     elif isinstance(content, dict):
+                        if isinstance(content.get("content"), str):
+                            content = {
+                                "role": content.get("role"),
+                                "parts": [{"text": content["content"]}],
+                            }
                         try:
                             validated_content = genai_types.Content.model_validate(
                                 content

{google_cloud_agentplatform-2.5.0 → google_cloud_agentplatform-2.6.0}/agentplatform/_genai/_evals_visualization.py

@@ -23,7 +23,7 @@ import textwrap
 from typing import Any, Optional
 
 import pandas as pd
-from pydantic import errors
+import pydantic_core
 
 from . import _evals_common
 from . import types
@@ -1483,7 +1483,7 @@ def display_evaluation_result(
         result_dump = eval_result_obj.model_dump(
             mode="json", exclude_none=True, exclude={"evaluation_dataset"}
         )
-    except errors.PydanticSerializationError as e:
+    except pydantic_core.PydanticSerializationError as e:
         logger.error(
             "Serialization Error: %s\nCould not display the evaluation "
             "result due to a data serialization issue. Please check the "

{google_cloud_agentplatform-2.5.0 → google_cloud_agentplatform-2.6.0}/agentplatform/_genai/memory_banks.py

@@ -590,6 +590,44 @@ def _StructuredMemorySchemaConfig_to_vertex(
     return to_object
 
 
+def _UpdateMemoryBankConfig_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+
+    if getv(from_object, ["display_name"]) is not None:
+        setv(parent_object, ["displayName"], getv(from_object, ["display_name"]))
+
+    if getv(from_object, ["description"]) is not None:
+        setv(parent_object, ["description"], getv(from_object, ["description"]))
+
+    return to_object
+
+
+def _UpdateMemoryBankRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["name"]) is not None:
+        setv(to_object, ["_url", "name"], getv(from_object, ["name"]))
+
+    if getv(from_object, ["memory_bank_config"]) is not None:
+        setv(
+            to_object,
+            ["context_spec", "memory_bank_config"],
+            _ReasoningEngineContextSpecMemoryBankConfig_to_vertex(
+                getv(from_object, ["memory_bank_config"]), to_object
+            ),
+        )
+
+    if getv(from_object, ["config"]) is not None:
+        _UpdateMemoryBankConfig_to_vertex(getv(from_object, ["config"]), to_object)
+
+    return to_object
+
+
 class MemoryBanks(_api_module.BaseModule):
 
     def _create(
@@ -669,6 +707,85 @@ class MemoryBanks(_api_module.BaseModule):
         self._api_client._verify_response(return_value)
         return return_value
 
+    def _update(
+        self,
+        *,
+        name: str,
+        memory_bank_config: Optional[
+            types.ReasoningEngineContextSpecMemoryBankConfigOrDict
+        ] = None,
+        config: Optional[types.UpdateMemoryBankConfigOrDict] = None,
+    ) -> types.MemoryBankOperation:
+        """
+        Updates a Memory Bank.
+        """
+
+        parameter_model = types._UpdateMemoryBankRequestParameters(
+            name=name,
+            memory_bank_config=memory_bank_config,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _UpdateMemoryBankRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("patch", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        if self._api_client.vertexai:
+            response_dict = _MemoryBankOperation_from_vertex(response_dict)
+
+        return_value = types.MemoryBankOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
     def _delete(
         self,
         *,
@@ -1082,6 +1199,41 @@ class MemoryBanks(_api_module.BaseModule):
         memory_bank = types.MemoryBank(name=operation.response.name)
         return memory_bank
 
+    def update(
+        self,
+        *,
+        name: str,
+        managed_semantic_memory_config: Optional[
+            types.ManagedSemanticMemoryConfigOrDict
+        ] = None,
+        config: Optional[types.UpdateMemoryBankConfigOrDict] = None,
+    ) -> types.MemoryBank:
+        """Updates a Memory Bank resource."""
+        memory_bank_config = (
+            _memory_bank_utils._managed_semantic_memory_config_to_memory_bank_config(
+                managed_semantic_memory_config
+            )
+        )
+
+        operation = self._update(
+            name=name,
+            memory_bank_config=memory_bank_config,
+            config=config,
+        )
+
+        operation = _memory_bank_utils._await_operation(
+            operation_name=operation.name,
+            get_operation_fn=self._get_memory_bank_operation,
+        )
+        if operation.error:
+            raise RuntimeError(operation.error)
+        if not operation.response:
+            raise RuntimeError(
+                f"Memory Bank update completed without a response: {operation}"
+            )
+        memory_bank = types.MemoryBank(name=operation.response.name)
+        return memory_bank
+
     def delete(
         self,
         *,
@@ -1332,6 +1484,87 @@ class AsyncMemoryBanks(_api_module.BaseModule):
         self._api_client._verify_response(return_value)
         return return_value
 
+    async def _update(
+        self,
+        *,
+        name: str,
+        memory_bank_config: Optional[
+            types.ReasoningEngineContextSpecMemoryBankConfigOrDict
+        ] = None,
+        config: Optional[types.UpdateMemoryBankConfigOrDict] = None,
+    ) -> types.MemoryBankOperation:
+        """
+        Updates a Memory Bank.
+        """
+
+        parameter_model = types._UpdateMemoryBankRequestParameters(
+            name=name,
+            memory_bank_config=memory_bank_config,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _UpdateMemoryBankRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "patch", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        if self._api_client.vertexai:
+            response_dict = _MemoryBankOperation_from_vertex(response_dict)
+
+        return_value = types.MemoryBankOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
     async def _delete(
         self,
         *,
@@ -1755,6 +1988,41 @@ class AsyncMemoryBanks(_api_module.BaseModule):
         memory_bank = types.MemoryBank(name=operation.response.name)
         return memory_bank
 
+    async def update(
+        self,
+        *,
+        name: str,
+        managed_semantic_memory_config: Optional[
+            types.ManagedSemanticMemoryConfigOrDict
+        ] = None,
+        config: Optional[types.UpdateMemoryBankConfigOrDict] = None,
+    ) -> types.MemoryBank:
+        """Updates a Memory Bank."""
+        memory_bank_config = (
+            _memory_bank_utils._managed_semantic_memory_config_to_memory_bank_config(
+                managed_semantic_memory_config
+            )
+        )
+
+        operation = await self._update(
+            name=name,
+            memory_bank_config=memory_bank_config,
+            config=config,
+        )
+
+        operation = await _memory_bank_utils._await_async_operation(
+            operation_name=operation.name,
+            get_operation_fn=self._get_memory_bank_operation,
+        )
+        if operation.error:
+            raise RuntimeError(operation.error)
+        if not operation.response:
+            raise RuntimeError(
+                f"Memory Bank update completed without a response: {operation}"
+            )
+        memory_bank = types.MemoryBank(name=operation.response.name)
+        return memory_bank
+
     async def delete(
         self,
         *,