arize-phoenix 5.9.1__tar.gz → 5.10.0__tar.gz

{arize_phoenix-5.9.1 → arize_phoenix-5.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 5.9.1
+Version: 5.10.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-5.9.1 → arize_phoenix-5.10.0}/src/phoenix/config.py

@@ -424,7 +424,9 @@ class OAuth2ClientConfig:
                 f"An OpenID Connect configuration URL must be set for the {idp_name} OAuth2 IDP "
                 f"via the {oidc_config_url_env_var} environment variable"
             )
-        if urlparse(oidc_config_url).scheme != "https":
+        parsed_oidc_config_url = urlparse(oidc_config_url)
+        is_local_oidc_config_url = parsed_oidc_config_url.hostname in ("localhost", "127.0.0.1")
+        if parsed_oidc_config_url.scheme != "https" and not is_local_oidc_config_url:
             raise ValueError(
                 f"Server metadata URL for {idp_name} OAuth2 IDP "
                 "must be a valid URL using the https protocol"

{arize_phoenix-5.9.1 → arize_phoenix-5.10.0}/src/phoenix/server/api/helpers/playground_clients.py

@@ -9,7 +9,11 @@ from functools import wraps
 from typing import TYPE_CHECKING, Any, Hashable, Mapping, Optional, Union
 
 from openinference.instrumentation import safe_json_dumps
-from openinference.semconv.trace import SpanAttributes
+from openinference.semconv.trace import (
+    OpenInferenceLLMProviderValues,
+    OpenInferenceLLMSystemValues,
+    SpanAttributes,
+)
 from strawberry import UNSET
 from strawberry.scalars import JSON as JSONScalarType
 from typing_extensions import TypeAlias, assert_never
@@ -44,7 +48,7 @@ from phoenix.server.api.types.ChatCompletionSubscriptionPayload import (
 from phoenix.server.api.types.GenerativeProvider import GenerativeProviderKey
 
 if TYPE_CHECKING:
-    from anthropic.types import MessageParam
+    from anthropic.types import MessageParam, TextBlockParam, ToolResultBlockParam
     from google.generativeai.types import ContentType
     from openai.types import CompletionUsage
     from openai.types.chat import ChatCompletionMessageParam, ChatCompletionMessageToolCallParam
@@ -255,6 +259,8 @@ class OpenAIStreamingClient(PlaygroundStreamingClient):
         from openai import RateLimitError as OpenAIRateLimitError
 
         super().__init__(model=model, api_key=api_key)
+        self._attributes[LLM_PROVIDER] = OpenInferenceLLMProviderValues.OPENAI.value
+        self._attributes[LLM_SYSTEM] = OpenInferenceLLMSystemValues.OPENAI.value
         self.client = AsyncOpenAI(api_key=api_key)
         self.model_name = model.name
         self.rate_limiter = PlaygroundRateLimiter(model.provider_key, OpenAIRateLimitError)
@@ -610,6 +616,8 @@ class AzureOpenAIStreamingClient(OpenAIStreamingClient):
         from openai import AsyncAzureOpenAI
 
         super().__init__(model=model, api_key=api_key)
+        self._attributes[LLM_PROVIDER] = OpenInferenceLLMProviderValues.AZURE.value
+        self._attributes[LLM_SYSTEM] = OpenInferenceLLMSystemValues.OPENAI.value
         if model.endpoint is None or model.api_version is None:
             raise ValueError("endpoint and api_version are required for Azure OpenAI models")
         self.client = AsyncAzureOpenAI(
@@ -638,6 +646,8 @@ class AnthropicStreamingClient(PlaygroundStreamingClient):
         import anthropic
 
         super().__init__(model=model, api_key=api_key)
+        self._attributes[LLM_PROVIDER] = OpenInferenceLLMProviderValues.ANTHROPIC.value
+        self._attributes[LLM_SYSTEM] = OpenInferenceLLMSystemValues.ANTHROPIC.value
         self.client = anthropic.AsyncAnthropic(api_key=api_key)
         self.model_name = model.name
         self.rate_limiter = PlaygroundRateLimiter(model.provider_key, anthropic.RateLimitError)
@@ -693,7 +703,6 @@ class AnthropicStreamingClient(PlaygroundStreamingClient):
         import anthropic.types as anthropic_types
 
         anthropic_messages, system_prompt = self._build_anthropic_messages(messages)
-
         anthropic_params = {
             "messages": anthropic_messages,
             "model": self.model_name,
@@ -751,19 +760,44 @@ class AnthropicStreamingClient(PlaygroundStreamingClient):
         anthropic_messages: list["MessageParam"] = []
         system_prompt = ""
         for role, content, _tool_call_id, _tool_calls in messages:
+            tool_aware_content = self._anthropic_message_content(content, _tool_calls)
             if role == ChatCompletionMessageRole.USER:
-                anthropic_messages.append({"role": "user", "content": content})
+                anthropic_messages.append({"role": "user", "content": tool_aware_content})
             elif role == ChatCompletionMessageRole.AI:
-                anthropic_messages.append({"role": "assistant", "content": content})
+                anthropic_messages.append({"role": "assistant", "content": tool_aware_content})
             elif role == ChatCompletionMessageRole.SYSTEM:
                 system_prompt += content + "\n"
             elif role == ChatCompletionMessageRole.TOOL:
-                raise NotImplementedError
+                anthropic_messages.append(
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "tool_result",
+                                "tool_use_id": _tool_call_id or "",
+                                "content": content or "",
+                            }
+                        ],
+                    }
+                )
             else:
                 assert_never(role)
 
         return anthropic_messages, system_prompt
 
+    def _anthropic_message_content(
+        self, content: str, tool_calls: Optional[list[JSONScalarType]]
+    ) -> Union[str, list[Union["ToolResultBlockParam", "TextBlockParam"]]]:
+        if tool_calls:
+            # Anthropic combines tool calls and the reasoning text into a single message object
+            tool_use_content: list[Union["ToolResultBlockParam", "TextBlockParam"]] = []
+            if content:
+                tool_use_content.append({"type": "text", "text": content})
+            tool_use_content.extend(tool_calls)
+            return tool_use_content
+
+        return content
+
 
 @register_llm_client(
     provider_key=GenerativeProviderKey.GEMINI,
@@ -784,6 +818,8 @@ class GeminiStreamingClient(PlaygroundStreamingClient):
         import google.generativeai as google_genai
 
         super().__init__(model=model, api_key=api_key)
+        self._attributes[LLM_PROVIDER] = OpenInferenceLLMProviderValues.GOOGLE.value
+        self._attributes[LLM_SYSTEM] = OpenInferenceLLMSystemValues.VERTEXAI.value
         google_genai.configure(api_key=api_key)
         self.model_name = model.name
 
@@ -905,6 +941,8 @@ def initialize_playground_clients() -> None:
     pass
 
 
+LLM_PROVIDER = SpanAttributes.LLM_PROVIDER
+LLM_SYSTEM = SpanAttributes.LLM_SYSTEM
 LLM_TOKEN_COUNT_PROMPT = SpanAttributes.LLM_TOKEN_COUNT_PROMPT
 LLM_TOKEN_COUNT_COMPLETION = SpanAttributes.LLM_TOKEN_COUNT_COMPLETION
 LLM_TOKEN_COUNT_TOTAL = SpanAttributes.LLM_TOKEN_COUNT_TOTAL

{arize_phoenix-5.9.1 → arize_phoenix-5.10.0}/src/phoenix/server/api/helpers/playground_spans.py

@@ -330,20 +330,45 @@ def llm_input_messages(
         tuple[ChatCompletionMessageRole, str, Optional[str], Optional[list[JSONScalarType]]]
     ],
 ) -> Iterator[tuple[str, Any]]:
-    for i, (role, content, _tool_call_id, tool_calls) in enumerate(messages):
+    for i, (role, content, tool_call_id, tool_calls) in enumerate(messages):
         yield f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_ROLE}", role.value.lower()
         yield f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_CONTENT}", content
+        if role == ChatCompletionMessageRole.TOOL and tool_call_id:
+            # Anthropic tool result spans
+            yield f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_TOOL_CALL_ID}", tool_call_id
+
         if tool_calls is not None:
             for tool_call_index, tool_call in enumerate(tool_calls):
-                yield (
-                    f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_TOOL_CALLS}.{tool_call_index}.{TOOL_CALL_FUNCTION_NAME}",
-                    tool_call["function"]["name"],
-                )
-                if arguments := tool_call["function"]["arguments"]:
+                if tool_call.get("type") == "tool_use":
+                    # Anthropic tool call spans
+                    yield (
+                        f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_TOOL_CALLS}.{tool_call_index}.{TOOL_CALL_FUNCTION_NAME}",
+                        tool_call["name"],
+                    )
                     yield (
                         f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_TOOL_CALLS}.{tool_call_index}.{TOOL_CALL_FUNCTION_ARGUMENTS_JSON}",
-                        safe_json_dumps(jsonify(arguments)),
+                        safe_json_dumps(jsonify(tool_call["input"])),
                     )
+                    yield (
+                        f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_TOOL_CALLS}.{tool_call_index}.{TOOL_CALL_ID}",
+                        tool_call["id"],
+                    )
+                elif tool_call_function := tool_call.get("function"):
+                    # OpenAI tool call spans
+                    yield (
+                        f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_TOOL_CALLS}.{tool_call_index}.{TOOL_CALL_FUNCTION_NAME}",
+                        tool_call_function["name"],
+                    )
+                    if arguments := tool_call_function["arguments"]:
+                        yield (
+                            f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_TOOL_CALLS}.{tool_call_index}.{TOOL_CALL_FUNCTION_ARGUMENTS_JSON}",
+                            safe_json_dumps(jsonify(arguments)),
+                        )
+                    if tool_call_id := tool_call.get("id"):
+                        yield (
+                            f"{LLM_INPUT_MESSAGES}.{i}.{MESSAGE_TOOL_CALLS}.{tool_call_index}.{TOOL_CALL_ID}",
+                            tool_call_id,
+                        )
 
 
 def _llm_output_messages(
@@ -418,5 +443,6 @@ MESSAGE_TOOL_CALLS = MessageAttributes.MESSAGE_TOOL_CALLS
 
 TOOL_CALL_FUNCTION_NAME = ToolCallAttributes.TOOL_CALL_FUNCTION_NAME
 TOOL_CALL_FUNCTION_ARGUMENTS_JSON = ToolCallAttributes.TOOL_CALL_FUNCTION_ARGUMENTS_JSON
-
+TOOL_CALL_ID = ToolCallAttributes.TOOL_CALL_ID
+MESSAGE_TOOL_CALL_ID = MessageAttributes.MESSAGE_TOOL_CALL_ID
 TOOL_JSON_SCHEMA = ToolAttributes.TOOL_JSON_SCHEMA

{arize_phoenix-5.9.1 → arize_phoenix-5.10.0}/src/phoenix/server/api/subscriptions.py

@@ -127,7 +127,7 @@ class Subscription:
             ):
                 span.add_response_chunk(chunk)
                 yield chunk
-            span.set_attributes(llm_client.attributes)
+        span.set_attributes(llm_client.attributes)
         if span.status_message is not None:
             yield ChatCompletionSubscriptionError(message=span.status_message)
         async with info.context.db() as session:

arize_phoenix-5.10.0/src/phoenix/server/api/types/GenerativeProvider.py

@@ -0,0 +1,85 @@
+from enum import Enum
+from typing import Any, ClassVar, Optional, Union
+
+import strawberry
+from openinference.semconv.trace import OpenInferenceLLMProviderValues, SpanAttributes
+
+from phoenix.trace.attributes import get_attribute_value
+
+
+@strawberry.enum
+class GenerativeProviderKey(Enum):
+    OPENAI = "OpenAI"
+    ANTHROPIC = "Anthropic"
+    AZURE_OPENAI = "Azure OpenAI"
+    GEMINI = "Google AI Studio"
+
+
+@strawberry.type
+class GenerativeProvider:
+    name: str
+    key: GenerativeProviderKey
+
+    model_provider_to_model_prefix_map: ClassVar[dict[GenerativeProviderKey, list[str]]] = {
+        GenerativeProviderKey.AZURE_OPENAI: [],
+        GenerativeProviderKey.ANTHROPIC: ["claude"],
+        GenerativeProviderKey.OPENAI: ["gpt", "o1"],
+        GenerativeProviderKey.GEMINI: ["gemini"],
+    }
+
+    attribute_provider_to_generative_provider_map: ClassVar[dict[str, GenerativeProviderKey]] = {
+        OpenInferenceLLMProviderValues.OPENAI.value: GenerativeProviderKey.OPENAI,
+        OpenInferenceLLMProviderValues.ANTHROPIC.value: GenerativeProviderKey.ANTHROPIC,
+        OpenInferenceLLMProviderValues.AZURE.value: GenerativeProviderKey.AZURE_OPENAI,
+        OpenInferenceLLMProviderValues.GOOGLE.value: GenerativeProviderKey.GEMINI,
+    }
+
+    @strawberry.field
+    async def dependencies(self) -> list[str]:
+        from phoenix.server.api.helpers.playground_registry import (
+            PLAYGROUND_CLIENT_REGISTRY,
+            PROVIDER_DEFAULT,
+        )
+
+        default_client = PLAYGROUND_CLIENT_REGISTRY.get_client(self.key, PROVIDER_DEFAULT)
+        if default_client:
+            return [dependency.name for dependency in default_client.dependencies()]
+        return []
+
+    @strawberry.field
+    async def dependencies_installed(self) -> bool:
+        from phoenix.server.api.helpers.playground_registry import (
+            PLAYGROUND_CLIENT_REGISTRY,
+            PROVIDER_DEFAULT,
+        )
+
+        default_client = PLAYGROUND_CLIENT_REGISTRY.get_client(self.key, PROVIDER_DEFAULT)
+        if default_client:
+            return default_client.dependencies_are_installed()
+        return False
+
+    @classmethod
+    def _infer_model_provider_from_model_name(
+        cls,
+        model_name: str,
+    ) -> Union[GenerativeProviderKey, None]:
+        for provider, prefixes in cls.model_provider_to_model_prefix_map.items():
+            if any(prefix.lower() in model_name.lower() for prefix in prefixes):
+                return provider
+        return None
+
+    @classmethod
+    def get_model_provider_from_attributes(
+        cls,
+        attributes: dict[str, Any],
+    ) -> Union[GenerativeProviderKey, None]:
+        llm_provider: Optional[str] = get_attribute_value(attributes, SpanAttributes.LLM_PROVIDER)
+
+        if isinstance(llm_provider, str) and (
+            provider := cls.attribute_provider_to_generative_provider_map.get(llm_provider)
+        ):
+            return provider
+        llm_model = get_attribute_value(attributes, SpanAttributes.LLM_MODEL_NAME)
+        if isinstance(llm_model, str):
+            return cls._infer_model_provider_from_model_name(llm_model)
+        return None

{arize_phoenix-5.9.1 → arize_phoenix-5.10.0}/src/phoenix/server/api/types/Span.py

@@ -25,7 +25,7 @@ from phoenix.server.api.input_types.SpanAnnotationSort import (
     SpanAnnotationColumn,
     SpanAnnotationSort,
 )
-from phoenix.server.api.types.GenerativeProvider import GenerativeProviderKey
+from phoenix.server.api.types.GenerativeProvider import GenerativeProvider
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.SpanAnnotation import to_gql_span_annotation
 from phoenix.trace.attributes import get_attribute_value
@@ -300,10 +300,9 @@ class Span(Node):
 
         db_span = self.db_span
         attributes = db_span.attributes
-        llm_provider: GenerativeProviderKey = (
-            get_attribute_value(attributes, SpanAttributes.LLM_PROVIDER)
-            or GenerativeProviderKey.OPENAI
-        )
+        llm_provider = GenerativeProvider.get_model_provider_from_attributes(attributes)
+        if llm_provider is None:
+            return []
         llm_model = get_attribute_value(attributes, SpanAttributes.LLM_MODEL_NAME)
         invocation_parameters = get_attribute_value(
             attributes, SpanAttributes.LLM_INVOCATION_PARAMETERS

arize_phoenix-5.10.0/src/phoenix/server/static/.vite/manifest.json

@@ -0,0 +1,78 @@
+{
+  "_components-BXIz9ZO8.js": {
+    "file": "assets/components-BXIz9ZO8.js",
+    "name": "components",
+    "imports": [
+      "_vendor-BX8_Znqy.js",
+      "_pages-B8FpJuXu.js",
+      "_vendor-arizeai-CtHir-Ua.js",
+      "_vendor-codemirror-DLlGiguX.js",
+      "_vendor-three-DwGkEfCM.js"
+    ]
+  },
+  "_pages-B8FpJuXu.js": {
+    "file": "assets/pages-B8FpJuXu.js",
+    "name": "pages",
+    "imports": [
+      "_vendor-BX8_Znqy.js",
+      "_vendor-arizeai-CtHir-Ua.js",
+      "_components-BXIz9ZO8.js",
+      "_vendor-recharts-CJRple0d.js",
+      "_vendor-codemirror-DLlGiguX.js"
+    ]
+  },
+  "_vendor-!~{003}~.js": {
+    "file": "assets/vendor-DxkFTwjz.css",
+    "src": "_vendor-!~{003}~.js"
+  },
+  "_vendor-BX8_Znqy.js": {
+    "file": "assets/vendor-BX8_Znqy.js",
+    "name": "vendor",
+    "imports": [
+      "_vendor-three-DwGkEfCM.js"
+    ],
+    "css": [
+      "assets/vendor-DxkFTwjz.css"
+    ]
+  },
+  "_vendor-arizeai-CtHir-Ua.js": {
+    "file": "assets/vendor-arizeai-CtHir-Ua.js",
+    "name": "vendor-arizeai",
+    "imports": [
+      "_vendor-BX8_Znqy.js"
+    ]
+  },
+  "_vendor-codemirror-DLlGiguX.js": {
+    "file": "assets/vendor-codemirror-DLlGiguX.js",
+    "name": "vendor-codemirror",
+    "imports": [
+      "_vendor-BX8_Znqy.js"
+    ]
+  },
+  "_vendor-recharts-CJRple0d.js": {
+    "file": "assets/vendor-recharts-CJRple0d.js",
+    "name": "vendor-recharts",
+    "imports": [
+      "_vendor-BX8_Znqy.js"
+    ]
+  },
+  "_vendor-three-DwGkEfCM.js": {
+    "file": "assets/vendor-three-DwGkEfCM.js",
+    "name": "vendor-three"
+  },
+  "index.tsx": {
+    "file": "assets/index-DTut7g1y.js",
+    "name": "index",
+    "src": "index.tsx",
+    "isEntry": true,
+    "imports": [
+      "_vendor-BX8_Znqy.js",
+      "_vendor-arizeai-CtHir-Ua.js",
+      "_pages-B8FpJuXu.js",
+      "_components-BXIz9ZO8.js",
+      "_vendor-three-DwGkEfCM.js",
+      "_vendor-recharts-CJRple0d.js",
+      "_vendor-codemirror-DLlGiguX.js"
+    ]
+  }
+}