arize-phoenix 10.0.4__py3-none-any.whl → 12.28.1__py3-none-any.whl

phoenix/server/api/helpers/playground_registry.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, Union
 
 from phoenix.server.api.types.GenerativeProvider import GenerativeProviderKey
 
@@ -59,7 +59,7 @@ PLAYGROUND_CLIENT_REGISTRY: PlaygroundClientRegistry = PlaygroundClientRegistry(
 
 def register_llm_client(
     provider_key: GenerativeProviderKey,
-    model_names: list[ModelName],
+    model_names: Sequence[ModelName],
 ) -> Callable[[type["PlaygroundStreamingClient"]], type["PlaygroundStreamingClient"]]:
     def decorator(cls: type["PlaygroundStreamingClient"]) -> type["PlaygroundStreamingClient"]:
         provider_registry = PLAYGROUND_CLIENT_REGISTRY._registry.setdefault(provider_key, {})

phoenix/server/api/helpers/playground_spans.py

@@ -222,6 +222,7 @@ def get_db_experiment_run(
     *,
     experiment_id: int,
     example_id: int,
+    repetition_number: int,
 ) -> models.ExperimentRun:
     return models.ExperimentRun(
         experiment_id=experiment_id,
@@ -230,7 +231,7 @@ def get_db_experiment_run(
         output=models.ExperimentRunOutput(
             task_output=get_dataset_example_output(db_span),
         ),
-        repetition_number=1,
+        repetition_number=repetition_number,
         start_time=db_span.start_time,
         end_time=db_span.end_time,
         error=db_span.status_message or None,
@@ -263,10 +264,13 @@ def llm_tools(tools: list[JSONScalarType]) -> Iterator[tuple[str, Any]]:
 def input_value_and_mime_type(
     input: Union[ChatCompletionInput, ChatCompletionOverDatasetInput],
 ) -> Iterator[tuple[str, Any]]:
-    assert (api_key := "api_key") in (input_data := jsonify(input))
-    disallowed_keys = {"api_key", "invocation_parameters"}
+    input_data = jsonify(input)
+    # Filter out sensitive credential information and invocation parameters
+    disallowed_keys = {"api_key", "credentials", "invocation_parameters"}
     input_data = {k: v for k, v in input_data.items() if k not in disallowed_keys}
-    assert api_key not in input_data
+    # Ensure sensitive data is not included in trace data
+    assert "api_key" not in input_data
+    assert "credentials" not in input_data
     yield INPUT_MIME_TYPE, JSON
     yield INPUT_VALUE, safe_json_dumps(input_data)
 

phoenix/server/api/helpers/playground_users.py

@@ -0,0 +1,26 @@
+from typing import (
+    Optional,
+)
+
+from starlette.requests import Request
+from strawberry import Info
+
+from phoenix.server.api.context import Context
+from phoenix.server.bearer_auth import PhoenixUser
+
+
+def get_user(info: Info[Context, None]) -> Optional[int]:
+    user_id: Optional[int] = None
+    try:
+        assert isinstance(request := info.context.request, Request)
+
+        if "user" in request.scope and isinstance((user := info.context.user), PhoenixUser):
+            user_id = int(user.identity)
+    except AssertionError:
+        # Request is not available, try to obtain user identify
+        # this will also throw an assertion error if auth is not available
+        # the finally block will continue execution returning None
+        if info.context.user.is_authenticated:
+            user_id = int(info.context.user.identity)
+    finally:
+        return user_id

phoenix/server/api/helpers/prompts/conversions/aws.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Union
+
+from typing_extensions import assert_never
+
+if TYPE_CHECKING:
+    from anthropic.types import (
+        ToolChoiceAnyParam,
+        ToolChoiceAutoParam,
+        ToolChoiceParam,
+        ToolChoiceToolParam,
+    )
+
+    from phoenix.server.api.helpers.prompts.models import (
+        PromptToolChoiceNone,
+        PromptToolChoiceOneOrMore,
+        PromptToolChoiceSpecificFunctionTool,
+        PromptToolChoiceZeroOrMore,
+    )
+
+
+class AwsToolChoiceConversion:
+    @staticmethod
+    def to_aws(
+        obj: Union[
+            PromptToolChoiceNone,
+            PromptToolChoiceZeroOrMore,
+            PromptToolChoiceOneOrMore,
+            PromptToolChoiceSpecificFunctionTool,
+        ],
+        disable_parallel_tool_use: Optional[bool] = None,
+    ) -> ToolChoiceParam:
+        if obj.type == "zero_or_more":
+            choice_auto: ToolChoiceAutoParam = {"type": "auto"}
+            if disable_parallel_tool_use is not None:
+                choice_auto["disable_parallel_tool_use"] = disable_parallel_tool_use
+            return choice_auto
+        if obj.type == "one_or_more":
+            choice_any: ToolChoiceAnyParam = {"type": "any"}
+            if disable_parallel_tool_use is not None:
+                choice_any["disable_parallel_tool_use"] = disable_parallel_tool_use
+            return choice_any
+        if obj.type == "specific_function":
+            choice_tool: ToolChoiceToolParam = {"type": "tool", "name": obj.function_name}
+            if disable_parallel_tool_use is not None:
+                choice_tool["disable_parallel_tool_use"] = disable_parallel_tool_use
+            return choice_tool
+        if obj.type == "none":
+            return {"type": "none"}
+        assert_never(obj.type)
+
+    @staticmethod
+    def from_aws(
+        obj: ToolChoiceParam,
+    ) -> Union[
+        PromptToolChoiceNone,
+        PromptToolChoiceZeroOrMore,
+        PromptToolChoiceOneOrMore,
+        PromptToolChoiceSpecificFunctionTool,
+    ]:
+        from phoenix.server.api.helpers.prompts.models import (
+            PromptToolChoiceNone,
+            PromptToolChoiceOneOrMore,
+            PromptToolChoiceSpecificFunctionTool,
+            PromptToolChoiceZeroOrMore,
+        )
+
+        if obj["type"] == "auto":
+            choice_zero_or_more = PromptToolChoiceZeroOrMore(type="zero_or_more")
+            return choice_zero_or_more
+        if obj["type"] == "any":
+            choice_one_or_more = PromptToolChoiceOneOrMore(type="one_or_more")
+            return choice_one_or_more
+        if obj["type"] == "tool":
+            choice_function_tool = PromptToolChoiceSpecificFunctionTool(
+                type="specific_function",
+                function_name=obj["name"],
+            )
+            return choice_function_tool
+        if obj["type"] == "none":
+            return PromptToolChoiceNone(type="none")
+        assert_never(obj)

phoenix/server/api/helpers/prompts/conversions/google.py

@@ -0,0 +1,103 @@
+from typing import TYPE_CHECKING, Any, Literal, Union
+
+from typing_extensions import NotRequired, TypedDict, assert_never
+
+if TYPE_CHECKING:
+    from phoenix.server.api.helpers.prompts.models import (
+        PromptToolChoiceNone,
+        PromptToolChoiceOneOrMore,
+        PromptToolChoiceSpecificFunctionTool,
+        PromptToolChoiceZeroOrMore,
+    )
+
+
+class GoogleFunctionCallingConfig(TypedDict, total=False):
+    """
+    Based on https://github.com/googleapis/python-genai/blob/97cc7e4eafbee4fa4035e7420170ab6a2c9da7fb/google/genai/types.py#L4245
+    """
+
+    mode: NotRequired[Literal["auto", "any", "none"]]
+    allowed_function_names: NotRequired[list[str]]
+
+
+class GoogleToolChoice(TypedDict):
+    """
+    Based on https://github.com/googleapis/python-genai/blob/97cc7e4eafbee4fa4035e7420170ab6a2c9da7fb/google/genai/types.py#L4341
+    """
+
+    function_calling_config: GoogleFunctionCallingConfig
+
+
+class GoogleToolChoiceConversion:
+    @staticmethod
+    def to_google(
+        obj: Union[
+            "PromptToolChoiceNone",
+            "PromptToolChoiceZeroOrMore",
+            "PromptToolChoiceOneOrMore",
+            "PromptToolChoiceSpecificFunctionTool",
+        ],
+    ) -> GoogleToolChoice:
+        if obj.type == "none":
+            return {"function_calling_config": {"mode": "none"}}
+        if obj.type == "zero_or_more":
+            return {"function_calling_config": {"mode": "auto"}}
+        if obj.type == "one_or_more":
+            return {"function_calling_config": {"mode": "any"}}
+        if obj.type == "specific_function":
+            return {
+                "function_calling_config": {
+                    "mode": "any",
+                    "allowed_function_names": [obj.function_name],
+                }
+            }
+        assert_never(obj)
+
+    @staticmethod
+    def from_google(
+        obj: Any,
+    ) -> Union[
+        "PromptToolChoiceNone",
+        "PromptToolChoiceZeroOrMore",
+        "PromptToolChoiceOneOrMore",
+        "PromptToolChoiceSpecificFunctionTool",
+    ]:
+        from google.genai.types import ToolConfig
+
+        from phoenix.server.api.helpers.prompts.models import (
+            PromptToolChoiceNone,
+            PromptToolChoiceOneOrMore,
+            PromptToolChoiceSpecificFunctionTool,
+            PromptToolChoiceZeroOrMore,
+        )
+
+        tool_config = ToolConfig.model_validate(obj)
+        if (function_calling_config := tool_config.function_calling_config) is None:
+            raise ValueError("function_calling_config is required")
+        # normalize mode to lowercase since Google's API is case-insensitive
+        # https://github.com/googleapis/python-genai/blob/97cc7e4eafbee4fa4035e7420170ab6a2c9da7fb/google/genai/types.py#L645
+        normalized_mode = (
+            function_calling_config.mode.value.lower()
+            if function_calling_config.mode is not None
+            else None
+        )
+        allowed_function_names = function_calling_config.allowed_function_names
+
+        if allowed_function_names:
+            if len(allowed_function_names) != 1:
+                raise ValueError("Only one allowed function name is currently supported")
+            if normalized_mode != "any":
+                raise ValueError("allowed function names only supported in 'any' mode")
+            return PromptToolChoiceSpecificFunctionTool(
+                type="specific_function",
+                function_name=allowed_function_names[0],
+            )
+
+        if normalized_mode == "none":
+            return PromptToolChoiceNone(type="none")
+        if normalized_mode == "auto" or normalized_mode is None:
+            return PromptToolChoiceZeroOrMore(type="zero_or_more")
+        if normalized_mode == "any":
+            return PromptToolChoiceOneOrMore(type="one_or_more")
+
+        raise ValueError(f"Unsupported Google tool choice mode: {normalized_mode}")

phoenix/server/api/helpers/prompts/models.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from enum import Enum
 from typing import Any, Literal, Mapping, Optional, Union
 
@@ -9,6 +7,8 @@ from typing_extensions import Annotated, Self, TypeAlias, TypeGuard, assert_neve
 from phoenix.db.types.db_models import UNDEFINED, DBBaseModel
 from phoenix.db.types.model_provider import ModelProvider
 from phoenix.server.api.helpers.prompts.conversions.anthropic import AnthropicToolChoiceConversion
+from phoenix.server.api.helpers.prompts.conversions.aws import AwsToolChoiceConversion
+from phoenix.server.api.helpers.prompts.conversions.google import GoogleToolChoiceConversion
 from phoenix.server.api.helpers.prompts.conversions.openai import OpenAIToolChoiceConversion
 
 JSONSerializable = Union[None, bool, int, float, str, dict[str, Any], list[Any]]
@@ -126,11 +126,6 @@ class PromptTemplateRootModel(RootModel[PromptTemplate]):
     root: PromptTemplate
 
 
-class PromptToolFunction(DBBaseModel):
-    type: Literal["function"]
-    function: PromptToolFunctionDefinition
-
-
 class PromptToolFunctionDefinition(DBBaseModel):
     name: str
     description: str = UNDEFINED
@@ -138,14 +133,12 @@ class PromptToolFunctionDefinition(DBBaseModel):
     strict: bool = UNDEFINED
 
 
-PromptTool: TypeAlias = Annotated[Union[PromptToolFunction], Field(..., discriminator="type")]
+class PromptToolFunction(DBBaseModel):
+    type: Literal["function"]
+    function: PromptToolFunctionDefinition
 
 
-class PromptTools(DBBaseModel):
-    type: Literal["tools"]
-    tools: Annotated[list[PromptTool], Field(..., min_length=1)]
-    tool_choice: PromptToolChoice = UNDEFINED
-    disable_parallel_tool_calls: bool = UNDEFINED
+PromptTool: TypeAlias = Annotated[Union[PromptToolFunction], Field(..., discriminator="type")]
 
 
 class PromptToolChoiceNone(DBBaseModel):
@@ -176,6 +169,13 @@ PromptToolChoice: TypeAlias = Annotated[
 ]
 
 
+class PromptTools(DBBaseModel):
+    type: Literal["tools"]
+    tools: Annotated[list[PromptTool], Field(..., min_length=1)]
+    tool_choice: PromptToolChoice = UNDEFINED
+    disable_parallel_tool_calls: bool = UNDEFINED
+
+
 class PromptOpenAIJSONSchema(DBBaseModel):
     """
     Based on https://github.com/openai/openai-python/blob/d16e6edde5a155626910b5758a0b939bfedb9ced/src/openai/types/shared/response_format_json_schema.py#L13
@@ -199,11 +199,6 @@ class PromptOpenAIResponseFormatJSONSchema(DBBaseModel):
     type: Literal["json_schema"]
 
 
-class PromptResponseFormatJSONSchema(DBBaseModel):
-    type: Literal["json_schema"]
-    json_schema: PromptResponseFormatJSONSchemaDefinition
-
-
 class PromptResponseFormatJSONSchemaDefinition(DBBaseModel):
     name: str
     description: str = UNDEFINED
@@ -211,6 +206,11 @@ class PromptResponseFormatJSONSchemaDefinition(DBBaseModel):
     strict: bool = UNDEFINED
 
 
+class PromptResponseFormatJSONSchema(DBBaseModel):
+    type: Literal["json_schema"]
+    json_schema: PromptResponseFormatJSONSchemaDefinition
+
+
 PromptResponseFormat: TypeAlias = Annotated[
     Union[PromptResponseFormatJSONSchema], Field(..., discriminator="type")
 ]
@@ -312,6 +312,24 @@ class AnthropicToolDefinition(DBBaseModel):
     description: str = UNDEFINED
 
 
+class BedrockToolDefinition(DBBaseModel):
+    """
+    Based on https://github.com/aws/amazon-bedrock-sdk-python/blob/main/src/bedrock/types/tool_param.py#L12
+    """
+
+    toolSpec: dict[str, Any]
+
+
+class GeminiToolDefinition(DBBaseModel):
+    """
+    Based on https://github.com/googleapis/python-genai/blob/c0b175a0ca20286db419390031a2239938d0c0b7/google/genai/types.py#L2792
+    """
+
+    name: str
+    description: str = UNDEFINED
+    parameters: dict[str, Any]
+
+
 class PromptOpenAIInvocationParametersContent(DBBaseModel):
     temperature: float = UNDEFINED
     max_tokens: int = UNDEFINED
@@ -320,7 +338,7 @@ class PromptOpenAIInvocationParametersContent(DBBaseModel):
     presence_penalty: float = UNDEFINED
     top_p: float = UNDEFINED
     seed: int = UNDEFINED
-    reasoning_effort: Literal["low", "medium", "high"] = UNDEFINED
+    reasoning_effort: Literal["none", "minimal", "low", "medium", "high", "xhigh"] = UNDEFINED
 
 
 class PromptOpenAIInvocationParameters(DBBaseModel):
@@ -332,11 +350,38 @@ class PromptAzureOpenAIInvocationParametersContent(PromptOpenAIInvocationParamet
     pass
 
 
+class PromptDeepSeekInvocationParametersContent(PromptOpenAIInvocationParametersContent):
+    pass
+
+
+class PromptXAIInvocationParametersContent(PromptOpenAIInvocationParametersContent):
+    pass
+
+
+class PromptOllamaInvocationParametersContent(PromptOpenAIInvocationParametersContent):
+    pass
+
+
 class PromptAzureOpenAIInvocationParameters(DBBaseModel):
     type: Literal["azure_openai"]
     azure_openai: PromptAzureOpenAIInvocationParametersContent
 
 
+class PromptDeepSeekInvocationParameters(DBBaseModel):
+    type: Literal["deepseek"]
+    deepseek: PromptDeepSeekInvocationParametersContent
+
+
+class PromptXAIInvocationParameters(DBBaseModel):
+    type: Literal["xai"]
+    xai: PromptXAIInvocationParametersContent
+
+
+class PromptOllamaInvocationParameters(DBBaseModel):
+    type: Literal["ollama"]
+    ollama: PromptOllamaInvocationParametersContent
+
+
 class PromptAnthropicThinkingConfigDisabled(DBBaseModel):
     type: Literal["disabled"]
 
@@ -370,6 +415,17 @@ class PromptAnthropicInvocationParameters(DBBaseModel):
     anthropic: PromptAnthropicInvocationParametersContent
 
 
+class PromptAwsInvocationParametersContent(DBBaseModel):
+    max_tokens: int = UNDEFINED
+    temperature: float = UNDEFINED
+    top_p: float = UNDEFINED
+
+
+class PromptAwsInvocationParameters(DBBaseModel):
+    type: Literal["aws"]
+    aws: PromptAwsInvocationParametersContent
+
+
 class PromptGoogleInvocationParametersContent(DBBaseModel):
     temperature: float = UNDEFINED
     max_output_tokens: int = UNDEFINED
@@ -391,6 +447,10 @@ PromptInvocationParameters: TypeAlias = Annotated[
         PromptAzureOpenAIInvocationParameters,
         PromptAnthropicInvocationParameters,
         PromptGoogleInvocationParameters,
+        PromptDeepSeekInvocationParameters,
+        PromptXAIInvocationParameters,
+        PromptOllamaInvocationParameters,
+        PromptAwsInvocationParameters,
     ],
     Field(..., discriminator="type"),
 ]
@@ -407,6 +467,14 @@ def get_raw_invocation_parameters(
         return invocation_parameters.anthropic.model_dump()
     if isinstance(invocation_parameters, PromptGoogleInvocationParameters):
         return invocation_parameters.google.model_dump()
+    if isinstance(invocation_parameters, PromptDeepSeekInvocationParameters):
+        return invocation_parameters.deepseek.model_dump()
+    if isinstance(invocation_parameters, PromptXAIInvocationParameters):
+        return invocation_parameters.xai.model_dump()
+    if isinstance(invocation_parameters, PromptOllamaInvocationParameters):
+        return invocation_parameters.ollama.model_dump()
+    if isinstance(invocation_parameters, PromptAwsInvocationParameters):
+        return invocation_parameters.aws.model_dump()
     assert_never(invocation_parameters)
 
 
@@ -420,6 +488,10 @@ def is_prompt_invocation_parameters(
             PromptAzureOpenAIInvocationParameters,
             PromptAnthropicInvocationParameters,
             PromptGoogleInvocationParameters,
+            PromptDeepSeekInvocationParameters,
+            PromptXAIInvocationParameters,
+            PromptOllamaInvocationParameters,
+            PromptAwsInvocationParameters,
         ),
     )
 
@@ -444,6 +516,13 @@ def validate_invocation_parameters(
                 invocation_parameters
             ),
         )
+    elif model_provider is ModelProvider.DEEPSEEK:
+        return PromptDeepSeekInvocationParameters(
+            type="deepseek",
+            deepseek=PromptDeepSeekInvocationParametersContent.model_validate(
+                invocation_parameters
+            ),
+        )
     elif model_provider is ModelProvider.ANTHROPIC:
         return PromptAnthropicInvocationParameters(
             type="anthropic",
@@ -456,6 +535,21 @@ def validate_invocation_parameters(
             type="google",
             google=PromptGoogleInvocationParametersContent.model_validate(invocation_parameters),
         )
+    elif model_provider is ModelProvider.XAI:
+        return PromptXAIInvocationParameters(
+            type="xai",
+            xai=PromptXAIInvocationParametersContent.model_validate(invocation_parameters),
+        )
+    elif model_provider is ModelProvider.OLLAMA:
+        return PromptOllamaInvocationParameters(
+            type="ollama",
+            ollama=PromptOllamaInvocationParametersContent.model_validate(invocation_parameters),
+        )
+    elif model_provider is ModelProvider.AWS:
+        return PromptAwsInvocationParameters(
+            type="aws",
+            aws=PromptAwsInvocationParametersContent.model_validate(invocation_parameters),
+        )
     assert_never(model_provider)
 
 
@@ -465,18 +559,39 @@ def normalize_tools(
     tool_choice: Optional[Union[str, Mapping[str, Any]]] = None,
 ) -> PromptTools:
     tools: list[PromptToolFunction]
-    if model_provider is ModelProvider.OPENAI or model_provider is ModelProvider.AZURE_OPENAI:
+    if (
+        model_provider is ModelProvider.OPENAI
+        or model_provider is ModelProvider.AZURE_OPENAI
+        or model_provider is ModelProvider.DEEPSEEK
+        or model_provider is ModelProvider.XAI
+        or model_provider is ModelProvider.OLLAMA
+    ):
         openai_tools = [OpenAIToolDefinition.model_validate(schema) for schema in schemas]
         tools = [_openai_to_prompt_tool(openai_tool) for openai_tool in openai_tools]
+    elif model_provider is ModelProvider.AWS:
+        bedrock_tools = [BedrockToolDefinition.model_validate(schema) for schema in schemas]
+        tools = [_bedrock_to_prompt_tool(bedrock_tool) for bedrock_tool in bedrock_tools]
     elif model_provider is ModelProvider.ANTHROPIC:
         anthropic_tools = [AnthropicToolDefinition.model_validate(schema) for schema in schemas]
         tools = [_anthropic_to_prompt_tool(anthropic_tool) for anthropic_tool in anthropic_tools]
+    elif model_provider is ModelProvider.GOOGLE:
+        gemini_tools = [GeminiToolDefinition.model_validate(schema) for schema in schemas]
+        tools = [_gemini_to_prompt_tool(gemini_tool) for gemini_tool in gemini_tools]
     else:
         raise ValueError(f"Unsupported model provider: {model_provider}")
     ans = PromptTools(type="tools", tools=tools)
+
     if tool_choice is not None:
-        if model_provider is ModelProvider.OPENAI or model_provider is ModelProvider.AZURE_OPENAI:
+        if (
+            model_provider is ModelProvider.OPENAI
+            or model_provider is ModelProvider.AZURE_OPENAI
+            or model_provider is ModelProvider.DEEPSEEK
+            or model_provider is ModelProvider.XAI
+            or model_provider is ModelProvider.OLLAMA
+        ):
             ans.tool_choice = OpenAIToolChoiceConversion.from_openai(tool_choice)  # type: ignore[arg-type]
+        elif model_provider is ModelProvider.AWS:
+            ans.tool_choice = AwsToolChoiceConversion.from_aws(tool_choice)  # type: ignore[arg-type]
         elif model_provider is ModelProvider.ANTHROPIC:
             choice, disable_parallel_tool_calls = AnthropicToolChoiceConversion.from_anthropic(
                 tool_choice  # type: ignore[arg-type]
@@ -484,6 +599,8 @@ def normalize_tools(
             ans.tool_choice = choice
             if disable_parallel_tool_calls is not None:
                 ans.disable_parallel_tool_calls = disable_parallel_tool_calls
+        elif model_provider is ModelProvider.GOOGLE:
+            ans.tool_choice = GoogleToolChoiceConversion.from_google(tool_choice)
     return ans
 
 
@@ -493,14 +610,28 @@ def denormalize_tools(
     assert tools.type == "tools"
     denormalized_tools: list[DBBaseModel]
     tool_choice: Optional[Any] = None
-    if model_provider is ModelProvider.OPENAI or model_provider is ModelProvider.AZURE_OPENAI:
+    if (
+        model_provider is ModelProvider.OPENAI
+        or model_provider is ModelProvider.AZURE_OPENAI
+        or model_provider is ModelProvider.DEEPSEEK
+        or model_provider is ModelProvider.XAI
+        or model_provider is ModelProvider.OLLAMA
+    ):
         denormalized_tools = [_prompt_to_openai_tool(tool) for tool in tools.tools]
         if tools.tool_choice:
             tool_choice = OpenAIToolChoiceConversion.to_openai(tools.tool_choice)
+    elif model_provider is ModelProvider.AWS:
+        denormalized_tools = [_prompt_to_bedrock_tool(tool) for tool in tools.tools]
+        if tools.tool_choice:
+            tool_choice = OpenAIToolChoiceConversion.to_openai(tools.tool_choice)
     elif model_provider is ModelProvider.ANTHROPIC:
         denormalized_tools = [_prompt_to_anthropic_tool(tool) for tool in tools.tools]
         if tools.tool_choice and tools.tool_choice.type != "none":
             tool_choice = AnthropicToolChoiceConversion.to_anthropic(tools.tool_choice)
+    elif model_provider is ModelProvider.GOOGLE:
+        denormalized_tools = [_prompt_to_gemini_tool(tool) for tool in tools.tools]
+        if tools.tool_choice:
+            tool_choice = GoogleToolChoiceConversion.to_google(tools.tool_choice)
     else:
         raise ValueError(f"Unsupported model provider: {model_provider}")
     return [tool.model_dump() for tool in denormalized_tools], tool_choice
@@ -540,6 +671,19 @@ def _prompt_to_openai_tool(
     )
 
 
+def _bedrock_to_prompt_tool(
+    tool: BedrockToolDefinition,
+) -> PromptToolFunction:
+    return PromptToolFunction(
+        type="function",
+        function=PromptToolFunctionDefinition(
+            name=tool.toolSpec["name"],
+            description=tool.toolSpec["description"],
+            parameters=tool.toolSpec["inputSchema"]["json"],
+        ),
+    )
+
+
 def _anthropic_to_prompt_tool(
     tool: AnthropicToolDefinition,
 ) -> PromptToolFunction:
@@ -562,3 +706,42 @@ def _prompt_to_anthropic_tool(
         name=function.name,
         description=function.description,
     )
+
+
+def _prompt_to_bedrock_tool(
+    tool: PromptToolFunction,
+) -> BedrockToolDefinition:
+    function = tool.function
+    return BedrockToolDefinition(
+        toolSpec={
+            "name": function.name,
+            "description": function.description,
+            "inputSchema": {
+                "json": function.parameters,
+            },
+        }
+    )
+
+
+def _gemini_to_prompt_tool(
+    tool: GeminiToolDefinition,
+) -> PromptToolFunction:
+    return PromptToolFunction(
+        type="function",
+        function=PromptToolFunctionDefinition(
+            name=tool.name,
+            description=tool.description,
+            parameters=tool.parameters,
+        ),
+    )
+
+
+def _prompt_to_gemini_tool(
+    tool: PromptToolFunction,
+) -> GeminiToolDefinition:
+    function = tool.function
+    return GeminiToolDefinition(
+        name=function.name,
+        description=function.description,
+        parameters=function.parameters,
+    )