scale-gp-beta 0.1.0a26__tar.gz → 0.1.0a27__tar.gz

scale_gp_beta-0.1.0a27/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.1.0-alpha.27"
+}

{scale_gp_beta-0.1.0a26 → scale_gp_beta-0.1.0a27}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.0-alpha.27 (2025-07-10)
+
+Full Changelog: [v0.1.0-alpha.26...v0.1.0-alpha.27](https://github.com/scaleapi/sgp-python-beta/compare/v0.1.0-alpha.26...v0.1.0-alpha.27)
+
+### Features
+
+* OpenAI subprocessor ([#121](https://github.com/scaleapi/sgp-python-beta/issues/121)) ([321507e](https://github.com/scaleapi/sgp-python-beta/commit/321507e666c4aec253451c670fbf42ff13361dbc))
+
 ## 0.1.0-alpha.26 (2025-07-09)
 
 Full Changelog: [v0.1.0-alpha.25...v0.1.0-alpha.26](https://github.com/scaleapi/sgp-python-beta/compare/v0.1.0-alpha.25...v0.1.0-alpha.26)

{scale_gp_beta-0.1.0a26 → scale_gp_beta-0.1.0a27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scale-gp-beta
-Version: 0.1.0a26
+Version: 0.1.0a27
 Summary: The official Python library for the Scale GP API
 Project-URL: Homepage, https://github.com/scaleapi/sgp-python-beta
 Project-URL: Repository, https://github.com/scaleapi/sgp-python-beta

scale_gp_beta-0.1.0a27/examples/tracing/3_openai_agent_tracing.py

@@ -0,0 +1,51 @@
+"""
+A simple example demonstrating how to trace an OpenAI Agent run.
+
+To run this example:
+1. Install the necessary packages:
+   pip install openai-agents
+2. Fill in your SGP `api_key` and `account_id`.
+3. Run the script from your terminal
+"""
+import os
+import asyncio
+
+try:
+    from agents import Agent, Runner, function_tool, set_trace_processors  # type: ignore
+except ImportError as e:
+    raise ImportError("Please install the required packages: pip install openai-agents") from e
+
+import scale_gp_beta.lib.tracing as tracing
+from scale_gp_beta import SGPClient
+from scale_gp_beta.lib.tracing.integrations import OpenAITracingSGPProcessor
+
+
+@function_tool  # type: ignore
+def get_current_weather(city: str) -> str:
+    if "san francisco" in city.lower():
+        return "The weather in San Francisco is foggy."
+    return f"The weather in {city} is sunny."
+
+
+async def main() -> None:
+    weather_agent = Agent(  # type: ignore
+        name="Weather Agent",
+        instructions="You are a helpful assistant that can provide weather information.",
+        model="gpt-4-turbo",
+        tools=[get_current_weather],
+    )
+
+    result = await Runner.run(weather_agent, "What's the weather like in San Francisco?")  # type: ignore
+    print("Final Output:", result.final_output)  # type: ignore
+
+
+if __name__ == "__main__":
+    api_key = "XXX"
+    account_id = "XXX"
+    os.environ["OPENAI_API_KEY"] = "XXX"
+
+    tracing.init(SGPClient(api_key=api_key, account_id=account_id), disabled=False)
+
+    sgp_processor = OpenAITracingSGPProcessor()
+    set_trace_processors([sgp_processor])
+    asyncio.run(main())

{scale_gp_beta-0.1.0a26 → scale_gp_beta-0.1.0a27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scale-gp-beta"
-version = "0.1.0-alpha.26"
+version = "0.1.0-alpha.27"
 description = "The official Python library for the Scale GP API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{scale_gp_beta-0.1.0a26 → scale_gp_beta-0.1.0a27}/src/scale_gp_beta/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "scale_gp_beta"
-__version__ = "0.1.0-alpha.26"  # x-release-please-version
+__version__ = "0.1.0-alpha.27"  # x-release-please-version

scale_gp_beta-0.1.0a27/src/scale_gp_beta/lib/tracing/integrations/__init__.py

@@ -0,0 +1,5 @@
+try:
+    from .openai.openai_tracing_sgp_processor import OpenAITracingSGPProcessor  # type: ignore[attr-defined]
+    __all__ = ["OpenAITracingSGPProcessor"]
+except ImportError:
+    pass

scale_gp_beta-0.1.0a27/src/scale_gp_beta/lib/tracing/integrations/openai/openai_span_type_map.py

@@ -0,0 +1,29 @@
+from typing import Dict, Optional
+
+from scale_gp_beta.lib.tracing.types import SpanTypeLiterals
+
+OPENAI_SPAN_TYPE_MAP: Dict[str, SpanTypeLiterals] = {
+    "generation": "COMPLETION",
+    "agent": "AGENT_WORKFLOW",
+    "function": "CODE_EXECUTION",
+    "response": "COMPLETION",
+    "handoff": "CUSTOM",
+    "custom": "CUSTOM",
+    "guardrail": "STANDALONE",
+    "transcription": "STANDALONE",
+    "speech": "STANDALONE",
+    "speech_group": "STANDALONE",
+    "mcp_tools": "STANDALONE",
+}
+
+
+def openai_span_type_map(span_type: Optional[str]) -> SpanTypeLiterals:
+    """
+    Maps an OpenAI span type string to its corresponding SGP SpanTypeLiteral.
+
+    Returns "CUSTOM" if the input is None or not found in the map.
+    """
+    if not span_type:
+        return "CUSTOM"
+
+    return OPENAI_SPAN_TYPE_MAP.get(span_type, "CUSTOM")

scale_gp_beta-0.1.0a27/src/scale_gp_beta/lib/tracing/integrations/openai/openai_tracing_sgp_processor.py

@@ -0,0 +1,144 @@
+# The following `type: ignore` is necessary because this file provides an optional
+# integration for the 'openai-agents' library. The linter will report missing
+# imports if the library isn't installed in the development environment, but the
+# code handles this gracefully at runtime with a try/except block.
+# type: ignore
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from scale_gp_beta.lib.tracing.span import BaseSpan
+from scale_gp_beta.lib.tracing.tracing import create_span, flush_queue, create_trace, tracing_queue_manager
+from scale_gp_beta.lib.tracing.trace_queue_manager import TraceQueueManager
+
+from .utils import sgp_span_name, parse_metadata, extract_response, parse_input_output
+from .openai_span_type_map import openai_span_type_map
+
+log: logging.Logger = logging.getLogger(__name__)
+
+try:
+    from agents.tracing import (
+        Span as OpenAISpan,
+        Trace as OpenAITrace,
+        SpanData as OpenAISpanData,
+        ResponseSpanData as OpenAIResponseSpanData,
+        TracingProcessor,
+    )
+
+    _openai_agents_installed = True
+except ImportError:
+    _openai_agents_installed = False
+    TracingProcessor = object
+    class _Fallback:
+        pass
+
+    OpenAISpan = _Fallback
+    OpenAITrace = _Fallback
+    OpenAISpanData = _Fallback
+    OpenAIResponseSpanData = _Fallback
+
+    if TYPE_CHECKING:
+        OpenAISpan = Any
+        OpenAITrace = Any
+        OpenAISpanData = Any
+        OpenAIResponseSpanData = Any
+
+
+class OpenAITracingSGPProcessor(TracingProcessor):
+    """
+    An SGP tracing processor that integrates with OpenAI Agents SDK.
+
+    This processor requires the 'openai-agents' library to be installed.
+    It will raise an ImportError on initialization if the library is not found.
+    """
+
+    def __init__(
+            self,
+            *,
+            queue_manager: Optional[TraceQueueManager] = None,
+    ):
+        """
+        Initializes the processor.
+
+        Args:
+            queue_manager: An optional custom trace queue manager.
+
+        Raises:
+            ImportError: If the 'openai-agents' package is not installed.
+        """
+        # This runtime check is the gatekeeper. If 'openai-agents' isn't
+        # installed, no instance of this class can be created.
+        if not _openai_agents_installed:
+            raise ImportError(
+                "The 'openai-agents' package is required to use the OpenAITracingSGPProcessor. "
+                "Please install it with: pip install 'openai-agents'"
+            )
+
+        self._queue_manager = queue_manager or tracing_queue_manager()
+        self._spans: Dict[str, BaseSpan] = {}
+
+    def on_trace_start(self, openai_trace: "OpenAITrace") -> None:
+        sgp_trace = create_trace(
+            name=openai_trace.name or "Agent Workflow",
+            span_type="AGENT_WORKFLOW",
+            group_id=openai_trace.group_id,
+            trace_id=openai_trace.trace_id,
+            metadata={"openai_metadata": openai_trace.metadata or {}},
+        )
+        sgp_trace.start()
+        self._spans[openai_trace.trace_id] = sgp_trace.root_span
+
+    def on_trace_end(self, openai_trace: "OpenAITrace") -> None:
+        root_span = self._spans.pop(openai_trace.trace_id, None)
+        if root_span is None:
+            log.warning(f"No root span found for trace_id: {openai_trace.trace_id}")
+            return
+        root_span.end()
+
+    def on_span_start(self, openai_span: "OpenAISpan") -> None:
+        _spans_key = openai_span.parent_id or openai_span.trace_id
+        parent_span = self._spans.get(_spans_key)
+        span_data = openai_span.span_data
+
+        if not parent_span:
+            log.warning(f"No parent span found for span_id: {openai_span.span_id}")
+            return
+
+        name = sgp_span_name(openai_span)
+        sgp_span_type = openai_span_type_map(span_data.type if span_data else None)
+
+        new_span = create_span(
+            name=name,
+            span_type=sgp_span_type,
+            span_id=openai_span.span_id,
+            trace_id=parent_span.trace_id,
+            parent_id=parent_span.span_id,
+        )
+        new_span.start()
+        self._spans[openai_span.span_id] = new_span
+
+    def on_span_end(self, openai_span: "OpenAISpan") -> None:
+        sgp_span = self._spans.pop(openai_span.span_id, None)
+        if sgp_span is None:
+            log.warning(f"No existing span found for span_id: {openai_span.span_id}")
+            return
+
+        # special case response type, if there are more like this we should change arch to support this
+        if isinstance(openai_span.span_data, OpenAIResponseSpanData):
+            response = extract_response(openai_span)
+            sgp_span.input = {"input": openai_span.span_data.input}
+            sgp_span.output = {"output": response.get("output", None) if response else None }
+        else:
+            sgp_span.output = parse_input_output(openai_span, "output")
+            sgp_span.input = parse_input_output(openai_span, "input")
+
+        sgp_span.metadata = parse_metadata(openai_span)
+
+        if openai_span.error:
+            sgp_span.set_error(error_message=str(openai_span.error))
+        sgp_span.end()
+
+    def shutdown(self) -> None:
+        self._queue_manager.shutdown()
+
+    def force_flush(self) -> None:
+        flush_queue()

scale_gp_beta-0.1.0a27/src/scale_gp_beta/lib/tracing/integrations/openai/utils.py

@@ -0,0 +1,68 @@
+# type: ignore
+import json
+from typing import Any, Dict, Optional
+
+try:
+    from agents.tracing import (
+        Span as OpenAISpan,
+        ResponseSpanData as OpenAIResponseSpanData,
+    )
+except ImportError:
+    OpenAISpan = Any
+    OpenAIResponseSpanData = Any
+
+
+def sgp_span_name(openai_span: "OpenAISpan") -> str:
+    span_data = openai_span.span_data
+    if span_data is None:
+        return "Unnamed Span"
+    default_name = str(type(span_data).__name__).replace("SpanData", "")
+
+    return span_data.export().get("name", default_name)
+
+
+def extract_response(openai_span: "OpenAISpan") -> Optional[Dict[str, Any]]:
+    span_data = openai_span.span_data
+    if not isinstance(span_data, OpenAIResponseSpanData):
+        return None
+
+    return {} if span_data.response is None else span_data.response.model_dump()
+
+
+def parse_metadata(openai_span: "OpenAISpan") -> Dict[str, Any]:
+    """Extracts and formats metadata from an OpenAI span."""
+    if not openai_span.span_data:
+        return {}
+
+    excluded_fields = ("output", "input")
+    exported_span_data: dict = openai_span.span_data.export()
+    exported_span_data["openai_span_id"] = openai_span.span_id
+
+    filtered_span_data: dict = {
+        k: v for k, v in exported_span_data.items() if k not in excluded_fields
+    }
+    response = extract_response(openai_span)
+    if response is not None:
+        filtered_span_data["openai_response"] = response
+    return {"openai_metadata": filtered_span_data}
+
+
+def parse_input_output(openai_span: "OpenAISpan", key: str) -> Dict[str, Any]:
+    """
+    Safely extracts and parses input/output data from a span.
+    The openai-agents SDK sometimes returns this data as a JSON string.
+    """
+    span_data = openai_span.span_data
+    if not span_data:
+        return {}
+    exported_span_data: dict = span_data.export()
+    value: Optional[Any] = exported_span_data.get(key)
+    if value is None:
+        return {}
+
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except (json.JSONDecodeError, TypeError):
+            return {key: value}
+    return {key: value}

scale_gp_beta-0.1.0a26/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.1.0-alpha.26"
-}