freeplay 0.4.0__tar.gz → 0.5.0__tar.gz

{freeplay-0.4.0 → freeplay-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: freeplay
-Version: 0.4.0
+Version: 0.5.0
 Summary: 
 License: MIT
 Author: FreePlay Engineering

{freeplay-0.4.0 → freeplay-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "freeplay"
-version = "0.4.0"
+version = "0.5.0"
 description = ""
 authors = ["FreePlay Engineering <engineering@freeplay.ai>"]
 license = "MIT"
@@ -17,9 +17,10 @@ pystache = "^0.6.5"
 mypy = "^1"
 types-requests = "^2.31"
 anthropic = { extras = ["bedrock"], version = "^0.39.0" }
-openai = "^1"
+openai = "1.98.0"
 boto3 = "^1.34.97"
-google-cloud-aiplatform = "1.51.0"
+google-cloud-aiplatform = "^1.71.0"
+vertexai = "^1.71.1"
 httpx = "0.27.2"
 
 [tool.poetry.group.test.dependencies]

{freeplay-0.4.0 → freeplay-0.5.0}/src/freeplay/model.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import List, Union, Any, Dict, Mapping, TypedDict, Literal
+from typing import Any, Dict, List, Literal, Mapping, TypedDict, Union
 
 InputValue = Union[str, int, bool, float, Dict[str, Any], List[Any]]
 InputVariables = Mapping[str, InputValue]
@@ -7,6 +7,23 @@ TestRunInput = Mapping[str, InputValue]
 FeedbackValue = Union[bool, str, int, float]
 
 
+@dataclass
+class MediaInputUrl:
+    type: Literal["url"]
+    url: str
+
+
+@dataclass
+class MediaInputBase64:
+    type: Literal["base64"]
+    data: str
+    content_type: str
+
+
+MediaInput = Union[MediaInputUrl, MediaInputBase64]
+MediaInputMap = Dict[str, MediaInput]
+
+
 @dataclass
 class TestRun:
     id: str

{freeplay-0.4.0 → freeplay-0.5.0}/src/freeplay/resources/prompts.py

@@ -8,7 +8,6 @@ from typing import (
     Any,
     Dict,
     List,
-    Literal,
     Optional,
     Protocol,
     Sequence,
@@ -24,7 +23,11 @@ from freeplay.errors import (
     log_freeplay_client_warning,
 )
 from freeplay.llm_parameters import LLMParameters
-from freeplay.model import InputVariables
+from freeplay.model import (
+    InputVariables,
+    MediaInputMap,
+    MediaInputUrl,
+)
 from freeplay.resources.adapters import (
     MediaContentBase64,
     MediaContentUrl,
@@ -52,7 +55,12 @@ logger = logging.getLogger(__name__)
 class UnsupportedToolSchemaError(FreeplayConfigurationError):
     def __init__(self) -> None:
         super().__init__(
-            f'Tool schema not supported for this model and provider.'
+            'Tool schema not supported for this model and provider.'
+        )
+class VertexAIToolSchemaError(FreeplayConfigurationError):
+    def __init__(self) -> None:
+        super().__init__(
+            'Vertex AI SDK not found. Install google-cloud-aiplatform to get proper Tool objects.'
         )
 
 
@@ -85,19 +93,22 @@ GenericProviderMessage = ProviderMessage
 
 
 # SDK-Exposed Classes
+
 @dataclass
-class PromptInfo:
+class PromptVersionInfo:
+    prompt_template_version_id: str
+    environment: Optional[str]
+
+@dataclass
+class PromptInfo(PromptVersionInfo):
     prompt_template_id: str
     prompt_template_version_id: str
     template_name: str
-    environment: Optional[str]
     model_parameters: LLMParameters
     provider_info: Optional[Dict[str, Any]]
     provider: str
     model: str
     flavor_name: str
-    project_id: str
-
 
 class FormattedPrompt:
     def __init__(
@@ -183,6 +194,21 @@ class BoundPrompt:
                     for tool_schema in tool_schema
                 ]
             }
+        elif flavor_name == "gemini_chat":
+            try:
+                from vertexai.generative_models import Tool, FunctionDeclaration  # type: ignore[import-untyped]
+                
+                function_declarations = [
+                    FunctionDeclaration(
+                        name=tool_schema.name,
+                        description=tool_schema.description,
+                        parameters=tool_schema.parameters
+                    )
+                    for tool_schema in tool_schema
+                ]
+                return [Tool(function_declarations=function_declarations)]
+            except ImportError:
+                raise VertexAIToolSchemaError()
 
         raise UnsupportedToolSchemaError()
 
@@ -214,22 +240,6 @@ class BoundPrompt:
             )
 
 
-@dataclass
-class MediaInputUrl:
-    type: Literal["url"]
-    url: str
-
-
-@dataclass
-class MediaInputBase64:
-    type: Literal["base64"]
-    data: str
-    content_type: str
-
-
-MediaInput = Union[MediaInputUrl, MediaInputBase64]
-
-MediaInputMap = Dict[str, MediaInput]
 
 
 def extract_media_content(media_inputs: MediaInputMap, media_slots: List[MediaSlot]) -> List[
@@ -483,6 +493,7 @@ class FilesystemTemplateResolver(TemplateResolver):
             'azure_openai_chat': 'azure',
             'anthropic_chat': 'anthropic',
             'openai_chat': 'openai',
+            "gemini_chat": "vertex",
         }
         provider = flavor_provider.get(flavor)
         if not provider:
@@ -552,7 +563,6 @@ class Prompts:
             model=model,
             flavor_name=prompt.metadata.flavor,
             provider_info=prompt.metadata.provider_info,
-            project_id=prompt.project_id
         )
 
         return TemplatePrompt(prompt_info, prompt.content, prompt.tool_schema)
@@ -588,7 +598,6 @@ class Prompts:
             model=model,
             flavor_name=prompt.metadata.flavor,
             provider_info=prompt.metadata.provider_info,
-            project_id=prompt.project_id
         )
 
         return TemplatePrompt(prompt_info, prompt.content, prompt.tool_schema)

{freeplay-0.4.0 → freeplay-0.5.0}/src/freeplay/resources/recordings.py

@@ -1,19 +1,27 @@
 import json
 import logging
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union, Literal
-from uuid import UUID
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Literal, Optional, Union
+from uuid import UUID, uuid4
 
 from requests import HTTPError
 
 from freeplay import api_support
 from freeplay.errors import FreeplayClientError, FreeplayError
 from freeplay.llm_parameters import LLMParameters
-from freeplay.model import InputVariables, OpenAIFunctionCall, TestRunInfo
-from freeplay.resources.prompts import PromptInfo, MediaInputMap, MediaInput, MediaInputUrl
+from freeplay.model import (
+    InputVariables,
+    MediaInputMap,
+    OpenAIFunctionCall,
+    TestRunInfo,
+)
+from freeplay.resources.prompts import (
+    PromptInfo,
+    PromptVersionInfo,
+)
 from freeplay.resources.sessions import SessionInfo, TraceInfo
-from freeplay.support import CallSupport
-
+from freeplay.support import CallSupport, media_inputs_to_json
+from freeplay.utils import convert_provider_message_to_dict
 
 logger = logging.getLogger(__name__)
 
@@ -29,11 +37,11 @@ ApiStyle = Union[Literal['batch'], Literal['default']]
 
 @dataclass
 class CallInfo:
-    provider: str
-    model: str
-    start_time: float
-    end_time: float
-    model_parameters: LLMParameters
+    provider: Optional[str] = None
+    model: Optional[str] = None
+    start_time: Optional[float] = None
+    end_time: Optional[float] = None
+    model_parameters: Optional[LLMParameters] = None
     provider_info: Optional[Dict[str, Any]] = None
     usage: Optional[UsageTokens] = None
     api_style: Optional[ApiStyle] = None
@@ -69,12 +77,15 @@ class ResponseInfo:
 
 @dataclass
 class RecordPayload:
+    project_id: str
     all_messages: List[Dict[str, Any]]
-    inputs: InputVariables
 
-    session_info: SessionInfo
-    prompt_info: PromptInfo
-    call_info: CallInfo
+    session_info: SessionInfo = field(
+        default_factory=lambda: SessionInfo(session_id=str(uuid4()), custom_metadata=None)
+    )
+    inputs: Optional[InputVariables] = None
+    prompt_version_info: Optional[PromptVersionInfo] = None
+    call_info: Optional[CallInfo] = None
     media_inputs: Optional[MediaInputMap] = None
     tool_schema: Optional[List[Dict[str, Any]]] = None
     response_info: Optional[ResponseInfo] = None
@@ -97,18 +108,7 @@ class RecordResponse:
     completion_id: str
 
 
-def media_inputs_to_json(media_input: MediaInput) -> Dict[str, Any]:
-    if isinstance(media_input, MediaInputUrl):
-        return {
-            "type": media_input.type,
-            "url": media_input.url
-        }
-    else:
-        return {
-            "type": media_input.type,
-            "data": media_input.data,
-            "content_type": media_input.content_type
-        }
+
 
 class Recordings:
     def __init__(self, call_support: CallSupport):
@@ -118,25 +118,33 @@ class Recordings:
         if len(record_payload.all_messages) < 1:
             raise FreeplayClientError("Messages list must have at least one message. "
                                       "The last message should be the current response.")
+        
+        if record_payload.tool_schema is not None:
+            record_payload.tool_schema = [convert_provider_message_to_dict(tool) for tool in record_payload.tool_schema]
 
         record_api_payload: Dict[str, Any] = {
             "messages": record_payload.all_messages,
             "inputs": record_payload.inputs,
             "tool_schema": record_payload.tool_schema,
             "session_info": {"custom_metadata": record_payload.session_info.custom_metadata},
-            "prompt_info": {
-                "environment": record_payload.prompt_info.environment,
-                "prompt_template_version_id": record_payload.prompt_info.prompt_template_version_id,
-            },
-            "call_info": {
+        }
+
+        if record_payload.prompt_version_info is not None:
+            record_api_payload["prompt_info"] = {
+                "environment": record_payload.prompt_version_info.environment,
+                "prompt_template_version_id": record_payload.prompt_version_info.prompt_template_version_id,
+            }
+        
+        if record_payload.call_info is not None:
+            record_api_payload["call_info"] = {
                 "start_time": record_payload.call_info.start_time,
                 "end_time": record_payload.call_info.end_time,
                 "model": record_payload.call_info.model,
                 "provider": record_payload.call_info.provider,
                 "provider_info": record_payload.call_info.provider_info,
                 "llm_parameters": record_payload.call_info.model_parameters,
+                "api_style": record_payload.call_info.api_style,
             }
-        }
 
         if record_payload.completion_id is not None:
             record_api_payload['completion_id'] = str(record_payload.completion_id)
@@ -167,15 +175,12 @@ class Recordings:
                 "trace_id": record_payload.trace_info.trace_id
             }
 
-        if record_payload.call_info.usage is not None:
+        if record_payload.call_info is not None and record_payload.call_info.usage is not None:
             record_api_payload['call_info']['usage'] = {
                 "prompt_tokens": record_payload.call_info.usage.prompt_tokens,
                 "completion_tokens": record_payload.call_info.usage.completion_tokens,
             }
 
-        if record_payload.call_info.api_style is not None:
-            record_api_payload['call_info']['api_style'] = record_payload.call_info.api_style
-
         if record_payload.media_inputs is not None:
             record_api_payload['media_inputs'] = {
                 name: media_inputs_to_json(media_input)
@@ -185,7 +190,7 @@ class Recordings:
         try:
             recorded_response = api_support.post_raw(
                 api_key=self.call_support.freeplay_api_key,
-                url=f'{self.call_support.api_base}/v2/projects/{record_payload.prompt_info.project_id}/sessions/{record_payload.session_info.session_id}/completions',
+                url=f'{self.call_support.api_base}/v2/projects/{record_payload.project_id}/sessions/{record_payload.session_info.session_id}/completions',
                 payload=record_api_payload
             )
             recorded_response.raise_for_status()

{freeplay-0.4.0 → freeplay-0.5.0}/src/freeplay/resources/test_cases.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import List, Optional, Dict, Any
 
-from freeplay.model import InputVariables, NormalizedMessage
+from freeplay.model import InputVariables, NormalizedMessage, MediaInputMap
 from freeplay.support import CallSupport, DatasetTestCaseRequest, DatasetTestCasesRetrievalResponse
 
 
@@ -13,12 +13,14 @@ class DatasetTestCase:
             output: Optional[str],
             history: Optional[List[NormalizedMessage]] = None,
             metadata: Optional[Dict[str, str]] = None,
+            media_inputs: Optional[MediaInputMap] = None,
             id: Optional[str] = None, # Only set on retrieval
     ):
         self.inputs = inputs
         self.output = output
         self.history = history
         self.metadata = metadata
+        self.media_inputs = media_inputs
         self.id = id
 
 
@@ -44,7 +46,7 @@ class TestCases:
         return self.create_many(project_id, dataset_id, [test_case])
 
     def create_many(self, project_id: str, dataset_id: str, test_cases: List[DatasetTestCase]) -> Dataset:
-        dataset_test_cases = [DatasetTestCaseRequest(test_case.history, test_case.inputs, test_case.metadata, test_case.output) for test_case in test_cases]
+        dataset_test_cases = [DatasetTestCaseRequest(test_case.history, test_case.inputs, test_case.metadata, test_case.output, test_case.media_inputs) for test_case in test_cases]
         self.call_support.create_test_cases(project_id, dataset_id, dataset_test_cases)
         return Dataset(dataset_id, test_cases)
 

{freeplay-0.4.0 → freeplay-0.5.0}/src/freeplay/resources/test_runs.py

@@ -1,25 +1,32 @@
-from dataclasses import dataclass
-from typing import List, Optional, Dict, Any
 import warnings
+from dataclasses import dataclass
+from uuid import UUID
+from typing import Any, Dict, List, Optional, Union
 
-from freeplay.model import InputVariables, TestRunInfo
+from freeplay.model import InputVariables, MediaInputBase64, MediaInputUrl, TestRunInfo
 from freeplay.support import CallSupport, SummaryStatistics
 
+
 @dataclass
 class CompletionTestCase:
     def __init__(
-            self,
-            test_case_id: str,
-            variables: InputVariables,
-            output: Optional[str],
-            history: Optional[List[Dict[str, str]]],
-            custom_metadata: Optional[Dict[str, str]]
+        self,
+        test_case_id: str,
+        variables: InputVariables,
+        output: Optional[str],
+        history: Optional[List[Dict[str, str]]],
+        custom_metadata: Optional[Dict[str, str]],
+        media_variables: Optional[
+            Dict[str, Union[MediaInputBase64, MediaInputUrl]]
+        ] = None,
     ):
         self.id = test_case_id
         self.variables = variables
         self.output = output
         self.history = history
         self.custom_metadata = custom_metadata
+        self.media_variables = media_variables
+
 
 class TestCase(CompletionTestCase):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
@@ -30,44 +37,55 @@ class TestCase(CompletionTestCase):
         )
         super().__init__(*args, **kwargs)
 
+
 class TraceTestCase:
     def __init__(
-            self,
-            test_case_id: str,
-            input: str,
-            output: Optional[str],
-            custom_metadata: Optional[Dict[str, str]]
+        self,
+        test_case_id: str,
+        input: str,
+        output: Optional[str],
+        custom_metadata: Optional[Dict[str, str]],
     ):
         self.id = test_case_id
         self.input = input
         self.output = output
         self.custom_metadata = custom_metadata
+
 @dataclass
 class TestRun:
     def __init__(
-            self,
-            test_run_id: str,
-            test_cases: List[CompletionTestCase] = [],
-            trace_test_cases: List[TraceTestCase] = []
+        self,
+        test_run_id: str,
+        test_cases: List[CompletionTestCase] = [],
+        trace_test_cases: List[TraceTestCase] = [],
     ):
         self.test_run_id = test_run_id
         self.test_cases = test_cases
         self.trace_test_cases = trace_test_cases
 
     def __must_not_be_both_trace_and_completion(self) -> None:
-        if self.test_cases and len(self.test_cases) > 0 and self.trace_test_cases and len(self.trace_test_cases) > 0:
+        if (
+            self.test_cases
+            and len(self.test_cases) > 0
+            and self.trace_test_cases
+            and len(self.trace_test_cases) > 0
+        ):
             raise ValueError("Test case and trace test case cannot both be present")
 
     def get_test_cases(self) -> List[CompletionTestCase]:
         self.__must_not_be_both_trace_and_completion()
         if len(self.trace_test_cases) > 0:
-            raise ValueError("Completion test cases are not present. Please use get_trace_test_cases() instead.")
+            raise ValueError(
+                "Completion test cases are not present. Please use get_trace_test_cases() instead."
+            )
         return self.test_cases
 
     def get_trace_test_cases(self) -> List[TraceTestCase]:
         self.__must_not_be_both_trace_and_completion()
         if len(self.test_cases) > 0:
-            raise ValueError("Trace test cases are not present. Please use get_test_cases() instead.")
+            raise ValueError(
+                "Trace test cases are not present. Please use get_test_cases() instead."
+            )
         return self.trace_test_cases
 
     def get_test_run_info(self, test_case_id: str) -> TestRunInfo:
@@ -100,16 +118,20 @@ class TestRuns:
             include_outputs: bool = False,
             name: Optional[str] = None,
             description: Optional[str] = None,
-            flavor_name: Optional[str] = None
+            flavor_name: Optional[str] = None,
+            target_evaluation_ids: Optional[List[UUID]] = None,
     ) -> TestRun:
         test_run = self.call_support.create_test_run(
-            project_id, testlist, include_outputs, name, description, flavor_name)
+            project_id, testlist, include_outputs, name, description, flavor_name, target_evaluation_ids)
         test_cases = [
-            CompletionTestCase(test_case_id=test_case.id,
-                     variables=test_case.variables,
-                     output=test_case.output,
-                     history=test_case.history,
-                     custom_metadata=test_case.custom_metadata)
+            CompletionTestCase(
+                test_case_id=test_case.id,
+                variables=test_case.variables,
+                output=test_case.output,
+                history=test_case.history,
+                custom_metadata=test_case.custom_metadata,
+                media_variables=test_case.media_variables,
+            )
             for test_case in test_run.test_cases
         ]
         trace_test_cases = [

{freeplay-0.4.0 → freeplay-0.5.0}/src/freeplay/support.py

@@ -1,11 +1,19 @@
-from dataclasses import dataclass, field, asdict
+from dataclasses import asdict, dataclass, field
 from json import JSONEncoder
-from typing import Optional, Dict, Any, List, Union, Literal
+from typing import Any, Dict, List, Literal, Optional, Union
+from uuid import UUID
 
 from freeplay import api_support
 from freeplay.api_support import try_decode
-from freeplay.errors import freeplay_response_error, FreeplayServerError
-from freeplay.model import InputVariables, FeedbackValue, NormalizedMessage, TestRunInfo
+from freeplay.errors import FreeplayServerError, freeplay_response_error
+from freeplay.model import (
+    FeedbackValue,
+    InputVariables,
+    MediaInputBase64,
+    MediaInputUrl,
+    NormalizedMessage,
+    TestRunInfo, MediaInputMap, MediaInput,
+)
 
 CustomMetadata = Optional[Dict[str, Union[str, int, float, bool]]]
 
@@ -28,7 +36,6 @@ class ToolSchema:
 
 Role = Literal['system', 'user', 'assistant']
 
-
 MediaType = Literal["image", "audio", "video", "file"]
 
 
@@ -49,6 +56,7 @@ class TemplateChatMessage:
 class HistoryTemplateMessage:
     kind: Literal["history"]
 
+
 TemplateMessage = Union[HistoryTemplateMessage, TemplateChatMessage]
 
 
@@ -87,6 +95,20 @@ class ProjectInfos:
     projects: List[ProjectInfo]
 
 
+def media_inputs_to_json(media_input: MediaInput) -> Dict[str, Any]:
+    if isinstance(media_input, MediaInputUrl):
+        return {
+            "type": media_input.type,
+            "url": media_input.url
+        }
+    else:
+        return {
+            "type": media_input.type,
+            "data": media_input.data,
+            "content_type": media_input.content_type
+        }
+
+
 class PromptTemplateEncoder(JSONEncoder):
     def default(self, prompt_template: PromptTemplate) -> Dict[str, Any]:
         return prompt_template.__dict__
@@ -100,6 +122,26 @@ class TestCaseTestRunResponse:
         self.history: Optional[List[Dict[str, Any]]] = test_case.get('history')
         self.custom_metadata: Optional[Dict[str, str]] = test_case.get('custom_metadata')
 
+        if test_case.get("media_variables", None):
+            self.media_variables: Optional[
+                Dict[str, Union[MediaInputBase64, MediaInputUrl]]
+            ] = {}
+            for name, media_data in test_case.get("media_variables", {}).items():
+                media_type = media_data.get("type", "base64")
+                if media_type == "url":
+                    self.media_variables[name] = MediaInputUrl(
+                        type="url",
+                        url=media_data["url"],
+                    )
+                else:
+                    self.media_variables[name] = MediaInputBase64(
+                        type="base64",
+                        data=media_data["data"],
+                        content_type=media_data["content_type"],
+                    )
+        else:
+            self.media_variables = None
+
 
 class TraceTestCaseTestRunResponse:
     def __init__(self, test_case: Dict[str, Any]):
@@ -149,12 +191,19 @@ class TestRunRetrievalResponse:
 
 
 class DatasetTestCaseRequest:
-    def __init__(self, history: Optional[List[NormalizedMessage]], inputs: InputVariables,
-                 metadata: Optional[Dict[str, str]], output: Optional[str]) -> None:
+    def __init__(
+            self,
+            history: Optional[List[NormalizedMessage]],
+            inputs: InputVariables,
+            metadata: Optional[Dict[str, str]],
+            output: Optional[str],
+            media_inputs: Optional[MediaInputMap] = None,
+    ) -> None:
         self.history: Optional[List[NormalizedMessage]] = history
         self.inputs: InputVariables = inputs
         self.metadata: Optional[Dict[str, str]] = metadata
         self.output: Optional[str] = output
+        self.media_inputs = media_inputs
 
 
 class DatasetTestCaseResponse:
@@ -298,7 +347,8 @@ class CallSupport:
             include_outputs: bool = False,
             name: Optional[str] = None,
             description: Optional[str] = None,
-            flavor_name: Optional[str] = None
+            flavor_name: Optional[str] = None,
+            target_evaluation_ids: Optional[List[UUID]] = None
     ) -> TestRunResponse:
         response = api_support.post_raw(
             api_key=self.freeplay_api_key,
@@ -308,7 +358,10 @@ class CallSupport:
                 'include_outputs': include_outputs,
                 'test_run_name': name,
                 'test_run_description': description,
-                'flavor_name': flavor_name
+                'flavor_name': flavor_name,
+                'target_evaluation_ids': [
+                    str(id) for id in target_evaluation_ids
+                ] if target_evaluation_ids is not None else None
             },
         )
 
@@ -376,13 +429,22 @@ class CallSupport:
         if response.status_code != 201:
             raise freeplay_response_error('Error while deleting session.', response)
 
-    def create_test_cases(self, project_id: str, dataset_id: str, test_cases: List[DatasetTestCaseRequest]) -> None:
+    def create_test_cases(
+            self,
+            project_id: str,
+            dataset_id: str,
+            test_cases: List[DatasetTestCaseRequest]
+    ) -> None:
         examples = [
             {
                 "history": test_case.history,
                 "output": test_case.output,
                 "metadata": test_case.metadata,
-                "inputs": test_case.inputs
+                "inputs": test_case.inputs,
+                "media_inputs": {
+                    name: media_inputs_to_json(media_input)
+                    for name, media_input in test_case.media_inputs.items()
+                } if test_case.media_inputs is not None else None
             } for test_case in test_cases]
         payload: Dict[str, Any] = {"examples": examples}
         url = f'{self.api_base}/v2/projects/{project_id}/datasets/id/{dataset_id}/test-cases'

{freeplay-0.4.0 → freeplay-0.5.0}/src/freeplay/utils.py

@@ -75,14 +75,55 @@ def get_user_agent() -> str:
 # Recursively convert Pydantic models, lists, and dicts to dict compatible format -- used to allow us to accept
 # provider message shapes (usually generated types) or the default {'content': ..., 'role': ...} shape.
 def convert_provider_message_to_dict(obj: Any) -> Any:
-    if hasattr(obj, 'model_dump'):
+    """
+    Convert provider message objects to dictionaries.
+    For Vertex AI objects, automatically converts to camelCase.
+    """
+    # List of possible raw attribute names in Vertex AI objects
+    vertex_raw_attrs = [
+        '_raw_content',      # For Content objects
+        '_raw_tool',         # For Tool objects  
+        '_raw_message',      # For message objects
+        '_raw_candidate',    # For Candidate objects
+        '_raw_response',     # For response objects
+        '_raw_function_declaration',  # For FunctionDeclaration
+        '_raw_generation_config',     # For GenerationConfig
+        '_pb',              # Generic protobuf attribute
+    ]
+    
+    # Check for Vertex AI objects with raw protobuf attributes
+    for attr_name in vertex_raw_attrs:
+        if hasattr(obj, attr_name):
+            raw_obj = getattr(obj, attr_name)
+            if raw_obj is not None:
+                try:
+                    # Use the metaclass to_dict with camelCase conversion
+                    return type(raw_obj).to_dict(
+                        raw_obj,
+                        preserving_proto_field_name=False,  # camelCase
+                        use_integers_for_enums=False,  # Keep as strings (we'll lowercase them)
+                        including_default_value_fields=False  # Exclude defaults
+                    )
+                except:  # noqa: E722
+                    # If we can't convert, continue to the next attribute
+                    pass
+    
+    # For non-Vertex AI objects, use their standard to_dict methods
+    if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
+        # Regular to_dict (for Vertex AI wrappers without _raw_* attributes)
+        return obj.to_dict()
+    elif hasattr(obj, 'model_dump'):
         # Pydantic v2
         return obj.model_dump(mode='json')
     elif hasattr(obj, 'dict'):
         # Pydantic v1
         return obj.dict(encode_json=True)
     elif isinstance(obj, dict):
+        # Handle dictionaries recursively
         return {k: convert_provider_message_to_dict(v) for k, v in obj.items()}
     elif isinstance(obj, list):
+        # Handle lists recursively
         return [convert_provider_message_to_dict(item) for item in obj]
+    
+    # Return as-is for primitive types
     return obj