Add files using upload-large-folder tool

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/__init__.py

@@ -0,0 +1,43 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""The agentplatform module."""
+
+import importlib
+
+from .client import Client
+
+_evals = None
+
+
+def __getattr__(name):  # type: ignore[no-untyped-def]
+    if name == "evals":
+        global _evals
+        if _evals is None:
+            try:
+                _evals = importlib.import_module(".evals", __package__)
+            except ImportError as e:
+                raise ImportError(
+                    "The 'evals' module requires additional dependencies. "
+                    "Please install them using pip install "
+                    "google-cloud-aiplatform[evaluation]"
+                ) from e
+        return _evals
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+__all__ = [
+    "Client",
+    "evals",
+]

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_agent_engines_utils.py

@@ -0,0 +1,1996 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Utility functions for agent engines."""
+
+import abc
+import asyncio
+import base64
+from importlib import metadata as importlib_metadata
+import inspect
+import io
+import json
+import logging
+import os
+import re
+import sys
+import tarfile
+import time
+import types
+import typing
+from typing import (
+    Any,
+    AsyncIterator,
+    Callable,
+    Coroutine,
+    Dict,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Protocol,
+    Sequence,
+    Set,
+    TypedDict,
+    Union,
+)
+
+import httpx
+
+import proto
+
+from google.api_core import exceptions
+from google.genai import types as google_genai_types
+from google.protobuf import struct_pb2
+from google.protobuf import json_format
+
+from . import types as genai_types
+
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+try:
+    _BUILTIN_MODULE_NAMES: Sequence[str] = sys.builtin_module_names
+except AttributeError:
+    _BUILTIN_MODULE_NAMES: Sequence[str] = []  # type: ignore[no-redef]
+
+try:
+    _PACKAGE_DISTRIBUTIONS: Mapping[str, Sequence[str]] = (
+        importlib_metadata.packages_distributions()
+    )
+except AttributeError:
+    _PACKAGE_DISTRIBUTIONS: Mapping[str, Sequence[str]] = {}  # type: ignore[no-redef]
+
+try:
+    # sys.stdlib_module_names is available from Python 3.10 onwards.
+    _STDLIB_MODULE_NAMES: frozenset[str] = sys.stdlib_module_names
+except AttributeError:
+    _STDLIB_MODULE_NAMES: frozenset[str] = frozenset()  # type: ignore[no-redef]
+
+
+if typing.TYPE_CHECKING:
+    from google.cloud import storage  # type: ignore[attr-defined]
+
+    _StorageBucket: TypeAlias = storage.Bucket
+else:
+    try:
+        from google.cloud import storage  # type: ignore[attr-defined]
+
+        _StorageBucket: type[Any] = storage.Bucket
+    except (ImportError, AttributeError):
+        _StorageBucket: type[Any] = Any  # type: ignore[no-redef]
+
+
+if typing.TYPE_CHECKING:
+    import packaging
+
+    _SpecifierSet = packaging.specifiers.SpecifierSet
+else:
+    try:
+        import packaging
+
+        _SpecifierSet: type[Any] = packaging.specifiers.SpecifierSet
+    except (ImportError, AttributeError):
+        _SpecifierSet: type[Any] = Any  # type: ignore[no-redef]
+
+
+try:
+    from a2a.types import (
+        AgentCard,
+        TransportProtocol,
+        Message,
+        TaskIdParams,
+        TaskQueryParams,
+    )
+    from a2a.client import ClientConfig, ClientFactory
+
+    AgentCard = AgentCard
+    TransportProtocol = TransportProtocol
+    Message = Message
+    ClientConfig = ClientConfig
+    ClientFactory = ClientFactory
+    TaskIdParams = TaskIdParams
+    TaskQueryParams = TaskQueryParams
+except (ImportError, AttributeError):
+    AgentCard = None
+    TransportProtocol = None
+    Message = None
+    ClientConfig = None
+    ClientFactory = None
+    TaskIdParams = None
+    TaskQueryParams = None
+
+_ACTIONS_KEY = "actions"
+_ACTION_APPEND = "append"
+_AGENT_FRAMEWORK_ATTR = "agent_framework"
+_ASYNC_API_MODE = "async"
+_ASYNC_STREAM_API_MODE = "async_stream"
+_BIDI_STREAM_API_MODE = "bidi_stream"
+_BASE_MODULES = set(_BUILTIN_MODULE_NAMES).union(_STDLIB_MODULE_NAMES)
+_BLOB_FILENAME = "agent_engine.pkl"
+_DEFAULT_AGENT_FRAMEWORK = "custom"
+_SUPPORTED_AGENT_FRAMEWORKS = frozenset(
+    [
+        "google-adk",
+        "langchain",
+        "langgraph",
+        "ag2",
+        "llama-index",
+        "custom",
+        "a2a",
+    ]
+)
+_DEFAULT_ASYNC_METHOD_NAME = "async_query"
+_DEFAULT_ASYNC_METHOD_RETURN_TYPE = "Coroutine[Any]"
+_DEFAULT_ASYNC_STREAM_METHOD_NAME = "async_stream_query"
+_DEFAULT_ASYNC_STREAM_METHOD_RETURN_TYPE = "AsyncIterable[Any]"
+_DEFAULT_GCS_DIR_NAME = "agent_engine"
+_DEFAULT_METHOD_DOCSTRING_TEMPLATE = """
+    Runs the Agent Engine to serve the user request.
+    This will be based on the `.{method_name}(...)` of the python object that
+    was passed in when creating the Agent Engine. The method will invoke the
+    `{default_method_name}` API client of the python object.
+    Args:
+        **kwargs:
+            Optional. The arguments of the `.{method_name}(...)` method.
+    Returns:
+        {return_type}: The response from serving the user request.
+"""
+_DEFAULT_METHOD_NAME = "query"
+_DEFAULT_METHOD_RETURN_TYPE = "dict[str, Any]"
+_DEFAULT_STREAM_METHOD_RETURN_TYPE = "Iterable[Any]"
+_DEFAULT_REQUIRED_PACKAGES = frozenset(["cloudpickle", "pydantic"])
+_DEFAULT_STREAM_METHOD_NAME = "stream_query"
+_DEFAULT_BIDI_STREAM_METHOD_NAME = "bidi_stream_query"
+_EXTRA_PACKAGES_FILE = "dependencies.tar.gz"
+_FAILED_TO_REGISTER_API_METHODS_WARNING_TEMPLATE = (
+    "Failed to register API methods. Please follow the guide to "
+    "register the API methods: "
+    "https://cloud.google.com/vertex-ai/generative-ai/docs/agent-engine/develop/custom#custom-methods. "
+    "Error: {%s}"
+)
+_INSTALLATION_SUBDIR = "installation_scripts"
+_METHOD_NAME_KEY_IN_SCHEMA = "name"
+_MODE_KEY_IN_SCHEMA = "api_mode"
+_REQUIREMENTS_FILE = "requirements.txt"
+_STANDARD_API_MODE = ""
+_STREAM_API_MODE = "stream"
+_A2A_EXTENSION_MODE = "a2a_extension"
+_A2A_AGENT_CARD = "a2a_agent_card"
+_WARNINGS_KEY = "warnings"
+_WARNING_MISSING = "missing"
+_WARNING_INCOMPATIBLE = "incompatible"
+
+_DEFAULT_METHOD_NAME_MAP = {
+    _STANDARD_API_MODE: _DEFAULT_METHOD_NAME,
+    _ASYNC_API_MODE: _DEFAULT_ASYNC_METHOD_NAME,
+    _STREAM_API_MODE: _DEFAULT_STREAM_METHOD_NAME,
+    _ASYNC_STREAM_API_MODE: _DEFAULT_ASYNC_STREAM_METHOD_NAME,
+}
+_DEFAULT_METHOD_RETURN_TYPE_MAP = {
+    _STANDARD_API_MODE: _DEFAULT_METHOD_RETURN_TYPE,
+    _ASYNC_API_MODE: _DEFAULT_ASYNC_METHOD_RETURN_TYPE,
+    _STREAM_API_MODE: _DEFAULT_STREAM_METHOD_RETURN_TYPE,
+    _ASYNC_STREAM_API_MODE: _DEFAULT_ASYNC_STREAM_METHOD_RETURN_TYPE,
+}
+
+
+logger = logging.getLogger("agentplatform_genai.agentengines")
+
+
+@typing.runtime_checkable
+class Queryable(Protocol):
+    """Protocol for Agent Engines that can be queried."""
+
+    @abc.abstractmethod
+    def query(self, **kwargs):  # type: ignore[no-untyped-def]
+        """Runs the Agent Engine to serve the user query."""
+
+
+@typing.runtime_checkable
+class AsyncQueryable(Protocol):
+    """Protocol for Agent Engines that can be queried asynchronously."""
+
+    @abc.abstractmethod
+    def async_query(self, **kwargs):  # type: ignore[no-untyped-def]
+        """Runs the Agent Engine to serve the user query asynchronously."""
+
+
+@typing.runtime_checkable
+class AsyncStreamQueryable(Protocol):
+    """Protocol for Agent Engines that can stream responses asynchronously."""
+
+    @abc.abstractmethod
+    async def async_stream_query(self, **kwargs) -> AsyncIterator[Any]:  # type: ignore[no-untyped-def]
+        """Asynchronously stream responses to serve the user query."""
+
+
+@typing.runtime_checkable
+class StreamQueryable(Protocol):
+    """Protocol for Agent Engines that can stream responses."""
+
+    @abc.abstractmethod
+    def stream_query(self, **kwargs) -> Iterator[Any]:  # type: ignore[no-untyped-def]
+        """Stream responses to serve the user query."""
+
+
+@typing.runtime_checkable
+class BidiStreamQueryable(Protocol):
+    """Protocol for Agent Engines that can stream requests and responses."""
+
+    @abc.abstractmethod
+    async def bidi_stream_query(
+        self, input_queue: asyncio.Queue[Any]
+    ) -> AsyncIterator[Any]:
+        """Stream requests and responses to serve the user queries."""
+
+
+@typing.runtime_checkable
+class Cloneable(Protocol):
+    """Protocol for Agent Engines that can be cloned."""
+
+    @abc.abstractmethod
+    def clone(self) -> Any:
+        """Return a clone of the object."""
+
+
+@typing.runtime_checkable
+class OperationRegistrable(Protocol):
+    """Protocol for agents that have registered operations."""
+
+    @abc.abstractmethod
+    def register_operations(self, **kwargs: Any) -> dict[str, list[str]]:
+        """Register the user provided operations (modes and methods)."""
+        pass
+
+
+if typing.TYPE_CHECKING:
+    from google.adk.agents import BaseAgent
+
+    ADKAgent: TypeAlias = BaseAgent
+else:
+    try:
+        from google.adk.agents import BaseAgent
+
+        ADKAgent: Optional[TypeAlias] = BaseAgent
+    except (ImportError, AttributeError):
+        ADKAgent = None  # type: ignore[no-redef]
+
+_AgentEngineInterface = Union[
+    ADKAgent,
+    AsyncQueryable,
+    AsyncStreamQueryable,
+    OperationRegistrable,
+    Queryable,
+    StreamQueryable,
+    BidiStreamQueryable,
+]
+
+
+class _ModuleAgentAttributes(TypedDict, total=False):
+    module_name: str
+    agent_name: str
+    register_operations: Dict[str, list[str]]
+    sys_paths: Optional[Sequence[str]]
+    agent: _AgentEngineInterface
+
+
+class ModuleAgent(Cloneable, OperationRegistrable):
+    """Agent that is defined by a module and an agent name.
+
+    This agent is instantiated by importing a module and instantiating an agent
+    from that module. It also allows to register operations that are defined in
+    the agent.
+    """
+
+    def __init__(
+        self,
+        *,
+        module_name: str,
+        agent_name: str,
+        register_operations: Dict[str, list[str]],
+        sys_paths: Optional[Sequence[str]] = None,
+    ):
+        """Initializes a module-based agent.
+
+        Args:
+            module_name (str):
+                Required. The name of the module to import.
+            agent_name (str):
+                Required. The name of the agent in the module to instantiate.
+            register_operations (Dict[str, list[str]]):
+                Required. A dictionary of API modes to a list of method names.
+            sys_paths (Sequence[str]):
+                Optional. The system paths to search for the module. It should
+                be relative to the directory where the code will be running.
+                I.e. it should correspond to the directory being passed to
+                `extra_packages=...` in the create method. It will be appended
+                to the system path in the sequence being specified here, and
+                only be appended if it is not already in the system path.
+        """
+        self._tmpl_attrs: _ModuleAgentAttributes = {
+            "module_name": module_name,
+            "agent_name": agent_name,
+            "register_operations": register_operations,
+            "sys_paths": sys_paths,
+        }
+
+    def clone(self) -> "ModuleAgent":
+        """Return a clone of the agent."""
+        return ModuleAgent(
+            module_name=self._tmpl_attrs.get("module_name"),
+            agent_name=self._tmpl_attrs.get("agent_name"),
+            register_operations=self._tmpl_attrs.get("register_operations"),
+            sys_paths=self._tmpl_attrs.get("sys_paths"),
+        )
+
+    def register_operations(self, **kwargs: Any) -> dict[str, list[str]]:
+        reg_operations = self._tmpl_attrs.get("register_operations")
+        if reg_operations is None:
+            raise ValueError("Register operations is not set.")
+        return reg_operations
+
+    def set_up(self) -> None:
+        """Sets up the agent for execution of queries at runtime.
+
+        It runs the code to import the agent from the module, and registers the
+        operations of the agent.
+        """
+        sys_paths = self._tmpl_attrs.get("sys_paths")
+        if isinstance(sys_paths, Sequence):
+            import sys
+
+            for sys_path in sys_paths:
+                abs_path = os.path.abspath(sys_path)
+                if abs_path not in sys.path:
+                    sys.path.append(abs_path)
+
+        import importlib
+
+        module = importlib.import_module(self._tmpl_attrs.get("module_name"))
+        try:
+            importlib.reload(module)
+        except Exception as e:
+            logger.warning(
+                f"Failed to reload module {self._tmpl_attrs.get('module_name')}: {e}"
+            )
+        agent_name = self._tmpl_attrs.get("agent_name")
+        try:
+            agent = getattr(module, agent_name)
+        except AttributeError as e:
+            raise AttributeError(
+                f"Agent {agent_name} not found in module "
+                f"{self._tmpl_attrs.get('module_name')}"
+            ) from e
+        self._tmpl_attrs["agent"] = agent
+        if hasattr(agent, "set_up"):
+            agent.set_up()
+        for operations in self.register_operations().values():
+            for operation in operations:
+                op = _wrap_agent_operation(agent=agent, operation=operation)
+                setattr(self, operation, types.MethodType(op, self))
+
+
+class _RequirementsValidationActions(TypedDict):
+    append: Set[str]
+
+
+class _RequirementsValidationWarnings(TypedDict):
+    missing: Set[str]
+    incompatible: Set[str]
+
+
+class _RequirementsValidationResult(TypedDict):
+    warnings: _RequirementsValidationWarnings
+    actions: _RequirementsValidationActions
+
+
+AgentEngineOperationUnion = Union[
+    genai_types.AgentEngineOperation,
+    genai_types.AgentEngineMemoryOperation,
+    genai_types.AgentEngineGenerateMemoriesOperation,
+]
+
+
+class GetOperationFunction(Protocol):
+    def __call__(
+        self, *, operation_name: str, **kwargs: Any
+    ) -> AgentEngineOperationUnion:
+        pass
+
+
+class GetAsyncOperationFunction(Protocol):
+    async def __call__(
+        self, *, operation_name: str, **kwargs: Any
+    ) -> AgentEngineOperationUnion:
+        pass
+
+
+def _get_reasoning_engine_id(operation_name: str = "", resource_name: str = "") -> str:
+    """Returns reasoning engine ID from operation name or resource name."""
+    if not resource_name and not operation_name:
+        raise ValueError("Resource name or operation name cannot be empty.")
+
+    if resource_name:
+        match = re.match(
+            r"^projects/[^/]+/locations/[^/]+/reasoningEngines/([^/]+)$",
+            resource_name,
+        )
+        if match:
+            return match.group(1)
+        else:
+            raise ValueError(
+                "Failed to parse reasoning engine ID from resource name: "
+                f"`{resource_name}`"
+            )
+
+    if not operation_name:
+        raise ValueError("Operation name cannot be empty.")
+
+    match = re.match(
+        r"^projects/[^/]+/locations/[^/]+/reasoningEngines/([^/]+)/operations/[^/]+$",
+        operation_name,
+    )
+    if match:
+        return match.group(1)
+    raise ValueError(
+        "Failed to parse reasoning engine ID from operation name: "
+        f"`{operation_name}`"
+    )
+
+
+async def _await_async_operation(
+    *,
+    operation_name: str,
+    get_operation_fn: GetAsyncOperationFunction,
+    poll_interval_seconds: float = 10,
+) -> Any:
+    """Waits for the operation for creating an agent engine to complete.
+
+    Args:
+        operation_name (str):
+            Required. The name of the operation for creating the Agent Engine.
+        poll_interval_seconds (float):
+            The number of seconds to wait between each poll.
+        get_operation_fn (Callable[[str], Awaitable[Any]]):
+            Optional. The async function to use for getting the operation. If not
+            provided, `self._get_agent_operation` will be used.
+
+    Returns:
+        The operation that has completed (i.e. `operation.done==True`).
+    """
+    operation = await get_operation_fn(operation_name=operation_name)
+    while not operation.done:
+        await asyncio.sleep(poll_interval_seconds)
+        operation = await get_operation_fn(operation_name=operation.name)
+
+    return operation
+
+
+def _await_operation(
+    *,
+    operation_name: str,
+    get_operation_fn: GetOperationFunction,
+    poll_interval_seconds: float = 10,
+) -> Any:
+    """Waits for the operation for creating an agent engine to complete.
+
+    Args:
+        operation_name (str):
+            Required. The name of the operation for creating the Agent Engine.
+        poll_interval_seconds (float):
+            The number of seconds to wait between each poll.
+        get_operation_fn (Callable[[str], Any]):
+            Optional. The function to use for getting the operation. If not
+            provided, `self._get_agent_operation` will be used.
+
+    Returns:
+        The operation that has completed (i.e. `operation.done==True`).
+    """
+    operation = get_operation_fn(operation_name=operation_name)
+    while not operation.done:
+        time.sleep(poll_interval_seconds)
+        operation = get_operation_fn(operation_name=operation.name)
+
+    return operation
+
+
+def _compare_requirements(
+    *,
+    requirements: Mapping[str, str],
+    constraints: Union[Sequence[str], Mapping[str, Optional["_SpecifierSet"]]],
+    required_packages: Optional[Iterator[str]] = None,
+) -> _RequirementsValidationResult:
+    """Compares the requirements with the constraints.
+
+    Args:
+        requirements (Mapping[str, str]):
+            Required. The packages (and their versions) to compare with the constraints.
+            This is assumed to be the result of `scan_requirements`.
+        constraints (Union[Sequence[str], Mapping[str, SpecifierSet]]):
+            Required. The package constraints to compare against. This is assumed
+            to be the result of `parse_constraints`.
+        required_packages (Iterator[str]):
+            Optional. The set of packages that are required to be in the
+            constraints. It defaults to the set of packages that are required
+            for deployment on Agent Engine.
+
+    Returns:
+        dict[str, dict[str, Any]]: The comparison result as a dictionary containing:
+            * warnings:
+                * missing: The set of packages that are not in the constraints.
+                * incompatible: The set of packages that are in the constraints
+                    but have versions that are not in the constraint specifier.
+            * actions:
+                * append: The set of packages that are not in the constraints
+                    but should be appended to the constraints.
+    """
+    packaging_version = _import_packaging_version_or_raise()
+    if required_packages is None:
+        required_packages = _DEFAULT_REQUIRED_PACKAGES  # type: ignore[assignment]
+    result = _RequirementsValidationResult(
+        warnings=_RequirementsValidationWarnings(missing=set(), incompatible=set()),
+        actions=_RequirementsValidationActions(append=set()),
+    )
+    if isinstance(constraints, list):
+        constraints = _parse_constraints(constraints=constraints)
+    for package, package_version in requirements.items():
+        if package not in constraints:
+            result[_WARNINGS_KEY][_WARNING_MISSING].add(package)  # type: ignore[literal-required]
+            if package in required_packages:  # type: ignore[operator]
+                result[_ACTIONS_KEY][_ACTION_APPEND].add(  # type: ignore[literal-required]
+                    f"{package}=={package_version}"
+                )
+            continue
+        if package_version:
+            package_specifier = constraints[package]  # type: ignore[call-overload]
+            if not package_specifier:
+                continue
+            if packaging_version.Version(package_version) not in package_specifier:
+                result[_WARNINGS_KEY][_WARNING_INCOMPATIBLE].add(  # type: ignore[literal-required]
+                    f"{package}=={package_version} (required: {str(package_specifier)})"
+                )
+    return result
+
+
+def _generate_class_methods_spec_or_raise(
+    *,
+    agent: _AgentEngineInterface,
+    operations: Dict[str, List[str]],
+) -> List[proto.Message]:
+    """Generates a ReasoningEngineSpec based on the registered operations.
+
+    Args:
+        agent: The AgentEngine instance.
+        operations: A dictionary of API modes and method names.
+
+    Returns:
+        A list of ReasoningEngineSpec.ClassMethod messages.
+
+    Raises:
+        ValueError: If a method defined in `register_operations` is not found on
+        the AgentEngine.
+    """
+    if isinstance(agent, ModuleAgent):
+        # We do a dry-run of setting up the agent engine to have the operations
+        # needed for registration.
+        agent: ModuleAgent = agent.clone()  # type: ignore[no-redef]
+        try:
+            agent.set_up()
+        except Exception as e:
+            raise ValueError(f"Failed to set up agent {agent}: {e}") from e
+    class_methods_spec = []
+    for mode, method_names in operations.items():
+        for method_name in method_names:
+            if not hasattr(agent, method_name):
+                raise ValueError(
+                    f"Method `{method_name}` defined in `register_operations`"
+                    " not found on agent."
+                )
+
+            method = getattr(agent, method_name)
+            try:
+                schema_dict = _generate_schema(method, schema_name=method_name)
+            except Exception as e:
+                logger.warning(f"failed to generate schema for {method_name}: {e}")
+                continue
+
+            class_method = _to_proto(schema_dict)
+            class_method[_MODE_KEY_IN_SCHEMA] = mode
+            if hasattr(agent, "agent_card"):
+                class_method[_A2A_AGENT_CARD] = json_format.MessageToJson(
+                    getattr(agent, "agent_card")
+                )
+            class_methods_spec.append(class_method)
+
+    return class_methods_spec
+
+
+def _class_methods_to_class_methods_spec(
+    class_methods: List[dict[str, Any]],
+) -> List[proto.Message]:
+    """Converts a list of class methods to a list of ReasoningEngineSpec.ClassMethod messages."""
+    return [_to_proto(class_method) for class_method in class_methods]
+
+
+def _is_pydantic_serializable(param: inspect.Parameter) -> bool:
+    """Checks if the parameter is pydantic serializable."""
+
+    if param.annotation == inspect.Parameter.empty:
+        return True
+
+    if "ForwardRef" in repr(param.annotation):
+        return True
+
+    if isinstance(param.annotation, str):
+        return False
+
+    pydantic = _import_pydantic_or_raise()
+    try:
+        pydantic.TypeAdapter(param.annotation)
+        return True
+    except Exception:
+        return False
+
+
+def _generate_schema(
+    f: Callable[..., Any],
+    *,
+    schema_name: Optional[str] = None,
+    descriptions: Mapping[str, str] = {},
+    required: Sequence[str] = [],
+) -> Dict[str, Any]:
+    """Generates the OpenAPI Schema for a callable object.
+
+    Only positional and keyword arguments of the function `f` will be supported
+    in the OpenAPI Schema that is generated. I.e. `*args` and `**kwargs` will
+    not be present in the OpenAPI schema returned from this function. For those
+    cases, you can either include it in the docstring for `f`, or modify the
+    OpenAPI schema returned from this function to include additional arguments.
+
+    Args:
+        f (Callable):
+            Required. The function to generate an OpenAPI Schema for.
+        schema_name (str):
+            Optional. The name for the OpenAPI schema. If unspecified, the name
+            of the Callable will be used.
+        descriptions (Mapping[str, str]):
+            Optional. A `{name: description}` mapping for annotating input
+            arguments of the function with user-provided descriptions. It
+            defaults to an empty dictionary (i.e. there will not be any
+            description for any of the inputs).
+        required (Sequence[str]):
+            Optional. For the user to specify the set of required arguments in
+            function calls to `f`. If specified, it will be automatically
+            inferred from `f`.
+
+    Returns:
+        dict[str, Any]: The OpenAPI Schema for the function `f` in JSON format.
+    """
+    pydantic = _import_pydantic_or_raise()
+    defaults = dict(inspect.signature(f).parameters)
+    fields_dict = {
+        name: (
+            # 1. We infer the argument type here: use Any rather than None so
+            # it will not try to auto-infer the type based on the default value.
+            (
+                param.annotation
+                if param.annotation != inspect.Parameter.empty
+                and "ForwardRef" not in repr(param.annotation)
+                else Any
+            ),
+            pydantic.Field(
+                # 2. We do not support default values for now.
+                # default=(
+                #     param.default if param.default != inspect.Parameter.empty
+                #     else None
+                # ),
+                # 3. We support user-provided descriptions.
+                description=descriptions.get(name, None),
+            ),
+        )
+        for name, param in defaults.items()
+        # We do not support *args or **kwargs
+        if param.kind
+        in (
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            inspect.Parameter.KEYWORD_ONLY,
+            inspect.Parameter.POSITIONAL_ONLY,
+        )
+        # For a bidi endpoint, it requires an asyncio.Queue as the input, but
+        # it is not JSON serializable. We hence exclude it from the schema.
+        and param.annotation != asyncio.Queue and _is_pydantic_serializable(param)
+    }
+    parameters = pydantic.create_model(f.__name__, **fields_dict).schema()
+    # Postprocessing
+    # 4. Suppress unnecessary title generation:
+    #    * https://github.com/pydantic/pydantic/issues/1051
+    #    * http://cl/586221780
+    parameters.pop("title", "")
+    for name, function_arg in parameters.get("properties", {}).items():
+        function_arg.pop("title", "")
+        annotation = defaults[name].annotation
+        # 5. Nullable fields:
+        #     * https://github.com/pydantic/pydantic/issues/1270
+        #     * https://stackoverflow.com/a/58841311
+        #     * https://github.com/pydantic/pydantic/discussions/4872
+        if typing.get_origin(annotation) is Union and type(None) in typing.get_args(
+            annotation
+        ):
+            # for "typing.Optional" arguments, function_arg might be a
+            # dictionary like
+            #
+            #   {'anyOf': [{'type': 'integer'}, {'type': 'null'}]
+            for schema in function_arg.pop("anyOf", []):
+                schema_type = schema.get("type")
+                if schema_type and schema_type != "null":
+                    function_arg["type"] = schema_type
+                    break
+            function_arg["nullable"] = True
+    # 6. Annotate required fields.
+    if required:
+        # We use the user-provided "required" fields if specified.
+        parameters["required"] = required
+    else:
+        # Otherwise we infer it from the function signature.
+        parameters["required"] = [
+            k
+            for k in defaults
+            if (
+                defaults[k].default == inspect.Parameter.empty
+                and defaults[k].kind
+                in (
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    inspect.Parameter.KEYWORD_ONLY,
+                    inspect.Parameter.POSITIONAL_ONLY,
+                )
+            )
+        ]
+    schema = dict(name=f.__name__, description=f.__doc__, parameters=parameters)
+    if schema_name:
+        schema["name"] = schema_name
+    return schema
+
+
+def _get_agent_framework(
+    *,
+    agent_framework: Optional[str],
+    agent: _AgentEngineInterface,
+) -> Union[str, Any]:
+    """Gets the agent framework to use.
+
+    The agent framework is determined in the following order of priority:
+    1. The `agent_framework` passed to this function.
+    2. The `agent_framework` attribute on the `agent` object.
+    3. The default framework, "custom".
+
+    Args:
+        agent_framework (str):
+            The agent framework provided by the user.
+        agent (_AgentEngineInterface):
+            The agent engine instance.
+
+    Returns:
+        str: The name of the agent framework to use.
+    """
+    if agent_framework is not None and agent_framework in _SUPPORTED_AGENT_FRAMEWORKS:
+        logger.info(f"Using agent framework: {agent_framework}")
+        return agent_framework
+    if hasattr(agent, _AGENT_FRAMEWORK_ATTR):
+        agent_framework_attr = getattr(agent, _AGENT_FRAMEWORK_ATTR)
+        if (
+            agent_framework_attr is not None
+            and isinstance(agent_framework_attr, str)
+            and agent_framework_attr in _SUPPORTED_AGENT_FRAMEWORKS
+        ):
+            logger.info(f"Using agent framework: {agent_framework_attr}")
+            return agent_framework_attr
+    logger.info(
+        f"The provided agent framework {agent_framework} is not supported."
+        f" Defaulting to {_DEFAULT_AGENT_FRAMEWORK}."
+    )
+    return _DEFAULT_AGENT_FRAMEWORK
+
+
+def _get_gcs_bucket(
+    *,
+    project: str,
+    location: str,
+    staging_bucket: str,
+    credentials: Optional[Any] = None,
+) -> _StorageBucket:
+    """Gets or creates the GCS bucket."""
+    storage = _import_cloud_storage_or_raise()
+    storage_client = storage.Client(project=project, credentials=credentials)
+    staging_bucket = staging_bucket.replace("gs://", "")
+    try:
+        gcs_bucket = storage_client.get_bucket(staging_bucket)
+        logger.info(f"Using bucket {staging_bucket}")
+    except exceptions.NotFound:
+        new_bucket = storage_client.bucket(staging_bucket)
+        gcs_bucket = storage_client.create_bucket(new_bucket, location=location)
+        logger.info(f"Creating bucket {staging_bucket} in {location=}")
+    return gcs_bucket
+
+
+def _get_registered_operations(
+    *,
+    agent: _AgentEngineInterface,
+) -> dict[str, list[str]]:
+    """Retrieves registered operations for a AgentEngine."""
+    if isinstance(agent, OperationRegistrable):
+        return agent.register_operations()
+
+    operations = {}
+    if isinstance(agent, Queryable):
+        operations[_STANDARD_API_MODE] = [_DEFAULT_METHOD_NAME]
+    if isinstance(agent, AsyncQueryable):
+        operations[_ASYNC_API_MODE] = [_DEFAULT_ASYNC_METHOD_NAME]
+    if isinstance(agent, StreamQueryable):
+        operations[_STREAM_API_MODE] = [_DEFAULT_STREAM_METHOD_NAME]
+    if isinstance(agent, AsyncStreamQueryable):
+        operations[_ASYNC_STREAM_API_MODE] = [_DEFAULT_ASYNC_STREAM_METHOD_NAME]
+    if isinstance(agent, BidiStreamQueryable):
+        operations[_BIDI_STREAM_API_MODE] = [_DEFAULT_BIDI_STREAM_METHOD_NAME]
+    return operations
+
+
+def _import_cloudpickle_or_raise() -> types.ModuleType:
+    """Tries to import the cloudpickle module."""
+    try:
+        import cloudpickle  # noqa:F401
+    except ImportError as e:
+        raise ImportError(
+            "cloudpickle is not installed. Please call "
+            "'pip install google-cloud-aiplatform[agent_engines]'."
+        ) from e
+    return cloudpickle  # type: ignore[no-any-return]
+
+
+def _import_cloud_storage_or_raise() -> types.ModuleType:
+    """Tries to import the Cloud Storage module."""
+    try:
+        from google.cloud import storage  # type: ignore[attr-defined]
+    except ImportError as e:
+        raise ImportError(
+            "Cloud Storage is not installed. Please call "
+            "'pip install google-cloud-aiplatform[agent_engines]'."
+        ) from e
+    return storage  # type: ignore[no-any-return]
+
+
+def _import_packaging_requirements_or_raise() -> types.ModuleType:
+    """Tries to import the packaging.requirements module."""
+    try:
+        from packaging import requirements
+    except ImportError as e:
+        raise ImportError(
+            "packaging.requirements is not installed. Please call "
+            "'pip install google-cloud-aiplatform[agent_engines]'."
+        ) from e
+    return requirements
+
+
+def _import_packaging_version_or_raise() -> types.ModuleType:
+    """Tries to import the packaging.requirements module."""
+    try:
+        from packaging import version
+    except ImportError as e:
+        raise ImportError(
+            "packaging.version is not installed. Please call "
+            "'pip install google-cloud-aiplatform[agent_engines]'."
+        ) from e
+    return version
+
+
+def _import_pydantic_or_raise() -> types.ModuleType:
+    """Tries to import the pydantic module."""
+    try:
+        import pydantic
+
+        _ = pydantic.Field
+    except AttributeError:
+        from pydantic import v1 as pydantic  # type: ignore[no-redef]
+    except ImportError as e:
+        raise ImportError(
+            "pydantic is not installed. Please call "
+            "'pip install google-cloud-aiplatform[agent_engines]'."
+        ) from e
+    return pydantic
+
+
+def _parse_constraints(
+    *,
+    constraints: Sequence[str],
+) -> Mapping[str, Optional["_SpecifierSet"]]:
+    """Parses a list of constraints into a dict of requirements.
+
+    Args:
+        constraints (list[str]):
+            Required. The list of package requirements to parse. This is assumed
+            to come from the `requirements.txt` file.
+
+    Returns:
+        dict[str, SpecifierSet]: The specifiers for each package.
+    """
+    requirements = _import_packaging_requirements_or_raise()
+    result: Dict[str, Optional[_SpecifierSet]] = {}
+    for constraint in constraints:
+        try:
+            if constraint.endswith(".whl"):
+                constraint = os.path.basename(constraint)
+            requirement = requirements.Requirement(constraint)
+        except Exception as e:
+            logger.warning(f"Failed to parse constraint: {constraint}. Exception: {e}")
+            continue
+        result[requirement.name] = requirement.specifier or None
+    return result
+
+
+def _prepare(
+    *,
+    agent: Optional[_AgentEngineInterface],
+    requirements: Optional[Sequence[str]],
+    extra_packages: Optional[Sequence[str]],
+    project: str,
+    location: str,
+    staging_bucket: str,
+    gcs_dir_name: str,
+    credentials: Optional[Any] = None,
+) -> None:
+    """Prepares the agent engine for creation or updates in Vertex AI.
+
+    This involves packaging and uploading artifacts to Cloud Storage. Note that
+    1. This does not actually update the Agent Engine in Vertex AI.
+    2. This will only generate and upload a pickled object if specified.
+    3. This will only generate and upload the dependencies.tar.gz file if
+    extra_packages is non-empty.
+
+    Args:
+        agent: The agent engine to be prepared.
+        requirements (Sequence[str]): The set of PyPI dependencies needed.
+        extra_packages (Sequence[str]): The set of extra user-provided packages.
+        project (str): The project for the staging bucket.
+        location (str): The location for the staging bucket.
+        staging_bucket (str): The staging bucket name in the form "gs://...".
+        gcs_dir_name (str): The GCS bucket directory under `staging_bucket` to use
+          for staging the artifacts needed.
+        credentials: The credentials to use for the storage client.
+    """
+    if agent is None:
+        return
+    gcs_bucket = _get_gcs_bucket(
+        project=project,
+        location=location,
+        staging_bucket=staging_bucket,
+        credentials=credentials,
+    )
+    _upload_agent_engine(
+        agent=agent,
+        gcs_bucket=gcs_bucket,
+        gcs_dir_name=gcs_dir_name,
+    )
+    if requirements is not None:
+        _upload_requirements(
+            requirements=requirements,
+            gcs_bucket=gcs_bucket,
+            gcs_dir_name=gcs_dir_name,
+        )
+    if extra_packages is not None:
+        _upload_extra_packages(
+            extra_packages=extra_packages,
+            gcs_bucket=gcs_bucket,
+            gcs_dir_name=gcs_dir_name,
+        )
+
+
+def _register_api_methods_or_raise(
+    *,
+    agent_engine: genai_types.AgentEngine | genai_types.AgentEngineRuntimeRevision,
+    wrap_operation_fn: Optional[
+        dict[str, Callable[[str, str], Callable[..., Any]]]
+    ] = None,
+) -> None:
+    """Registers Agent Engine API methods based on operation schemas.
+
+    This function iterates through operation schemas provided by the
+    `agent_engine`.  Each schema defines an API mode and method name.
+    It dynamically creates and registers methods on the `agent_engine`
+    to handle API calls based on the specified API mode.
+    Currently, only standard API mode `` is supported.
+
+    Args:
+        agent_engine: The AgentEngine to augment with API methods.
+        wrap_operation_fn: A dictionary of API modes and method wrapping
+            functions.
+
+    Raises:
+        ValueError: If the API mode is not supported or if the operation schema
+        is missing any required fields (e.g. `api_mode` or `name`).
+    """
+    operation_schemas = agent_engine.operation_schemas()
+    if not operation_schemas:
+        return
+    for operation_schema in operation_schemas:
+        if _MODE_KEY_IN_SCHEMA not in operation_schema:
+            raise ValueError(
+                f"Operation schema {operation_schema} does not"
+                f" contain an `{_MODE_KEY_IN_SCHEMA}` field."
+            )
+        api_mode = operation_schema.get(_MODE_KEY_IN_SCHEMA)
+        # For bidi stream api mode, we don't need to wrap the operation.
+        if api_mode == _BIDI_STREAM_API_MODE:
+            continue
+
+        if _METHOD_NAME_KEY_IN_SCHEMA not in operation_schema:
+            raise ValueError(
+                f"Operation schema {operation_schema} does not"
+                f" contain a `{_METHOD_NAME_KEY_IN_SCHEMA}` field."
+            )
+        method_name = operation_schema.get(_METHOD_NAME_KEY_IN_SCHEMA)
+        if not isinstance(method_name, str):
+            raise ValueError(
+                "Operation schema has a non-string value for"
+                f" `{_METHOD_NAME_KEY_IN_SCHEMA}`: {method_name}"
+            )
+        method_description = operation_schema.get(
+            "description",
+            _DEFAULT_METHOD_DOCSTRING_TEMPLATE.format(
+                method_name=method_name,
+                default_method_name=_DEFAULT_METHOD_NAME_MAP.get(
+                    api_mode, _DEFAULT_METHOD_NAME
+                ),
+                return_type=_DEFAULT_METHOD_RETURN_TYPE_MAP.get(
+                    api_mode,
+                    _DEFAULT_METHOD_RETURN_TYPE,
+                ),
+            ),
+        )
+        _wrap_operation_map = {
+            _STANDARD_API_MODE: _wrap_query_operation,
+            _ASYNC_API_MODE: _wrap_async_query_operation,
+            _STREAM_API_MODE: _wrap_stream_query_operation,
+            _ASYNC_STREAM_API_MODE: _wrap_async_stream_query_operation,
+            _A2A_EXTENSION_MODE: _wrap_a2a_operation,
+        }
+        if isinstance(wrap_operation_fn, dict) and api_mode in wrap_operation_fn:
+            # Override the default function with user-specified function if it exists.
+            _wrap_operation = wrap_operation_fn[api_mode]
+        elif api_mode in _wrap_operation_map:
+            _wrap_operation = _wrap_operation_map[api_mode]  # type: ignore[assignment]
+        else:
+            supported_api_modes = ", ".join(
+                f"`{mode}`" for mode in sorted(_wrap_operation_map.keys())
+            )
+            raise ValueError(
+                f"Unsupported api mode: `{api_mode}`,"
+                f" Supported modes are: {supported_api_modes}."
+            )
+
+        # Bind the method to the object.
+        if api_mode == _A2A_EXTENSION_MODE:
+            agent_card = operation_schema.get(_A2A_AGENT_CARD)
+            method = _wrap_operation(
+                method_name=method_name, agent_card=agent_card
+            )  # type: ignore[call-arg]
+        else:
+            method = _wrap_operation(method_name=method_name)  # type: ignore[call-arg]
+        method.__name__ = method_name
+        if method_description and isinstance(method_description, str):
+            method.__doc__ = method_description
+        setattr(agent_engine, method_name, types.MethodType(method, agent_engine))
+
+
+def _scan_requirements(
+    *,
+    obj: Any,
+    ignore_modules: Optional[Sequence[str]] = None,
+    package_distributions: Optional[Mapping[str, Sequence[str]]] = None,
+    inspect_getmembers_kwargs: Optional[Mapping[str, Any]] = None,
+) -> Mapping[str, str]:
+    """Scans the object for modules and returns the requirements discovered.
+
+    This is not a comprehensive scan of the object, and only detects for common
+    cases based on the members of the object returned by `dir(obj)`.
+
+    Args:
+        obj (Any):
+            Required. The object to scan for package requirements.
+        ignore_modules (Sequence[str]):
+            Optional. The set of modules to ignore. It defaults to the set of
+            built-in and stdlib modules.
+        package_distributions (Mapping[str, Sequence[str]]):
+            Optional. The mapping of module names to the set of packages that
+            contain them. It defaults to the set of packages from
+            `importlib_metadata.packages_distributions()`.
+        inspect_getmembers_kwargs (Mapping[str, Any]):
+            Optional. The keyword arguments to pass to `inspect.getmembers`. It
+            defaults to an empty dictionary.
+
+    Returns:
+        Sequence[str]: The list of requirements that were discovered.
+    """
+    if ignore_modules is None:
+        ignore_modules = _BASE_MODULES  # type: ignore[assignment]
+    if package_distributions is None:
+        package_distributions = _PACKAGE_DISTRIBUTIONS
+    modules_found = set(_DEFAULT_REQUIRED_PACKAGES)
+    inspect_getmembers_kwargs = inspect_getmembers_kwargs or {}
+    for _, attr in inspect.getmembers(obj, **inspect_getmembers_kwargs):
+        if not attr or inspect.isbuiltin(attr) or not hasattr(attr, "__module__"):
+            continue
+        module_name = (attr.__module__ or "").split(".")[0]
+        if module_name and module_name not in ignore_modules:  # type: ignore[operator]
+            for module in package_distributions.get(module_name, []):
+                modules_found.add(module)
+    return {module: importlib_metadata.version(module) for module in modules_found}
+
+
+def _to_dict(message: proto.Message) -> Dict[str, Any]:
+    """Converts the contents of the protobuf message to JSON format.
+
+    Args:
+        message (proto.Message):
+            Required. The proto message to be converted to a JSON dictionary.
+
+    Returns:
+        dict[str, Any]: A dictionary containing the contents of the proto.
+    """
+    try:
+        # Best effort attempt to convert the message into a JSON dictionary.
+        result: Dict[str, Any] = json.loads(
+            json_format.MessageToJson(
+                message._pb,
+                preserving_proto_field_name=True,
+            )
+        )
+    except AttributeError:
+        result: Dict[str, Any] = json.loads(  # type: ignore[no-redef]
+            json_format.MessageToJson(
+                message,
+                preserving_proto_field_name=True,
+            )
+        )
+    return result
+
+
+def _to_proto(
+    obj: Union[Dict[str, Any], proto.Message],
+    message: Optional[proto.Message] = None,
+) -> proto.Message:
+    """Parses a JSON-like object into a message.
+
+    If the object is already a message, this will return the object as-is. If
+    the object is a JSON Dict, this will parse and merge the object into the
+    message.
+
+    Args:
+        obj (Union[dict[str, Any], proto.Message]):
+            Required. The object to convert to a proto message.
+        message (proto.Message):
+            Optional. A protocol buffer message to merge the obj into. It
+            defaults to Struct() if unspecified.
+
+    Returns:
+        proto.Message: The same message passed as argument.
+    """
+    if message is None:
+        message = struct_pb2.Struct()
+    if isinstance(obj, (proto.Message, struct_pb2.Struct)):
+        return obj
+    try:
+        json_format.ParseDict(obj, message._pb)
+    except AttributeError:
+        json_format.ParseDict(obj, message)
+    return message
+
+
+def _upload_agent_engine(
+    *,
+    agent: _AgentEngineInterface,
+    gcs_bucket: _StorageBucket,
+    gcs_dir_name: str,
+) -> None:
+    """Uploads the agent engine to GCS."""
+    cloudpickle = _import_cloudpickle_or_raise()
+    blob = gcs_bucket.blob(f"{gcs_dir_name}/{_BLOB_FILENAME}")
+    with blob.open("wb") as f:
+        try:
+            cloudpickle.dump(agent, f)
+        except Exception as e:
+            url = "https://cloud.google.com/vertex-ai/generative-ai/docs/agent-engine/develop/custom#deployment-considerations"
+            error_msg = f"Failed to serialize agent engine. Visit {url} for details."
+            if "google._upb._message" in str(e) or "Descriptor" in str(e):
+                error_msg += (
+                    " This is often caused by protobuf objects (like Part, AgentCard) "
+                    "being imported at the global module level. Please move these "
+                    "imports inside the functions or methods where they are used. "
+                    "Alternatively, you can import the entire module: "
+                    "`from a2a import types`."
+                )
+            raise TypeError(error_msg) from e
+    with blob.open("rb") as f:
+        try:
+            _ = cloudpickle.load(f)
+        except Exception as e:
+            raise TypeError("Agent engine serialized to an invalid format") from e
+    dir_name = f"gs://{gcs_bucket.name}/{gcs_dir_name}"
+    logger.info(f"Wrote to {dir_name}/{_BLOB_FILENAME}")
+
+
+def _upload_requirements(
+    *,
+    requirements: Sequence[str],
+    gcs_bucket: _StorageBucket,
+    gcs_dir_name: str,
+) -> None:
+    """Uploads the requirements file to GCS."""
+    blob = gcs_bucket.blob(f"{gcs_dir_name}/{_REQUIREMENTS_FILE}")
+    blob.upload_from_string("\n".join(requirements))
+    dir_name = f"gs://{gcs_bucket.name}/{gcs_dir_name}"
+    logger.info(f"Writing to {dir_name}/{_REQUIREMENTS_FILE}")
+
+
+def _upload_extra_packages(
+    *,
+    extra_packages: Sequence[str],
+    gcs_bucket: _StorageBucket,
+    gcs_dir_name: str,
+) -> None:
+    """Uploads extra packages to GCS."""
+    logger.info("Creating in-memory tarfile of extra_packages")
+    tar_fileobj = io.BytesIO()
+    with tarfile.open(fileobj=tar_fileobj, mode="w|gz") as tar:
+        for file in extra_packages:
+            tar.add(file)
+    tar_fileobj.seek(0)
+    blob = gcs_bucket.blob(f"{gcs_dir_name}/{_EXTRA_PACKAGES_FILE}")
+    blob.upload_from_string(tar_fileobj.read())
+    dir_name = f"gs://{gcs_bucket.name}/{gcs_dir_name}"
+    logger.info(f"Writing to {dir_name}/{_EXTRA_PACKAGES_FILE}")
+
+
+def _create_base64_encoded_tarball(
+    *,
+    source_packages: Sequence[str],
+) -> str:
+    """Creates a base64 encoded tarball from the source packages."""
+    logger.info("Creating in-memory tarfile of source_packages")
+    tar_fileobj = io.BytesIO()
+    project_dir = os.path.realpath(os.getcwd())
+    with tarfile.open(fileobj=tar_fileobj, mode="w|gz") as tar:
+        for file in source_packages:
+            real_file_path = os.path.realpath(file)
+            if real_file_path != project_dir and not real_file_path.startswith(
+                project_dir + os.sep
+            ):
+                raise ValueError(
+                    f"File path '{file}' is outside the project directory "
+                    f"'{project_dir}'."
+                )
+            tar.add(file)
+    tar_fileobj.seek(0)
+    tarball_bytes = tar_fileobj.read()
+    return base64.b64encode(tarball_bytes).decode("utf-8")
+
+
+def _validate_packages_or_raise(
+    *,
+    packages: Sequence[str],
+    build_options: Optional[Dict[str, Sequence[str]]] = None,
+) -> Sequence[str]:
+    """Tries to validates the packages."""
+    packages = packages or []
+    if build_options and _INSTALLATION_SUBDIR in build_options:
+        _validate_installation_scripts_or_raise(
+            script_paths=build_options[_INSTALLATION_SUBDIR],
+            packages=packages,
+        )
+    for package in packages:
+        if not os.path.exists(package):
+            raise FileNotFoundError(f"Package specified but not found: {package=}")
+    return packages
+
+
+def _validate_installation_scripts_or_raise(
+    *,
+    script_paths: Sequence[str],
+    packages: Sequence[str],
+) -> None:
+    """Validates the installation scripts' path explicitly provided by the user.
+
+    Args:
+        script_paths (Sequence[str]):
+            Required. The paths to the installation scripts.
+        packages (Sequence[str]):
+            Required. The user-provided packages.
+
+    Raises:
+        ValueError: If a user-defined script is not under the expected
+            subdirectory, or not in `packages`, or if a package is
+            in the installation scripts subdirectory, but is not specified as an
+            installation script.
+    """
+    for script_path in script_paths:
+        if not script_path.startswith(_INSTALLATION_SUBDIR):
+            logger.warning(
+                f"User-defined installation script '{script_path}' is not in "
+                f"the expected '{_INSTALLATION_SUBDIR}' subdirectory. "
+                f"Ensure it is placed in '{_INSTALLATION_SUBDIR}' within your "
+                f"'extra_packages' or 'source_packages'."
+            )
+            raise ValueError(
+                f"Required installation script '{script_path}' "
+                f"is not under '{_INSTALLATION_SUBDIR}'"
+            )
+
+        if script_path not in packages:
+            logger.warning(
+                f"User-defined installation script '{script_path}' is not in "
+                f"'extra_packages' or 'source_packages'. Ensure it is added to "
+                f"'extra_packages' or 'source_packages'."
+            )
+            raise ValueError(
+                f"User-defined installation script '{script_path}' "
+                f"does not exist in 'extra_packages' or 'source_packages'."
+            )
+
+    for package in packages:
+        if package.startswith(_INSTALLATION_SUBDIR) and package not in script_paths:
+            logger.warning(
+                f"Package '{package}' is in the installation "
+                "scripts subdirectory, but is not specified as an installation "
+                "script in `build_options`. "
+                "Ensure it is added to installation_scripts for "
+                "automatic execution."
+            )
+            raise ValueError(
+                f"Package '{package}' is in the installation "
+                "scripts subdirectory, but is not specified as an installation "
+                "script in `build_options`."
+            )
+    return
+
+
+def _validate_staging_bucket_or_raise(*, staging_bucket: str) -> str:
+    """Tries to validate the staging bucket."""
+    if not staging_bucket:
+        raise ValueError(
+            "Please provide a `staging_bucket` in `client.agent_engines.create(...)`."
+        )
+    if not staging_bucket.startswith("gs://"):
+        raise ValueError(f"{staging_bucket=} must start with `gs://`")
+    return staging_bucket
+
+
+def _validate_requirements_or_warn(
+    *,
+    obj: Any,
+    requirements: List[str],
+) -> List[str]:
+    """Compiles the requirements into a list of requirements."""
+    requirements = requirements.copy()
+    try:
+        current_requirements = _scan_requirements(obj=obj)
+        logger.info(f"Identified the following requirements: {current_requirements}")
+        constraints = _parse_constraints(constraints=requirements)
+        missing_requirements = _compare_requirements(
+            requirements=current_requirements,
+            constraints=constraints,
+        )
+        for warning_type, warnings in missing_requirements["warnings"].items():
+            if warnings:
+                logger.warning(
+                    f"The following requirements are {warning_type}: {warnings}"
+                )
+        for action_type, actions in missing_requirements["actions"].items():
+            if actions and action_type == _ACTION_APPEND:
+                for action in actions:  # type: ignore[attr-defined]
+                    requirements.append(action)
+                logger.info(f"The following requirements are appended: {actions}")
+    except Exception as e:
+        logger.warning(f"Failed to compile requirements: {e}")
+    return requirements
+
+
+def _validate_requirements_or_raise(
+    *,
+    agent: Any,
+    requirements: Optional[Sequence[str]] = None,
+) -> Sequence[str]:
+    """Tries to validate the requirements."""
+    if requirements is None:
+        requirements = []
+    elif isinstance(requirements, str):
+        try:
+            logger.info(f"Reading requirements from {requirements=}")
+            with open(requirements) as f:
+                requirements = f.read().splitlines()
+                logger.info(f"Read the following lines: {requirements}")
+        except IOError as err:
+            raise IOError(f"Failed to read requirements from {requirements=}") from err
+    requirements = _validate_requirements_or_warn(
+        obj=agent,
+        requirements=requirements,
+    )
+    logger.info(f"The final list of requirements: {requirements}")
+    return requirements
+
+
+def _validate_agent_or_raise(
+    *,
+    agent: _AgentEngineInterface,
+) -> _AgentEngineInterface:
+    """Tries to validate the agent engine.
+
+    The agent engine must have one of the following:
+    * a callable method named `query`
+    * a callable method named `stream_query`
+    * a callable method named `async_stream_query`
+    * a callable method named `bidi_stream_query`
+    * a callable method named `register_operations`
+
+    Args:
+        agent: The agent to be validated.
+
+    Returns:
+        The validated agent engine.
+
+    Raises:
+        TypeError: If `agent_engine` has no callable method named `query`,
+        `stream_query` or `register_operations`.
+        ValueError: If `agent_engine` has an invalid `query`, `stream_query` or
+        `register_operations` signature.
+    """
+    try:
+        from google.adk.agents import BaseAgent
+
+        if isinstance(agent, BaseAgent):
+            logger.info("Deploying google.adk.agents.Agent as an application.")
+            from agentplatform import agent_engines
+
+            agent = agent_engines.AdkApp(agent=agent)
+    except Exception:
+        pass
+    is_queryable = isinstance(agent, Queryable) and callable(agent.query)
+    is_async_queryable = isinstance(agent, AsyncQueryable) and callable(
+        agent.async_query
+    )
+    is_stream_queryable = isinstance(agent, StreamQueryable) and callable(
+        agent.stream_query
+    )
+    is_async_stream_queryable = isinstance(agent, AsyncStreamQueryable) and callable(
+        agent.async_stream_query
+    )
+    is_bidi_stream_queryable = isinstance(agent, BidiStreamQueryable) and callable(
+        agent.bidi_stream_query
+    )
+    is_operation_registrable = isinstance(agent, OperationRegistrable) and callable(
+        agent.register_operations
+    )
+
+    if not (
+        is_queryable
+        or is_async_queryable
+        or is_stream_queryable
+        or is_operation_registrable
+        or is_bidi_stream_queryable
+        or is_async_stream_queryable
+    ):
+        raise TypeError(
+            "agent_engine has none of the following callable methods: "
+            "`query`, `async_query`, `stream_query`, `async_stream_query`, "
+            "`bidi_stream_query`, or `register_operations`."
+        )
+
+    if is_queryable:
+        try:
+            inspect.signature(getattr(agent, "query"))
+        except ValueError as err:
+            raise ValueError(
+                "Invalid query signature. This might be due to a missing "
+                "`self` argument in the agent.query method."
+            ) from err
+
+    if is_async_queryable:
+        try:
+            inspect.signature(getattr(agent, "async_query"))
+        except ValueError as err:
+            raise ValueError(
+                "Invalid async_query signature. This might be due to a missing "
+                "`self` argument in the agent.async_query method."
+            ) from err
+
+    if is_stream_queryable:
+        try:
+            inspect.signature(getattr(agent, "stream_query"))
+        except ValueError as err:
+            raise ValueError(
+                "Invalid stream_query signature. This might be due to a missing"
+                " `self` argument in the agent.stream_query method."
+            ) from err
+
+    if is_async_stream_queryable:
+        try:
+            inspect.signature(getattr(agent, "async_stream_query"))
+        except ValueError as err:
+            raise ValueError(
+                "Invalid async_stream_query signature. This might be due to a "
+                " missing `self` argument in the agent.async_stream_query method."
+            ) from err
+
+    if is_bidi_stream_queryable:
+        try:
+            inspect.signature(getattr(agent, "bidi_stream_query"))
+        except ValueError as err:
+            raise ValueError(
+                "Invalid bidi_stream_query signature. This might be due to a "
+                " missing `self` argument in the agent.bidi_stream_query method."
+            ) from err
+
+    if is_operation_registrable:
+        try:
+            inspect.signature(getattr(agent, "register_operations"))
+        except ValueError as err:
+            raise ValueError(
+                "Invalid register_operations signature. This might be due to a "
+                "missing `self` argument in the agent.register_operations method."
+            ) from err
+
+    if isinstance(agent, Cloneable):
+        # Avoid undeployable states.
+        agent = agent.clone()
+    return agent
+
+
+def _wrap_agent_operation(*, agent: Any, operation: str) -> Callable[..., Any]:
+    """Wraps an agent operation into a method (works for all API modes)."""
+
+    def _method(self, **kwargs) -> Any:  # type: ignore[no-untyped-def]
+        if not self._tmpl_attrs.get("agent"):
+            self.set_up()
+        return getattr(self._tmpl_attrs["agent"], operation)(**kwargs)
+
+    _method.__name__ = operation
+    _method.__doc__ = getattr(agent, operation).__doc__
+    return _method
+
+
+def _wrap_query_operation(*, method_name: str) -> Callable[..., Any]:
+    """Wraps an Agent Engine method, creating a callable for `query` API.
+
+    This function creates a callable object that executes the specified
+    Agent Engine method using the `query` API.  It handles the creation of
+    the API request and the processing of the API response.
+
+    Args:
+        method_name: The name of the Agent Engine method to call.
+        doc: Documentation string for the method.
+
+    Returns:
+        A callable object that executes the method on the Agent Engine via
+        the `query` API.
+    """
+
+    def _method(self: genai_types.AgentEngine, **kwargs) -> Any:  # type: ignore[no-untyped-def]
+        if not self.api_client:
+            raise ValueError("api_client is not initialized.")
+        if not self.api_resource:
+            raise ValueError("api_resource is not initialized.")
+        response = self.api_client._query(
+            name=self.api_resource.name,
+            config={
+                "class_method": method_name,
+                "input": kwargs,
+                "include_all_fields": True,
+            },
+        )
+        return response.output
+
+    return _method
+
+
+def _wrap_async_query_operation(
+    *, method_name: str
+) -> Callable[..., Coroutine[Any, Any, Any]]:
+    """Wraps an Agent Engine method, creating an async callable for `query` API.
+
+    This function creates a callable object that executes the specified
+    Agent Engine method asynchronously using the `query` API. It handles the
+    creation of the API request and the processing of the API response.
+
+    Args:
+        method_name: The name of the Agent Engine method to call.
+        doc: Documentation string for the method.
+
+    Returns:
+        A callable object that executes the method on the Agent Engine via
+        the `query` API.
+    """
+
+    async def _method(
+        self: genai_types.AgentEngine, **kwargs: Any
+    ) -> Union[Coroutine[Any, Any, Any], Any]:
+        if not self.api_async_client:
+            raise ValueError("api_async_client is not initialized.")
+        if not self.api_resource:
+            raise ValueError("api_resource is not initialized.")
+        response = await self.api_async_client._query(
+            name=self.api_resource.name,
+            config={
+                "class_method": method_name,
+                "input": kwargs,
+                "include_all_fields": True,
+            },
+        )
+        return response.output
+
+    return _method
+
+
+def _wrap_stream_query_operation(*, method_name: str) -> Callable[..., Iterator[Any]]:
+    """Wraps an Agent Engine method, creating a callable for `stream_query` API.
+
+    This function creates a callable object that executes the specified
+    Agent Engine method using the `stream_query` API.  It handles the
+    creation of the API request and the processing of the API response.
+
+    Args:
+        method_name: The name of the Agent Engine method to call.
+        doc: Documentation string for the method.
+
+    Returns:
+        A callable object that executes the method on the Agent Engine via
+        the `stream_query` API.
+    """
+
+    def _method(self: genai_types.AgentEngine, **kwargs) -> Iterator[Any]:  # type: ignore[no-untyped-def]
+        if not self.api_client:
+            raise ValueError("api_client is not initialized.")
+        if not self.api_resource:
+            raise ValueError("api_resource is not initialized.")
+        for http_response in self.api_client._stream_query(
+            name=self.api_resource.name,
+            config={
+                "class_method": method_name,
+                "input": kwargs,
+                "include_all_fields": True,
+            },
+        ):
+            for line in _yield_parsed_json(http_response=http_response):
+                if line is not None:
+                    yield line
+
+    return _method
+
+
+def _wrap_async_stream_query_operation(
+    *, method_name: str
+) -> Callable[..., AsyncIterator[Any]]:
+    """Wraps an Agent Engine method, creating an async callable for `stream_query` API.
+
+    This function creates a callable object that executes the specified
+    Agent Engine method using the `stream_query` API.  It handles the
+    creation of the API request and the processing of the API response.
+
+    Args:
+        method_name: The name of the Agent Engine method to call.
+        doc: Documentation string for the method.
+
+    Returns:
+        A callable object that executes the method on the Agent Engine via
+        the `stream_query` API.
+    """
+
+    async def _method(self: genai_types.AgentEngine, **kwargs) -> AsyncIterator[Any]:  # type: ignore[no-untyped-def]
+        if not self.api_client:
+            raise ValueError("api_client is not initialized.")
+        if not self.api_resource:
+            raise ValueError("api_resource is not initialized.")
+        async for http_response in self.api_client._async_stream_query(
+            name=self.api_resource.name,
+            config={
+                "class_method": method_name,
+                "input": kwargs,
+                "include_all_fields": True,
+            },
+        ):
+            for line in _yield_parsed_json(http_response=http_response):
+                if line is not None:
+                    yield line
+
+    return _method
+
+
+def _wrap_a2a_operation(method_name: str, agent_card: str) -> Callable[..., list[Any]]:
+    """Wraps an Agent Engine method, creating a callable for A2A API.
+
+    Args:
+        method_name: The name of the Agent Engine method to call.
+        agent_card: The agent card to use for the A2A API call.
+            Example:
+                {'additionalInterfaces': None,
+                'capabilities': {'extensions': None,
+                'pushNotifications': None,
+                'stateTransitionHistory': None,
+                'streaming': False},
+                'defaultInputModes': ['text'],
+                'defaultOutputModes': ['text'],
+                'description': (
+                    'A helpful assistant agent that can answer questions.'
+                ),
+                'documentationUrl': None,
+                'iconUrl': None,
+                'name': 'Q&A Agent',
+                'preferredTransport': 'JSONRPC',
+                'protocolVersion': '0.3.0',
+                'provider': None,
+                'security': None,
+                'securitySchemes': None,
+                'signatures': None,
+                'skills': [{
+                    'description': (
+                        'A helpful assistant agent that can answer questions.'
+                    ),
+                    'examples': ['Who is leading 2025 F1 Standings?',
+                        'Where can i find an active volcano?'],
+                    'id': 'question_answer',
+                'inputModes': None,
+                'name': 'Q&A Agent',
+                'outputModes': None,
+                'security': None,
+                'tags': ['Question-Answer']}],
+                'supportsAuthenticatedExtendedCard': True,
+                'url': 'http://localhost:8080/',
+                'version': '1.0.0'}
+    Returns:
+        A callable object that executes the method on the Agent Engine via
+        the A2A API.
+    """
+
+    async def _method(self, **kwargs) -> Any:  # type: ignore[no-untyped-def]
+        """Wraps an Agent Engine method, creating a callable for A2A API."""
+        if not self.api_client:
+            raise ValueError("api_client is not initialized.")
+        if not self.api_resource:
+            raise ValueError("api_resource is not initialized.")
+        a2a_agent_card = AgentCard(**json.loads(agent_card))
+        # A2A + AE integration currently only supports Rest API.
+        if (
+            a2a_agent_card.preferred_transport
+            and a2a_agent_card.preferred_transport != TransportProtocol.http_json
+        ):
+            raise ValueError(
+                "Only HTTP+JSON is supported for preferred transport on agent card "
+            )
+
+        # Set preferred transport to HTTP+JSON if not set.
+        if not hasattr(a2a_agent_card, "preferred_transport"):
+            a2a_agent_card.preferred_transport = TransportProtocol.http_json
+
+        if not hasattr(a2a_agent_card.capabilities, "streaming"):
+            a2a_agent_card.capabilities.streaming = False
+
+        # agent_card is set on the class_methods before set_up is invoked.
+        # Ensure that the agent_card url is set correctly before the client is created.
+        base_url = self.api_client._api_client._http_options.base_url.rstrip("/")
+        api_version = self.api_client._api_client._http_options.api_version
+        a2a_agent_card.url = f"{base_url}/{api_version}/{self.api_resource.name}/a2a"
+
+        # Using a2a client, inject the auth token from the global config.
+        config = ClientConfig(
+            supported_transports=[
+                TransportProtocol.http_json,
+            ],
+            use_client_preference=True,
+            httpx_client=httpx.AsyncClient(
+                headers={
+                    "Authorization": (
+                        f"Bearer {self.api_client._api_client._credentials.token}"
+                    )
+                },
+                timeout=(
+                    self.api_client._api_client._http_options.timeout / 1000.0
+                    if self.api_client._api_client._http_options.timeout
+                    else None
+                ),
+            ),
+        )
+        factory = ClientFactory(config)
+        client = factory.create(a2a_agent_card)
+
+        if method_name == "on_message_send":
+            response = client.send_message(Message(**kwargs))
+            chunks = []
+            async for chunk in response:
+                chunks.append(chunk)
+            return chunks
+        elif method_name == "on_get_task":
+            response = await client.get_task(TaskQueryParams(**kwargs))
+        elif method_name == "on_cancel_task":
+            response = await client.cancel_task(TaskIdParams(**kwargs))
+        elif method_name == "handle_authenticated_agent_card":
+            response = await client.get_card()
+        else:
+            raise ValueError(f"Unknown method name: {method_name}")
+
+        return response
+
+    return _method  # type: ignore[return-value]
+
+
+def _yield_parsed_json(http_response: google_genai_types.HttpResponse) -> Iterator[Any]:
+    """Converts the body of the HTTP Response message to JSON format.
+
+    Args:
+        http_response (google.genai.types.HttpResponse):
+            Required. The httpbody body to be converted to JSON object(s).
+
+    Yields:
+        Any: A JSON object or line of the original body or None.
+    """
+    if not http_response.body:
+        yield None
+        return
+
+    # Handle the case of multiple dictionaries delimited by newlines.
+    for line in http_response.body.split("\n"):
+        if line:
+            try:
+                line = json.loads(line)
+            except Exception as e:
+                logger.warning(f"failed to parse json: {line}. Exception: {e}")
+            yield line
+
+
+def _validate_resource_limits_or_raise(resource_limits: dict[str, str]) -> None:
+    """Validates the resource limits.
+
+    Checks that the resource limits are a dict with 'cpu' and 'memory' keys.
+    Checks that the 'cpu' value is one of 1, 2, 4, 6, 8.
+    Checks that the 'memory' value is a string ending with 'Gi'.
+    Checks that the memory size is smaller than 32Gi.
+    Checks that the memory size requires at least the specified number of CPUs.
+
+    Args:
+        resource_limits: The resource limits to be validated.
+
+    Raises:
+        TypeError: If the resource limits are not a dict.
+        KeyError: If the resource limits do not contain 'cpu' and 'memory' keys.
+        ValueError: If the 'cpu' value is not one of 1, 2, 4, 6, 8.
+        ValueError: If the 'memory' value is not a string ending with 'Gi'.
+        ValueError: If the memory size is too large.
+        ValueError: If the memory size requires more CPUs than the specified
+        'cpu' value.
+    """
+    if not isinstance(resource_limits, dict):
+        raise TypeError(f"resource_limits must be a dict. Got {type(resource_limits)}")
+    if "cpu" not in resource_limits or "memory" not in resource_limits:
+        raise KeyError("resource_limits must contain 'cpu' and 'memory' keys.")
+
+    cpu = int(resource_limits["cpu"])
+    memory_str = resource_limits["memory"]
+
+    if cpu not in [1, 2, 4, 6, 8]:
+        raise ValueError(
+            "resource_limits['cpu'] must be one of 1, 2, 4, 6, 8. Got" f" {cpu}"
+        )
+
+    if not isinstance(memory_str, str) or not memory_str.endswith("Gi"):
+        raise ValueError(
+            "resource_limits['memory'] must be a string ending with 'Gi'."
+            f" Got {memory_str}"
+        )
+
+    try:
+        memory_gb = int(memory_str[:-2])
+    except ValueError:
+        raise ValueError(
+            f"Invalid memory value: {memory_str}. Must be an integer"
+            " followed by 'Gi'."
+        )
+
+    # https://cloud.google.com/run/docs/configuring/memory-limits
+    if memory_gb > 32:
+        raise ValueError(
+            f"Memory size of {memory_str} is too large. Must be smaller than 32Gi."
+        )
+    if memory_gb > 24:
+        min_cpu = 8
+    elif memory_gb > 16:
+        min_cpu = 6
+    elif memory_gb > 8:
+        min_cpu = 4
+    elif memory_gb > 4:
+        min_cpu = 2
+    else:
+        min_cpu = 1
+
+    if cpu < min_cpu:
+        raise ValueError(
+            f"Memory size of {memory_str} requires at least {min_cpu} CPUs."
+            f" Got {cpu}"
+        )
+
+
+def _is_adk_agent(agent_engine: _AgentEngineInterface) -> bool:
+    """Checks if the agent engine is an ADK agent.
+
+    Args:
+        agent_engine: The agent engine to check.
+
+    Returns:
+        True if the agent engine is an ADK agent, False otherwise.
+    """
+
+    from agentplatform.agent_engines.templates import adk
+
+    return isinstance(agent_engine, adk.AdkApp)
+
+
+def _add_telemetry_enablement_env(
+    env_vars: Optional[Dict[str, Union[str, Any]]]
+) -> Optional[Dict[str, Union[str, Any]]]:
+    """Adds telemetry enablement env var to the env vars.
+
+    This is in order to achieve default-on telemetry.
+    If the telemetry enablement env var is already set, we do not override it.
+
+    Args:
+        env_vars: The env vars to add the telemetry enablement env var to.
+
+    Returns:
+        The env vars with the telemetry enablement env var added.
+    """
+
+    GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY = (
+        "GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY"
+    )
+    env_to_add = {GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY: "unspecified"}
+
+    if env_vars is None:
+        return env_to_add
+
+    if not isinstance(env_vars, dict):
+        raise TypeError(f"env_vars must be a dict, but got {type(env_vars)}.")
+
+    if GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY in env_vars:
+        return env_vars
+
+    return env_vars | env_to_add

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_bigquery_utils.py

@@ -0,0 +1,49 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import logging
+
+from google.cloud import bigquery
+from google.genai._api_client import BaseApiClient
+import pandas as pd
+
+
+logger = logging.getLogger(__name__)
+
+
+class BigQueryUtils:
+    """Handles BigQuery operations."""
+
+    def __init__(self, api_client: BaseApiClient):
+        self.api_client = api_client
+        self.bigquery_client = bigquery.Client(
+            project=self.api_client.project,
+            credentials=self.api_client._credentials,
+        )
+
+    def load_bigquery_to_dataframe(self, table_uri: str) -> "pd.DataFrame":
+        """Loads data from a BigQuery table into a DataFrame."""
+        table = self.bigquery_client.get_table(table_uri)
+        return self.bigquery_client.list_rows(table).to_dataframe()
+
+    def upload_dataframe_to_bigquery(
+        self, df: "pd.DataFrame", bq_table_uri: str
+    ) -> None:
+        """Uploads a Pandas DataFrame to a BigQuery table."""
+        job = self.bigquery_client.load_table_from_dataframe(df, bq_table_uri)
+        job.result()
+        logger.info(
+            f"DataFrame successfully uploaded to BigQuery table: {bq_table_uri}"
+        )

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_datasets_utils.py

@@ -0,0 +1,280 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Utility functions for multimodal dataset."""
+
+import asyncio
+import datetime
+from typing import Any, Type, TypeVar
+import uuid
+
+import google.auth.credentials
+from agentplatform._genai.types import common
+from google.genai import _common
+
+
+METADATA_SCHEMA_URI = (
+    "gs://google-cloud-aiplatform/schema/dataset/metadata/multimodal_1.0.0.yaml"
+)
+_BQ_MULTIREGIONS = {"us", "eu"}
+_DEFAULT_BQ_DATASET_PREFIX = "vertex_datasets"
+_DEFAULT_BQ_TABLE_PREFIX = "multimodal_dataset"
+
+T = TypeVar("T", bound=_common.BaseModel)
+
+
+def create_from_response(
+    model_type: Type[T],
+    response: dict[str, Any],
+    config: Any | None = None,
+) -> T:
+    """Creates a model from a response."""
+    kwargs = (
+        {
+            "config": {
+                "response_schema": getattr(config, "response_schema", None),
+                "response_json_schema": getattr(config, "response_json_schema", None),
+                "include_all_fields": getattr(config, "include_all_fields", None),
+            }
+        }
+        if config
+        else {}
+    )
+    return model_type._from_response(response=response, kwargs=kwargs)
+
+
+def validate_multimodal_dataset_bigquery_uri(
+    multimodal_dataset: common.MultimodalDataset,
+) -> None:
+    """Validates that a multimodal dataset has a bigquery uri or raises ValueError."""
+    if (
+        not hasattr(multimodal_dataset, "metadata")
+        or multimodal_dataset.metadata is None
+    ):
+        raise ValueError("Multimodal dataset metadata is required.")
+    if (
+        not hasattr(multimodal_dataset.metadata, "input_config")
+        or multimodal_dataset.metadata.input_config is None
+    ):
+        raise ValueError("Multimodal dataset input config is required.")
+    if (
+        not hasattr(multimodal_dataset.metadata.input_config, "bigquery_source")
+        or multimodal_dataset.metadata.input_config.bigquery_source is None
+    ):
+        raise ValueError("Multimodal dataset input config bigquery source is required.")
+    if (
+        not hasattr(multimodal_dataset.metadata.input_config.bigquery_source, "uri")
+        or multimodal_dataset.metadata.input_config.bigquery_source.uri is None
+    ):
+        raise ValueError(
+            "Multimodal dataset input config bigquery source uri is required."
+        )
+    if not str(multimodal_dataset.metadata.input_config.bigquery_source.uri).startswith(
+        "bq://"
+    ):
+        raise ValueError(
+            "Multimodal dataset bigquery source uri must start with 'bq://'."
+        )
+
+
+def _try_import_bigframes() -> Any:
+    """Tries to import `bigframes`."""
+    try:
+        import bigframes
+        import bigframes.pandas
+        import bigframes.bigquery
+
+        return bigframes
+    except ImportError as exc:
+        raise ImportError(
+            "`bigframes` is not installed. Please call 'pip install bigframes'."
+        ) from exc
+
+
+def _try_import_bigquery() -> Any:
+    """Tries to import `bigquery`."""
+    try:
+        from google.cloud import bigquery
+
+        return bigquery
+    except ImportError as exc:
+        raise ImportError(
+            "`bigquery` is not installed. Please call 'pip install"
+            " google-cloud-bigquery'."
+        ) from exc
+
+
+def _bq_dataset_location_allowed(
+    vertex_location: str, bq_dataset_location: str
+) -> bool:
+    if bq_dataset_location == vertex_location:
+        return True
+    if bq_dataset_location in _BQ_MULTIREGIONS:
+        return vertex_location.startswith(bq_dataset_location)
+    return False
+
+
+def _normalize_and_validate_table_id(
+    *,
+    table_id: str,
+    project: str,
+    location: str,
+    credentials: google.auth.credentials.Credentials,
+) -> str:
+    bigquery = _try_import_bigquery()
+
+    table_ref = bigquery.TableReference.from_string(table_id, default_project=project)
+    if table_ref.project != project:
+        raise ValueError(
+            "The BigQuery table "
+            f"`{table_ref.project}.{table_ref.dataset_id}.{table_ref.table_id}`"
+            " must be in the same project as the multimodal dataset."
+            f" The multimodal dataset is in `{project}`, but the BigQuery table"
+            f" is in `{table_ref.project}`."
+        )
+
+    dataset_ref = bigquery.DatasetReference(
+        project=table_ref.project, dataset_id=table_ref.dataset_id
+    )
+    client = bigquery.Client(project=project, credentials=credentials)
+    bq_dataset = client.get_dataset(dataset_ref=dataset_ref)
+    if not _bq_dataset_location_allowed(location, bq_dataset.location):
+        raise ValueError(
+            "The BigQuery dataset"
+            f" `{dataset_ref.project}.{dataset_ref.dataset_id}` must be in the"
+            " same location as the multimodal dataset. The multimodal dataset"
+            f" is in `{location}`, but the BigQuery dataset is in"
+            f" `{bq_dataset.location}`."
+        )
+    return f"{table_ref.project}.{table_ref.dataset_id}.{table_ref.table_id}"
+
+
+async def _normalize_and_validate_table_id_async(
+    *,
+    table_id: str,
+    project: str,
+    location: str,
+    credentials: google.auth.credentials.Credentials,
+) -> str:
+    bigquery = _try_import_bigquery()
+
+    table_ref = bigquery.TableReference.from_string(table_id, default_project=project)
+    if table_ref.project != project:
+        raise ValueError(
+            "The BigQuery table "
+            f"`{table_ref.project}.{table_ref.dataset_id}.{table_ref.table_id}`"
+            " must be in the same project as the multimodal dataset."
+            f" The multimodal dataset is in `{project}`, but the BigQuery table"
+            f" is in `{table_ref.project}`."
+        )
+
+    dataset_ref = bigquery.DatasetReference(
+        project=table_ref.project, dataset_id=table_ref.dataset_id
+    )
+    client = bigquery.Client(project=project, credentials=credentials)
+    bq_dataset = await asyncio.to_thread(client.get_dataset, dataset_ref=dataset_ref)
+    if not _bq_dataset_location_allowed(location, bq_dataset.location):
+        raise ValueError(
+            "The BigQuery dataset"
+            f" `{dataset_ref.project}.{dataset_ref.dataset_id}` must be in the"
+            " same location as the multimodal dataset. The multimodal dataset"
+            f" is in `{location}`, but the BigQuery dataset is in"
+            f" `{bq_dataset.location}`."
+        )
+    return f"{table_ref.project}.{table_ref.dataset_id}.{table_ref.table_id}"
+
+
+def _create_default_bigquery_dataset_if_not_exists(
+    *,
+    project: str,
+    location: str,
+    credentials: google.auth.credentials.Credentials,
+) -> str:
+    bigquery = _try_import_bigquery()
+
+    bigquery_client = bigquery.Client(project=project, credentials=credentials)
+    location_str = location.lower().replace("-", "_")
+    dataset_id = bigquery.DatasetReference(
+        project, f"{_DEFAULT_BQ_DATASET_PREFIX}_{location_str}"
+    )
+    dataset = bigquery.Dataset(dataset_ref=dataset_id)
+    dataset.location = location
+    bigquery_client.create_dataset(dataset, exists_ok=True)
+    return f"{dataset_id.project}.{dataset_id.dataset_id}"
+
+
+async def _create_default_bigquery_dataset_if_not_exists_async(
+    *,
+    project: str,
+    location: str,
+    credentials: google.auth.credentials.Credentials,
+) -> str:
+    bigquery = _try_import_bigquery()
+
+    bigquery_client = bigquery.Client(project=project, credentials=credentials)
+    location_str = location.lower().replace("-", "_")
+    dataset_id = bigquery.DatasetReference(
+        project, f"{_DEFAULT_BQ_DATASET_PREFIX}_{location_str}"
+    )
+    dataset = bigquery.Dataset(dataset_ref=dataset_id)
+    dataset.location = location
+    await asyncio.to_thread(bigquery_client.create_dataset, dataset, exists_ok=True)
+    return f"{dataset_id.project}.{dataset_id.dataset_id}"
+
+
+def _generate_target_table_id(dataset_id: str) -> str:
+    return f"{dataset_id}.{_DEFAULT_BQ_TABLE_PREFIX}_{str(uuid.uuid4())}"
+
+
+def generate_multimodal_dataset_display_name() -> str:
+    """Generates a display name with a timestamp."""
+    return f"MultimodalDataset {datetime.datetime.now().isoformat(sep=' ')}"
+
+
+def save_dataframe_to_bigquery(
+    dataframe: "bigframes.pandas.DataFrame",  # type: ignore # noqa: F821
+    target_table_id: str,
+    bq_client: "bigquery.Client",  # type: ignore # noqa: F821
+) -> None:
+    # `to_gbq` does not support cross-region use cases. We use `copy_table` as a workaround.
+    temp_table_id = dataframe.to_gbq()
+    copy_job = bq_client.copy_table(
+        sources=temp_table_id,
+        destination=target_table_id,
+    )
+    copy_job.result()
+    bq_client.delete_table(temp_table_id)
+
+
+async def save_dataframe_to_bigquery_async(
+    dataframe: "bigframes.pandas.DataFrame",  # type: ignore # noqa: F821
+    target_table_id: str,
+    bq_client: "bigquery.Client",  # type: ignore # noqa: F821
+) -> None:
+    # `to_gbq` does not support cross-region use cases. We use `copy_table` as a workaround.
+    temp_table_id = await asyncio.to_thread(dataframe.to_gbq)
+    copy_job = await asyncio.to_thread(
+        bq_client.copy_table,
+        sources=temp_table_id,
+        destination=target_table_id,
+    )
+    await asyncio.to_thread(copy_job.result)
+    await asyncio.to_thread(bq_client.delete_table, temp_table_id)
+
+
+def resolve_dataset_name(resource_name_or_id: str, project: str, location: str) -> str:
+    """Resolves a dataset name or ID to a full resource name."""
+    if "/" not in resource_name_or_id:
+        return f"projects/{project}/locations/{location}/datasets/{resource_name_or_id}"
+    return resource_name_or_id

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_evals_constant.py

@@ -0,0 +1,78 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Constants for evals module."""
+
+SUPPORTED_PREDEFINED_METRICS = frozenset(
+    {
+        "general_quality_v1",
+        "text_quality_v1",
+        "instruction_following_v1",
+        "grounding_v1",
+        "safety_v1",
+        "multi_turn_general_quality_v1",
+        "multi_turn_text_quality_v1",
+        "multi_turn_tool_use_quality_v1",
+        "multi_turn_trajectory_quality_v1",
+        "multi_turn_task_success_v1",
+        "final_response_match_v2",
+        "final_response_reference_free_v1",
+        "final_response_quality_v1",
+        "hallucination_v1",
+        "tool_use_quality_v1",
+        "gecko_text2image_v1",
+        "gecko_text2video_v1",
+    }
+)
+
+SUPPORTED_VERTEX_MAAS_MODEL_PREFIXES = frozenset(
+    {
+        "meta/",  # Meta/Llama
+        "deepseek-ai/",  # DeepSeek AI
+        "qwen/",  # Qwen
+        "openai/",  # OpenAI (GPT-OSS)
+        "claude-",  # Anthropic (Claude)
+        "mistral-",  # Mistral AI
+        "jamba-",  # AI21 (Jamba)
+    }
+)
+INTERMEDIATE_EVENTS = "intermediate_events"
+RESPONSE = "response"
+PROMPT = "prompt"
+REFERENCE = "reference"
+SESSION_INPUT = "session_inputs"
+CONTEXT = "context"
+CONTENT = "content"
+PARTS = "parts"
+USER_AUTHOR = "user"
+AGENT_DATA = "agent_data"
+STARTING_PROMPT = "starting_prompt"
+CONVERSATION_PLAN = "conversation_plan"
+HISTORY = "history"
+CONVERSATION_HISTORY = "conversation_history"
+
+COMMON_DATASET_COLUMNS = frozenset(
+    {
+        INTERMEDIATE_EVENTS,
+        PROMPT,
+        REFERENCE,
+        SESSION_INPUT,
+        CONTEXT,
+        HISTORY,
+        CONVERSATION_HISTORY,
+        STARTING_PROMPT,
+        CONVERSATION_PLAN,
+        AGENT_DATA,
+    }
+)

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_evals_data_converters.py

@@ -0,0 +1,918 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Dataset converters for evals."""
+
+import copy
+import json
+import logging
+from typing import Any, Optional, Union
+
+from google.genai import _common
+from google.genai import types as genai_types
+from pydantic import ValidationError
+from typing_extensions import override
+
+from . import _evals_utils
+from . import _observability_data_converter
+from . import types
+
+
+logger = logging.getLogger("agentplatform_genai._evals_data_converters")
+
+
+class EvalDatasetSchema(_common.CaseInSensitiveEnum):
+    """Represents the schema of an evaluation dataset."""
+
+    GEMINI = "gemini"
+    FLATTEN = "flatten"
+    OPENAI = "openai"
+    OBSERVABILITY = "observability"
+    UNKNOWN = "unknown"
+
+
+_PLACEHOLDER_RESPONSE_TEXT = "Error: Missing response for this candidate"
+
+
+def _create_placeholder_response_candidate(
+    text: str = _PLACEHOLDER_RESPONSE_TEXT,
+) -> types.ResponseCandidate:
+    """Creates a ResponseCandidate with placeholder text."""
+    return types.ResponseCandidate(
+        response=genai_types.Content(parts=[genai_types.Part(text=text)])
+    )
+
+
+class _GeminiEvalDataConverter(_evals_utils.EvalDataConverter):
+    """Converter for dataset in the Gemini format."""
+
+    def _parse_request(self, request_data: dict[str, Any]) -> tuple[
+        genai_types.Content,
+        genai_types.Content,
+        list[types.evals.Message],
+        types.ResponseCandidate,
+    ]:
+        """Parses a request from a Gemini dataset."""
+        system_instruction = genai_types.Content()
+        prompt = genai_types.Content()
+        reference = types.ResponseCandidate()
+        conversation_history = []
+
+        if "system_instruction" in request_data:
+            system_instruction = genai_types.Content.model_validate(
+                request_data["system_instruction"]
+            )
+        for turn_id, content_dict in enumerate(request_data.get("contents", [])):
+            if not isinstance(content_dict, dict):
+                raise TypeError(
+                    "Expected a dictionary for content at turn %s, but got %s: %s"
+                    % (turn_id, type(content_dict).__name__, content_dict)
+                )
+            if "parts" not in content_dict:
+                raise ValueError(
+                    "Missing 'parts' key in content structure at turn %s: %s"
+                    % (turn_id, content_dict)
+                )
+            conversation_history.append(
+                types.evals.Message(
+                    turn_id=str(turn_id),
+                    content=genai_types.Content.model_validate(content_dict),
+                )
+            )
+        if conversation_history:
+            last_message = conversation_history.pop()
+            last_message_role = (
+                last_message.content.role if last_message.content else "user"
+            )
+            if last_message_role in ["user", None]:
+                prompt = (
+                    last_message.content
+                    if last_message.content
+                    else genai_types.Content()
+                )
+            elif last_message_role == "model":
+                reference = types.ResponseCandidate(response=last_message.content)
+                if conversation_history:
+                    second_to_last_message = conversation_history.pop()
+                    prompt = (
+                        second_to_last_message.content
+                        if second_to_last_message.content
+                        else genai_types.Content()
+                    )
+                else:
+                    prompt = genai_types.Content()
+
+        return prompt, system_instruction, conversation_history, reference
+
+    @override
+    def convert(self, raw_data: list[dict[str, Any]]) -> types.EvaluationDataset:
+        """Converts a list of raw data into an EvaluationDataset."""
+        eval_cases = []
+
+        for i, item in enumerate(raw_data):
+            eval_case_id = "gemini_eval_case_%s" % i
+            request_data = item.get("request", {})
+            response_data = item.get("response", {})
+
+            (
+                prompt,
+                system_instruction,
+                conversation_history,
+                reference,
+            ) = self._parse_request(request_data)
+
+            responses = []
+            if isinstance(response_data, str):
+                responses.append(
+                    types.ResponseCandidate(
+                        response=genai_types.Content(
+                            parts=[genai_types.Part(text=response_data)]
+                        )
+                    )
+                )
+            elif isinstance(response_data, dict):
+                try:
+                    generate_content_response = (
+                        genai_types.GenerateContentResponse.model_validate(
+                            response_data
+                        )
+                    )
+                    if generate_content_response.candidates:
+                        candidate = generate_content_response.candidates[0]
+                        if candidate.content:
+                            responses.append(
+                                types.ResponseCandidate(
+                                    response=genai_types.Content.model_validate(
+                                        candidate.content
+                                    )
+                                )
+                            )
+                    else:
+                        responses.append(_create_placeholder_response_candidate())
+                except Exception:
+                    responses.append(_create_placeholder_response_candidate())
+            else:
+                responses.append(_create_placeholder_response_candidate())
+
+            eval_case = types.EvalCase(
+                eval_case_id=eval_case_id,
+                prompt=prompt,
+                responses=responses,
+                reference=reference,
+                system_instruction=system_instruction,
+                conversation_history=conversation_history,
+            )
+            eval_cases.append(eval_case)
+
+        return types.EvaluationDataset(eval_cases=eval_cases)
+
+
+class _FlattenEvalDataConverter(_evals_utils.EvalDataConverter):
+    """Converter for datasets in a structured table format."""
+
+    def convert(self, raw_data: list[dict[str, Any]]) -> types.EvaluationDataset:
+        """Converts a list of raw data into an EvaluationDataset."""
+        eval_cases = []
+        for i, item_dict in enumerate(raw_data):
+            if not isinstance(item_dict, dict):
+                raise TypeError(
+                    "Expected a dictionary for item at index %s, but got %s: %s"
+                    % (i, type(item_dict).__name__, item_dict)
+                )
+            item = copy.deepcopy(item_dict)
+            eval_case_id = "eval_case_%s" % i
+            prompt_data = item.pop("prompt", None)
+            if not prompt_data:
+                prompt_data = item.pop("source", None)
+
+            conversation_history_data = item.pop("conversation_history", None)
+            if conversation_history_data is None:
+                conversation_history_data = item.pop("history", None)
+            response_data = item.pop("response", None)
+            reference_data = item.pop("reference", None)
+            system_instruction_data = item.pop("instruction", None)
+            rubric_groups_data = item.pop("rubric_groups", None)
+            intermediate_events_data = item.pop("intermediate_events", None)
+            agent_data_raw = item.pop("agent_data", None)
+
+            if not response_data and not agent_data_raw:
+                raise ValueError(
+                    "Response is required but missing for %s." % eval_case_id
+                )
+            if not prompt_data and not agent_data_raw:
+                raise ValueError(
+                    "Prompt is required but missing for %s." % eval_case_id
+                )
+
+            prompt: Optional[genai_types.Content] = None
+            if isinstance(prompt_data, str):
+                prompt = genai_types.Content(parts=[genai_types.Part(text=prompt_data)])
+            elif isinstance(prompt_data, dict):
+                prompt = genai_types.Content.model_validate(prompt_data)
+            elif isinstance(prompt_data, genai_types.Content):
+                prompt = prompt_data
+            elif not agent_data_raw:
+                raise ValueError(
+                    "Invalid prompt type for case %s: %s" % (i, type(prompt_data))
+                )
+
+            conversation_history: Optional[list[types.evals.Message]] = None
+            if isinstance(conversation_history_data, list):
+                conversation_history = []
+                for turn_id, content in enumerate(conversation_history_data):
+                    if isinstance(content, genai_types.Content):
+                        conversation_history.append(
+                            types.evals.Message(
+                                turn_id=str(turn_id),
+                                content=content,
+                            )
+                        )
+                    elif isinstance(content, dict):
+                        try:
+                            validated_content = genai_types.Content.model_validate(
+                                content
+                            )
+                            conversation_history.append(
+                                types.evals.Message(
+                                    turn_id=str(turn_id),
+                                    content=validated_content,
+                                )
+                            )
+                        except ValidationError as e:
+                            logger.warning(
+                                "Item at index %s in 'history' column for case "
+                                " %s is a dict but could not be validated as"
+                                " genai_types.Content: %s",
+                                turn_id,
+                                eval_case_id,
+                                e,
+                            )
+                    else:
+                        logger.warning(
+                            "Invalid type in 'history' column for case %s at index %s. "
+                            "Expected genai_types.Content or dict, but got %s. "
+                            "Skipping this history item.",
+                            eval_case_id,
+                            turn_id,
+                            type(content),
+                        )
+
+            responses: Optional[list[types.ResponseCandidate]] = None
+            if isinstance(response_data, dict):
+                responses = [
+                    types.ResponseCandidate(
+                        response=genai_types.Content.model_validate(response_data)
+                    )
+                ]
+            elif isinstance(response_data, str):
+                responses = [
+                    types.ResponseCandidate(
+                        response=genai_types.Content(
+                            parts=[genai_types.Part(text=response_data)]
+                        )
+                    )
+                ]
+            elif isinstance(response_data, genai_types.Content):
+                responses = [types.ResponseCandidate(response=response_data)]
+            elif not agent_data_raw:
+                raise ValueError(
+                    "Invalid response type for case %s: %s" % (i, type(response_data))
+                )
+
+            reference: Optional[types.ResponseCandidate] = None
+            if reference_data:
+                if isinstance(reference_data, dict):
+                    reference = types.ResponseCandidate(
+                        response=genai_types.Content.model_validate(reference_data)
+                    )
+                elif isinstance(reference_data, str):
+                    reference = types.ResponseCandidate(
+                        response=genai_types.Content(
+                            parts=[genai_types.Part(text=reference_data)]
+                        )
+                    )
+                elif isinstance(reference_data, genai_types.Content):
+                    reference = types.ResponseCandidate(response=reference_data)
+
+            system_instruction: Optional[genai_types.Content] = None
+            if system_instruction_data:
+                if isinstance(system_instruction_data, dict):
+                    system_instruction = genai_types.Content.model_validate(
+                        system_instruction_data
+                    )
+                elif isinstance(system_instruction_data, str):
+                    system_instruction = genai_types.Content(
+                        parts=[genai_types.Part(text=system_instruction_data)]
+                    )
+                elif isinstance(system_instruction_data, genai_types.Content):
+                    system_instruction = system_instruction_data
+
+            rubric_groups: Optional[dict[str, types.RubricGroup]] = None
+            if rubric_groups_data:
+                if isinstance(rubric_groups_data, dict):
+                    rubric_groups = {}
+                    for key, value in rubric_groups_data.items():
+                        if isinstance(value, list):
+                            try:
+                                validated_rubrics = [
+                                    (
+                                        types.evals.Rubric.model_validate(r)
+                                        if isinstance(r, dict)
+                                        else r
+                                    )
+                                    for r in value
+                                ]
+                                if all(
+                                    isinstance(r, types.evals.Rubric)
+                                    for r in validated_rubrics
+                                ):
+                                    rubric_groups[key] = types.RubricGroup(
+                                        rubrics=validated_rubrics
+                                    )
+                                else:
+                                    logger.warning(
+                                        "Invalid item type in rubric list for group '%s' in case %s.",
+                                        key,
+                                        i,
+                                    )
+                            except Exception as e:
+                                logger.warning(
+                                    "Failed to validate rubrics for group '%s' in case %s: %s",
+                                    key,
+                                    i,
+                                    e,
+                                )
+                        elif isinstance(value, types.RubricGroup):
+                            rubric_groups[key] = value
+                        elif isinstance(value, dict):
+                            try:
+                                rubric_groups[key] = types.RubricGroup.model_validate(
+                                    value
+                                )
+                            except Exception as e:
+                                logger.warning(
+                                    "Failed to validate RubricGroup dict for group '%s' in case %s: %s",
+                                    key,
+                                    i,
+                                    e,
+                                )
+                        else:
+                            logger.warning(
+                                "Invalid type for rubric group '%s' in case %s."
+                                " Expected list of rubrics, dict, or RubricGroup.",
+                                key,
+                                i,
+                            )
+                else:
+                    logger.warning(
+                        "Invalid type for rubric_groups in case %s. Expected dict.",
+                        i,
+                    )
+
+            intermediate_events: Optional[list[types.evals.Event]] = None
+            if intermediate_events_data:
+                if isinstance(intermediate_events_data, list):
+                    intermediate_events = []
+                    for event in intermediate_events_data:
+                        if isinstance(event, dict):
+                            try:
+                                validated_event = types.evals.Event.model_validate(
+                                    event
+                                )
+                                intermediate_events.append(validated_event)
+                            except Exception as e:
+                                logger.warning(
+                                    "Failed to validate intermediate event dict for"
+                                    " case %s: %s",
+                                    i,
+                                    e,
+                                )
+                        elif isinstance(event, types.evals.Event):
+                            intermediate_events.append(event)
+                        else:
+                            logger.warning(
+                                "Invalid type for intermediate_event in case"
+                                " %s. Expected list of dicts or list of"
+                                " types.evals.Event objects.",
+                                i,
+                            )
+                else:
+                    logger.warning(
+                        "Invalid type for intermediate_events in case %s. Expected"
+                        " list of types.evals.Event objects.",
+                        i,
+                    )
+
+            agent_data: Optional[types.evals.AgentData] = None
+            if agent_data_raw:
+                if isinstance(agent_data_raw, str):
+                    try:
+                        agent_data_dict = json.loads(agent_data_raw)
+                        agent_data = types.evals.AgentData.model_validate(
+                            agent_data_dict
+                        )
+                    except json.JSONDecodeError:
+                        logger.warning(
+                            "Could not decode agent_data JSON string for case %s.", i
+                        )
+                    except ValidationError as e:
+                        logger.warning(
+                            "Failed to validate agent_data for case %s: %s", i, e
+                        )
+                elif isinstance(agent_data_raw, dict):
+                    try:
+                        agent_data = types.evals.AgentData.model_validate(
+                            agent_data_raw
+                        )
+                    except ValidationError as e:
+                        logger.warning(
+                            "Failed to validate agent_data for case %s: %s", i, e
+                        )
+                elif isinstance(agent_data_raw, types.evals.AgentData):
+                    agent_data = agent_data_raw
+                else:
+                    logger.warning(
+                        "Invalid type for agent_data in case %s. Expected str, dict"
+                        " or types.evals.AgentData object. Got %s",
+                        i,
+                        type(agent_data_raw),
+                    )
+
+            eval_case = types.EvalCase(
+                eval_case_id=eval_case_id,
+                prompt=prompt,
+                responses=responses,
+                reference=reference,
+                conversation_history=conversation_history,
+                system_instruction=system_instruction,
+                rubric_groups=rubric_groups,
+                intermediate_events=intermediate_events,
+                agent_data=agent_data,
+                **item,  # Pass remaining columns as extra fields to EvalCase.
+                # They can be used for custom metric prompt templates.
+            )
+            eval_cases.append(eval_case)
+
+        return types.EvaluationDataset(eval_cases=eval_cases)
+
+
+class _OpenAIDataConverter(_evals_utils.EvalDataConverter):
+    """Converter for dataset in OpenAI's Chat Completion format."""
+
+    def _parse_messages(self, messages: list[dict[str, Any]]) -> tuple[
+        Optional[genai_types.Content],
+        list[types.evals.Message],
+        Optional[genai_types.Content],
+        Optional[types.ResponseCandidate],
+    ]:
+        """Parses a list of messages into instruction, history, prompt, and reference."""
+        system_instruction = None
+        prompt = None
+        reference = None
+        conversation_history = []
+
+        if messages and messages[0].get("role") in ["system", "developer"]:
+            system_instruction = genai_types.Content(
+                parts=[genai_types.Part(text=messages[0].get("content"))]
+            )
+            messages = messages[1:]
+
+        for turn_id, msg in enumerate(messages):
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            conversation_history.append(
+                types.evals.Message(
+                    turn_id=str(turn_id),
+                    content=genai_types.Content(
+                        parts=[genai_types.Part(text=content)], role=role
+                    ),
+                    author=role,
+                )
+            )
+
+        if conversation_history:
+            last_message = conversation_history.pop()
+            if last_message.content and last_message.content.role == "user":
+                prompt = last_message.content
+            elif last_message.content and last_message.content.role == "assistant":
+                reference = types.ResponseCandidate(response=last_message.content)
+                if conversation_history:
+                    second_to_last_message = conversation_history.pop()
+                    prompt = second_to_last_message.content
+
+        return system_instruction, conversation_history, prompt, reference
+
+    @override
+    def convert(self, raw_data: list[dict[str, Any]]) -> types.EvaluationDataset:
+        """Converts a list of OpenAI ChatCompletion data into an EvaluationDataset."""
+        eval_cases = []
+        for i, item in enumerate(raw_data):
+            eval_case_id = "openai_eval_case_%s" % i
+
+            if "request" not in item or "response" not in item:
+                logger.warning(
+                    "Skipping case %s due to missing 'request' or 'response' key.", i
+                )
+                continue
+
+            request_data = item.get("request", {})
+            response_data_raw = item.get("response", {})
+
+            response_data = {}
+            if isinstance(response_data_raw, str):
+                try:
+                    loaded_json = json.loads(response_data_raw)
+                    if isinstance(loaded_json, dict):
+                        response_data = loaded_json
+                    else:
+                        logger.warning(
+                            "Decoded response JSON is not a dictionary for case"
+                            " %s. Type: %s",
+                            i,
+                            type(loaded_json),
+                        )
+                except json.JSONDecodeError:
+                    logger.warning(
+                        "Could not decode response JSON string for case %s."
+                        " Treating as empty response.",
+                        i,
+                    )
+            elif isinstance(response_data_raw, dict):
+                response_data = response_data_raw
+
+            messages = request_data.get("messages", [])
+            choices = response_data.get("choices", [])
+
+            (
+                system_instruction,
+                conversation_history,
+                prompt,
+                reference,
+            ) = self._parse_messages(messages)
+
+            if prompt is None and reference is None:
+                logger.warning(
+                    "Could not determine a user prompt or reference for case %s."
+                    " Skipping.",
+                    i,
+                )
+                continue
+
+            responses = []
+            if (
+                choices
+                and isinstance(choices, list)
+                and isinstance(choices[0], dict)
+                and choices[0].get("message")
+            ):
+                response_content = choices[0]["message"].get("content", "")
+                responses.append(
+                    types.ResponseCandidate(
+                        response=genai_types.Content(
+                            parts=[genai_types.Part(text=response_content)]
+                        )
+                    )
+                )
+            else:
+                responses.append(_create_placeholder_response_candidate())
+
+            other_fields = {
+                k: v for k, v in item.items() if k not in ["request", "response"]
+            }
+
+            eval_case = types.EvalCase(
+                eval_case_id=eval_case_id,
+                prompt=prompt,
+                responses=responses,
+                reference=reference,
+                system_instruction=system_instruction,
+                conversation_history=conversation_history,
+                **other_fields,
+            )
+            eval_cases.append(eval_case)
+
+        return types.EvaluationDataset(eval_cases=eval_cases)
+
+
+def auto_detect_dataset_schema(
+    raw_dataset: list[dict[str, Any]],
+) -> Union[EvalDatasetSchema, str]:
+    """Detects the schema of a raw dataset."""
+    if not raw_dataset:
+        return EvalDatasetSchema.UNKNOWN
+
+    first_item = raw_dataset[0]
+    keys = set(first_item.keys())
+
+    if "format" in keys:
+        format_content = first_item.get("format", "")
+        if isinstance(format_content, str) and format_content == "observability":
+            return EvalDatasetSchema.OBSERVABILITY
+
+    if "request" in keys and "response" in keys:
+        request_content = first_item.get("request", {})
+        if isinstance(request_content, dict) and "contents" in request_content:
+            contents_list = request_content.get("contents")
+            if (
+                contents_list
+                and isinstance(contents_list, list)
+                and isinstance(contents_list[0], dict)
+            ):
+                if "parts" in contents_list[0]:
+                    return EvalDatasetSchema.GEMINI
+
+    if "request" in keys and "response" in keys:
+        request_content = first_item.get("request", {})
+        if isinstance(request_content, dict) and "messages" in request_content:
+            messages_list = request_content.get("messages")
+            if (
+                messages_list
+                and isinstance(messages_list, list)
+                and isinstance(messages_list[0], dict)
+            ):
+                if "role" in messages_list[0] and "content" in messages_list[0]:
+                    return EvalDatasetSchema.OPENAI
+
+    if "agent_data" in keys:
+        return EvalDatasetSchema.FLATTEN
+
+    if {"prompt", "response"}.issubset(keys) or {
+        "response",
+        "reference",
+    }.issubset(keys):
+        return EvalDatasetSchema.FLATTEN
+    else:
+        return EvalDatasetSchema.UNKNOWN
+
+
+_CONVERTER_REGISTRY = {
+    EvalDatasetSchema.GEMINI: _GeminiEvalDataConverter,
+    EvalDatasetSchema.FLATTEN: _FlattenEvalDataConverter,
+    EvalDatasetSchema.OPENAI: _OpenAIDataConverter,
+    EvalDatasetSchema.OBSERVABILITY: _observability_data_converter.ObservabilityDataConverter,
+}
+
+
+def get_dataset_converter(
+    dataset_schema: EvalDatasetSchema,
+) -> _evals_utils.EvalDataConverter:
+    """Returns the appropriate dataset converter for the given schema."""
+    if dataset_schema in _CONVERTER_REGISTRY:
+        return _CONVERTER_REGISTRY[dataset_schema]()  # type: ignore[abstract]
+    else:
+        raise ValueError("Unsupported dataset schema: %s" % dataset_schema)
+
+
+def _get_content_text(content: genai_types.Content) -> str:
+    """Safely extracts text from all parts of a content.
+
+    If the content has multiple parts, text from all parts is concatenated.
+    If a part is not text, it is ignored. If no text parts are found,
+    an empty string is returned.
+    """
+    text_parts = []
+    if (
+        content
+        and hasattr(content, "parts")
+        and isinstance(content.parts, list)
+        and content.parts
+    ):
+        for part in content.parts:
+            if hasattr(part, "text") and part.text is not None:
+                text_parts.append(str(part.text))
+    return "".join(text_parts)
+
+
+def _get_text_from_reference(
+    reference: Optional[types.ResponseCandidate],
+) -> Optional[str]:
+    """Safely extracts text from a reference field."""
+    if reference and hasattr(reference, "response") and reference.response:
+        return _get_content_text(reference.response)
+    return None
+
+
+def _validate_case_consistency(
+    base_case: types.EvalCase,
+    current_case: types.EvalCase,
+    case_idx: int,
+    dataset_idx: int,
+) -> None:
+    """Logs warnings if prompt or reference mismatches occur."""
+    if base_case.prompt != current_case.prompt:
+        base_prompt_text_preview = _get_content_text(base_case.prompt)[:50]
+        current_prompt_text_preview = _get_content_text(current_case.prompt)[:50]
+        logger.warning(
+            "Prompt mismatch for case index %d between base dataset (0)"
+            " and dataset %d. Using prompt from base. Base prompt"
+            " preview: '%s...', Dataset"
+            " %d prompt preview: '%s...'",
+            case_idx,
+            dataset_idx,
+            base_prompt_text_preview,
+            dataset_idx,
+            current_prompt_text_preview,
+        )
+
+    base_ref_text = _get_text_from_reference(base_case.reference)
+    current_ref_text = _get_text_from_reference(current_case.reference)
+
+    if bool(base_case.reference) != bool(current_case.reference):
+        logger.warning(
+            "Reference presence mismatch for case index %d between base"
+            " dataset (0) and dataset %d. Using reference (or lack"
+            " thereof) from base.",
+            case_idx,
+            dataset_idx,
+        )
+    elif base_ref_text != current_ref_text:
+        logger.warning(
+            "Reference text mismatch for case index %d between base"
+            " dataset (0) and dataset %d. Using reference from base. "
+            " Base ref: '%s...', Current ref:"
+            " '%s...'",
+            case_idx,
+            dataset_idx,
+            str(base_ref_text)[:50],
+            str(current_ref_text)[:50],
+        )
+
+
+def merge_evaluation_datasets(
+    datasets: list[types.EvaluationDataset],
+    agent_info: Optional[types.evals.AgentInfo] = None,
+) -> types.EvaluationDataset:
+    """Merges multiple EvaluationDatasets into a single EvaluationDataset.
+
+    Assumes that each dataset has responses corresponding to the same set of
+    prompts, in the same order. The prompt, reference, system_instruction, and
+    conversation_history are taken from the first dataset.
+    """
+    if not datasets:
+        raise ValueError("Input 'datasets' cannot be empty.")
+
+    num_expected_cases = 0
+    if datasets[0].eval_cases:
+        num_expected_cases = len(datasets[0].eval_cases)
+
+    if num_expected_cases == 0:
+        logger.warning(
+            "The first dataset has no evaluation cases. Result will be empty."
+        )
+        return types.EvaluationDataset(eval_cases=[])
+
+    for i, ds in enumerate(datasets):
+        current_len = len(ds.eval_cases) if ds.eval_cases else 0
+        if current_len != num_expected_cases:
+            raise ValueError(
+                "All datasets must have the same number of evaluation cases. "
+                "Base dataset (0) has %s, but dataset %s has %s."
+                % (num_expected_cases, i, current_len)
+            )
+
+    merged_eval_cases: list[types.EvalCase] = []
+    base_parsed_dataset = datasets[0]
+
+    for case_idx in range(num_expected_cases):
+        base_eval_case: types.EvalCase = (
+            base_parsed_dataset.eval_cases[case_idx]
+            if base_parsed_dataset.eval_cases
+            else types.EvalCase()
+        )
+        candidate_responses: list[types.ResponseCandidate] = []
+
+        if base_eval_case.responses:
+            candidate_responses.append(base_eval_case.responses[0])
+        elif base_eval_case.agent_data:
+            candidate_responses.append(_create_placeholder_response_candidate(""))
+        else:
+            logger.warning(
+                "No response or agent data found for base dataset (index 0) in case %s. "
+                "Adding placeholder.",
+                case_idx,
+            )
+            candidate_responses.append(
+                _create_placeholder_response_candidate(
+                    "Missing response from base dataset (0) for case %s" % case_idx
+                )
+            )
+
+        eval_case_custom_columns = base_eval_case.model_dump(
+            exclude={
+                "eval_case_id",
+                "prompt",
+                "responses",
+                "reference",
+                "system_instruction",
+                "conversation_history",
+                "intermediate_events",
+                "agent_data",
+                "agent_info",
+            },
+            exclude_none=True,
+        )
+        for dataset_idx_offset, current_parsed_ds in enumerate(datasets[1:], start=1):
+            current_ds_eval_case: types.EvalCase = (
+                current_parsed_ds.eval_cases[case_idx]
+                if current_parsed_ds.eval_cases
+                else types.EvalCase()
+            )
+
+            _validate_case_consistency(
+                base_eval_case, current_ds_eval_case, case_idx, dataset_idx_offset
+            )
+
+            current_ds_extra_attrs = current_ds_eval_case.model_dump(
+                exclude={
+                    "eval_case_id",
+                    "prompt",
+                    "responses",
+                    "reference",
+                    "system_instruction",
+                    "conversation_history",
+                    "intermediate_events",
+                    "agent_data",
+                    "agent_info",
+                },
+                exclude_none=True,
+            )
+            eval_case_custom_columns.update(current_ds_extra_attrs)
+
+            if current_ds_eval_case.responses:
+                candidate_responses.append(current_ds_eval_case.responses[0])
+            elif current_ds_eval_case.agent_data:
+                candidate_responses.append(_create_placeholder_response_candidate(""))
+            else:
+                logger.warning(
+                    "No response or agent data found for dataset %s in case %s. Adding"
+                    " placeholder.",
+                    dataset_idx_offset,
+                    case_idx,
+                )
+                candidate_responses.append(
+                    _create_placeholder_response_candidate(
+                        "Missing response from dataset %s for case %s"
+                        % (dataset_idx_offset, case_idx)
+                    )
+                )
+
+        merged_case = types.EvalCase(
+            eval_case_id=base_eval_case.eval_case_id
+            or "merged_eval_case_%s" % case_idx,
+            prompt=base_eval_case.prompt,
+            responses=candidate_responses if candidate_responses else None,
+            reference=base_eval_case.reference,
+            system_instruction=base_eval_case.system_instruction,
+            conversation_history=base_eval_case.conversation_history,
+            agent_info=agent_info or base_eval_case.agent_info,
+            agent_data=base_eval_case.agent_data,
+            intermediate_events=base_eval_case.intermediate_events,
+            **eval_case_custom_columns,
+        )
+        merged_eval_cases.append(merged_case)
+
+    return types.EvaluationDataset(eval_cases=merged_eval_cases)
+
+
+def merge_response_datasets_into_canonical_format(
+    raw_datasets: list[list[dict[str, Any]]],
+    schemas: list[str],
+    agent_info: Optional[types.evals.AgentInfo] = None,
+) -> types.EvaluationDataset:
+    """Merges multiple raw response datasets into a single EvaluationDataset.
+
+    Assumes that each dataset in raw_datasets has responses corresponding
+    to the same set of prompts, in the same order. The prompt, reference,
+    system_instruction, and conversation_history are taken from the first dataset.
+    """
+    if not isinstance(raw_datasets, list):
+        raise TypeError(
+            "Input 'raw_datasets' must be a list, got %s." % type(raw_datasets)
+        )
+    if not raw_datasets or not all(isinstance(ds, list) for ds in raw_datasets):
+        raise ValueError(
+            "Input 'raw_datasets' cannot be empty and must be a list of lists."
+        )
+    if not schemas or len(schemas) != len(raw_datasets):
+        raise ValueError(
+            "A list of schemas must be provided, one for each raw dataset. "
+            "Got %s schemas for %s datasets." % (len(schemas), len(raw_datasets))
+        )
+
+    parsed_evaluation_datasets: list[types.EvaluationDataset] = []
+    for i, (raw_ds_entry, schema) in enumerate(zip(raw_datasets, schemas)):
+        converter = get_dataset_converter(schema)
+        parsed_evaluation_datasets.append(converter.convert(raw_ds_entry))
+
+    return merge_evaluation_datasets(parsed_evaluation_datasets, agent_info)

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_evals_metric_handlers.py

@@ -0,0 +1,1755 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Handlers for computing evaluation metrics."""
+
+import abc
+import collections
+from concurrent import futures
+import json
+import logging
+import random
+import statistics
+import time
+from typing import Any, Callable, Generic, Optional, TypeVar, Union
+
+from google.genai import errors as genai_errors
+from google.genai import _common
+from google.genai import types as genai_types
+from tqdm import tqdm
+from typing_extensions import override
+
+from . import _evals_common
+from . import _evals_constant
+from . import _evals_utils
+from . import evals
+from . import types
+
+
+logger = logging.getLogger(__name__)
+_MAX_RETRIES = 5
+# HTTP status codes that are safe to retry with backoff.
+_RETRYABLE_STATUS_CODES = frozenset(
+    {
+        408,  # RequestTimeout (DEADLINE_EXCEEDED)
+        409,  # Conflict / Aborted (ABORTED)
+        429,  # TooManyRequests / ResourceExhausted (RESOURCE_EXHAUSTED)
+        499,  # Client Closed Request (CANCELLED)
+        500,  # InternalServerError (INTERNAL)
+        502,  # BadGateway
+        503,  # ServiceUnavailable (UNAVAILABLE)
+        504,  # GatewayTimeout (DEADLINE_EXCEEDED)
+    }
+)
+
+R = TypeVar("R")
+T = TypeVar("T", types.Metric, types.MetricSource, types.LLMMetric)
+
+
+def _call_with_retry(
+    fn: Callable[[], R],
+    metric_name: str,
+) -> R:
+    """Calls ``fn()`` with exponential backoff + jitter on retryable errors.
+
+    Retries up to ``_MAX_RETRIES`` times on errors whose HTTP status code is
+    in ``_RETRYABLE_STATUS_CODES`` (Aborted, DeadlineExceeded,
+    ResourceExhausted, ServiceUnavailable, Cancelled). Non-retryable errors
+    are re-raised immediately. If all retries are exhausted the last
+    exception is re-raised so the caller can decide how to handle it.
+
+    Args:
+        fn: A zero-argument callable that performs the API call.
+        metric_name: Name of the metric, used for log messages.
+
+    Returns:
+        The return value of ``fn()``.
+
+    Raises:
+        genai_errors.APIError: If all retries are exhausted or the error is
+            not retryable.
+    """
+    for attempt in range(_MAX_RETRIES):
+        try:
+            return fn()
+        except genai_errors.APIError as e:
+            if e.code in _RETRYABLE_STATUS_CODES:
+                backoff = 2**attempt + random.uniform(0, 1)
+                logger.warning(
+                    "Retryable error (code=%s) on attempt %d/%d for metric"
+                    " '%s': %s. Retrying in %.1f seconds...",
+                    e.code,
+                    attempt + 1,
+                    _MAX_RETRIES,
+                    metric_name,
+                    e,
+                    backoff,
+                )
+                if attempt == _MAX_RETRIES - 1:
+                    raise
+                time.sleep(backoff)
+            else:
+                raise
+    raise genai_errors.APIError(
+        code=504, response_json={"message": "Retries exhausted"}
+    )
+
+
+def _has_tool_call(events: Optional[list[Any]]) -> bool:
+    """Checks if any event in events has a function call."""
+    if not events:
+        return False
+    for event in events:
+        if getattr(event, "content", None) and getattr(event.content, "parts", None):
+            for part in event.content.parts:
+                if hasattr(part, "function_call") and part.function_call:
+                    return True
+    return False
+
+
+def _extract_text_from_content(
+    content: Optional[genai_types.Content], warn_property: str = "text"
+) -> Optional[str]:
+    """Extracts and concatenates all text parts from a Content object."""
+    if not content or not content.parts:
+        return None
+
+    text_accumulator = ""
+    any_text_part_found = False
+    non_text_part_names = []
+
+    for part_obj in content.parts:
+        part_dump = part_obj.model_dump(exclude={"text", "thought"})
+        for field_name, field_value in part_dump.items():
+            if field_value is not None:
+                if field_name not in non_text_part_names:
+                    non_text_part_names.append(field_name)
+
+        if isinstance(part_obj.text, str):
+            if (
+                hasattr(part_obj, "thought")
+                and isinstance(part_obj.thought, bool)
+                and part_obj.thought
+            ):
+                continue
+            any_text_part_found = True
+            text_accumulator += part_obj.text
+
+    if non_text_part_names and any_text_part_found:
+        logger.warning(
+            "Warning: content contains non-text parts: %s. Returning"
+            " concatenated %s result from text parts. Inspect individual parts"
+            " for full content.",
+            non_text_part_names,
+            warn_property,
+        )
+    return text_accumulator if any_text_part_found else None
+
+
+def _get_prompt_from_eval_case(
+    eval_case: types.EvalCase,
+) -> Optional[genai_types.Content]:
+    """Extracts prompt content from eval_case.prompt or starting_prompt."""
+    if eval_case.prompt:
+        return eval_case.prompt
+
+    user_scenario = getattr(eval_case, "user_scenario", None)
+    if user_scenario and user_scenario.starting_prompt:
+        return genai_types.Content(
+            parts=[genai_types.Part(text=user_scenario.starting_prompt)]
+        )
+
+    return None
+
+
+def _get_response_from_eval_case(
+    eval_case: types.EvalCase, response_index: int, metric_name: str
+) -> Optional[genai_types.Content]:
+    """Extracts response content from eval_case.responses."""
+    response_content = None
+    if eval_case.responses and response_index < len(eval_case.responses):
+        response_content = eval_case.responses[response_index].response
+
+    return response_content
+
+
+def _value_to_content_list(value: Any) -> list[genai_types.Content]:
+    """Converts a value to a list of Content objects."""
+    if isinstance(value, genai_types.Content):
+        return [value]
+    if isinstance(value, types.ResponseCandidate):
+        return [value.response] if value.response else []
+    if isinstance(value, list) and value:
+        if isinstance(value[0], genai_types.Content):
+            return value
+        if isinstance(value[0], types.evals.Message):
+            history_texts = []
+            for msg_obj in value:
+                msg_text = _extract_text_from_content(msg_obj.content)
+                if msg_text:
+                    role = msg_obj.content.role or msg_obj.author or "user"
+                    history_texts.append(f"{role}: {msg_text}")
+            return [
+                genai_types.Content(
+                    parts=[genai_types.Part(text="\n".join(history_texts))]
+                )
+            ]
+        return [genai_types.Content(parts=[genai_types.Part(text=json.dumps(value))])]
+    if isinstance(value, dict):
+        return [genai_types.Content(parts=[genai_types.Part(text=json.dumps(value))])]
+    return [genai_types.Content(parts=[genai_types.Part(text=str(value))])]
+
+
+def _get_autorater_config(metric: types.Metric) -> dict[str, Any]:
+    """Extracts autorater config settings from a metric."""
+    autorater_config: dict[str, Any] = {}
+    if metric.judge_model:
+        autorater_config["autorater_model"] = metric.judge_model
+    if metric.judge_model_generation_config:
+        autorater_config["generation_config"] = metric.judge_model_generation_config
+    if metric.judge_model_sampling_count:
+        autorater_config["sampling_count"] = metric.judge_model_sampling_count
+    return autorater_config
+
+
+def _default_aggregate_scores(
+    metric_name: str,
+    eval_case_metric_results: list[types.EvalCaseMetricResult],
+    calculate_pass_rate: bool = False,
+) -> types.AggregatedMetricResult:
+    """Default aggregation logic using mean and standard deviation."""
+    scores = []
+    num_error = 0
+    num_valid = 0
+    num_passing = 0
+
+    for result in eval_case_metric_results:
+        if result.error_message is None and result.score is not None:
+            try:
+                score = float(result.score)
+                scores.append(score)
+                num_valid += 1
+                if calculate_pass_rate and score == 1.0:
+                    num_passing += 1
+            except (ValueError, TypeError):
+                logger.warning(
+                    "Could not convert score '%s' to float for metric '%s' during"
+                    " default aggregation. Counting as error.",
+                    result.score,
+                    metric_name,
+                )
+                num_error += 1
+        else:
+            num_error += 1
+
+    mean_score = None
+    stdev_score = None
+    pass_rate = None
+
+    if num_valid > 0:
+        try:
+            mean_score = statistics.mean(scores)
+        except statistics.StatisticsError as e:
+            logger.warning("Could not calculate mean for %s: %s", metric_name, e)
+        if calculate_pass_rate:
+            pass_rate = num_passing / num_valid
+
+    if num_valid > 1:
+        try:
+            stdev_score = statistics.stdev(scores)
+        except statistics.StatisticsError as e:
+            logger.warning("Could not calculate stdev for %s: %s", metric_name, e)
+
+    return types.AggregatedMetricResult(
+        metric_name=metric_name,
+        num_cases_total=len(eval_case_metric_results),
+        num_cases_valid=num_valid,
+        num_cases_error=num_error,
+        mean_score=mean_score,
+        stdev_score=stdev_score,
+        pass_rate=pass_rate if calculate_pass_rate else None,
+    )
+
+
+class MetricHandler(abc.ABC, Generic[T]):
+    """Abstract base class for metric handlers."""
+
+    def __init__(self, module: "evals.Evals", metric: T):
+        self.module = module
+        self.metric: T = metric
+
+    @property
+    @abc.abstractmethod
+    def metric_name(self) -> str:
+        """Returns the name of the metric polymorphically."""
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def get_metric_result(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> types.EvalCaseMetricResult:
+        """Processes a single evaluation case for a specific metric."""
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def aggregate(
+        self, eval_case_metric_results: list[types.EvalCaseMetricResult]
+    ) -> types.AggregatedMetricResult:
+        """Aggregates the metric results for a specific metric."""
+        raise NotImplementedError()
+
+
+class ComputationMetricHandler(MetricHandler[types.Metric]):
+    """Metric handler for computation metrics."""
+
+    SUPPORTED_COMPUTATION_METRICS = frozenset(
+        {
+            "exact_match",
+            "bleu",
+            "rouge_1",
+            "rouge_l_sum",
+            "tool_call_valid",
+            "tool_name_match",
+            "tool_parameter_key_match",
+            "tool_parameter_kv_match",
+            # TODO b/423934249 - Add trajectory metrics once they are supported.
+        }
+    )
+
+    @property
+    def metric_name(self) -> str:
+        return self.metric.name or "unknown_metric"
+
+    def __init__(self, module: "evals.Evals", metric: types.Metric):
+        super().__init__(module=module, metric=metric)
+        if self.metric.name not in self.SUPPORTED_COMPUTATION_METRICS:
+            raise ValueError(
+                f"Metric '{self.metric.name}' is not supported for computation."
+            )
+
+    def _build_request_payload(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> dict[str, Any]:
+        """Builds the request parameters for evaluate instances."""
+        request_payload = {}
+
+        response_content = _get_response_from_eval_case(
+            eval_case, response_index, self.metric.name
+        )
+        prediction_text = _extract_text_from_content(response_content)
+
+        if prediction_text is None:
+            raise ValueError(
+                f"Response text missing for candidate {response_index} in eval_case"
+                f" {eval_case.eval_case_id or 'Unknown ID'}."
+            )
+
+        if (
+            eval_case.reference is None
+            or _extract_text_from_content(eval_case.reference.response) is None
+        ):
+            raise ValueError(
+                "Reference text missing for eval_case"
+                f" {eval_case.eval_case_id or 'Unknown ID'}."
+            )
+        logger.debug("eval_case: %s", eval_case)
+
+        if self.metric.name and self.metric.name.startswith("rouge"):
+            request_payload["rouge_input"] = {
+                "metric_spec": {
+                    "rouge_type": (
+                        "rougeLsum" if self.metric.name == "rouge_l_sum" else "rouge1"
+                    ),
+                },
+                "instances": [
+                    {
+                        "prediction": prediction_text,
+                        "reference": _extract_text_from_content(
+                            eval_case.reference.response
+                        ),
+                    }
+                ],
+            }
+        else:
+            request_payload[f"{self.metric.name}_input"] = {
+                "metric_spec": {},
+                "instances": [
+                    {
+                        "prediction": prediction_text,
+                        "reference": _extract_text_from_content(
+                            eval_case.reference.response
+                        ),
+                    }
+                ],
+            }
+        logger.debug("request_payload: %s", request_payload)
+        return request_payload
+
+    @override
+    def get_metric_result(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> types.EvalCaseMetricResult:
+        """Processes a single evaluation case for a specific computation metric."""
+
+        metric_name = self.metric.name
+        logger.debug(
+            "ComputationMetricHandler: Processing '%s' for case: %s",
+            metric_name,
+            eval_case.model_dump(exclude_none=True),
+        )
+        response = _call_with_retry(
+            lambda: self.module.evaluate_instances(
+                metric_config=self._build_request_payload(eval_case, response_index)
+            ).model_dump(exclude_none=True),
+            metric_name,
+        )
+        logger.debug("response: %s", response)
+        score = None
+        for _, result_value in response.items():
+            if isinstance(result_value, dict) and result_value:
+                for _, metric_value in result_value.items():
+                    if isinstance(metric_value, list) and metric_value:
+                        score = metric_value[0]["score"]
+                        break
+        logger.debug("Metric result: %s", score)
+        return types.EvalCaseMetricResult(
+            metric_name=metric_name,
+            score=score,
+        )
+
+    @override
+    def aggregate(
+        self, eval_case_metric_results: list[types.EvalCaseMetricResult]
+    ) -> types.AggregatedMetricResult:
+        """Aggregates the metric results for a computation metric."""
+        logger.debug("Aggregating results for computation metric: %s", self.metric.name)
+        return _default_aggregate_scores(self.metric.name, eval_case_metric_results)
+
+
+class TranslationMetricHandler(MetricHandler[types.Metric]):
+    """Metric handler for translation metrics."""
+
+    SUPPORTED_TRANSLATION_METRICS = frozenset({"comet", "metricx"})
+
+    @property
+    def metric_name(self) -> str:
+        return self.metric.name or "unknown_metric"
+
+    def __init__(self, module: "evals.Evals", metric: types.Metric):
+        super().__init__(module=module, metric=metric)
+
+        if self.metric.name not in self.SUPPORTED_TRANSLATION_METRICS:
+            raise ValueError(
+                f"Metric '{self.metric.name}' is not supported for translation."
+            )
+
+    def _build_request_payload(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> dict[str, Any]:
+        """Builds the request parameters for evaluate instances."""
+        request_payload = {}
+        metric_input_name = f"{self.metric.name}_input"
+        version = None
+        if hasattr(self.metric, "version"):
+            version = self.metric.version
+        elif self.metric.name == "comet":
+            version = "COMET_22_SRC_REF"
+        elif self.metric.name == "metricx":
+            version = "METRICX_24_SRC_REF"
+
+        source_language = None
+        target_language = None
+        if hasattr(self.metric, "source_language"):
+            source_language = self.metric.source_language
+        if hasattr(self.metric, "target_language"):
+            target_language = self.metric.target_language
+
+        response_content = _get_response_from_eval_case(
+            eval_case, response_index, self.metric.name
+        )
+        prediction_text = _extract_text_from_content(response_content)
+        prompt_text = _extract_text_from_content(_get_prompt_from_eval_case(eval_case))
+
+        if prediction_text is None:
+            raise ValueError(
+                f"Response text missing for candidate {response_index} in eval_case"
+                f" {eval_case.eval_case_id or 'Unknown ID'}."
+            )
+
+        if (
+            eval_case.reference is None
+            or _extract_text_from_content(eval_case.reference.response) is None
+        ):
+            raise ValueError(
+                "Reference text missing for eval_case"
+                f" {eval_case.eval_case_id or 'Unknown ID'}."
+            )
+        if prompt_text is None:
+            raise ValueError(
+                "Prompt text (source for translation) missing for eval_case"
+                f" {eval_case.eval_case_id or 'Unknown ID'}."
+            )
+
+        request_payload[metric_input_name] = {
+            "metric_spec": {
+                "version": version,
+                "source_language": source_language,
+                "target_language": target_language,
+            },
+            "instance": {
+                "prediction": prediction_text,
+                "reference": _extract_text_from_content(eval_case.reference.response),
+                "source": prompt_text,
+            },
+        }
+        return request_payload
+
+    @override
+    def get_metric_result(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> types.EvalCaseMetricResult:
+        """Processes a single evaluation case for a specific translation metric."""
+        metric_name = self.metric.name
+        logger.debug(
+            "TranslationMetricHandler: Processing '%s' for case: %s",
+            metric_name,
+            eval_case,
+        )
+        api_response = _call_with_retry(
+            lambda: self.module.evaluate_instances(
+                metric_config=self._build_request_payload(eval_case, response_index)
+            ),
+            metric_name,
+        )
+        logger.debug("API Response: %s", api_response)
+
+        score = None
+        error_message = None
+
+        try:
+            if metric_name == "comet":
+                if api_response and api_response.comet_result:
+                    score = api_response.comet_result.score
+                else:
+                    logger.warning(
+                        "Comet result missing in API response for metric '%s'."
+                        " API response: %s",
+                        metric_name,
+                        (
+                            api_response.model_dump_json(exclude_none=True)
+                            if api_response
+                            else "None"
+                        ),
+                    )
+            elif metric_name == "metricx":
+                if api_response and api_response.metricx_result:
+                    score = api_response.metricx_result.score
+                else:
+                    logger.warning(
+                        "MetricX result missing in API response for metric '%s'."
+                        " API response: %s",
+                        metric_name,
+                        (
+                            api_response.model_dump_json(exclude_none=True)
+                            if api_response
+                            else "None"
+                        ),
+                    )
+            if score is None and not error_message:
+                logger.warning(
+                    "Score could not be extracted for translation metric '%s'."
+                    " API response: %s",
+                    metric_name,
+                    (
+                        api_response.model_dump_json(exclude_none=True)
+                        if api_response
+                        else "None"
+                    ),
+                )
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error(
+                "Error processing/extracting score for translation metric '%s': %s."
+                " API response: %s",
+                metric_name,
+                e,
+                (
+                    api_response.model_dump_json(exclude_none=True)
+                    if api_response
+                    else "None"
+                ),
+                exc_info=True,
+            )
+            error_message = f"Error extracting score: {e}"
+
+        return types.EvalCaseMetricResult(
+            metric_name=metric_name,
+            score=score,
+            error_message=error_message,
+        )
+
+    @override
+    def aggregate(
+        self, eval_case_metric_results: list[types.EvalCaseMetricResult]
+    ) -> types.AggregatedMetricResult:
+        """Aggregates the metric results for a translation metric."""
+        logger.debug("Aggregating results for translation metric: %s", self.metric.name)
+        return _default_aggregate_scores(self.metric.name, eval_case_metric_results)
+
+
+def _content_to_instance_data(
+    content: Optional[genai_types.Content],
+) -> Optional[types.evals.InstanceData]:
+    """Converts a genai_types.Content object to a types.InstanceData object."""
+    if not content:
+        return None
+    return types.evals.InstanceData(
+        contents=types.evals.InstanceDataContents(contents=[content])
+    )
+
+
+def _eval_case_to_agent_data(
+    eval_case: types.EvalCase,
+    prompt_content: Optional[genai_types.Content] = None,
+    response_content: Optional[genai_types.Content] = None,
+) -> Optional[types.evals.AgentData]:
+    """Converts an EvalCase object to a single turn AgentData object.
+
+    If `eval_case.agent_data` is provided, it is returned directly, and
+    `prompt_content` and `response_content` are ignored.
+    """
+    if getattr(eval_case, "agent_data", None):
+        return eval_case.agent_data
+
+    if (
+        not eval_case.agent_info
+        and not eval_case.intermediate_events
+        and not prompt_content
+        and not response_content
+    ):
+        return None
+
+    agents_map = eval_case.agent_info.agents if eval_case.agent_info else None
+    events = []
+    if prompt_content:
+        events.append(types.evals.AgentEvent(author="user", content=prompt_content))
+
+    if eval_case.intermediate_events:
+        for event in eval_case.intermediate_events:
+            events.append(
+                types.evals.AgentEvent(
+                    author=event.author,
+                    content=event.content,
+                    event_time=event.creation_timestamp,
+                )
+            )
+
+    if response_content:
+        events.append(types.evals.AgentEvent(author="model", content=response_content))
+
+    turns = (
+        [types.evals.ConversationTurn(turn_index=0, turn_id="turn_0", events=events)]
+        if events
+        else None
+    )
+    return types.evals.AgentData(agents=agents_map, turns=turns)
+
+
+def _build_evaluation_instance(
+    eval_case: types.EvalCase,
+    response_content: Optional[genai_types.Content],
+    prompt_instance_data: Optional[types.evals.InstanceData] = None,
+    prompt_template: Optional[str] = None,
+) -> types.EvaluationInstance:
+    """Builds a unified EvaluationInstance. Multi-turn logic is handled by the caller."""
+    extracted_prompt = _get_prompt_from_eval_case(eval_case)
+
+    # 1. Use caller-provided prompt data (multi-turn) or default to simple content
+    if prompt_instance_data is None:
+        prompt_instance_data = _content_to_instance_data(extracted_prompt)
+
+    # 2. Collect placeholders for other_data
+    other_data_map: dict[str, Any] = {}
+    if hasattr(eval_case, "context") and eval_case.context:
+        if isinstance(eval_case.context, str):
+            other_data_map["context"] = types.evals.InstanceData(text=eval_case.context)
+        elif isinstance(eval_case.context, genai_types.Content):
+            other_data_map["context"] = _content_to_instance_data(eval_case.context)
+
+    # 3. Extract custom variables from LLMMetric templates
+    if prompt_template:
+        template_vars = types.PromptTemplate(text=prompt_template).variables
+        standard_fields = {"prompt", "response", "reference", "context", "agent_data"}
+        for full_path in template_vars:
+            # Extract the root variable (e.g. 'metadata' from 'metadata.user_id')
+            root_var = full_path.split(".")[0].split("[")[0]
+
+            if root_var not in standard_fields and hasattr(eval_case, root_var):
+                val = getattr(eval_case, root_var)
+                # Add the root object to other_data so the backend can traverse it
+                other_data_map[root_var] = types.evals.InstanceData(
+                    contents=types.evals.InstanceDataContents(
+                        contents=_value_to_content_list(val)
+                    )
+                )
+
+    return types.EvaluationInstance(
+        prompt=prompt_instance_data,
+        response=_content_to_instance_data(response_content),
+        reference=(
+            _content_to_instance_data(eval_case.reference.response)
+            if eval_case.reference
+            else None
+        ),
+        rubric_groups=eval_case.rubric_groups,
+        other_data=(
+            types.MapInstance(map_instance=other_data_map) if other_data_map else None
+        ),
+        agent_data=_eval_case_to_agent_data(
+            eval_case, extracted_prompt, response_content
+        ),
+    )
+
+
+class LLMMetricHandler(MetricHandler[types.LLMMetric]):
+    """Metric handler for LLM metrics."""
+
+    @property
+    def metric_name(self) -> str:
+        return self.metric.name or "unknown_metric"
+
+    def __init__(self, module: "evals.Evals", metric: types.LLMMetric):
+        super().__init__(module=module, metric=metric)
+
+    @override
+    def get_metric_result(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> types.EvalCaseMetricResult:
+        """Processes a single evaluation case using the unified backend interface."""
+        try:
+            response_content = _get_response_from_eval_case(
+                eval_case, response_index, self.metric_name
+            )
+            if not response_content:
+                raise ValueError(
+                    f"Response content missing for candidate {response_index}."
+                )
+
+            instance = _build_evaluation_instance(
+                eval_case, response_content, prompt_template=self.metric.prompt_template
+            )
+            api_response = _call_with_retry(
+                lambda: self.module._evaluate_instances(
+                    metrics=[self.metric],
+                    instance=instance,
+                ),
+                self.metric_name,
+            )
+
+            if api_response and api_response.metric_results:
+                result = api_response.metric_results[0]
+                error_msg = None
+                if result.error and getattr(result.error, "code"):
+                    error_msg = f"Error in metric result: {result.error}"
+
+                return types.EvalCaseMetricResult(
+                    metric_name=self.metric_name,
+                    score=result.score,
+                    explanation=result.explanation,
+                    rubric_verdicts=result.rubric_verdicts,
+                    error_message=error_msg,
+                )
+            else:
+                return types.EvalCaseMetricResult(
+                    metric_name=self.metric_name,
+                    error_message="Metric results missing in API response.",
+                )
+
+        except Exception as e:
+            logger.error(
+                "Error processing metric %s for case %s.",
+                self.metric_name,
+                eval_case.eval_case_id,
+                exc_info=True,
+            )
+            return types.EvalCaseMetricResult(
+                metric_name=self.metric_name, error_message=str(e)
+            )
+
+    @override
+    def aggregate(
+        self, eval_case_metric_results: list[types.EvalCaseMetricResult]
+    ) -> types.AggregatedMetricResult:
+        """Aggregates the metric results for a LLM metric."""
+        if self.metric.aggregate_summary_fn and callable(
+            self.metric.aggregate_summary_fn
+        ):
+            logger.info(
+                "Using custom aggregate_summary_fn for metric '%s'", self.metric.name
+            )
+            try:
+                custom_summary_dict = self.metric.aggregate_summary_fn(
+                    eval_case_metric_results
+                )
+                if not isinstance(custom_summary_dict, dict):
+                    raise TypeError("aggregate_summary_fn must return a dictionary.")
+
+                num_cases_total = len(eval_case_metric_results)
+                num_cases_error = len(
+                    [
+                        result
+                        for result in eval_case_metric_results
+                        if result.error_message is not None
+                    ]
+                )
+                num_cases_valid = num_cases_total - num_cases_error
+                required_fields = {
+                    "num_cases_total": num_cases_total,
+                    "num_cases_error": num_cases_error,
+                    "num_cases_valid": num_cases_valid,
+                }
+                final_summary_dict = {**required_fields, **custom_summary_dict}
+
+                return types.AggregatedMetricResult(
+                    metric_name=self.metric.name,
+                    **final_summary_dict,
+                )
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                logger.error(
+                    "Error executing custom aggregate_summary_fn for metric '%s': %s."
+                    " Falling back to default aggregation.",
+                    self.metric.name,
+                    e,
+                    exc_info=True,
+                )
+                return _default_aggregate_scores(
+                    self.metric.name, eval_case_metric_results
+                )
+        else:
+            logger.debug(
+                "Using default aggregation for LLM metric '%s'", self.metric.name
+            )
+            return _default_aggregate_scores(self.metric.name, eval_case_metric_results)
+
+
+class CustomMetricHandler(MetricHandler[types.Metric]):
+    """Metric handler for custom metrics."""
+
+    @property
+    def metric_name(self) -> str:
+        return self.metric.name or "unknown_metric"
+
+    def __init__(self, module: "evals.Evals", metric: types.Metric):
+        super().__init__(module=module, metric=metric)
+
+        if not self.metric.custom_function:
+            raise ValueError(
+                f"CustomMetricHandler for '{self.metric.name}' needs "
+                " Metric.custom_function to be set."
+            )
+        if not isinstance(self.metric.custom_function, Callable):
+            raise ValueError(
+                f"CustomMetricHandler for '{self.metric.name}' needs "
+                " Metric.custom_function to be a callable function."
+            )
+
+    @override
+    def get_metric_result(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> types.EvalCaseMetricResult:
+        """Processes a single evaluation case for a custom metric."""
+        metric_name = self.metric.name
+        logger.debug(
+            "CustomMetricHandler: Processing '%s' for case: %s",
+            metric_name,
+            eval_case.model_dump(exclude_none=True),
+        )
+
+        try:
+            response_content = _get_response_from_eval_case(
+                eval_case, response_index, metric_name
+            )
+        except ValueError as e:
+            return types.EvalCaseMetricResult(
+                metric_name=metric_name,
+                error_message=str(e),
+            )
+
+        if not response_content:
+            return types.EvalCaseMetricResult(
+                metric_name=metric_name,
+                error_message=(
+                    f"No response found for candidate {response_index} in EvalCase"
+                    f" {eval_case.eval_case_id}."
+                ),
+            )
+
+        instance_for_custom_fn = eval_case.model_dump(
+            exclude={"responses"}, mode="json", exclude_none=True
+        )
+        instance_for_custom_fn["response"] = response_content.model_dump(
+            mode="json", exclude_none=True
+        )
+        extracted_prompt = _get_prompt_from_eval_case(eval_case)
+        if extracted_prompt:
+            instance_for_custom_fn["prompt"] = extracted_prompt.model_dump(
+                mode="json", exclude_none=True
+            )
+
+        error_msg = None
+        score = None
+        explanation = None
+        try:
+            if self.metric.custom_function and callable(self.metric.custom_function):
+                custom_function_result = self.metric.custom_function(
+                    instance_for_custom_fn
+                )
+
+                if isinstance(custom_function_result, types.EvalCaseMetricResult):
+                    return custom_function_result
+                elif (
+                    isinstance(custom_function_result, dict)
+                    and "score" in custom_function_result
+                ):
+                    score = custom_function_result["score"]
+                    explanation = custom_function_result.get("explanation", None)
+                elif isinstance(custom_function_result, (float, int)):
+                    score = custom_function_result
+                    explanation = None
+                else:
+                    error_msg = (
+                        f"CustomFunctionError({self.metric.custom_function}): Returned"
+                        f" unexpected type {type(custom_function_result)}"
+                    )
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            if self.metric.custom_function and hasattr(
+                self.metric.custom_function, "__name__"
+            ):
+                custom_function_name = self.metric.custom_function.__name__
+            else:
+                custom_function_name = "unknown_custom_function"
+            error_msg = f"CustomFunctionError({custom_function_name}): {e}"
+            score = None
+            explanation = None
+
+        return types.EvalCaseMetricResult(
+            metric_name=self.metric.name,
+            score=score,
+            explanation=explanation,
+            error_message=error_msg,
+        )
+
+    @override
+    def aggregate(
+        self, eval_case_metric_results: list[types.EvalCaseMetricResult]
+    ) -> types.AggregatedMetricResult:
+        """Aggregates the metric results for a custom metric."""
+        logger.debug("Aggregating results for custom metric: %s", self.metric.name)
+        return _default_aggregate_scores(self.metric.name, eval_case_metric_results)
+
+
+class PredefinedMetricHandler(MetricHandler[types.Metric]):
+    """Metric handler for predefined metrics."""
+
+    @property
+    def metric_name(self) -> str:
+        return self.metric.name or "unknown_metric"
+
+    def __init__(self, module: "evals.Evals", metric: types.Metric):
+        super().__init__(module=module, metric=metric)
+        if self.metric.name not in _evals_constant.SUPPORTED_PREDEFINED_METRICS:
+            raise ValueError(
+                f"Metric '{self.metric.name}' is not a supported predefined metric."
+            )
+
+    def _build_request_payload(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> dict[str, Any]:
+        """Builds the request parameters for evaluate instances request."""
+        response_content = _get_response_from_eval_case(
+            eval_case, response_index, self.metric.name
+        )
+
+        if not response_content and not getattr(eval_case, "agent_data", None):
+            raise ValueError(
+                f"Response content missing for candidate {response_index}."
+            )
+
+        if self.metric.name == "tool_use_quality_v1":
+            has_tool_call = _has_tool_call(eval_case.intermediate_events)
+
+            # Check agent_data for tool calls if intermediate_events is empty
+            agent_data = getattr(eval_case, "agent_data", None)
+            if not has_tool_call and agent_data:
+                for turn in agent_data.turns or []:
+                    if _has_tool_call(turn.events):
+                        has_tool_call = True
+                        break
+
+            if not has_tool_call:
+                logger.warning(
+                    "Metric 'tool_use_quality_v1' requires tool usage in "
+                    "'intermediate_events' or 'agent_data', but no tool usage was found for case %s.",
+                    eval_case.eval_case_id,
+                )
+
+        extracted_prompt = _get_prompt_from_eval_case(eval_case)
+        prompt_instance_data = None
+        if self.metric.name and self.metric.name.startswith("multi_turn"):
+            prompt_contents = [
+                msg.content for msg in (eval_case.conversation_history or [])
+            ]
+            if extracted_prompt:
+                prompt_contents.append(extracted_prompt)
+            prompt_instance_data = types.evals.InstanceData(
+                contents=types.evals.InstanceDataContents(contents=prompt_contents)
+            )
+
+        instance_payload = _build_evaluation_instance(
+            eval_case=eval_case,
+            response_content=response_content,
+            prompt_instance_data=prompt_instance_data,
+        )
+
+        request_payload: dict[str, Any] = {
+            "instance": instance_payload,
+        }
+
+        autorater_config = _get_autorater_config(self.metric)
+        if autorater_config:
+            request_payload["autorater_config"] = genai_types.AutoraterConfig(
+                **autorater_config
+            )
+        return request_payload
+
+    @override
+    def get_metric_result(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> types.EvalCaseMetricResult:
+        """Processes a single evaluation case for a specific predefined metric."""
+        metric_name = self.metric.name
+        try:
+            payload = self._build_request_payload(eval_case, response_index)
+            api_response = _call_with_retry(
+                lambda: self.module._evaluate_instances(
+                    metrics=[self.metric],
+                    instance=payload.get("instance"),
+                    autorater_config=payload.get("autorater_config"),
+                ),
+                metric_name,
+            )
+
+            if (
+                api_response
+                and hasattr(api_response, "metric_results")
+                and api_response.metric_results
+            ):
+                result_data = api_response.metric_results[0]
+
+                error_message = None
+                if result_data.error and getattr(result_data.error, "code"):
+                    error_message = f"Error in metric result: {result_data.error}"
+                return types.EvalCaseMetricResult(
+                    metric_name=metric_name,
+                    score=result_data.score,
+                    explanation=result_data.explanation,
+                    rubric_verdicts=result_data.rubric_verdicts,
+                    error_message=error_message,
+                )
+            else:
+                logger.error(
+                    "Metric results missing in API response for predefined metric '%s'."
+                    " API response: %s",
+                    metric_name,
+                    (
+                        api_response.model_dump_json(exclude_none=True)
+                        if api_response
+                        else "None"
+                    ),
+                )
+                return types.EvalCaseMetricResult(
+                    metric_name=metric_name,
+                    error_message="Metric results missing in API response.",
+                )
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error(
+                "Error processing metric %s for case %s: %s",
+                metric_name,
+                eval_case.eval_case_id,
+                e,
+                exc_info=True,
+            )
+            return types.EvalCaseMetricResult(
+                metric_name=metric_name, error_message=str(e)
+            )
+
+    @override
+    def aggregate(
+        self, eval_case_metric_results: list[types.EvalCaseMetricResult]
+    ) -> types.AggregatedMetricResult:
+        """Aggregates the metric results for a predefined metric."""
+        logger.debug("Aggregating results for predefined metric: %s", self.metric.name)
+        return _default_aggregate_scores(
+            self.metric.name, eval_case_metric_results, calculate_pass_rate=True
+        )
+
+
+class CustomCodeExecutionMetricHandler(MetricHandler[types.Metric]):
+    """Metric handler for custom code execution metrics."""
+
+    @property
+    def metric_name(self) -> str:
+        return self.metric.name or "unknown_metric"
+
+    def __init__(self, module: "evals.Evals", metric: types.Metric):
+        super().__init__(module=module, metric=metric)
+
+        if not self.metric.remote_custom_function and not self.metric.custom_function:
+            raise ValueError(
+                f"CustomCodeExecutionMetricHandler for '{self.metric.name}' needs "
+                " custom function to be set."
+            )
+
+    def _build_request_payload(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> dict[str, Any]:
+        """Builds the request parameters for evaluate instances request."""
+        response_content = _get_response_from_eval_case(
+            eval_case, response_index, self.metric.name
+        )
+
+        if not response_content and not getattr(eval_case, "agent_data", None):
+            raise ValueError(
+                f"Response content missing for candidate {response_index}."
+            )
+
+        reference_instance_data = None
+        if eval_case.reference:
+            reference_instance_data = _content_to_instance_data(
+                eval_case.reference.response
+            )
+
+        extracted_prompt = _get_prompt_from_eval_case(eval_case)
+        prompt_instance_data = _content_to_instance_data(extracted_prompt)
+
+        instance_payload = types.EvaluationInstance(
+            prompt=prompt_instance_data,
+            response=_content_to_instance_data(response_content),
+            reference=reference_instance_data,
+            agent_data=_eval_case_to_agent_data(eval_case),
+        )
+
+        return {
+            "instance": instance_payload,
+        }
+
+    @override
+    def get_metric_result(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> types.EvalCaseMetricResult:
+        """Processes a single evaluation case for a specific custom code execution metric."""
+        metric_name = self.metric.name
+        try:
+            payload = self._build_request_payload(eval_case, response_index)
+            api_response = _call_with_retry(
+                lambda: self.module._evaluate_instances(
+                    metrics=[self.metric],
+                    instance=payload.get("instance"),
+                ),
+                metric_name,
+            )
+
+            if (
+                api_response
+                and hasattr(api_response, "metric_results")
+                and api_response.metric_results
+            ):
+                result_data = api_response.metric_results[0]
+
+                error_message = None
+                if result_data.error and getattr(result_data.error, "code"):
+                    error_message = f"Error in metric result: {result_data.error}"
+                return types.EvalCaseMetricResult(
+                    metric_name=metric_name,
+                    score=result_data.score,
+                    explanation=result_data.explanation,
+                    error_message=error_message,
+                )
+            else:
+                logger.error(
+                    "Metric results missing in API response for metric '%s'."
+                    " API response: %s",
+                    metric_name,
+                    (
+                        api_response.model_dump_json(exclude_none=True)
+                        if api_response
+                        else "None"
+                    ),
+                )
+                return types.EvalCaseMetricResult(
+                    metric_name=metric_name,
+                    error_message="Metric results missing in API response.",
+                )
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error(
+                "Error processing metric %s for case %s",
+                metric_name,
+                eval_case.eval_case_id,
+                exc_info=True,
+            )
+            return types.EvalCaseMetricResult(
+                metric_name=metric_name, error_message=str(e)
+            )
+
+    @override
+    def aggregate(
+        self, eval_case_metric_results: list[types.EvalCaseMetricResult]
+    ) -> types.AggregatedMetricResult:
+        """Aggregates the metric results for a custom code execution metric."""
+        logger.debug(
+            "Aggregating results for custom code execution metric: %s", self.metric.name
+        )
+        return _default_aggregate_scores(
+            self.metric.name, eval_case_metric_results, calculate_pass_rate=True
+        )
+
+
+class RegisteredMetricHandler(MetricHandler[types.Metric]):
+    """Metric handler for registered metrics."""
+
+    def __init__(
+        self,
+        module: "evals.Evals",
+        metric: types.Metric,
+    ):
+        if isinstance(metric, dict):
+            metric = types.MetricSource(**metric)
+        super().__init__(module=module, metric=metric)
+
+    def _build_request_payload(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> dict[str, Any]:
+        """Builds request payload for registered metric by assembling EvaluationInstance."""
+        response_content = _get_response_from_eval_case(
+            eval_case, response_index, self.metric_name
+        )
+
+        if not response_content and not getattr(eval_case, "agent_data", None):
+            raise ValueError(
+                f"Response content missing for candidate {response_index}."
+            )
+
+        reference_instance_data = None
+        if eval_case.reference:
+            reference_instance_data = _content_to_instance_data(
+                eval_case.reference.response
+            )
+
+        extracted_prompt = _get_prompt_from_eval_case(eval_case)
+        prompt_instance_data = _content_to_instance_data(extracted_prompt)
+
+        instance_payload = types.EvaluationInstance(
+            prompt=prompt_instance_data,
+            response=_content_to_instance_data(response_content),
+            reference=reference_instance_data,
+            rubric_groups=eval_case.rubric_groups,
+            agent_data=_eval_case_to_agent_data(eval_case),
+        )
+
+        request_payload = {
+            "instance": instance_payload,
+        }
+        return request_payload
+
+    @property
+    def metric_name(self) -> str:
+        return self.metric.name or "unknown_metric"
+
+    @override
+    def get_metric_result(
+        self, eval_case: types.EvalCase, response_index: int
+    ) -> types.EvalCaseMetricResult:
+        """Processes a single evaluation case using a MetricSource reference."""
+        metric_name = self.metric_name
+        metric_source = types.MetricSource(
+            metric_resource_name=self.metric.metric_resource_name
+        )
+
+        try:
+            payload = self._build_request_payload(eval_case, response_index)
+            api_response = _call_with_retry(
+                lambda: self.module._evaluate_instances(
+                    metric_sources=[metric_source],
+                    instance=payload.get("instance"),
+                    autorater_config=payload.get("autorater_config"),
+                ),
+                metric_name,
+            )
+
+            if api_response and api_response.metric_results:
+                result_data = api_response.metric_results[0]
+                error_message = None
+                if result_data.error and getattr(result_data.error, "code"):
+                    error_message = f"Error in metric result: {result_data.error}"
+                return types.EvalCaseMetricResult(
+                    metric_name=metric_name,
+                    score=result_data.score,
+                    explanation=result_data.explanation,
+                    rubric_verdicts=result_data.rubric_verdicts,
+                    error_message=error_message,
+                )
+            else:
+                return types.EvalCaseMetricResult(
+                    metric_name=metric_name,
+                    error_message="Metric results missing in API response.",
+                )
+        except Exception as e:
+            return types.EvalCaseMetricResult(
+                metric_name=metric_name, error_message=str(e)
+            )
+
+    @override
+    def aggregate(
+        self, eval_case_metric_results: list[types.EvalCaseMetricResult]
+    ) -> types.AggregatedMetricResult:
+        """Aggregates the metric results for a registered metric."""
+        return _default_aggregate_scores(
+            self.metric_name, eval_case_metric_results, calculate_pass_rate=True
+        )
+
+
+_METRIC_HANDLER_MAPPING = [
+    (
+        lambda m: (
+            # Recognize the user-facing class
+            isinstance(m, types.CodeExecutionMetric)
+            and (hasattr(m, "custom_function") and m.custom_function)
+        )
+        or (hasattr(m, "remote_custom_function") and m.remote_custom_function)
+        # Recognize base Metric objects that have been coerced by Pydantic
+        or (
+            isinstance(m, types.Metric)
+            and isinstance(getattr(m, "custom_function", None), str)
+        ),
+        CustomCodeExecutionMetricHandler,
+    ),
+    (
+        lambda m: m.custom_function and isinstance(m.custom_function, Callable),
+        CustomMetricHandler,
+    ),
+    (
+        lambda m: getattr(m, "metric_resource_name", None) is not None,
+        RegisteredMetricHandler,
+    ),
+    (
+        lambda m: m.name in ComputationMetricHandler.SUPPORTED_COMPUTATION_METRICS,
+        ComputationMetricHandler,
+    ),
+    (
+        lambda m: m.name in TranslationMetricHandler.SUPPORTED_TRANSLATION_METRICS,
+        TranslationMetricHandler,
+    ),
+    (
+        lambda m: m.name in _evals_constant.SUPPORTED_PREDEFINED_METRICS,
+        PredefinedMetricHandler,
+    ),
+    (lambda m: isinstance(m, types.LLMMetric), LLMMetricHandler),
+]
+
+MetricHandlerType = TypeVar(
+    "MetricHandlerType",
+    ComputationMetricHandler,
+    TranslationMetricHandler,
+    LLMMetricHandler,
+    CustomMetricHandler,
+    CustomCodeExecutionMetricHandler,
+    PredefinedMetricHandler,
+)
+
+
+def get_handler_for_metric(
+    module: "evals.Evals", metric: types.Metric
+) -> Union[MetricHandlerType, Any]:
+    """Returns a metric handler for the given metric."""
+    for condition, handler_class in _METRIC_HANDLER_MAPPING:
+        if condition(metric):  # type: ignore[no-untyped-call]
+            return handler_class(module=module, metric=metric)
+    raise ValueError(f"Unsupported metric: {metric.name}")
+
+
+def calculate_win_rates(eval_result: types.EvaluationResult) -> dict[str, Any]:
+    """Calculates win/tie rates for comparison results."""
+    if not eval_result.eval_case_results:
+        return {}
+    max_models = max(
+        (
+            len(case.response_candidate_results)
+            for case in eval_result.eval_case_results
+            if case.response_candidate_results
+        ),
+        default=0,
+    )
+    if max_models == 0:
+        return {}
+    stats: collections.defaultdict[str, dict[str, Any]] = collections.defaultdict(
+        lambda: {"wins": [0] * max_models, "ties": 0, "valid_comparisons": 0}
+    )
+    for case in eval_result.eval_case_results:
+        if not case.response_candidate_results:
+            continue
+        scores_by_metric = collections.defaultdict(list)
+        for idx, candidate in enumerate(case.response_candidate_results):
+            for name, res in (
+                candidate.metric_results.items() if candidate.metric_results else {}
+            ):
+                if res.score is not None:
+                    scores_by_metric[name].append({"score": res.score, "cand_idx": idx})
+        for name, scores in scores_by_metric.items():
+            if not scores:
+                continue
+            stats[name]["valid_comparisons"] += 1
+            max_score = max(s["score"] for s in scores)
+            winners = [s["cand_idx"] for s in scores if s["score"] == max_score]
+            if len(winners) == 1:
+                stats[name]["wins"][winners[0]] += 1
+            else:
+                stats[name]["ties"] += 1
+    win_rates = {}
+    for name, metric_stats in stats.items():
+        if metric_stats["valid_comparisons"] > 0:
+            win_rates[name] = {
+                "win_rates": [
+                    w / metric_stats["valid_comparisons"] for w in metric_stats["wins"]
+                ],
+                "tie_rate": metric_stats["ties"] / metric_stats["valid_comparisons"],
+            }
+    return win_rates
+
+
+def _aggregate_metric_results(
+    metric_handlers: list[MetricHandler[Any]],
+    eval_case_results: list[types.EvalCaseResult],
+) -> list[types.AggregatedMetricResult]:
+    """Aggregates results by calling the aggregate method of each handler."""
+    aggregated_metric_results = []
+    logger.info("Aggregating results per metric...")
+    for handler in metric_handlers:
+        metric_name = handler.metric_name
+        results_for_this_metric: list[types.EvalCaseMetricResult] = []
+        for case_result in eval_case_results:
+            if case_result.response_candidate_results:
+                for response_candidate_res in case_result.response_candidate_results:
+                    if (
+                        response_candidate_res.metric_results
+                        and metric_name in response_candidate_res.metric_results
+                        and isinstance(metric_name, str)
+                    ):
+                        results_for_this_metric.append(
+                            response_candidate_res.metric_results[metric_name]
+                        )
+        if not results_for_this_metric:
+            logger.warning(
+                "No results found for metric '%s' to aggregate.", metric_name
+            )
+            continue
+
+        try:
+            summary = handler.aggregate(results_for_this_metric)
+            aggregated_metric_results.append(summary)
+        except NotImplementedError:
+            logger.warning(
+                "Aggregation not implemented for metric handler: %s (metric: '%s')."
+                " Skipping summary.",
+                type(handler).__name__,
+                metric_name,
+            )
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error(
+                "Error during aggregation for metric '%s' using handler %s: %s",
+                metric_name,
+                type(handler).__name__,
+                e,
+                exc_info=True,
+            )
+            aggregated_metric_results.append(
+                types.AggregatedMetricResult(
+                    metric_name=metric_name,
+                    num_cases_total=len(results_for_this_metric),
+                    num_cases_valid=0,
+                    num_cases_error=len(results_for_this_metric),
+                    mean_score=None,
+                    stdev_score=None,
+                )
+            )
+    logger.debug("Finished aggregation, returning: %s", aggregated_metric_results)
+    return aggregated_metric_results
+
+
+class EvaluationRunConfig(_common.BaseModel):
+    """Configuration for an evaluation run."""
+
+    evals_module: Any
+    """The module to be used for the evaluation run."""
+    dataset: types.EvaluationDataset
+    """The dataset to be used for the evaluation run."""
+    metrics: list[types.Metric]
+    """The list of metrics to be used for the evaluation run."""
+    num_response_candidates: int
+    """The number of response candidates for the evaluation run."""
+
+
+def _rate_limited_get_metric_result(
+    rate_limiter: _evals_utils.RateLimiter,
+    handler: MetricHandler[Any],
+    eval_case: types.EvalCase,
+    response_index: int,
+) -> types.EvalCaseMetricResult:
+    """Wraps a handler's get_metric_result with rate limiting."""
+    rate_limiter.sleep_and_advance()
+    return handler.get_metric_result(eval_case, response_index)
+
+
+def compute_metrics_and_aggregate(
+    evaluation_run_config: EvaluationRunConfig,
+    evaluation_service_qps: Optional[float] = None,
+) -> types.EvaluationResult:
+    """Computes metrics and aggregates them for a given evaluation run config.
+
+    Args:
+        evaluation_run_config: The configuration for the evaluation run.
+        evaluation_service_qps: Optional QPS limit for the evaluation service.
+            Defaults to _DEFAULT_EVAL_SERVICE_QPS (10). Users with higher
+            quotas can increase this value.
+    """
+    metric_handlers = []
+    all_futures = []
+    results_by_case_response_metric: collections.defaultdict[
+        Any, collections.defaultdict[Any, dict[Any, Any]]
+    ] = collections.defaultdict(lambda: collections.defaultdict(dict))
+    submission_errors = []
+    execution_errors = []
+    case_indices_with_errors = set()
+
+    if evaluation_service_qps is not None and evaluation_service_qps <= 0:
+        raise ValueError("evaluation_service_qps must be a positive number.")
+    qps = evaluation_service_qps or _evals_utils._DEFAULT_EVAL_SERVICE_QPS
+    rate_limiter = _evals_utils.RateLimiter(rate=qps)
+    logger.info("Rate limiting evaluation service requests to %.1f QPS.", qps)
+
+    for eval_metric in evaluation_run_config.metrics:
+        metric_handlers.append(
+            get_handler_for_metric(evaluation_run_config.evals_module, eval_metric)
+        )
+
+    eval_case_count = len(evaluation_run_config.dataset.eval_cases)
+    logger.info("Total number of evaluation cases: %d", eval_case_count)
+    logger.info(
+        "Number of response candidates: %d",
+        evaluation_run_config.num_response_candidates,
+    )
+    total_metric_computations = (
+        eval_case_count
+        * len(metric_handlers)
+        * evaluation_run_config.num_response_candidates
+    )
+    logger.info("Total number of metric computations: %d", total_metric_computations)
+
+    with tqdm(
+        total=total_metric_computations,
+        desc="Computing Metrics for Evaluation Dataset",
+    ) as pbar:
+        with futures.ThreadPoolExecutor(
+            max_workers=_evals_common.MAX_WORKERS
+        ) as executor:
+            for metric_handler_instance in metric_handlers:
+                for eval_case_index, eval_case in enumerate(
+                    evaluation_run_config.dataset.eval_cases
+                ):
+                    num_responses = (
+                        len(eval_case.responses) if eval_case.responses else 0
+                    )
+                    if num_responses == 0 and getattr(eval_case, "agent_data", None):
+                        num_responses = 1
+
+                    actual_num_candidates_for_case = min(
+                        evaluation_run_config.num_response_candidates,
+                        num_responses,
+                    )
+                    for response_index in range(actual_num_candidates_for_case):
+                        try:
+                            future = executor.submit(
+                                _rate_limited_get_metric_result,
+                                rate_limiter,
+                                metric_handler_instance,
+                                eval_case,
+                                response_index,
+                            )
+                            future.add_done_callback(lambda _: pbar.update(1))
+                            logger.debug(
+                                "Submitting metric computation for case %d, "
+                                "response %d for metric %s.",
+                                eval_case_index,
+                                response_index,
+                                metric_handler_instance.metric_name,
+                            )
+                            all_futures.append(
+                                (
+                                    future,
+                                    metric_handler_instance.metric_name,
+                                    eval_case_index,
+                                    response_index,
+                                )
+                            )
+                        except Exception as e:  # pylint: disable=broad-exception-caught
+                            logger.error(
+                                "Error submitting metric computation for case %d, "
+                                "response %d for metric %s: %s",
+                                eval_case_index,
+                                response_index,
+                                metric_handler_instance.metric_name,
+                                e,
+                                exc_info=True,
+                            )
+                            submission_errors.append(
+                                (
+                                    metric_handler_instance.metric_name,
+                                    eval_case_index,
+                                    response_index,
+                                    f"Error: {e}",
+                                )
+                            )
+                            error_result = types.EvalCaseMetricResult(
+                                metric_name=metric_handler_instance.metric_name,
+                                error_message=f"Submission Error: {e}",
+                            )
+                            results_by_case_response_metric[eval_case_index][
+                                response_index
+                            ][metric_handler_instance.metric_name] = error_result
+                            case_indices_with_errors.add(eval_case_index)
+                            pbar.update(1)
+
+        for future, metric_name, eval_case_index, response_index in all_futures:
+            try:
+                eval_case_metric_result = future.result()
+                logger.debug(
+                    "Successfully obtained result for metric '%s', case %d, response"
+                    " %d: %s.",
+                    metric_name,
+                    eval_case_index,
+                    response_index,
+                    eval_case_metric_result,
+                )
+                results_by_case_response_metric[eval_case_index][response_index][
+                    metric_name
+                ] = eval_case_metric_result
+                logger.debug(
+                    "Stored result for metric '%s', case %d, response %d.",
+                    metric_name,
+                    eval_case_index,
+                    response_index,
+                )
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                logger.error(
+                    "Error executing metric '%s' for case %s, response %s: %s",
+                    metric_name,
+                    eval_case_index,
+                    response_index,
+                    e,
+                    exc_info=True,
+                )
+                error_msg = (
+                    f"Error executing metric '{metric_name}' for case"
+                    f" {eval_case_index}, response {response_index}: {e}"
+                )
+                execution_errors.append(
+                    (
+                        metric_name,
+                        eval_case_index,
+                        response_index,
+                        error_msg,
+                    )
+                )
+                case_indices_with_errors.add(eval_case_index)
+                error_result = types.EvalCaseMetricResult(
+                    metric_name=metric_name,
+                    error_message=error_msg,
+                )
+                results_by_case_response_metric[eval_case_index][response_index][
+                    metric_name
+                ] = error_result
+
+    final_eval_case_results = []
+    sorted_eval_case_indices = sorted(results_by_case_response_metric.keys())
+    for eval_case_index in sorted_eval_case_indices:
+        per_response_results_for_this_case = results_by_case_response_metric[
+            eval_case_index
+        ]
+
+        current_response_candidate_results_list = []
+        sorted_response_indices = sorted(per_response_results_for_this_case.keys())
+
+        for response_index in sorted_response_indices:
+            metric_results_for_this_response = per_response_results_for_this_case[
+                response_index
+            ]
+
+            response_candidate_result_obj = types.ResponseCandidateResult(
+                response_index=response_index,
+                metric_results=metric_results_for_this_response,
+            )
+            current_response_candidate_results_list.append(
+                response_candidate_result_obj
+            )
+
+        if current_response_candidate_results_list:
+            eval_case_result = types.EvalCaseResult(
+                eval_case_index=eval_case_index,
+                response_candidate_results=current_response_candidate_results_list,
+            )
+            final_eval_case_results.append(eval_case_result)
+        elif eval_case_index in case_indices_with_errors or any(
+            err_case_idx == eval_case_index
+            for _, err_case_idx, _, _ in submission_errors
+        ):
+            logger.warning(
+                "EvalCase %d had errors but no metric results were"
+                " processed into the structure.",
+                eval_case_index,
+            )
+            eval_case_result = types.EvalCaseResult(
+                eval_case_index=eval_case_index,
+                response_candidate_results=[],
+            )
+            final_eval_case_results.append(eval_case_result)
+
+    if submission_errors:
+        logger.warning("Encountered %d submission errors.", len(submission_errors))
+        logger.warning("Submission errors: %s", submission_errors)
+    if execution_errors:
+        logger.warning("Encountered %d execution errors.", len(execution_errors))
+        logger.warning("Execution errors: %s", execution_errors)
+
+    aggregated_metric_results = _aggregate_metric_results(
+        metric_handlers, final_eval_case_results
+    )
+    eval_result = types.EvaluationResult(
+        eval_case_results=final_eval_case_results,
+        summary_metrics=aggregated_metric_results,
+    )
+    if evaluation_run_config.num_response_candidates > 1:
+        try:
+            eval_result.win_rates = calculate_win_rates(eval_result)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error("Error calculating win rates: %s", e, exc_info=True)
+    return eval_result

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_evals_metric_loaders.py

@@ -0,0 +1,381 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Utility functions for evals."""
+
+import json
+import logging
+import os
+import re
+from typing import Any, Optional, Union, TYPE_CHECKING
+
+import yaml
+
+from . import _evals_constant
+from . import _gcs_utils
+
+if TYPE_CHECKING:
+    from . import types
+
+
+logger = logging.getLogger(__name__)
+
+
+class LazyLoadedPrebuiltMetric:
+    """A proxy object representing a prebuilt metric to be loaded on demand.
+
+    This can resolve to either an API Predefined Metric or an LLM Metric
+    loaded from GCS.
+    """
+
+    _cache: dict[str, "types.Metric"] = {}
+    _base_gcs_path = (
+        "gs://vertex-ai-generative-ai-eval-sdk-resources/metrics/{metric_name}/"
+    )
+
+    def __init__(self, name: str, version: Optional[str] = None, **kwargs: Any):
+        self.name = name.upper()
+        self.version = version
+        self.metric_kwargs = kwargs
+        self._resolved_metric: Optional["types.Metric"] = None
+
+    def _get_api_metric_spec_name(self) -> Optional[str]:
+        """Constructs the metric_spec_name for API Predefined Metrics."""
+        base_name = self.name.lower()
+        if self.version:
+            # Explicit version provided
+            version = self.version.lower()
+            potential_name = f"{base_name}_{version}"
+            return (
+                potential_name
+                if potential_name in _evals_constant.SUPPORTED_PREDEFINED_METRICS
+                else None
+            )
+        else:
+            # Default versioning: Try _v1, then base name
+            v1_name = f"{base_name}_v1"
+            if v1_name in _evals_constant.SUPPORTED_PREDEFINED_METRICS:
+                return v1_name
+            if base_name in _evals_constant.SUPPORTED_PREDEFINED_METRICS:
+                return base_name
+        return None
+
+    def _resolve_api_predefined(self) -> Optional["types.Metric"]:
+        """Attempts to resolve as an API Predefined Metric."""
+        from . import types
+
+        metric_spec_name = self._get_api_metric_spec_name()
+        if metric_spec_name:
+            logger.info(
+                "Resolving '%s' as API Predefined Metric with spec name: %s",
+                self.name,
+                metric_spec_name,
+            )
+            return types.Metric(name=metric_spec_name, **self.metric_kwargs)
+        return None
+
+    def _get_latest_version_uri(self, api_client: Any, metric_gcs_dir: str) -> str:
+        """Lists files in GCS directory and determines the latest version URI."""
+        gcs_utils = _gcs_utils.GcsUtils(api_client)
+        bucket_name, prefix = gcs_utils.parse_gcs_path(metric_gcs_dir)
+
+        blobs = gcs_utils.storage_client.list_blobs(bucket_name, prefix=prefix)
+
+        version_files: list[dict[str, Union[list[int], str]]] = (
+            []
+        )  # {'version_parts': [1,0,0], 'filename': 'v1.0.0.yaml'}
+
+        version_pattern = re.compile(
+            r"v(\d+)(?:\.(\d+))?(?:\.(\d+))?\.(yaml|yml|json)$", re.IGNORECASE
+        )
+
+        for blob in blobs:
+            match = version_pattern.match(os.path.basename(blob.name))
+            if match:
+                major = int(match.group(1))
+                minor = int(match.group(2)) if match.group(2) else 0
+                patch = int(match.group(3)) if match.group(3) else 0
+                version_files.append(
+                    {
+                        "version_parts": [major, minor, patch],
+                        "filename": os.path.basename(blob.name),
+                    }
+                )
+
+        if not version_files:
+            raise IOError(f"No versioned metric files found in {metric_gcs_dir}")
+
+        version_files.sort(key=lambda x: x["version_parts"], reverse=True)
+
+        latest_filename = version_files[0]["filename"]
+        return os.path.join(metric_gcs_dir, latest_filename)
+
+    def _fetch_and_parse(self, api_client: Any) -> "types.LLMMetric":
+        """Fetches and parses the metric definition from GCS."""
+
+        from . import types
+
+        metric_gcs_dir = self._base_gcs_path.format(metric_name=self.name.lower())
+        uri: str
+        if self.version == "latest" or self.version is None:
+            uri = self._get_latest_version_uri(api_client, metric_gcs_dir)
+            resolved_version_match = re.match(
+                r"(v\d+(?:\.\d+)*)\.(?:yaml|yml|json)",
+                os.path.basename(uri),
+                re.IGNORECASE,
+            )
+            if resolved_version_match:
+                self.version = resolved_version_match.group(1)
+            else:
+                # Fallback if regex fails
+                self.version = os.path.splitext(os.path.basename(uri))[0]
+        else:
+            yaml_uri = os.path.join(metric_gcs_dir, f"{self.version}.yaml")
+            json_uri = os.path.join(metric_gcs_dir, f"{self.version}.json")
+
+            gcs_utils = _gcs_utils.GcsUtils(api_client)
+            try:
+                bucket_name, blob_path = gcs_utils.parse_gcs_path(yaml_uri)
+                if (
+                    gcs_utils.storage_client.bucket(bucket_name)
+                    .blob(blob_path)
+                    .exists()
+                ):
+                    uri = yaml_uri
+                else:
+                    bucket_name_json, blob_path_json = gcs_utils.parse_gcs_path(
+                        json_uri
+                    )
+                    if (
+                        gcs_utils.storage_client.bucket(bucket_name_json)
+                        .blob(blob_path_json)
+                        .exists()
+                    ):
+                        uri = json_uri
+                    else:
+                        raise IOError(
+                            f"Metric file for version '{self.version}' "
+                            f"not found as .yaml or .json in {metric_gcs_dir}"
+                        )
+            except Exception as e:
+                raise IOError(
+                    f"Error checking for metric file version '{self.version}' in"
+                    f" {metric_gcs_dir}: {e}"
+                ) from e
+
+        logger.info(
+            "Fetching predefined metric '%s@%s' from %s...",
+            self.name,
+            self.version,
+            uri,
+        )
+
+        gcs_utils = _gcs_utils.GcsUtils(api_client)
+        content_str = gcs_utils.read_file_contents(uri)
+
+        file_extension = os.path.splitext(uri)[1].lower()
+        data: dict[str, Any]
+        if file_extension == ".yaml" or file_extension == ".yml":
+            if yaml is None:
+                raise ImportError(
+                    "YAML parsing requires the pyyaml library. Please install it"
+                    " with `pip install google-cloud-aiplatform[evaluation]`."
+                )
+            data = yaml.safe_load(content_str)
+        elif file_extension == ".json":
+            data = json.loads(content_str)
+        else:
+            raise ValueError(f"Unsupported file extension: {file_extension}")
+
+        if not isinstance(data, dict):
+            raise ValueError("Metric config content did not parse into a dictionary.")
+
+        metric_obj = types.LLMMetric.model_validate({**data, **self.metric_kwargs})
+        metric_obj._is_predefined = True
+        metric_obj._config_source = uri
+        metric_obj._version = self.version
+        return metric_obj
+
+    def resolve(self, api_client: Any) -> "types.Metric":
+        """Resolves the metric by checking API Predefined, then GCS, caching results."""
+        if self._resolved_metric:
+            return self._resolved_metric
+
+        cache_key = f"{self.name}@{self.version or 'default'}"
+        if cache_key in LazyLoadedPrebuiltMetric._cache:
+            self._resolved_metric = LazyLoadedPrebuiltMetric._cache[cache_key]
+            logger.debug("Metric '%s' found in cache.", cache_key)
+            return self._resolved_metric
+
+        # Try resolving as API Predefined Metric first
+        api_metric = self._resolve_api_predefined()
+        if api_metric:
+            self._resolved_metric = api_metric
+            LazyLoadedPrebuiltMetric._cache[cache_key] = self._resolved_metric
+            return self._resolved_metric
+
+        # Fallback to GCS loading for custom LLM-based Prebuilt Metrics
+        logger.debug(
+            "Metric '%s' not an API Predefined Metric, trying GCS...", self.name
+        )
+        try:
+            gcs_metric = self._fetch_and_parse(api_client)
+            final_cache_key = f"{self.name}@{self.version}"
+            LazyLoadedPrebuiltMetric._cache[final_cache_key] = gcs_metric
+            self._resolved_metric = gcs_metric
+            return self._resolved_metric
+        except Exception as e:
+            logger.error(
+                "Error loading metric %s (requested version: %s) from GCS: %s",
+                self.name,
+                self.version,
+                e,
+            )
+            raise ValueError(
+                f"Metric '{self.name}' could not be resolved as an API "
+                "Predefined Metric or loaded from GCS."
+            ) from e
+
+    def __call__(
+        self, version: Optional[str] = None, **kwargs: Any
+    ) -> "LazyLoadedPrebuiltMetric":
+        """Allows setting a specific version and other metric attributes."""
+        updated_kwargs = self.metric_kwargs.copy()
+        updated_kwargs.update(kwargs)
+        return LazyLoadedPrebuiltMetric(
+            name=self.name, version=version or self.version, **updated_kwargs
+        )
+
+
+class PrebuiltMetricLoader:
+    """Provides access to predefined evaluation metrics via attributes.
+
+    This class provides a set of predefined LLM-based metrics (Autorater recipes)
+    for evaluation. These metrics are lazily loaded from a GCS repository
+    when they are first accessed.
+
+    Example:
+      from agentplatform import types
+      text_quality_metric = types.RubricMetric.TEXT_QUALITY
+    """
+
+    def __getattr__(
+        self, name: str, version: Optional[str] = None, **kwargs: Any
+    ) -> LazyLoadedPrebuiltMetric:
+        return LazyLoadedPrebuiltMetric(name=name, version=version, **kwargs)
+
+    @property
+    def GENERAL_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("GENERAL_QUALITY")
+
+    @property
+    def TEXT_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("TEXT_QUALITY")
+
+    @property
+    def INSTRUCTION_FOLLOWING(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("INSTRUCTION_FOLLOWING")
+
+    @property
+    def SAFETY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("SAFETY")
+
+    @property
+    def MULTI_TURN_GENERAL_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("MULTI_TURN_GENERAL_QUALITY")
+
+    @property
+    def MULTI_TURN_TEXT_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("MULTI_TURN_TEXT_QUALITY")
+
+    @property
+    def MULTI_TURN_TOOL_USE_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("MULTI_TURN_TOOL_USE_QUALITY", version="v1")
+
+    @property
+    def MULTI_TURN_TRAJECTORY_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("MULTI_TURN_TRAJECTORY_QUALITY", version="v1")
+
+    @property
+    def MULTI_TURN_TASK_SUCCESS(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("MULTI_TURN_TASK_SUCCESS", version="v1")
+
+    @property
+    def FINAL_RESPONSE_MATCH(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("FINAL_RESPONSE_MATCH", version="v2")
+
+    @property
+    def FINAL_RESPONSE_REFERENCE_FREE(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("FINAL_RESPONSE_REFERENCE_FREE")
+
+    @property
+    def COHERENCE(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("COHERENCE")
+
+    @property
+    def FLUENCY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("FLUENCY")
+
+    @property
+    def VERBOSITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("VERBOSITY")
+
+    @property
+    def SUMMARIZATION_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("SUMMARIZATION_QUALITY")
+
+    @property
+    def QUESTION_ANSWERING_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("QUESTION_ANSWERING_QUALITY")
+
+    @property
+    def MULTI_TURN_CHAT_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("MULTI_TURN_CHAT_QUALITY")
+
+    @property
+    def MULTI_TURN_SAFETY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("MULTI_TURN_SAFETY")
+
+    @property
+    def FINAL_RESPONSE_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("FINAL_RESPONSE_QUALITY")
+
+    @property
+    def HALLUCINATION(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("HALLUCINATION")
+
+    @property
+    def TOOL_USE_QUALITY(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("TOOL_USE_QUALITY")
+
+    @property
+    def GECKO_TEXT2IMAGE(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("GECKO_TEXT2IMAGE")
+
+    @property
+    def GECKO_TEXT2VIDEO(self) -> LazyLoadedPrebuiltMetric:
+        return self.__getattr__("GECKO_TEXT2VIDEO")
+
+
+PrebuiltMetric = PrebuiltMetricLoader()
+RubricMetric = PrebuiltMetric
+
+
+def CodeExecutionMetric(
+    name: str, custom_function: str, **kwargs: Any
+) -> "types.Metric":
+    """Instantiates a code execution metric."""
+    from . import types
+
+    return types.Metric(name=name, remote_custom_function=custom_function, **kwargs)

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_evals_utils.py

@@ -0,0 +1,1043 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Utility functions for evals."""
+
+import abc
+import asyncio
+import json
+import logging
+import os
+import threading
+import time
+from typing import Any, Optional, Union
+
+from google.genai._api_client import BaseApiClient
+from google.genai._common import get_value_by_path as getv
+from google.genai._common import set_value_by_path as setv
+import pandas as pd
+
+from . import _bigquery_utils
+from . import _gcs_utils
+from . import _transformers
+from . import types
+
+
+logger = logging.getLogger(__name__)
+
+
+GCS_PREFIX = "gs://"
+BQ_PREFIX = "bq://"
+_DEFAULT_EVAL_SERVICE_QPS = 10
+
+
+class RateLimiter:
+    """Helper class for rate-limiting requests to Vertex AI to improve QoS.
+
+    Implements a token bucket algorithm to limit the rate at which API calls
+    can occur. Designed for cases where the batch size is always 1 for traffic
+    shaping and rate limiting.
+
+    Attributes:
+        seconds_per_event: The time interval (in seconds) between events to
+            maintain the desired rate.
+        last: The timestamp of the last event.
+        _lock: A lock to ensure thread safety.
+    """
+
+    def __init__(self, rate: float) -> None:
+        """Initializes the rate limiter.
+
+        Args:
+            rate: The number of queries allowed per second.
+
+        Raises:
+            ValueError: If the rate is not positive.
+        """
+        if not rate or rate <= 0:
+            raise ValueError("Rate must be a positive number")
+        self.seconds_per_event = 1.0 / rate
+        self._next_allowed = time.monotonic()
+        self._lock = threading.Lock()
+
+    def sleep_and_advance(self) -> None:
+        """Blocks the current thread until the next event can be admitted.
+
+        The lock is held only long enough to reserve a time slot. The
+        actual sleep happens outside the lock so that multiple threads
+        can be sleeping concurrently with staggered wake-up times.
+        """
+        with self._lock:
+            now = time.monotonic()
+            wait_until = max(now, self._next_allowed)
+            delay = wait_until - now
+            self._next_allowed = wait_until + self.seconds_per_event
+
+        if delay > 0:
+            time.sleep(delay)
+
+
+class EvalDatasetLoader:
+    """A loader for datasets from various sources, using a shared client."""
+
+    def __init__(self, api_client: BaseApiClient) -> None:
+        self.api_client = api_client
+        self.gcs_utils = _gcs_utils.GcsUtils(self.api_client)
+        self.bigquery_utils = _bigquery_utils.BigQueryUtils(self.api_client)
+
+    def _load_file(
+        self, filepath: str, file_type: str
+    ) -> Union[list[dict[str, Any]], Any]:
+        """Loads data from a file into a list of dictionaries."""
+        if filepath.startswith(GCS_PREFIX):
+            df = self.gcs_utils.read_gcs_file_to_dataframe(filepath, file_type)
+            return df.to_dict(orient="records")
+        else:
+            if file_type == "jsonl":
+                df = pd.read_json(filepath, lines=True)
+                return df.to_dict(orient="records")
+            elif file_type == "csv":
+                df = pd.read_csv(filepath, encoding="utf-8")
+                return df.to_dict(orient="records")
+            else:
+                raise ValueError(
+                    f"Unsupported file type: '{file_type}'. Please provide 'jsonl' or"
+                    " 'csv'."
+                )
+
+    def load(
+        self, source: Union[str, "pd.DataFrame"]
+    ) -> Union[list[dict[str, Any]], Any]:
+        """Loads dataset from various sources into a list of dictionaries."""
+        if isinstance(source, pd.DataFrame):
+            return source.to_dict(orient="records")
+        elif isinstance(source, str):
+            if source.startswith(BQ_PREFIX):
+                df = self.bigquery_utils.load_bigquery_to_dataframe(
+                    source[len(BQ_PREFIX) :]
+                )
+                return df.to_dict(orient="records")
+
+            _, extension = os.path.splitext(source)
+            file_type = extension.lower()[1:]
+
+            if file_type == "jsonl":
+                return self._load_file(source, "jsonl")
+            elif file_type == "csv":
+                return self._load_file(source, "csv")
+            else:
+                raise TypeError(
+                    f"Unsupported file type: {file_type} from {source}. Please"
+                    " provide a valid GCS path with `jsonl` or `csv` suffix, "
+                    "a local file path, or a valid BigQuery table URI."
+                )
+        else:
+            raise TypeError(
+                "Unsupported dataset type. Must be a `pd.DataFrame`, Python"
+                " a valid GCS path with `jsonl` or `csv` suffix, a local"
+                " file path, or a valid BigQuery table URI."
+            )
+
+
+class BatchEvaluateRequestPreparer:
+    """Prepares data for requests."""
+
+    @staticmethod
+    def _EvaluationDataset_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, ["gcs_source"]) is not None:
+            setv(
+                to_object,
+                ["gcs_source"],
+                getv(from_object, ["gcs_source"]),
+            )
+
+        if getv(from_object, ["bigquery_source"]) is not None:
+            setv(
+                to_object,
+                ["bigquery_source"],
+                getv(from_object, ["bigquery_source"]),
+            )
+
+        return to_object
+
+    @staticmethod
+    def _Metric_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, ["prompt_template"]) is not None:
+            setv(
+                to_object,
+                ["pointwise_metric_spec", "prompt_template"],
+                getv(from_object, ["prompt_template"]),
+            )
+
+        if getv(from_object, ["judge_model"]) is not None:
+            setv(
+                parent_object,
+                ["autorater_config", "autorater_model"],
+                getv(from_object, ["judge_model"]),
+            )
+
+        if getv(from_object, ["judge_model_sampling_count"]) is not None:
+            setv(
+                parent_object,
+                ["autorater_config", "sampling_count"],
+                getv(from_object, ["judge_model_sampling_count"]),
+            )
+
+        if getv(from_object, ["judge_model_system_instruction"]) is not None:
+            setv(
+                to_object,
+                ["pointwise_metric_spec", "system_instruction"],
+                getv(from_object, ["judge_model_system_instruction"]),
+            )
+
+        if getv(from_object, ["return_raw_output"]) is not None:
+            setv(
+                to_object,
+                [
+                    "pointwise_metric_spec",
+                    "custom_output_format_config",
+                    "return_raw_output",
+                ],
+                getv(from_object, ["return_raw_output"]),
+            )
+
+        return to_object
+
+    @staticmethod
+    def _OutputConfig_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, ["gcs_destination"]) is not None:
+            setv(
+                to_object,
+                ["gcsDestination"],
+                getv(from_object, ["gcs_destination"]),
+            )
+
+        return to_object
+
+    @staticmethod
+    def _EvaluationDataset_from_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, ["dataset", "gcs_source"]) is not None:
+            setv(
+                to_object,
+                ["gcs_source"],
+                getv(from_object, ["dataset", "gcs_source"]),
+            )
+
+        if getv(from_object, ["dataset", "bigquery_source"]) is not None:
+            setv(
+                to_object,
+                ["bigquery_source"],
+                getv(from_object, ["dataset", "bigquery_source"]),
+            )
+
+        return to_object
+
+    @staticmethod
+    def _AutoraterConfig_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, ["sampling_count"]) is not None:
+            setv(to_object, ["samplingCount"], getv(from_object, ["sampling_count"]))
+
+        if getv(from_object, ["flip_enabled"]) is not None:
+            setv(to_object, ["flipEnabled"], getv(from_object, ["flip_enabled"]))
+
+        if getv(from_object, ["autorater_model"]) is not None:
+            setv(
+                to_object,
+                ["autoraterModel"],
+                getv(from_object, ["autorater_model"]),
+            )
+
+        return to_object
+
+    @staticmethod
+    def EvaluateDatasetOperation_from_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, ["name"], getv(from_object, ["name"]))
+
+        if getv(from_object, ["metadata"]) is not None:
+            setv(to_object, ["metadata"], getv(from_object, ["metadata"]))
+
+        if getv(from_object, ["done"]) is not None:
+            setv(to_object, ["done"], getv(from_object, ["done"]))
+
+        if getv(from_object, ["error"]) is not None:
+            setv(to_object, ["error"], getv(from_object, ["error"]))
+
+        if getv(from_object, ["response"]) is not None:
+            setv(
+                to_object,
+                ["response"],
+                BatchEvaluateRequestPreparer._EvaluationDataset_from_vertex(
+                    getv(from_object, ["response"]), to_object
+                ),
+            )
+
+        return to_object
+
+    @staticmethod
+    def EvaluateDatasetRequestParameters_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, ["dataset"]) is not None:
+            setv(
+                to_object,
+                ["dataset"],
+                BatchEvaluateRequestPreparer._EvaluationDataset_to_vertex(
+                    getv(from_object, ["dataset"]), to_object
+                ),
+            )
+
+        if getv(from_object, ["metrics"]) is not None:
+            setv(
+                to_object,
+                ["metrics"],
+                [
+                    BatchEvaluateRequestPreparer._Metric_to_vertex(item, to_object)
+                    for item in getv(from_object, ["metrics"])
+                ],
+            )
+
+        if getv(from_object, ["output_config"]) is not None:
+            setv(
+                to_object,
+                ["outputConfig"],
+                BatchEvaluateRequestPreparer._OutputConfig_to_vertex(
+                    getv(from_object, ["output_config"]), to_object
+                ),
+            )
+
+        if getv(from_object, ["autorater_config"]) is not None:
+            setv(
+                to_object,
+                ["autoraterConfig"],
+                BatchEvaluateRequestPreparer._AutoraterConfig_to_vertex(
+                    getv(from_object, ["autorater_config"]), to_object
+                ),
+            )
+
+        if getv(from_object, ["config"]) is not None:
+            setv(to_object, ["config"], getv(from_object, ["config"]))
+
+        return to_object
+
+    @staticmethod
+    def prepare_metric_payload(
+        request_dict: dict[str, Any], resolved_metrics: list["types.MetricSubclass"]
+    ) -> dict[str, Any]:
+        """Prepares the metric payload for the evaluation request.
+
+        Args:
+            request_dict: The dictionary containing the request details.
+            resolved_metrics: A list of resolved metric objects.
+
+        Returns:
+            The updated request dictionary with the prepared metric payload.
+        """
+        request_dict["metrics"] = _transformers.t_metrics(
+            resolved_metrics, set_default_aggregation_metrics=True
+        )
+        return request_dict
+
+
+class EvalDataConverter(abc.ABC):
+    """Abstract base class for dataset converters."""
+
+    @abc.abstractmethod
+    def convert(self, raw_data: Any) -> "types.EvaluationDataset":
+        """Converts a loaded raw dataset into an EvaluationDataset."""
+        raise NotImplementedError()
+
+
+def _postprocess_user_scenarios_response(
+    response: types.GenerateUserScenariosResponse,
+) -> types.EvaluationDataset:
+    """Postprocesses the response from generating user scenarios."""
+    eval_cases = []
+    data_for_df = []
+    if hasattr(response, "user_scenarios") and response.user_scenarios:
+        for scenario in response.user_scenarios:
+            eval_case = types.EvalCase(
+                user_scenario=scenario,
+            )
+            eval_cases.append(eval_case)
+            data_for_df.append(
+                {
+                    "starting_prompt": scenario.starting_prompt,
+                    "conversation_plan": scenario.conversation_plan,
+                }
+            )
+    eval_dataset_df = None
+    if pd is not None:
+        eval_dataset_df = pd.DataFrame(data_for_df)
+    else:
+        logger.warning("Pandas is not installed. eval_dataset_df will be None.")
+    return types.EvaluationDataset(
+        eval_cases=eval_cases, eval_dataset_df=eval_dataset_df
+    )
+
+
+def _display_loss_analysis_result(
+    result: types.LossAnalysisResult,
+) -> None:
+    """Displays a LossAnalysisResult as a formatted pandas DataFrame."""
+    metric = result.config.metric if result.config else None
+    candidate = result.config.candidate if result.config else None
+    rows: list[dict[str, Any]] = []
+    for cluster in result.clusters or []:
+        entry = cluster.taxonomy_entry
+        row = {
+            "metric": metric,
+            "candidate": candidate,
+            "cluster_id": cluster.cluster_id,
+            "l1_category": entry.l1_category if entry else None,
+            "l2_category": entry.l2_category if entry else None,
+            "description": entry.description if entry else None,
+            "item_count": cluster.item_count,
+        }
+        rows.append(row)
+
+    if not rows:
+        logger.info("No loss clusters found.")
+        return
+
+    df = pd.DataFrame(rows)
+    try:
+        from IPython.display import display  # pylint: disable=g-import-not-at-top
+
+        display(df)
+    except ImportError:
+        print(df.to_string())  # pylint: disable=print-function
+
+
+def _resolve_metric_name(
+    metric: Optional[Any],
+) -> Optional[str]:
+    """Extracts a metric name string from a metric argument.
+
+    Accepts a string, a Metric object, or a LazyLoadedPrebuiltMetric
+    (RubricMetric) and returns the metric name as a string.
+
+    For LazyLoadedPrebuiltMetric (e.g., RubricMetric.MULTI_TURN_TASK_SUCCESS),
+    this resolves to the API metric spec name (e.g.,
+    "multi_turn_task_success_v1") so it matches the keys in eval results.
+
+    Args:
+        metric: A metric name string, Metric object, RubricMetric enum value, or
+          None.
+
+    Returns:
+        The metric name as a string, or None if metric is None.
+    """
+    if metric is None:
+        return None
+    if isinstance(metric, str):
+        return metric
+    # LazyLoadedPrebuiltMetric: resolve to versioned API spec name.
+    if hasattr(metric, "_get_api_metric_spec_name"):
+        spec_name: Optional[str] = metric._get_api_metric_spec_name()
+        if spec_name:
+            return spec_name
+    # Metric objects and other types with a .name attribute.
+    if hasattr(metric, "name"):
+        return str(metric.name)
+    return str(metric)
+
+
+def _resolve_eval_run_loss_configs(
+    loss_analysis_metrics: Optional[list[Any]] = None,
+    loss_analysis_configs: Optional[list[Any]] = None,
+    inference_configs: Optional[dict[str, Any]] = None,
+) -> Optional[list[types.LossAnalysisConfig]]:
+    """Resolves loss analysis configs for create_evaluation_run.
+
+    Supports two modes:
+    1. ``loss_analysis_metrics``: A simplified list of metrics. The candidate
+       is auto-inferred from ``inference_configs`` when there is exactly one
+       candidate. Each metric is resolved via ``_resolve_metric_name()``.
+    2. ``loss_analysis_configs``: Explicit ``LossAnalysisConfig`` objects or
+       dicts for full control.
+
+    Args:
+        loss_analysis_metrics: Optional list of metric references (strings,
+            Metric objects, or RubricMetric enums).
+        loss_analysis_configs: Optional list of LossAnalysisConfig or dicts.
+        inference_configs: The resolved inference_configs dict (candidate name
+            -> config). Used to auto-infer candidate for the metrics path.
+
+    Returns:
+        A list of resolved LossAnalysisConfig objects, or None if neither
+        loss_analysis_metrics nor loss_analysis_configs is provided.
+
+    Raises:
+        ValueError: If candidate cannot be inferred for loss_analysis_metrics.
+    """
+    if not loss_analysis_metrics and not loss_analysis_configs:
+        return None
+
+    if loss_analysis_configs:
+        return [
+            types.LossAnalysisConfig.model_validate(c) if isinstance(c, dict) else c
+            for c in loss_analysis_configs
+        ]
+
+    # loss_analysis_metrics path: auto-infer candidate from inference_configs
+    candidate = None
+    if inference_configs and len(inference_configs) == 1:
+        candidate = next(iter(inference_configs))
+    elif inference_configs and len(inference_configs) > 1:
+        raise ValueError(
+            "Cannot infer candidate for loss analysis: multiple candidates"
+            f" found in inference_configs: {list(inference_configs.keys())}."
+            " Please use loss_analysis_configs with explicit candidate values"
+            " instead."
+        )
+
+    configs = []
+    for m in loss_analysis_metrics or []:
+        metric_name = _resolve_metric_name(m)
+        configs.append(
+            types.LossAnalysisConfig(metric=metric_name, candidate=candidate)
+        )
+    return configs
+
+
+def _resolve_red_teaming_config(
+    red_teaming_config: Optional[types.RedTeamingAnalysisConfigOrDict] = None,
+) -> Optional[list[types.AnalysisConfig]]:
+    """Wraps a RedTeamingAnalysisConfig into analysis_configs for the API."""
+    if not red_teaming_config:
+        return None
+    config = (
+        types.RedTeamingAnalysisConfig.model_validate(red_teaming_config)
+        if isinstance(red_teaming_config, dict)
+        else red_teaming_config
+    )
+    return [types.AnalysisConfig(red_teaming_analysis_config=config)]
+
+
+def _resolve_loss_analysis_config(
+    eval_result: types.EvaluationResult,
+    config: Optional[types.LossAnalysisConfig] = None,
+    metric: Optional[str] = None,
+    candidate: Optional[str] = None,
+) -> types.LossAnalysisConfig:
+    """Resolves and validates the LossAnalysisConfig for generate_loss_clusters.
+
+    Auto-infers `metric` and `candidate` from the EvaluationResult when not
+    explicitly provided. Validates that provided values exist in the eval result.
+
+    Args:
+        eval_result: The EvaluationResult from client.evals.evaluate().
+        config: Optional explicit LossAnalysisConfig. If provided, metric and
+          candidate from config take precedence over the separate arguments.
+        metric: Optional metric name override.
+        candidate: Optional candidate name override.
+
+    Returns:
+        A resolved LossAnalysisConfig with metric and candidate populated.
+
+    Raises:
+        ValueError: If metric/candidate cannot be inferred or are invalid.
+    """
+    # Start from config if provided, otherwise create a new one.
+    if config is not None:
+        resolved_metric = metric or config.metric
+        resolved_candidate = candidate or config.candidate
+        resolved_config = config.model_copy(
+            update={"metric": resolved_metric, "candidate": resolved_candidate}
+        )
+    else:
+        resolved_config = types.LossAnalysisConfig(metric=metric, candidate=candidate)
+
+    # Collect available metric names from the eval result.
+    available_metrics: set[str] = set()
+    if eval_result.eval_case_results:
+        for case_result in eval_result.eval_case_results:
+            for resp_cand in case_result.response_candidate_results or []:
+                for m_name in (resp_cand.metric_results or {}).keys():
+                    available_metrics.add(m_name)
+
+    # Collect available candidate names from metadata.
+    available_candidates: list[str] = []
+    if eval_result.metadata and eval_result.metadata.candidate_names:
+        available_candidates = list(eval_result.metadata.candidate_names)
+
+    # Auto-infer metric if not provided.
+    if not resolved_config.metric:
+        if len(available_metrics) == 1:
+            resolved_config = resolved_config.model_copy(
+                update={"metric": next(iter(available_metrics))}
+            )
+        elif len(available_metrics) == 0:
+            raise ValueError(
+                "Cannot infer metric: no metric results found in eval_result."
+                " Please provide metric explicitly via"
+                " config=types.LossAnalysisConfig(metric='...')."
+            )
+        else:
+            raise ValueError(
+                "Cannot infer metric: multiple metrics found in eval_result:"
+                f" {sorted(available_metrics)}. Please provide metric"
+                " explicitly via config=types.LossAnalysisConfig(metric='...')."
+            )
+
+    # Validate metric if provided explicitly.
+    if available_metrics and resolved_config.metric not in available_metrics:
+        raise ValueError(
+            f"Metric '{resolved_config.metric}' not found in eval_result."
+            f" Available metrics: {sorted(available_metrics)}."
+        )
+
+    # Auto-infer candidate if not provided.
+    if not resolved_config.candidate:
+        if len(available_candidates) == 1:
+            resolved_config = resolved_config.model_copy(
+                update={"candidate": available_candidates[0]}
+            )
+        elif len(available_candidates) == 0:
+            # Fallback: use default candidate naming convention from SDK.
+            resolved_config = resolved_config.model_copy(
+                update={"candidate": "candidate_1"}
+            )
+            logger.warning(
+                "No candidate names found in eval_result.metadata."
+                " Defaulting to 'candidate_1'. If this is incorrect, provide"
+                " candidate explicitly via"
+                " config=types.LossAnalysisConfig(candidate='...')."
+            )
+        else:
+            raise ValueError(
+                "Cannot infer candidate: multiple candidates found in"
+                f" eval_result: {available_candidates}. Please provide"
+                " candidate explicitly via"
+                " config=types.LossAnalysisConfig(candidate='...')."
+            )
+
+    # Validate candidate if provided explicitly and candidates are known.
+    if available_candidates and resolved_config.candidate not in available_candidates:
+        raise ValueError(
+            f"Candidate '{resolved_config.candidate}' not found in"
+            f" eval_result. Available candidates: {available_candidates}."
+        )
+
+    return resolved_config
+
+
+def _build_rubric_description_map(
+    eval_result: types.EvaluationResult,
+) -> dict[str, str]:
+    """Builds a rubric_id -> description map from the EvaluationResult."""
+    rubric_map: dict[str, str] = {}
+    for case_result in eval_result.eval_case_results or []:
+        for resp_cand in case_result.response_candidate_results or []:
+            for metric_res in (resp_cand.metric_results or {}).values():
+                for verdict in metric_res.rubric_verdicts or []:
+                    rubric = verdict.evaluated_rubric
+                    if rubric and rubric.rubric_id and rubric.content:
+                        if (
+                            rubric.content.property
+                            and rubric.content.property.description
+                        ):
+                            rubric_map[rubric.rubric_id] = (
+                                rubric.content.property.description
+                            )
+    return rubric_map
+
+
+def _extract_scenario_preview_from_dict(
+    eval_result_dict: dict[str, Any],
+) -> Optional[str]:
+    """Extracts the first user message from an evaluation_result dict.
+
+    Handles both snake_case (SDK-side) and camelCase (API echo-back) keys.
+    """
+    request = eval_result_dict.get("request")
+    if not request:
+        return None
+    prompt = request.get("prompt")
+    if not prompt:
+        return None
+    # Try agent_data (snake_case or camelCase)
+    agent_data = prompt.get("agent_data") or prompt.get("agentData")
+    if agent_data and isinstance(agent_data, dict):
+        turns = agent_data.get("turns", [])
+        for turn in turns:
+            events = turn.get("events", [])
+            for event in events:
+                author = event.get("author", "")
+                content = event.get("content")
+                if author.lower() == "user" and content and isinstance(content, dict):
+                    parts = content.get("parts", [])
+                    for part in parts:
+                        text = str(part.get("text", "")).strip()
+                        if text:
+                            if len(text) > 150:
+                                return text[:150] + "..."
+                            return text
+    # Try simple prompt path
+    parts = prompt.get("parts", [])
+    for part in parts:
+        text = str(part.get("text", "")).strip()
+        if text:
+            if len(text) > 150:
+                return text[:150] + "..."
+            return text
+    return None
+
+
+def _extract_scenario_from_agent_data(agent_data: Any) -> Optional[str]:
+    """Extracts the first user message from an AgentData object or dict."""
+    if agent_data is None:
+        return None
+    if hasattr(agent_data, "model_dump"):
+        agent_data = agent_data.model_dump()
+    if isinstance(agent_data, str):
+        try:
+            agent_data = json.loads(agent_data)
+        except (json.JSONDecodeError, ValueError):
+            return None
+    if not isinstance(agent_data, dict):
+        return None
+    turns = agent_data.get("turns", [])
+    if not isinstance(turns, list):
+        return None
+    for turn in turns:
+        if not isinstance(turn, dict):
+            continue
+        events = turn.get("events", [])
+        if not isinstance(events, list):
+            continue
+        for event in events:
+            if not isinstance(event, dict):
+                continue
+            author = event.get("author", "")
+            if not isinstance(author, str) or author.lower() != "user":
+                continue
+            content = event.get("content")
+            if not content or not isinstance(content, dict):
+                continue
+            parts = content.get("parts", [])
+            if not isinstance(parts, list):
+                continue
+            for part in parts:
+                if not isinstance(part, dict):
+                    continue
+                text = str(part.get("text", "")).strip()
+                if text:
+                    if len(text) > 150:
+                        return text[:150] + "..."
+                    return text
+    return None
+
+
+def _truncate_scenario(text: str, max_len: int = 150) -> str:
+    """Truncates a scenario preview to max_len characters."""
+    text = text.strip()
+    if len(text) > max_len:
+        return text[:max_len] + "..."
+    return text
+
+
+def _build_scenario_preview_list(
+    eval_result: types.EvaluationResult,
+) -> list[Optional[str]]:
+    """Builds an ordered list of scenario previews from the EvaluationResult.
+
+    Returns one scenario preview per eval_case_result, in the same order as
+    eval_case_results. This extracts the first user message from the original
+    SDK EvaluationResult (via eval_cases or DataFrame), rather than relying
+    on the API echo-back which may not preserve the request data.
+
+    Extraction priority per eval case:
+    1. eval_case.agent_data → first user message in turns
+    2. eval_case.user_scenario.starting_prompt
+    3. eval_case.prompt → text content
+    4. DataFrame agent_data column → first user message
+    5. DataFrame starting_prompt column
+    """
+    eval_dataset = eval_result.evaluation_dataset
+    eval_cases: list[Any] = []
+    if isinstance(eval_dataset, list) and eval_dataset:
+        eval_cases = getv(eval_dataset[0], ["eval_cases"]) or []
+
+    eval_case_results = eval_result.eval_case_results or []
+    scenarios: list[Optional[str]] = []
+
+    for case_result in eval_case_results:
+        case_idx = case_result.eval_case_index or 0
+        scenario: Optional[str] = None
+
+        eval_case = None
+        if 0 <= case_idx < len(eval_cases):
+            eval_case = eval_cases[case_idx]
+
+        if eval_case:
+            # 1. Try agent_data (populated after run_inference)
+            agent_data = getv(eval_case, ["agent_data"])
+            if agent_data:
+                scenario = _extract_scenario_from_agent_data(agent_data)
+
+            # 2. Try user_scenario.starting_prompt (from
+            #    generate_conversation_scenarios)
+            if scenario is None:
+                user_scenario = getv(eval_case, ["user_scenario"])
+                if user_scenario:
+                    starting_prompt = getv(user_scenario, ["starting_prompt"])
+                    if starting_prompt and isinstance(starting_prompt, str):
+                        scenario = _truncate_scenario(starting_prompt)
+
+            # 3. Try prompt text
+            if scenario is None:
+                prompt = getv(eval_case, ["prompt"])
+                if prompt:
+                    from . import _evals_data_converters
+
+                    text = _evals_data_converters._get_content_text(prompt)
+                    if text:
+                        scenario = _truncate_scenario(str(text))
+
+        # 4. Fallback: extract agent_data from DataFrame
+        if scenario is None and eval_dataset:
+            df_agent_data = _transformers._extract_agent_data_from_df(
+                eval_dataset, case_idx
+            )
+            if df_agent_data is not None:
+                scenario = _extract_scenario_from_agent_data(df_agent_data)
+
+        # 5. Fallback: extract starting_prompt from DataFrame
+        if scenario is None and eval_dataset:
+            ds = eval_dataset[0] if isinstance(eval_dataset, list) else eval_dataset
+            df = getv(ds, ["eval_dataset_df"])
+            if df is not None and hasattr(df, "iloc"):
+                if 0 <= case_idx < len(df):
+                    row = df.iloc[case_idx]
+                    sp = row.get("starting_prompt")
+                    if sp and isinstance(sp, str) and sp.strip():
+                        scenario = _truncate_scenario(sp)
+
+        scenarios.append(scenario)
+
+    return scenarios
+
+
+def _enrich_loss_response_with_rubric_descriptions(
+    response: types.GenerateLossClustersResponse,
+    eval_result: types.EvaluationResult,
+) -> None:
+    """Enriches loss response with rubric descriptions and scenario previews.
+
+    Rubric descriptions and scenario previews are extracted from the original
+    SDK EvaluationResult object, because the API echo-back in
+    LossExample.evaluation_result may not preserve all request data (e.g.,
+    agent_data turns with user messages).
+    """
+    rubric_map = _build_rubric_description_map(eval_result)
+    scenario_list = _build_scenario_preview_list(eval_result)
+    logger.debug(
+        "Enriching loss response: %d scenarios extracted, %d rubric" " descriptions",
+        sum(1 for s in scenario_list if s),
+        len(rubric_map),
+    )
+    for result in response.results or []:
+        for cluster in result.clusters or []:
+            for example in cluster.examples or []:
+                if example.evaluation_result is None:
+                    example.evaluation_result = {}
+                if rubric_map:
+                    example.evaluation_result["rubric_descriptions"] = rubric_map
+                # Try extracting scenario from the API echo-back first
+                if "scenario_preview" not in example.evaluation_result:
+                    scenario = _extract_scenario_preview_from_dict(
+                        example.evaluation_result
+                    )
+                    if scenario:
+                        example.evaluation_result["scenario_preview"] = scenario
+                # Fallback: match against scenarios from original eval_result
+                if "scenario_preview" not in example.evaluation_result:
+                    if scenario_list:
+                        for s in scenario_list:
+                            if s:
+                                example.evaluation_result["scenario_preview"] = s
+                                break
+
+
+def _poll_operation(
+    api_client: BaseApiClient,
+    operation: types.GenerateLossClustersOperation,
+    poll_interval_seconds: float = 5.0,
+) -> types.GenerateLossClustersOperation:
+    """Polls a long-running operation until completion.
+
+    Args:
+        api_client: The API client to use for polling.
+        operation: The initial operation returned from the API call.
+        poll_interval_seconds: Time between polls.
+
+    Returns:
+        The completed operation.
+    """
+    if operation.done:
+        return operation
+    start_time = time.time()
+    while True:
+        response = api_client.request("get", operation.name, {}, None)
+        response_dict = {} if not response.body else json.loads(response.body)
+        polled = types.GenerateLossClustersOperation._from_response(
+            response=response_dict, kwargs={}
+        )
+        if polled.done:
+            return polled
+        elapsed = int(time.time() - start_time)
+        logger.info(
+            "Loss analysis operation still running... Elapsed time: %d seconds",
+            elapsed,
+        )
+        time.sleep(poll_interval_seconds)
+
+
+async def _poll_operation_async(
+    api_client: BaseApiClient,
+    operation: types.GenerateLossClustersOperation,
+    poll_interval_seconds: float = 5.0,
+) -> types.GenerateLossClustersOperation:
+    """Polls a long-running operation until completion (async).
+
+    Args:
+        api_client: The API client to use for polling.
+        operation: The initial operation returned from the API call.
+        poll_interval_seconds: Time between polls.
+
+    Returns:
+        The completed operation.
+    """
+    if operation.done:
+        return operation
+    start_time = time.time()
+    while True:
+        response = await api_client.async_request("get", operation.name, {}, None)
+        response_dict = {} if not response.body else json.loads(response.body)
+        polled = types.GenerateLossClustersOperation._from_response(
+            response=response_dict, kwargs={}
+        )
+        if polled.done:
+            return polled
+        elapsed = int(time.time() - start_time)
+        logger.info(
+            "Loss analysis operation still running... Elapsed time: %d seconds",
+            elapsed,
+        )
+        await asyncio.sleep(poll_interval_seconds)
+
+
+def _validate_dataset_agent_data(
+    dataset: types.EvaluationDataset,
+    inference_configs: Optional[dict[str, Any]] = None,
+) -> None:
+    """Validates agent_data in the EvaluationDataset.
+
+    Checks that agent_data matches the expected AgentData type and that
+    'agents' are not defined in both the dataset's agent_data and inference_configs.
+    """
+    has_inference_agent_configs = False
+    if inference_configs:
+        for cand_config in inference_configs.values():
+            if isinstance(cand_config, dict) and cand_config.get("agent_configs"):
+                has_inference_agent_configs = True
+            elif hasattr(cand_config, "agent_configs") and cand_config.agent_configs:
+                has_inference_agent_configs = True
+
+    def _validate_single_agent_data(agent_data_val: Any, identifier: str) -> None:
+
+        if not agent_data_val:
+            return
+
+        agent_data_obj = None
+        if isinstance(agent_data_val, str):
+            try:
+                agent_data_val = json.loads(agent_data_val)
+                if "error" in agent_data_val:
+                    return
+                agent_data_obj = types.evals.AgentData.model_validate(agent_data_val)
+            except json.JSONDecodeError as e:
+                raise ValueError(
+                    f"{identifier}: 'agent_data' is not valid JSON: {e}"
+                ) from e
+        elif isinstance(agent_data_val, dict) and "error" in agent_data_val:
+            return
+        elif isinstance(agent_data_val, dict):
+            try:
+                agent_data_obj = types.evals.AgentData.model_validate(agent_data_val)
+            except Exception as e:
+                raise ValueError(
+                    f"{identifier}: 'agent_data' "
+                    f"is inconsistent with AgentData type: {e}"
+                ) from e
+        elif isinstance(agent_data_val, types.evals.AgentData):
+            agent_data_obj = agent_data_val
+        else:
+            raise ValueError(
+                f"{identifier}: 'agent_data' is inconsistent with AgentData type. "
+                f"Got {type(agent_data_val)}"
+            )
+
+        if agent_data_obj and agent_data_obj.agents and has_inference_agent_configs:
+            raise ValueError(
+                f"{identifier}: Cannot provide 'agents' in the dataset's 'agent_data' "
+                "and 'agent_configs' in inference_configs at the same time."
+            )
+
+    if (
+        dataset.eval_dataset_df is not None
+        and "agent_data" in dataset.eval_dataset_df.columns
+    ):
+        for idx, row in dataset.eval_dataset_df.iterrows():
+            _validate_single_agent_data(row.get("agent_data"), f"Row {idx}")
+
+    if dataset.eval_cases:
+        for idx, eval_case in enumerate(dataset.eval_cases):
+            agent_data = None
+            if isinstance(eval_case, dict):
+                agent_data = eval_case.get("agent_data", None)
+            elif hasattr(eval_case, "agent_data"):
+                agent_data = eval_case.agent_data
+            _validate_single_agent_data(agent_data, f"EvalCase {idx}")

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_gcs_utils.py

@@ -0,0 +1,192 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import io
+import json
+import logging
+from typing import Any, Union
+
+from google.cloud import storage  # type: ignore[attr-defined]
+from google.cloud.aiplatform.utils.gcs_utils import blob_from_uri
+from google.genai._api_client import BaseApiClient
+import pandas as pd
+import uuid
+
+
+logger = logging.getLogger(__name__)
+
+
+GCS_PREFIX = "gs://"
+
+
+class GcsUtils:
+    """Handles File I/O operations with Google Cloud Storage (GCS)"""
+
+    def __init__(self, api_client: BaseApiClient):
+        self.api_client = api_client
+        self.storage_client = storage.Client(
+            project=self.api_client.project,
+            credentials=self.api_client._credentials,
+        )
+
+    def parse_gcs_path(self, gcs_path: str) -> tuple[str, str]:
+        """Helper to parse gs://bucket/path into (bucket_name, blob_path)."""
+        if not gcs_path.startswith(GCS_PREFIX):
+            raise ValueError(
+                f"Invalid GCS path: '{gcs_path}'. It must start with '{GCS_PREFIX}'."
+            )
+        path_without_prefix = gcs_path[len(GCS_PREFIX) :]
+        if "/" not in path_without_prefix:
+            return path_without_prefix, ""
+        bucket_name, blob_path = path_without_prefix.split("/", 1)
+        return bucket_name, blob_path
+
+    def upload_file_to_gcs(self, upload_gcs_path: str, filename: str) -> None:
+        """Uploads the provided file to a Google Cloud Storage location."""
+
+        blob_from_uri(
+            uri=upload_gcs_path, client=self.storage_client
+        ).upload_from_filename(filename)
+
+    def upload_dataframe(
+        self,
+        df: "pd.DataFrame",
+        gcs_destination_blob_path: str,
+        file_type: str = "jsonl",
+    ) -> None:
+        """Uploads a Pandas DataFrame to a Google Cloud Storage location.
+
+        Args:
+          df: The Pandas DataFrame to upload.
+          gcs_destination_blob_path: The full GCS path for the destination blob
+            (e.g., 'gs://bucket/data/my_dataframe.jsonl').
+          file_type: The format to save the DataFrame ('jsonl' or 'csv'). Defaults
+            to 'jsonl'.
+        """
+        bucket_name, blob_name = self.parse_gcs_path(gcs_destination_blob_path)
+        if not blob_name:
+            raise ValueError(
+                f"Invalid GCS path for blob: '{gcs_destination_blob_path}'. "
+                "It must include the object name (e.g., gs://bucket/file.csv)."
+            )
+        bucket = self.storage_client.bucket(bucket_name)
+        blob = bucket.blob(blob_name)
+
+        buffer = io.StringIO()
+        if file_type == "csv":
+            df.to_csv(buffer, index=False)
+            content_type = "text/csv"
+        elif file_type == "jsonl":
+            df.to_json(buffer, orient="records", lines=True)
+            content_type = "application/jsonl"
+        else:
+            raise ValueError(
+                f"Unsupported file type: '{file_type}'. "
+                "Please provide 'jsonl' or 'csv'."
+            )
+        blob.upload_from_string(buffer.getvalue(), content_type=content_type)
+
+        logger.info(
+            f"DataFrame successfully uploaded to: gs://{bucket.name}/{blob.name}"
+        )
+
+    def upload_json(self, data: dict[str, Any], gcs_destination_blob_path: str) -> None:
+        """Uploads a dictionary as a JSON file to Google Cloud Storage."""
+        bucket_name, blob_name = self.parse_gcs_path(gcs_destination_blob_path)
+        if not blob_name:
+            raise ValueError(
+                f"Invalid GCS path for blob: '{gcs_destination_blob_path}'. "
+                "It must include the object name (e.g., gs://bucket/file.json)."
+            )
+        bucket = self.storage_client.bucket(bucket_name)
+        blob = bucket.blob(blob_name)
+
+        json_data = json.dumps(data, indent=2)
+        blob.upload_from_string(json_data, content_type="application/json")
+
+        logger.info(
+            f"JSON data successfully uploaded to: gs://{bucket_name}/{blob_name}"
+        )
+
+    def upload_json_to_prefix(
+        self,
+        data: dict[str, Any],
+        gcs_dest_prefix: str,
+        filename_prefix: str = "data",
+    ) -> str:
+        """Uploads a dictionary to a GCS prefix with a UUID JSON filename.
+
+        Args:
+          data: The dictionary to upload.
+          gcs_dest_prefix: The GCS prefix (e.g., 'gs://bucket/path/prefix/').
+          filename_prefix: Prefix for the generated filename. Defaults to 'data'.
+
+        Returns:
+          The full GCS path where the file was uploaded.
+
+        Raises:
+          ValueError: If the gcs_dest_prefix is not a valid GCS path.
+        """
+        if not gcs_dest_prefix.startswith(GCS_PREFIX):
+            raise ValueError(
+                f"Invalid GCS destination prefix: '{gcs_dest_prefix}'. Must start"
+                f" with '{GCS_PREFIX}'."
+            )
+
+        gcs_path_without_scheme = gcs_dest_prefix[len(GCS_PREFIX) :]
+        bucket_name, *path_parts = gcs_path_without_scheme.split("/")
+
+        user_prefix_path = "/".join(path_parts)
+        if user_prefix_path and not user_prefix_path.endswith("/"):
+            user_prefix_path += "/"
+
+        filename = f"{filename_prefix}_{uuid.uuid4()}.json"
+
+        blob_name = f"{user_prefix_path}{filename}"
+
+        full_gcs_path = f"{GCS_PREFIX}{bucket_name}/{blob_name}"
+
+        self.upload_json(data, full_gcs_path)
+        return full_gcs_path
+
+    def read_file_contents(self, gcs_filepath: str) -> Union[str, Any]:
+        """Reads the contents of a file from Google Cloud Storage."""
+
+        bucket_name, blob_path = self.parse_gcs_path(gcs_filepath)
+        if not blob_path:
+            raise ValueError(
+                f"Invalid GCS file path: '{gcs_filepath}'. Path must point to a file,"
+                " not just a bucket."
+            )
+        bucket = self.storage_client.bucket(bucket_name)
+        blob = bucket.blob(blob_path)
+        content = blob.download_as_bytes().decode("utf-8")
+        logger.info(f"Successfully read content from '{gcs_filepath}'")
+        return content
+
+    def read_gcs_file_to_dataframe(
+        self, gcs_filepath: str, file_type: str
+    ) -> "pd.DataFrame":
+        """Reads a file from Google Cloud Storage into a Pandas DataFrame."""
+        file_contents = self.read_file_contents(gcs_filepath)
+        if file_type == "csv":
+            return pd.read_csv(io.StringIO(file_contents), encoding="utf-8")
+        elif file_type == "jsonl":
+            return pd.read_json(io.StringIO(file_contents), lines=True)
+        else:
+            raise ValueError(
+                f"Unsupported file type: '{file_type}'. Please provide 'jsonl' or"
+                " 'csv'."
+            )

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_logging_utils.py

@@ -0,0 +1,47 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import functools
+from typing import Any, Callable
+from google.genai import _common
+import warnings
+
+
+def show_deprecation_warning_once(
+    message: str,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Decorator to show a deprecation warning once for a function."""
+
+    def decorator(func: Any) -> Any:
+        warning_done = False
+
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            nonlocal warning_done
+            if not warning_done:
+                warning_done = True
+                warnings.warn(message, DeprecationWarning, stacklevel=2)
+
+            # Suppress ExperimentalWarning while executing the deprecated wrapper
+            with warnings.catch_warnings():
+                # We ignore ExperimentalWarning because the user will see it
+                # when they migrate to the new prompts module
+                warnings.simplefilter("ignore", category=_common.ExperimentalWarning)
+                return func(*args, **kwargs)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_observability_data_converter.py

@@ -0,0 +1,186 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Dataset converter for Google Observability GenAI data."""
+
+import json
+import logging
+from typing import Any, Optional
+
+from google.genai import types as genai_types
+from typing_extensions import override
+
+from . import _evals_utils
+from . import types
+
+
+logger = logging.getLogger("agentplatform_genai._observability_data_converters")
+
+
+def _load_jsonl(data: Any, case_id: str) -> list[dict[Any, Any]]:
+    """Parses the raw JSONL data into a list of dict possible."""
+    if isinstance(data, str):
+        json_list = []
+        for line in data.splitlines():
+            loaded_json = json.loads(line)
+            if not isinstance(loaded_json, dict):
+                raise TypeError(
+                    f"Decoded JSON payload is not a dict for case "
+                    f"{case_id}. Type found: {type(loaded_json).__name__}"
+                )
+            json_list.append(loaded_json)
+        return json_list
+    else:
+        raise TypeError(
+            f"Payload is not a JSONL string for case {case_id}. Type "
+            f"found: {type(data).__name__}"
+        )
+
+
+class ObservabilityDataConverter(_evals_utils.EvalDataConverter):
+    """Converter for dataset in GCP Observability GenAI format."""
+
+    def _message_to_content(self, message: dict[str, Any]) -> genai_types.Content:
+        """Converts Observability GenAI Message format to Content."""
+        parts = []
+        message_parts = message.get("parts", [])
+        if isinstance(message_parts, list):
+            for message_part in message_parts:
+                part = None
+                part_type = message_part.get("type", "")
+                if part_type == "text":
+                    part = genai_types.Part(text=message_part.get("content", ""))
+                elif part_type == "blob":
+                    part = genai_types.Part(
+                        inline_data=genai_types.Blob(
+                            data=message_part.get("data", ""),
+                            mime_type=message_part.get("mime_type", ""),
+                        )
+                    )
+                elif part_type == "file_data":
+                    part = genai_types.Part(
+                        file_data=genai_types.FileData(
+                            file_uri=message_part.get("file_uri", ""),
+                            mime_type=message_part.get("mime_type", ""),
+                        )
+                    )
+                elif part_type == "tool_call":
+                    # O11y format requires use of id in place of name
+                    part = genai_types.Part(
+                        function_call=genai_types.FunctionCall(
+                            id=message_part.get("id", ""),
+                            name=message_part.get("id", ""),
+                            args=message_part.get("arguments", {}),
+                        )
+                    )
+                elif part_type == "tool_call_response":
+                    # O11y format requires use of id in place of name
+                    part = genai_types.Part(
+                        function_response=genai_types.FunctionResponse(
+                            id=message_part.get("id", ""),
+                            name=message_part.get("id", ""),
+                            response=message_part.get("result", {}),
+                        )
+                    )
+                else:
+                    logger.warning(
+                        "Skipping message part due to unrecognized message "
+                        "part type of '%s'",
+                        part_type,
+                    )
+
+                if part is not None:
+                    parts.append(part)
+
+        return genai_types.Content(parts=parts, role=message.get("role", ""))
+
+    def _parse_messages(
+        self,
+        eval_case_id: str,
+        request_msgs: list[Any],
+        response_msgs: list[Any],
+        system_instruction_msg: Optional[dict[str, Any]] = None,
+    ) -> types.EvalCase:
+        """Parses a set of Observability messages into an EvalCase."""
+        # System instruction message
+        system_instruction = None
+        if system_instruction_msg is not None:
+            system_instruction = self._message_to_content(system_instruction_msg)
+
+        # Request messages
+        prompt = None
+        conversation_history = []
+        if request_msgs:
+            # Extract latest message as prompt
+            prompt = self._message_to_content(request_msgs[-1])
+
+            # All previous messages are conversation history
+            if len(request_msgs) > 1:
+                for i, msg in enumerate(request_msgs[:-1]):
+                    conversation_history.append(
+                        types.evals.Message(
+                            turn_id=str(i),
+                            content=self._message_to_content(msg),
+                            author=msg.get("role", ""),
+                        )
+                    )
+
+        # Output messages
+        responses = []
+        for msg in response_msgs:
+            response = types.ResponseCandidate(response=self._message_to_content(msg))
+            responses.append(response)
+
+        return types.EvalCase(
+            eval_case_id=eval_case_id,
+            prompt=prompt,
+            responses=responses,
+            system_instruction=system_instruction,
+            conversation_history=conversation_history,
+            reference=None,
+        )
+
+    @override
+    def convert(self, raw_data: list[dict[str, Any]]) -> types.EvaluationDataset:
+        """Converts a list of GCP Observability GenAI cases into an EvaluationDataset."""
+        eval_cases = []
+
+        for i, case in enumerate(raw_data):
+            eval_case_id = f"observability_eval_case_{i}"
+
+            if "request" not in case or "response" not in case:
+                logger.warning(
+                    "Skipping case %s due to missing 'request' or 'response' key.",
+                    eval_case_id,
+                )
+                continue
+
+            request_data = case.get("request", [])
+            request_list = _load_jsonl(request_data, eval_case_id)
+
+            response_data = case.get("response", [])
+            response_list = _load_jsonl(response_data, eval_case_id)
+
+            system_dict = None
+            if "system_instruction" in case:
+                system_data = case.get("system_instruction", {})
+                system_list = _load_jsonl(system_data, eval_case_id)
+                system_dict = system_list[0] if system_list else {}
+
+            eval_case = self._parse_messages(
+                eval_case_id, request_list, response_list, system_dict
+            )
+            eval_cases.append(eval_case)
+
+        return types.EvaluationDataset(eval_cases=eval_cases)

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_prompt_management_utils.py

@@ -0,0 +1,147 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Utility functions for prompt management."""
+
+from typing import Optional
+
+from google.genai import types as genai_types
+
+from . import types
+
+
+DEFAULT_API_SCHEMA_VERSION = "1.0.0"
+PROMPT_SCHEMA_URI = (
+    "gs://google-cloud-aiplatform/schema/dataset/metadata/text_prompt_1.0.0.yaml"
+)
+PROMPT_TYPE = "multimodal_freeform"
+
+
+def _create_dataset_metadata_from_prompt(
+    prompt: types.Prompt,
+    variables: Optional[list[dict[str, genai_types.Part]]] = None,
+) -> types.SchemaTextPromptDatasetMetadata:
+    """Convert a types.Prompt into types.SchemaTextPromptDatasetMetadata."""
+
+    prompt_metadata = types.SchemaTextPromptDatasetMetadata()
+
+    prompt_api_schema = types.SchemaPromptApiSchema()
+    prompt_api_schema.multimodal_prompt = types.SchemaPromptSpecMultimodalPrompt(
+        prompt_message=prompt.prompt_data
+    )
+
+    prompt_api_schema.api_schema_version = DEFAULT_API_SCHEMA_VERSION
+
+    prompt_metadata.has_prompt_variable = bool(variables)
+
+    if variables:
+        prompt_execution_list = []
+        for prompt_var in variables:
+            prompt_instance_execution = types.SchemaPromptInstancePromptExecution()
+            prompt_instance_execution.arguments = {}
+            for key, val in prompt_var.items():
+                prompt_instance_execution.arguments[key] = (
+                    types.SchemaPromptInstanceVariableValue(
+                        part_list=types.SchemaPromptSpecPartList(parts=[val])
+                    )
+                )
+            prompt_execution_list.append(prompt_instance_execution)
+        prompt_api_schema.executions = prompt_execution_list
+
+    # Need to exclude variables from the prompt message as it is a client side
+    # only field
+    if prompt_api_schema.multimodal_prompt.prompt_message:
+        prompt_message_dict = (
+            prompt_api_schema.multimodal_prompt.prompt_message.model_dump(
+                exclude=["variables"], exclude_none=True
+            )
+        )
+        prompt_api_schema.multimodal_prompt.prompt_message = (
+            types.SchemaPromptSpecPromptMessage(**prompt_message_dict)
+        )
+    prompt_metadata.prompt_api_schema = prompt_api_schema
+
+    prompt_metadata.prompt_type = PROMPT_TYPE
+
+    return prompt_metadata
+
+
+def _create_prompt_from_dataset_metadata(
+    dataset: types.Dataset,
+) -> types.Prompt:
+    """Constructs a types.Prompt from a types.Dataset resource returned from the API.
+
+    Args:
+      dataset: The types.Dataset object containing the prompt metadata.
+
+    Returns:
+      A types.Prompt object reconstructed from the dataset metadata.
+    """
+    if (
+        not hasattr(dataset, "metadata")
+        or dataset.metadata is None
+        or not isinstance(dataset.metadata, types.SchemaTextPromptDatasetMetadata)
+    ):
+        raise ValueError(
+            "Error retrieving prompt: prompt dataset resource is missing 'metadata'."
+        )
+    api_schema = dataset.metadata.prompt_api_schema
+    prompt = types.Prompt()
+
+    if api_schema is None:
+        return prompt
+
+    if api_schema.multimodal_prompt:
+
+        prompt_message = api_schema.multimodal_prompt.prompt_message
+        prompt.prompt_data = prompt_message
+
+        if api_schema.executions:
+            executions = api_schema.executions
+            if executions and prompt.prompt_data is not None:
+                prompt.prompt_data.variables = []
+                for execution in executions:
+                    if execution.arguments:
+                        args = execution.arguments
+                        var_map = {}
+                        for key, val in args.items():
+                            if (
+                                val.part_list is not None
+                                and val.part_list.parts is not None
+                            ):
+                                part_list = val.part_list.parts
+                                if part_list and part_list[0].text:
+                                    var_map[key] = part_list[0]
+                        if var_map and prompt.prompt_data.variables is not None:
+                            prompt.prompt_data.variables.append(var_map)
+
+    return prompt
+
+
+def _raise_for_invalid_prompt(
+    prompt: types.Prompt,
+) -> None:
+
+    if not prompt.prompt_data:
+        raise ValueError("Prompt data must be provided.")
+    if not prompt.prompt_data.contents:
+        raise ValueError("Prompt contents must be provided.")
+    if not prompt.prompt_data.model:
+        raise ValueError("Model name must be provided.")
+    if (
+        prompt.prompt_data
+        and prompt.prompt_data.contents
+        and len(prompt.prompt_data.contents) > 1
+    ):
+        raise ValueError("Multi-turn prompts are not currently supported.")

data/conda_envs/evalclaw/lib/python3.11/site-packages/agentplatform/_genai/_prompt_optimizer_utils.py

@@ -0,0 +1,215 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Utility functions for prompt optimizer."""
+
+import json
+from typing import Any, Optional, Union
+from typing_extensions import TypeAlias
+
+from pydantic import ValidationError
+
+from . import types
+
+try:
+    import pandas as pd  # pylint: disable=g-import-not-at-top
+
+    PandasDataFrame: TypeAlias = pd.DataFrame
+except ImportError:
+    pd = None
+    PandasDataFrame = Any  # type: ignore[misc]
+
+
+def _construct_input_prompt(
+    example_df: PandasDataFrame,
+    *,
+    prompt_col_name: str,
+    model_response_col_name: str,
+    rubrics_col_name: str,
+    rubrics_evaluations_col_name: str,
+    target_response_col_name: str,
+    system_instruction: Optional[str] = None,
+) -> str:
+    """Construct the input prompt for the few shot prompt optimizer."""
+
+    all_prompts = []
+    for row in example_df.to_dict(orient="records"):
+        example_data = {
+            "prompt": row[prompt_col_name],
+            "model_response": row[model_response_col_name],
+        }
+        if rubrics_col_name:
+            example_data["rubrics"] = row[rubrics_col_name]
+        if rubrics_evaluations_col_name:
+            example_data["rubrics_evaluations"] = row[rubrics_evaluations_col_name]
+        if target_response_col_name:
+            example_data["target_response"] = row[target_response_col_name]
+
+        json_str = json.dumps(example_data, indent=2)
+        all_prompts.append(f"```JSON\n{json_str}\n```")
+
+    all_prompts_str = "\n\n".join(all_prompts)
+
+    if system_instruction is None:
+        system_instruction = ""
+
+    return "\n".join(
+        [
+            "Original System Instructions:\n",
+            system_instruction,
+            "Examples:\n",
+            all_prompts_str,
+            "\nNew Output:\n",
+        ]
+    )
+
+
+def _get_few_shot_prompt(
+    system_instruction: str,
+    config: types.OptimizeConfig,
+) -> str:
+    """Builds the few shot prompt."""
+
+    if config.examples_dataframe is None:
+        raise ValueError("The 'examples_dataframe' is required in the config.")
+
+    if "prompt" not in config.examples_dataframe.columns:
+        raise ValueError("'prompt' is required in the examples_dataframe.")
+
+    if "prompt" not in config.examples_dataframe.columns:
+        raise ValueError("'prompt' is required in the examples_dataframe.")
+    prompt_col_name = "prompt"
+
+    if "model_response" not in config.examples_dataframe.columns:
+        raise ValueError("'model_response' is required in the example_df.")
+    model_response_col_name = "model_response"
+
+    target_response_col_name = ""
+    rubrics_col_name = ""
+    rubrics_evaluations_col_name = ""
+
+    if (
+        config.optimization_target
+        == types.OptimizeTarget.OPTIMIZATION_TARGET_FEW_SHOT_TARGET_RESPONSE
+    ):
+        if "target_response" not in config.examples_dataframe.columns:
+            raise ValueError("'target_response' is required in the examples_dataframe.")
+        target_response_col_name = "target_response"
+        if "rubrics" in config.examples_dataframe.columns:
+            raise ValueError(
+                "Only 'target_response' should be provided "
+                "for OPTIMIZATION_TARGET_FEW_SHOT_TARGET_RESPONSE "
+                "but 'rubrics' was provided."
+            )
+
+    elif (
+        config.optimization_target
+        == types.OptimizeTarget.OPTIMIZATION_TARGET_FEW_SHOT_RUBRICS
+    ):
+        if not {"rubrics", "rubrics_evaluations"}.issubset(
+            config.examples_dataframe.columns
+        ):
+            raise ValueError(
+                "rubrics and rubrics_evaluations is required in the"
+                "examples_dataframe when rubrics is set."
+            )
+
+        rubrics_col_name = "rubrics"
+        rubrics_evaluations_col_name = "rubrics_evaluations"
+        if "target_response" in config.examples_dataframe.columns:
+            raise ValueError(
+                "Only 'rubrics' and 'rubrics_evaluations' should be provided "
+                "for OPTIMIZATION_TARGET_FEW_SHOT_RUBRICS "
+                "but target_response was provided."
+            )
+    else:
+        raise ValueError("One of 'target_response' or 'rubrics' must be provided.")
+
+    return _construct_input_prompt(
+        config.examples_dataframe,
+        prompt_col_name=prompt_col_name,
+        model_response_col_name=model_response_col_name,
+        rubrics_col_name=rubrics_col_name,
+        rubrics_evaluations_col_name=rubrics_evaluations_col_name,
+        target_response_col_name=target_response_col_name,
+        system_instruction=system_instruction,
+    )
+
+
+def _get_service_account(
+    config: types.PromptOptimizerConfigOrDict,
+) -> str:
+    """Get the service account from the config for the custom job."""
+    if isinstance(config, dict):
+        config = types.PromptOptimizerConfig.model_validate(config)
+
+    if (
+        config.service_account and config.service_account_project_number
+    ):  # pytype: disable=attribute-error
+        raise ValueError(
+            "Only one of service_account or "
+            "service_account_project_number can be provided."
+        )
+    elif config.service_account:  # pytype: disable=attribute-error
+        return config.service_account  # pytype: disable=attribute-error
+    elif config.service_account_project_number:  # pytype: disable=attribute-error
+        return f"{config.service_account_project_number}-compute@developer.gserviceaccount.com"  # pytype: disable=attribute-error
+    else:
+        raise ValueError(
+            "Either service_account or service_account_project_number " "is required."
+        )
+
+
+def _clean_and_parse_optimized_prompt(output_str: str) -> Optional[Any]:
+    """Cleans a string response returned from the prompt optimizer endpoint.
+
+    Args:
+        output_str: The optimized prompt string containing the JSON data,
+          potentially with markdown formatting like ```json ... ```.
+
+    Returns:
+        The parsed JSON data, or None if parsing fails.
+    """
+    lines = output_str.strip().split("\n")
+    # Remove markdown delimiters
+    if lines and lines[0].strip().startswith("```"):
+        cleaned_string = "\n".join(lines[1:-1])
+    else:
+        cleaned_string = output_str
+
+    # remove any 'json' labels if they exist on the first line.
+    if cleaned_string.strip().startswith("json"):
+        cleaned_string = cleaned_string.strip()[4:].strip()
+
+    try:
+        return json.loads(cleaned_string)
+    except json.JSONDecodeError as e:
+        # TODO(b/437144880): raise errors.ClientError here instead
+        raise ValueError(
+            f"Failed to parse the response from prompt optimizer endpoint. {e}"
+        ) from e
+
+
+def _parse(
+    output_str: str,
+) -> Union[
+    types.prompts.ParsedResponse,
+    types.prompts.ParsedResponseFewShot,
+]:
+    """Parses the output string from the prompt optimizer endpoint."""
+    parsed_out = _clean_and_parse_optimized_prompt(output_str)
+    try:
+        return types.prompts.ParsedResponse(**parsed_out)
+    except ValidationError:
+        return types.prompts.ParsedResponseFewShot(**parsed_out)