arize-phoenix 10.13.2__py3-none-any.whl → 10.15.0__py3-none-any.whl

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/models.py

@@ -9,6 +9,7 @@ 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.openai import OpenAIToolChoiceConversion
 
 JSONSerializable = Union[None, bool, int, float, str, dict[str, Any], list[Any]]
@@ -312,6 +313,14 @@ 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 PromptOpenAIInvocationParametersContent(DBBaseModel):
     temperature: float = UNDEFINED
     max_tokens: int = UNDEFINED
@@ -397,6 +406,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
@@ -421,6 +441,7 @@ PromptInvocationParameters: TypeAlias = Annotated[
         PromptDeepSeekInvocationParameters,
         PromptXAIInvocationParameters,
         PromptOllamaInvocationParameters,
+        PromptAwsInvocationParameters,
     ],
     Field(..., discriminator="type"),
 ]
@@ -443,6 +464,8 @@ def get_raw_invocation_parameters(
         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)
 
 
@@ -459,6 +482,7 @@ def is_prompt_invocation_parameters(
             PromptDeepSeekInvocationParameters,
             PromptXAIInvocationParameters,
             PromptOllamaInvocationParameters,
+            PromptAwsInvocationParameters,
         ),
     )
 
@@ -512,6 +536,11 @@ def validate_invocation_parameters(
             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)
 
 
@@ -530,12 +559,16 @@ def normalize_tools(
     ):
         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]
     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
@@ -545,6 +578,8 @@ def normalize_tools(
             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]
@@ -571,6 +606,10 @@ def denormalize_tools(
         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":
@@ -614,6 +653,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:
@@ -636,3 +688,18 @@ 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,
+            },
+        }
+    )

phoenix/server/api/input_types/GenerativeModelInput.py

@@ -17,3 +17,5 @@ class GenerativeModelInput:
     """ The endpoint to use for the model. Only required for Azure OpenAI models. """
     api_version: Optional[str] = UNSET
     """ The API version to use for the model. """
+    region: Optional[str] = UNSET
+    """ The region to use for the model. """

phoenix/server/api/types/GenerativeProvider.py

@@ -17,6 +17,7 @@ class GenerativeProviderKey(Enum):
     DEEPSEEK = "DeepSeek"
     XAI = "xAI"
     OLLAMA = "Ollama"
+    AWS = "AWS Bedrock"
 
 
 @strawberry.type
@@ -38,6 +39,7 @@ class GenerativeProvider:
         GenerativeProviderKey.DEEPSEEK: ["deepseek"],
         GenerativeProviderKey.XAI: ["grok"],
         GenerativeProviderKey.OLLAMA: ["llama", "mistral", "codellama", "phi", "qwen", "gemma"],
+        GenerativeProviderKey.AWS: ["nova", "titan"],
     }
 
     attribute_provider_to_generative_provider_map: ClassVar[dict[str, GenerativeProviderKey]] = {
@@ -45,6 +47,7 @@ class GenerativeProvider:
         OpenInferenceLLMProviderValues.ANTHROPIC.value: GenerativeProviderKey.ANTHROPIC,
         OpenInferenceLLMProviderValues.AZURE.value: GenerativeProviderKey.AZURE_OPENAI,
         OpenInferenceLLMProviderValues.GOOGLE.value: GenerativeProviderKey.GOOGLE,
+        OpenInferenceLLMProviderValues.AWS.value: GenerativeProviderKey.AWS,
         # Note: DeepSeek uses OpenAI compatibility but we can't duplicate the key in the dict
         # The provider will be determined through model name prefix matching instead
         # Note: xAI uses OpenAI compatibility but we can't duplicate the key in the dict
@@ -58,26 +61,36 @@ class GenerativeProvider:
     E.x. OpenAI requires a single API key
     """
     model_provider_to_credential_requirements_map: ClassVar[
-        dict[GenerativeProviderKey, GenerativeProviderCredentialConfig]
+        dict[GenerativeProviderKey, list[GenerativeProviderCredentialConfig]]
     ] = {
-        GenerativeProviderKey.AZURE_OPENAI: GenerativeProviderCredentialConfig(
-            env_var_name="AZURE_OPENAI_API_KEY", is_required=True
-        ),
-        GenerativeProviderKey.ANTHROPIC: GenerativeProviderCredentialConfig(
-            env_var_name="ANTHROPIC_API_KEY", is_required=True
-        ),
-        GenerativeProviderKey.OPENAI: GenerativeProviderCredentialConfig(
-            env_var_name="OPENAI_API_KEY", is_required=True
-        ),
-        GenerativeProviderKey.GOOGLE: GenerativeProviderCredentialConfig(
-            env_var_name="GEMINI_API_KEY", is_required=True
-        ),
-        GenerativeProviderKey.DEEPSEEK: GenerativeProviderCredentialConfig(
-            env_var_name="DEEPSEEK_API_KEY", is_required=True
-        ),
-        GenerativeProviderKey.XAI: GenerativeProviderCredentialConfig(
-            env_var_name="XAI_API_KEY", is_required=True
-        ),
+        GenerativeProviderKey.AZURE_OPENAI: [
+            GenerativeProviderCredentialConfig(
+                env_var_name="AZURE_OPENAI_API_KEY", is_required=True
+            )
+        ],
+        GenerativeProviderKey.ANTHROPIC: [
+            GenerativeProviderCredentialConfig(env_var_name="ANTHROPIC_API_KEY", is_required=True)
+        ],
+        GenerativeProviderKey.OPENAI: [
+            GenerativeProviderCredentialConfig(env_var_name="OPENAI_API_KEY", is_required=True)
+        ],
+        GenerativeProviderKey.GOOGLE: [
+            GenerativeProviderCredentialConfig(env_var_name="GEMINI_API_KEY", is_required=True)
+        ],
+        GenerativeProviderKey.DEEPSEEK: [
+            GenerativeProviderCredentialConfig(env_var_name="DEEPSEEK_API_KEY", is_required=True)
+        ],
+        GenerativeProviderKey.XAI: [
+            GenerativeProviderCredentialConfig(env_var_name="XAI_API_KEY", is_required=True)
+        ],
+        GenerativeProviderKey.OLLAMA: [],
+        GenerativeProviderKey.AWS: [
+            GenerativeProviderCredentialConfig(env_var_name="AWS_ACCESS_KEY_ID", is_required=True),
+            GenerativeProviderCredentialConfig(
+                env_var_name="AWS_SECRET_ACCESS_KEY", is_required=True
+            ),
+            GenerativeProviderCredentialConfig(env_var_name="AWS_SESSION_TOKEN", is_required=False),
+        ],
     }
 
     @strawberry.field
@@ -110,7 +123,7 @@ class GenerativeProvider:
         credential_requirements = self.model_provider_to_credential_requirements_map.get(self.key)
         if credential_requirements is None:
             return []
-        return [credential_requirements]
+        return self.model_provider_to_credential_requirements_map[self.key]
 
     @strawberry.field(description="Whether the credentials are set on the server for the provider")  # type: ignore
     async def credentials_set(self) -> bool:

phoenix/server/email/sender.py

@@ -3,7 +3,6 @@ import ssl
 from email.message import EmailMessage
 from pathlib import Path
 from typing import Literal
-from urllib.parse import urljoin
 
 from anyio import to_thread
 from jinja2 import Environment, FileSystemLoader, select_autoescape
@@ -49,9 +48,10 @@ class SimpleEmailSender:
         template_name = "welcome.html"
 
         template = self.env.get_template(template_name)
+
         html_content = template.render(
             name=name,
-            welcome_url=urljoin(str(get_env_root_url()), "forgot-password"),
+            welcome_url=str(get_env_root_url()),
         )
 
         msg = EmailMessage()

phoenix/server/main.py

@@ -91,13 +91,13 @@ _WELCOME_MESSAGE = Environment(loader=BaseLoader()).from_string("""
 ██║     ██║  ██║╚██████╔╝███████╗██║ ╚████║██║██╔╝ ██╗
 ╚═╝     ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═╝ v{{ version }}
 
+|  ⭐️⭐️⭐️ Support Open Source ⭐️⭐️⭐️
+|  ⭐️⭐️⭐️ Star on GitHub! ⭐️⭐️⭐️
+|  https://github.com/Arize-ai/phoenix
 |
 |  🌎 Join our Community 🌎
 |  https://arize-ai.slack.com/join/shared_invite/zt-2w57bhem8-hq24MB6u7yE_ZF_ilOYSBw#/shared-invite/email
 |
-|  ⭐️ Leave us a Star ⭐️
-|  https://github.com/Arize-ai/phoenix
-|
 |  📚 Documentation 📚
 |  https://arize.com/docs/phoenix
 |
@@ -387,12 +387,15 @@ def main() -> None:
     # Print information about the server
     http_scheme = "https" if tls_enabled_for_http else "http"
     grpc_scheme = "https" if tls_enabled_for_grpc else "http"
+    # Use localhost for display when host is the loopback address to make URLs clickable
+    display_host = "localhost" if host in ("0.0.0.0", "::") else host
     root_path = urljoin(f"{http_scheme}://{host}:{port}", host_root_path)
+    display_root_path = urljoin(f"{http_scheme}://{display_host}:{port}", host_root_path)
     msg = _WELCOME_MESSAGE.render(
         version=phoenix_version,
-        ui_path=root_path,
-        grpc_path=f"{grpc_scheme}://{host}:{get_env_grpc_port()}",
-        http_path=urljoin(root_path, "v1/traces"),
+        ui_path=display_root_path,
+        grpc_path=f"{grpc_scheme}://{display_host}:{get_env_grpc_port()}",
+        http_path=urljoin(display_root_path, "v1/traces"),
         storage=get_printable_db_url(db_connection_str),
         schema=get_env_database_schema(),
         auth_enabled=auth_settings.enable_auth,

phoenix/server/static/.vite/manifest.json

@@ -1,28 +1,28 @@
 {
-  "_components-D-yJsfVa.js": {
-    "file": "assets/components-D-yJsfVa.js",
+  "_components-SpUMF1qV.js": {
+    "file": "assets/components-SpUMF1qV.js",
     "name": "components",
     "imports": [
-      "_vendor-BKYy4SMr.js",
-      "_pages-Dn4XFHMU.js",
-      "_vendor-arizeai-CaqmrQdQ.js",
-      "_vendor-codemirror-BlmFw5CA.js",
+      "_vendor-DCZoBorz.js",
+      "_pages-YX47cEoQ.js",
+      "_vendor-arizeai-Ckci3irT.js",
+      "_vendor-codemirror-BODM513D.js",
       "_vendor-three-C5WAXd5r.js"
     ]
   },
-  "_pages-Dn4XFHMU.js": {
-    "file": "assets/pages-Dn4XFHMU.js",
+  "_pages-YX47cEoQ.js": {
+    "file": "assets/pages-YX47cEoQ.js",
     "name": "pages",
     "imports": [
-      "_vendor-BKYy4SMr.js",
-      "_vendor-arizeai-CaqmrQdQ.js",
-      "_components-D-yJsfVa.js",
-      "_vendor-codemirror-BlmFw5CA.js",
-      "_vendor-recharts-Bz7zqjbW.js"
+      "_vendor-DCZoBorz.js",
+      "_vendor-arizeai-Ckci3irT.js",
+      "_components-SpUMF1qV.js",
+      "_vendor-codemirror-BODM513D.js",
+      "_vendor-recharts-C9O2a-N3.js"
     ]
   },
-  "_vendor-BKYy4SMr.js": {
-    "file": "assets/vendor-BKYy4SMr.js",
+  "_vendor-DCZoBorz.js": {
+    "file": "assets/vendor-DCZoBorz.js",
     "name": "vendor",
     "imports": [
       "_vendor-three-C5WAXd5r.js"
@@ -35,33 +35,33 @@
     "file": "assets/vendor-WIZid84E.css",
     "src": "_vendor-WIZid84E.css"
   },
-  "_vendor-arizeai-CaqmrQdQ.js": {
-    "file": "assets/vendor-arizeai-CaqmrQdQ.js",
+  "_vendor-arizeai-Ckci3irT.js": {
+    "file": "assets/vendor-arizeai-Ckci3irT.js",
     "name": "vendor-arizeai",
     "imports": [
-      "_vendor-BKYy4SMr.js"
+      "_vendor-DCZoBorz.js"
     ]
   },
-  "_vendor-codemirror-BlmFw5CA.js": {
-    "file": "assets/vendor-codemirror-BlmFw5CA.js",
+  "_vendor-codemirror-BODM513D.js": {
+    "file": "assets/vendor-codemirror-BODM513D.js",
     "name": "vendor-codemirror",
     "imports": [
-      "_vendor-BKYy4SMr.js",
-      "_vendor-shiki-BitvudxD.js"
+      "_vendor-DCZoBorz.js",
+      "_vendor-shiki-Dq54rRC7.js"
     ]
   },
-  "_vendor-recharts-Bz7zqjbW.js": {
-    "file": "assets/vendor-recharts-Bz7zqjbW.js",
+  "_vendor-recharts-C9O2a-N3.js": {
+    "file": "assets/vendor-recharts-C9O2a-N3.js",
     "name": "vendor-recharts",
     "imports": [
-      "_vendor-BKYy4SMr.js"
+      "_vendor-DCZoBorz.js"
     ]
   },
-  "_vendor-shiki-BitvudxD.js": {
-    "file": "assets/vendor-shiki-BitvudxD.js",
+  "_vendor-shiki-Dq54rRC7.js": {
+    "file": "assets/vendor-shiki-Dq54rRC7.js",
     "name": "vendor-shiki",
     "imports": [
-      "_vendor-BKYy4SMr.js"
+      "_vendor-DCZoBorz.js"
     ]
   },
   "_vendor-three-C5WAXd5r.js": {
@@ -69,19 +69,19 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-BXRcSHM6.js",
+    "file": "assets/index-DIlhmbjB.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
-      "_vendor-BKYy4SMr.js",
-      "_vendor-arizeai-CaqmrQdQ.js",
-      "_pages-Dn4XFHMU.js",
-      "_components-D-yJsfVa.js",
+      "_vendor-DCZoBorz.js",
+      "_vendor-arizeai-Ckci3irT.js",
+      "_pages-YX47cEoQ.js",
+      "_components-SpUMF1qV.js",
       "_vendor-three-C5WAXd5r.js",
-      "_vendor-codemirror-BlmFw5CA.js",
-      "_vendor-shiki-BitvudxD.js",
-      "_vendor-recharts-Bz7zqjbW.js"
+      "_vendor-codemirror-BODM513D.js",
+      "_vendor-shiki-Dq54rRC7.js",
+      "_vendor-recharts-C9O2a-N3.js"
     ]
   }
 }