@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+
+# 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.
+#
+"""Tests that `vertexai.types` metrics resolve in the `vertexai` evals client.
+
+`vertexai.types` resolves to the agentplatform classes, so these objects reach
+`vertexai._genai._evals_common` as agentplatform instances.
+"""
+
+from unittest import mock
+
+import vertexai
+from vertexai._genai import _evals_common
+from vertexai._genai import _evals_metric_loaders
+from vertexai._genai import types as legacy_types
+from google.genai import types as genai_types
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def gcs_utils():
+    with mock.patch.object(_evals_metric_loaders._gcs_utils, "GcsUtils") as gcs:
+        yield gcs
+
+
+def test_rubric_metric_resolves_to_predefined_spec_in_evaluation_run(gcs_utils):
+    resolved = _evals_common._resolve_evaluation_run_metrics(
+        [vertexai.types.RubricMetric.TOOL_USE_QUALITY(version="v2")], mock.Mock()
+    )
+
+    assert len(resolved) == 1
+    assert isinstance(resolved[0], legacy_types.EvaluationRunMetric)
+    assert resolved[0].metric == "tool_use_quality_v2"
+    assert (
+        resolved[0].metric_config.predefined_metric_spec.metric_spec_name
+        == "tool_use_quality_v2"
+    )
+    gcs_utils.assert_not_called()
+
+
+def test_rubric_metric_keeps_requested_version(gcs_utils):
+    resolved = _evals_common._resolve_evaluation_run_metrics(
+        [vertexai.types.RubricMetric.TOOL_USE_QUALITY(version="v1")], mock.Mock()
+    )
+
+    assert resolved[0].metric == "tool_use_quality_v1"
+    gcs_utils.assert_not_called()
+
+
+def test_rubric_metric_resolves_in_evaluate(gcs_utils):
+    resolved = _evals_common._resolve_metrics(
+        [vertexai.types.RubricMetric.TOOL_USE_QUALITY(version="v2")], mock.Mock()
+    )
+
+    assert len(resolved) == 1
+    assert isinstance(resolved[0], legacy_types.Metric)
+    assert resolved[0].name == "tool_use_quality_v2"
+    gcs_utils.assert_not_called()
+
+
+def test_llm_metric_resolves_in_evaluation_run():
+    resolved = _evals_common._resolve_evaluation_run_metrics(
+        [vertexai.types.LLMMetric(name="my_metric", prompt_template="Rate {response}")],
+        mock.Mock(),
+    )
+
+    assert resolved[0].metric == "my_metric"
+    assert resolved[0].metric_config is not None
+
+
+def test_llm_metric_converts_to_legacy_class_in_evaluate():
+    metric = vertexai.types.LLMMetric(
+        name="my_metric", prompt_template="Rate {response}"
+    )
+
+    resolved = _evals_common._resolve_metrics([metric], mock.Mock())
+
+    assert type(resolved[0]) is legacy_types.LLMMetric
+    assert resolved[0].name == "my_metric"
+    assert resolved[0].prompt_template == "Rate {response}"
+
+
+def test_evaluation_run_metric_passes_through():
+    metric = vertexai.types.EvaluationRunMetric(
+        metric="my_metric",
+        metric_config=vertexai.types.UnifiedMetric(
+            predefined_metric_spec=genai_types.PredefinedMetricSpec(
+                metric_spec_name="my_metric"
+            )
+        ),
+    )
+
+    resolved = _evals_common._resolve_evaluation_run_metrics([metric], mock.Mock())
+
+    assert type(resolved[0]) is legacy_types.EvaluationRunMetric
+    assert resolved[0].metric == "my_metric"
+
+
+@pytest.mark.parametrize(
+    "resolve",
+    [
+        _evals_common._resolve_evaluation_run_metrics,
+        _evals_common._resolve_metrics,
+    ],
+)
+def test_unsupported_metric_type_raises_type_error(resolve, gcs_utils):
+    with pytest.raises(TypeError, match="Unsupported metric type"):
+        resolve([object()], mock.Mock())
+    gcs_utils.assert_not_called()
@@ -30,6 +30,12 @@
 
 from google.api_core import exceptions as api_exceptions
 import vertexai
+from agentplatform._genai import (
+    _evals_metric_loaders as _agentplatform_metric_loaders,
+)
+from agentplatform._genai import (
+    types as _agentplatform_types,
+)
 from google.genai import errors as genai_errors
 from google.genai import types as genai_types
 from google.genai._api_client import BaseApiClient
@@ -1692,6 +1698,36 @@ def _resolve_dataset_inputs(
     return processed_eval_dataset, num_response_candidates
 
 
+def _to_vertexai_metric(metric: Any) -> Any:
+    """Converts an agentplatform metric object to its vertexai._genai class.
+
+    `vertexai.types` resolves to the agentplatform classes, which fail
+    isinstance checks against the vertexai._genai classes used in this module.
+
+    Args:
+        metric: A metric object, metric name, or any other value.
+
+    Returns:
+        The vertexai._genai equivalent of an agentplatform metric, otherwise
+        `metric` unchanged.
+    """
+    if isinstance(metric, _agentplatform_metric_loaders.LazyLoadedPrebuiltMetric):
+        return _evals_metric_loaders.LazyLoadedPrebuiltMetric(
+            name=metric.name, version=metric.version, **metric.metric_kwargs
+        )
+    if isinstance(
+        metric,
+        (_agentplatform_types.Metric, _agentplatform_types.EvaluationRunMetric),
+    ):
+        converted = getattr(types, type(metric).__name__).model_validate(
+            metric, from_attributes=True
+        )
+        if metric.__pydantic_private__:
+            converted.__pydantic_private__.update(metric.__pydantic_private__)
+        return converted
+    return metric
+
+
 def _resolve_evaluation_run_metrics(
     metrics: Union[list[types.EvaluationRunMetric], list[types.Metric]], api_client: Any
 ) -> list[types.EvaluationRunMetric]:
@@ -1700,6 +1736,7 @@ def _resolve_evaluation_run_metrics(
         return []
     resolved_metrics_list = []
     for metric_instance in metrics:
+        metric_instance = _to_vertexai_metric(metric_instance)
         if isinstance(metric_instance, types.EvaluationRunMetric):
             resolved_metrics_list.append(metric_instance)
         elif isinstance(
@@ -1736,6 +1773,8 @@ def _resolve_evaluation_run_metrics(
                     metric_resource_name=res_name,
                 )
             )
+        elif not isinstance(metric_instance, str):
+            raise TypeError(f"Unsupported metric type: {type(metric_instance)}")
         else:
             try:
                 metric_name_str = str(metric_instance)
@@ -1777,6 +1816,7 @@ def _resolve_metrics(
     """Resolves a list of metric instances, loading RubricMetric if necessary."""
     resolved_metrics_list = []
     for metric_instance in metrics:
+        metric_instance = _to_vertexai_metric(metric_instance)
         if isinstance(metric_instance, _evals_metric_loaders.LazyLoadedPrebuiltMetric):
             try:
                 resolved_metrics_list.append(
@@ -1792,6 +1832,8 @@ def _resolve_metrics(
                 raise
         elif isinstance(metric_instance, types.Metric):
             resolved_metrics_list.append(metric_instance)
+        elif not isinstance(metric_instance, str):
+            raise TypeError(f"Unsupported metric type: {type(metric_instance)}")
         else:
             try:
                 metric_name_str = str(metric_instance)
 
@@ -6,5 +6,8 @@ disable_error_code = import-not-found, import-untyped, arg-type
 [mypy-vertexai.*]
 ignore_errors = True
 
+[mypy-agentplatform.*]
+ignore_errors = True
+
 [mypy-vertexai._genai.*]
 ignore_errors = False