eval-protocol 0.2.45.dev1__tar.gz → 0.2.46.dev0__tar.gz

{eval_protocol-0.2.45.dev1/eval_protocol.egg-info → eval_protocol-0.2.46.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eval-protocol
-Version: 0.2.45.dev1
+Version: 0.2.46.dev0
 Summary: The official Python SDK for Eval Protocol (EP.) EP is an open protocol that standardizes how developers author evals for large language model (LLM) applications.
 Author-email: Fireworks AI <info@fireworks.ai>
 License-Expression: MIT

{eval_protocol-0.2.45.dev1 → eval_protocol-0.2.46.dev0}/eval_protocol/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-10-09T01:30:59-0700",
+ "date": "2025-10-10T00:24:47-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "1eef32fcf8f230ad2ee2b46f90a4f62c77fd89a7",
- "version": "0.2.45-dev1"
+ "full-revisionid": "98d81a75608e700f91e697f88c149641328d9507",
+ "version": "0.2.46-dev"
 }
 '''  # END VERSION_JSON
 

{eval_protocol-0.2.45.dev1 → eval_protocol-0.2.46.dev0}/eval_protocol/proxy/__init__.py

@@ -5,11 +5,13 @@ A proxy service for extracting evaluation metadata from URL paths and managing
 Langfuse tracing for distributed evaluation workflows.
 """
 
-from .proxy_core import create_app, AuthProvider, NoAuthProvider, ProxyConfig
+from .proxy_core import create_app, AuthProvider, NoAuthProvider, ProxyConfig, ChatParams, TracesParams
 
 __all__ = [
     "create_app",
     "AuthProvider",
     "NoAuthProvider",
     "ProxyConfig",
+    "ChatParams",
+    "TracesParams",
 ]

{eval_protocol-0.2.45.dev1 → eval_protocol-0.2.46.dev0}/eval_protocol/proxy/proxy_core/__init__.py

@@ -1,9 +1,11 @@
-from .models import ProxyConfig
+from .models import ProxyConfig, ChatParams, TracesParams
 from .app import create_app
 from .auth import AuthProvider, NoAuthProvider
 
 __all__ = [
     "ProxyConfig",
+    "ChatParams",
+    "TracesParams",
     "create_app",
     "AuthProvider",
     "NoAuthProvider",

{eval_protocol-0.2.45.dev1 → eval_protocol-0.2.46.dev0}/eval_protocol/proxy/proxy_core/app.py

@@ -4,67 +4,75 @@ A FastAPI service that sits in front of LiteLLM and extracts metadata from URL p
 """
 
 from fastapi import FastAPI, Depends, HTTPException, Request, Query
-from typing import Optional, List
+from typing import Optional, Callable, Dict, Any, List
 import os
 import redis
 import logging
-import json
+import yaml
 from pathlib import Path
 import sys
 from contextlib import asynccontextmanager
 
-from .models import ProxyConfig, LangfuseTracesResponse
+from .models import ProxyConfig, LangfuseTracesResponse, TracesParams, ChatParams, ChatRequestHook, TracesRequestHook
 from .auth import AuthProvider, NoAuthProvider
 from .litellm import handle_chat_completion, proxy_to_litellm
 from .langfuse import fetch_langfuse_traces
 
 # Configure logging before any other imports (so all modules inherit this config)
 log_level = os.getenv("LOG_LEVEL", "INFO").upper()
-logging.basicConfig(
-    level=getattr(logging, log_level),
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(sys.stdout)],
-)
+if not logging.getLogger().hasHandlers():
+    logging.basicConfig(
+        level=getattr(logging, log_level),
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
 
 logger = logging.getLogger(__name__)
 
 
-def build_proxy_config() -> ProxyConfig:
-    """Load environment and secrets, and build ProxyConfig (no Redis)."""
+def build_proxy_config(
+    preprocess_chat_request: Optional[ChatRequestHook] = None,
+    preprocess_traces_request: Optional[TracesRequestHook] = None,
+) -> ProxyConfig:
+    """Load environment and secrets, and build ProxyConfig"""
     # Env
     litellm_url = os.getenv("LITELLM_URL")
     if not litellm_url:
         raise ValueError("LITELLM_URL environment variable must be set")
     request_timeout = float(os.getenv("REQUEST_TIMEOUT", "300.0"))
+    langfuse_host = os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com")
 
-    # Secrets - use SECRETS_PATH env var if set, otherwise default to proxy/secrets.json
+    # Secrets - use SECRETS_PATH env var if set, otherwise default to proxy/secrets.yaml
     secrets_path_str = os.getenv("SECRETS_PATH")
     if secrets_path_str:
         secrets_path = Path(secrets_path_str)
     else:
-        secrets_path = Path(__file__).parent / "secrets.json"
+        secrets_path = Path(__file__).parent / "secrets.yaml"
     if not secrets_path.exists():
         raise ValueError(
-            "secrets.json not found! Please create it from secrets.json.example:\n"
-            "  cp litellm_proxy_config/proxy/secrets.json.example litellm_proxy_config/proxy/secrets.json\n"
-            "Then add your Langfuse API keys to secrets.json"
+            "Secrets file not found! Please create it from secrets.yaml.example:\n"
+            "  cp eval_protocol/proxy/proxy_core/secrets.yaml.example eval_protocol/proxy/proxy_core/secrets.yaml\n"
+            "Then add your Langfuse API keys to the secrets file"
         )
     try:
         with open(secrets_path, "r") as f:
-            secrets_config = json.load(f)
+            secrets_config = yaml.safe_load(f)
         langfuse_keys = secrets_config["langfuse_keys"]
         default_project_id = secrets_config["default_project_id"]
-        logger.info(f"Loaded {len(langfuse_keys)} Langfuse project(s) from secrets.json")
+        logger.info(f"Loaded {len(langfuse_keys)} Langfuse project(s) from {secrets_path.name}")
     except KeyError as e:
-        raise ValueError(f"Missing required key in secrets.json: {e}")
-    except json.JSONDecodeError as e:
-        raise ValueError(f"Invalid JSON in secrets.json: {e}")
+        raise ValueError(f"Missing required key in secrets file: {e}")
+    except yaml.YAMLError as e:
+        raise ValueError(f"Invalid format in secrets file {secrets_path.name}: {e}")
 
     return ProxyConfig(
         litellm_url=litellm_url,
         request_timeout=request_timeout,
+        langfuse_host=langfuse_host,
         langfuse_keys=langfuse_keys,
         default_project_id=default_project_id,
+        preprocess_chat_request=preprocess_chat_request,
+        preprocess_traces_request=preprocess_traces_request,
     )
 
 
@@ -95,12 +103,15 @@ def init_redis() -> redis.Redis:
 
 def create_app(
     auth_provider: AuthProvider = NoAuthProvider(),
+    preprocess_chat_request: Optional[ChatRequestHook] = None,
+    preprocess_traces_request: Optional[TracesRequestHook] = None,
 ) -> FastAPI:
     @asynccontextmanager
     async def lifespan(app: FastAPI):
         # Build runtime on startup
-        app.state.config = build_proxy_config()
+        app.state.config = build_proxy_config(preprocess_chat_request, preprocess_traces_request)
         app.state.redis = init_redis()
+
         try:
             yield
         finally:
@@ -117,13 +128,46 @@ def create_app(
     def get_redis(request: Request) -> redis.Redis:
         return request.app.state.redis
 
-    async def require_auth(request: Request) -> None:
-        auth_header = request.headers.get("authorization", "")
-        api_key = None
-        if auth_header.startswith("Bearer "):
-            api_key = auth_header.replace("Bearer ", "").strip()
+    def get_traces_params(
+        tags: Optional[List[str]] = Query(default=None),
+        project_id: Optional[str] = None,
+        limit: int = 100,
+        sample_size: Optional[int] = None,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        name: Optional[str] = None,
+        environment: Optional[str] = None,
+        version: Optional[str] = None,
+        release: Optional[str] = None,
+        fields: Optional[str] = None,
+        hours_back: Optional[int] = None,
+        from_timestamp: Optional[str] = None,
+        to_timestamp: Optional[str] = None,
+        sleep_between_gets: float = 2.5,
+        max_retries: int = 3,
+    ) -> TracesParams:
+        return TracesParams(
+            tags=tags,
+            project_id=project_id,
+            limit=limit,
+            sample_size=sample_size,
+            user_id=user_id,
+            session_id=session_id,
+            name=name,
+            environment=environment,
+            version=version,
+            release=release,
+            fields=fields,
+            hours_back=hours_back,
+            from_timestamp=from_timestamp,
+            to_timestamp=to_timestamp,
+            sleep_between_gets=sleep_between_gets,
+            max_retries=max_retries,
+        )
 
-        auth_provider.validate(api_key)
+    async def require_auth(request: Request) -> None:
+        account_id = auth_provider.validate_and_return_account_id(request)
+        request.state.account_id = account_id
         return None
 
     # =====================
@@ -164,11 +208,9 @@ def create_app(
         encoded_base_url: Optional[str] = None,
         config: ProxyConfig = Depends(get_config),
         redis_client: redis.Redis = Depends(get_redis),
+        _: None = Depends(require_auth),
     ):
-        return await handle_chat_completion(
-            config=config,
-            redis_client=redis_client,
-            request=request,
+        params = ChatParams(
             project_id=project_id,
             rollout_id=rollout_id,
             invocation_id=invocation_id,
@@ -177,6 +219,12 @@ def create_app(
             row_id=row_id,
             encoded_base_url=encoded_base_url,
         )
+        return await handle_chat_completion(
+            config=config,
+            redis_client=redis_client,
+            request=request,
+            params=params,
+        )
 
     @app.post("/project_id/{project_id}/chat/completions")
     @app.post("/v1/project_id/{project_id}/chat/completions")
@@ -185,12 +233,14 @@ def create_app(
         request: Request,
         config: ProxyConfig = Depends(get_config),
         redis_client: redis.Redis = Depends(get_redis),
+        _: None = Depends(require_auth),
     ):
+        params = ChatParams(project_id=project_id)
         return await handle_chat_completion(
             config=config,
             redis_client=redis_client,
             request=request,
-            project_id=project_id,
+            params=params,
         )
 
     # ===============
@@ -201,45 +251,20 @@ def create_app(
     @app.get("/project_id/{project_id}/traces", response_model=LangfuseTracesResponse)
     @app.get("/v1/project_id/{project_id}/traces", response_model=LangfuseTracesResponse)
     async def get_langfuse_traces(
-        tags: List[str] = Query(...),  # REQUIRED query param
+        request: Request,
+        params: TracesParams = Depends(get_traces_params),
         project_id: Optional[str] = None,
-        limit: int = 100,
-        sample_size: Optional[int] = None,
-        user_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-        name: Optional[str] = None,
-        environment: Optional[str] = None,
-        version: Optional[str] = None,
-        release: Optional[str] = None,
-        fields: Optional[str] = None,
-        hours_back: Optional[int] = None,
-        from_timestamp: Optional[str] = None,
-        to_timestamp: Optional[str] = None,
-        sleep_between_gets: float = 2.5,
-        max_retries: int = 3,
         config: ProxyConfig = Depends(get_config),
         redis_client: redis.Redis = Depends(get_redis),
         _: None = Depends(require_auth),
     ) -> LangfuseTracesResponse:
+        if project_id is not None:
+            params.project_id = project_id
         return await fetch_langfuse_traces(
             config=config,
             redis_client=redis_client,
-            tags=tags,
-            project_id=project_id,
-            limit=limit,
-            sample_size=sample_size,
-            user_id=user_id,
-            session_id=session_id,
-            name=name,
-            environment=environment,
-            version=version,
-            release=release,
-            fields=fields,
-            hours_back=hours_back,
-            from_timestamp=from_timestamp,
-            to_timestamp=to_timestamp,
-            sleep_between_gets=sleep_between_gets,
-            max_retries=max_retries,
+            request=request,
+            params=params,
         )
 
     # Health

eval_protocol-0.2.46.dev0/eval_protocol/proxy/proxy_core/auth.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+import logging
+from fastapi import Request
+from fastapi import HTTPException
+import httpx
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class AuthProvider(ABC):
+    @abstractmethod
+    def validate_and_return_account_id(self, request: Request) -> Optional[str]: ...
+
+
+class NoAuthProvider(AuthProvider):
+    def validate_and_return_account_id(self, request: Request) -> Optional[str]:
+        return None

{eval_protocol-0.2.45.dev1 → eval_protocol-0.2.46.dev0}/eval_protocol/proxy/proxy_core/langfuse.py

@@ -8,16 +8,18 @@ import logging
 import asyncio
 from typing import List, Optional, Dict, Any, Set
 from datetime import datetime, timedelta
-from fastapi import HTTPException
+from fastapi import HTTPException, Request
 import redis
 from .redis_utils import get_insertion_ids
-from .models import ProxyConfig, LangfuseTracesResponse, TraceResponse
+from .models import ProxyConfig, LangfuseTracesResponse, TraceResponse, TracesParams
 
 logger = logging.getLogger(__name__)
 
 
-def _extract_tag_value(tags: List[str], prefix: str) -> Optional[str]:
+def _extract_tag_value(tags: Optional[List[str]], prefix: str) -> Optional[str]:
     """Extract value from a tag with the given prefix (e.g., 'rollout_id:' or 'insertion_id:')."""
+    if not tags:
+        return None
     for tag in tags:
         if tag.startswith(prefix):
             return tag.split(":", 1)[1]
@@ -60,7 +62,7 @@ async def _fetch_trace_list_with_retry(
     langfuse_client: Any,
     page: int,
     limit: int,
-    tags: List[str],
+    tags: Optional[List[str]],
     user_id: Optional[str],
     session_id: Optional[str],
     name: Optional[str],
@@ -152,22 +154,8 @@ async def _fetch_trace_detail_with_retry(
 async def fetch_langfuse_traces(
     config: ProxyConfig,
     redis_client: redis.Redis,
-    tags: List[str],
-    project_id: Optional[str] = None,
-    limit: int = 100,
-    sample_size: Optional[int] = None,
-    user_id: Optional[str] = None,
-    session_id: Optional[str] = None,
-    name: Optional[str] = None,
-    environment: Optional[str] = None,
-    version: Optional[str] = None,
-    release: Optional[str] = None,
-    fields: Optional[str] = None,
-    hours_back: Optional[int] = None,
-    from_timestamp: Optional[str] = None,
-    to_timestamp: Optional[str] = None,
-    sleep_between_gets: float = 2.5,
-    max_retries: int = 3,
+    request: Request,
+    params: TracesParams,
 ):
     """
     Fetch full traces from Langfuse for the specified project.
@@ -184,9 +172,27 @@ async def fetch_langfuse_traces(
 
     Returns a list of full trace objects (including observations) in JSON format.
     """
-    # Validate tags
-    if not tags or not any(tag.startswith("rollout_id:") for tag in tags):
-        raise HTTPException(status_code=422, detail="Tags must include at least one 'rollout_id:*' tag")
+
+    # Preprocess traces request
+    if config.preprocess_traces_request:
+        params = config.preprocess_traces_request(request, params)
+
+    tags = params.tags
+    project_id = params.project_id
+    limit = params.limit
+    sample_size = params.sample_size
+    user_id = params.user_id
+    session_id = params.session_id
+    name = params.name
+    environment = params.environment
+    version = params.version
+    release = params.release
+    fields = params.fields
+    hours_back = params.hours_back
+    from_timestamp = params.from_timestamp
+    to_timestamp = params.to_timestamp
+    sleep_between_gets = params.sleep_between_gets
+    max_retries = params.max_retries
 
     # Use default project if not specified
     if project_id is None:
@@ -210,7 +216,7 @@ async def fetch_langfuse_traces(
         langfuse_client = Langfuse(
             public_key=config.langfuse_keys[project_id]["public_key"],
             secret_key=config.langfuse_keys[project_id]["secret_key"],
-            host="https://langfuse.fireworks.ai",
+            host=config.langfuse_host,
         )
 
         # Parse datetime strings if provided

{eval_protocol-0.2.45.dev1 → eval_protocol-0.2.46.dev0}/eval_protocol/proxy/proxy_core/litellm.py

@@ -11,7 +11,7 @@ from fastapi import Request, Response, HTTPException
 from typing import Optional
 import redis
 from .redis_utils import register_insertion_id
-from .models import ProxyConfig
+from .models import ProxyConfig, ChatParams
 
 logger = logging.getLogger(__name__)
 
@@ -20,13 +20,7 @@ async def handle_chat_completion(
     config: ProxyConfig,
     redis_client: redis.Redis,
     request: Request,
-    project_id: Optional[str] = None,
-    rollout_id: Optional[str] = None,
-    invocation_id: Optional[str] = None,
-    experiment_id: Optional[str] = None,
-    run_id: Optional[str] = None,
-    row_id: Optional[str] = None,
-    encoded_base_url: Optional[str] = None,
+    params: ChatParams,
 ) -> Response:
     """
     Handle chat completion requests and forward to LiteLLM.
@@ -36,14 +30,24 @@ async def handle_chat_completion(
 
     If encoded_base_url is provided, it will be decoded and added to the request.
     """
+    body = await request.body()
+    data = json.loads(body) if body else {}
+
+    if config.preprocess_chat_request:
+        data, params = config.preprocess_chat_request(data, request, params)
+
+    project_id = params.project_id
+    rollout_id = params.rollout_id
+    invocation_id = params.invocation_id
+    experiment_id = params.experiment_id
+    run_id = params.run_id
+    row_id = params.row_id
+    encoded_base_url = params.encoded_base_url
+
     # Use default project if not specified
     if project_id is None:
         project_id = config.default_project_id
 
-    # Read the original request body
-    body = await request.body()
-    data = json.loads(body) if body else {}
-
     # Decode and add base_url if provided
     if encoded_base_url:
         try:
@@ -87,7 +91,7 @@ async def handle_chat_completion(
     # Add Langfuse configuration
     data["langfuse_public_key"] = config.langfuse_keys[project_id]["public_key"]
     data["langfuse_secret_key"] = config.langfuse_keys[project_id]["secret_key"]
-    data["langfuse_host"] = "https://langfuse.fireworks.ai"
+    data["langfuse_host"] = config.langfuse_host
 
     # Forward to LiteLLM's standard /chat/completions endpoint
     # Set longer timeout for LLM API calls (LLMs can be slow)
@@ -135,12 +139,11 @@ async def proxy_to_litellm(config: ProxyConfig, path: str, request: Request) ->
         # Get body
         body = await request.body()
 
-        # For POST/PUT/PATCH with JSON, extract API key from header
+        # Pass through API key from Authorization header
         if request.method in ["POST", "PUT", "PATCH"] and body:
             try:
                 data = json.loads(body)
 
-                # Extract API key from Authorization header
                 auth_header = request.headers.get("authorization", "")
                 if auth_header.startswith("Bearer "):
                     api_key = auth_header.replace("Bearer ", "").strip()

eval_protocol-0.2.46.dev0/eval_protocol/proxy/proxy_core/models.py

@@ -0,0 +1,92 @@
+"""
+Models for the LiteLLM Metadata Proxy.
+"""
+
+from pydantic import BaseModel
+from typing import Optional, List, Any, Dict, Callable, TypeAlias
+from fastapi import Request, Query
+
+
+ChatRequestHook: TypeAlias = Callable[[Dict[str, Any], Request, "ChatParams"], tuple[Dict[str, Any], "ChatParams"]]
+TracesRequestHook: TypeAlias = Callable[[Request, "TracesParams"], "TracesParams"]
+
+
+class ChatParams(BaseModel):
+    """Typed container for chat completion URL path parameters."""
+
+    project_id: Optional[str] = None
+    rollout_id: Optional[str] = None
+    invocation_id: Optional[str] = None
+    experiment_id: Optional[str] = None
+    run_id: Optional[str] = None
+    row_id: Optional[str] = None
+    encoded_base_url: Optional[str] = None
+
+
+class TracesParams(BaseModel):
+    """Typed container for traces query parameters and controls."""
+
+    tags: Optional[List[str]] = None
+    project_id: Optional[str] = None
+    limit: int = 100
+    sample_size: Optional[int] = None
+    user_id: Optional[str] = None
+    session_id: Optional[str] = None
+    name: Optional[str] = None
+    environment: Optional[str] = None
+    version: Optional[str] = None
+    release: Optional[str] = None
+    fields: Optional[str] = None
+    hours_back: Optional[int] = None
+    from_timestamp: Optional[str] = None
+    to_timestamp: Optional[str] = None
+    sleep_between_gets: float = 2.5
+    max_retries: int = 3
+
+
+class ProxyConfig(BaseModel):
+    """Configuration model for the LiteLLM Metadata Proxy"""
+
+    litellm_url: str
+    request_timeout: float = 300.0
+    langfuse_host: str
+    langfuse_keys: Dict[str, Dict[str, str]]
+    default_project_id: str
+    preprocess_chat_request: Optional[ChatRequestHook] = None
+    preprocess_traces_request: Optional[TracesRequestHook] = None
+
+
+class ObservationResponse(BaseModel):
+    """Response model for a single observation within a trace"""
+
+    id: str
+    type: Optional[str] = None
+    name: Optional[str] = None
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    input: Optional[Any] = None
+    output: Optional[Any] = None
+    parent_observation_id: Optional[str] = None
+
+
+class TraceResponse(BaseModel):
+    """Response model for a single trace"""
+
+    id: str
+    name: Optional[str] = None
+    user_id: Optional[str] = None
+    session_id: Optional[str] = None
+    tags: List[str] = []
+    timestamp: Optional[str] = None
+    input: Optional[Any] = None
+    output: Optional[Any] = None
+    metadata: Optional[Any] = None
+    observations: List[ObservationResponse] = []
+
+
+class LangfuseTracesResponse(BaseModel):
+    """Response model for the /traces endpoint"""
+
+    project_id: str
+    total_traces: int
+    traces: List[TraceResponse]

{eval_protocol-0.2.45.dev1 → eval_protocol-0.2.46.dev0/eval_protocol.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eval-protocol
-Version: 0.2.45.dev1
+Version: 0.2.46.dev0
 Summary: The official Python SDK for Eval Protocol (EP.) EP is an open protocol that standardizes how developers author evals for large language model (LLM) applications.
 Author-email: Fireworks AI <info@fireworks.ai>
 License-Expression: MIT

eval_protocol-0.2.45.dev1/eval_protocol/proxy/proxy_core/auth.py

@@ -1,12 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional
-
-
-class AuthProvider(ABC):
-    @abstractmethod
-    def validate(self, api_key: Optional[str]) -> Optional[str]: ...
-
-
-class NoAuthProvider(AuthProvider):
-    def validate(self, api_key: Optional[str]) -> Optional[str]:
-        return None

eval_protocol-0.2.45.dev1/eval_protocol/proxy/proxy_core/models.py

@@ -1,51 +0,0 @@
-"""
-Models for the LiteLLM Metadata Proxy.
-"""
-
-from pydantic import BaseModel
-from typing import Optional, List, Any, Dict
-
-
-class ProxyConfig(BaseModel):
-    """Configuration model for the LiteLLM Metadata Proxy"""
-
-    litellm_url: str
-    request_timeout: float = 300.0
-    langfuse_keys: Dict[str, Dict[str, str]]
-    default_project_id: str
-
-
-class ObservationResponse(BaseModel):
-    """Response model for a single observation within a trace"""
-
-    id: str
-    type: Optional[str] = None
-    name: Optional[str] = None
-    start_time: Optional[str] = None
-    end_time: Optional[str] = None
-    input: Optional[Any] = None
-    output: Optional[Any] = None
-    parent_observation_id: Optional[str] = None
-
-
-class TraceResponse(BaseModel):
-    """Response model for a single trace"""
-
-    id: str
-    name: Optional[str] = None
-    user_id: Optional[str] = None
-    session_id: Optional[str] = None
-    tags: List[str] = []
-    timestamp: Optional[str] = None
-    input: Optional[Any] = None
-    output: Optional[Any] = None
-    metadata: Optional[Any] = None
-    observations: List[ObservationResponse] = []
-
-
-class LangfuseTracesResponse(BaseModel):
-    """Response model for the /traces endpoint"""
-
-    project_id: str
-    total_traces: int
-    traces: List[TraceResponse]