veris-ai 1.7.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

veris_ai/README.md

@@ -49,8 +49,33 @@ Environment variables are processed in [`tool_mock.py`](tool_mock.py):
 - `VERIS_ENDPOINT_URL`: Mock server endpoint
 - `VERIS_MOCK_TIMEOUT`: Request timeout (default: 90s)  
 - `ENV`: Set to `"simulation"` for mock mode
-- `VERIS_SERVICE_NAME`: Tracing service identifier
-- `VERIS_OTLP_ENDPOINT`: OpenTelemetry collector endpoint
+
+### Observability (OTLP / Logfire)
+
+When using the observability helpers (`init_observability`, `instrument_fastapi_app`), configure the following environment variables so traces export correctly and are attributed to the right service name:
+
+- `OTEL_SERVICE_NAME` — e.g. `simulation-server` (keep consistent with any `VERIS_SERVICE_NAME` you use)
+- `OTEL_EXPORTER_OTLP_ENDPOINT` — e.g. `https://logfire-api.pydantic.dev`
+- `LOGFIRE_TOKEN` — API token for Logfire
+- `OTEL_EXPORTER_OTLP_HEADERS` — e.g. `Authorization=Bearer <LOGFIRE_TOKEN>` (quote the value)
+
+Minimal shell setup:
+
+```bash
+export OTEL_SERVICE_NAME="simulation-server"
+export OTEL_EXPORTER_OTLP_ENDPOINT="https://logfire-api.pydantic.dev"
+export LOGFIRE_TOKEN="<your-token>"
+export OTEL_EXPORTER_OTLP_HEADERS="Authorization=${LOGFIRE_TOKEN}"
+```
+
+Then in code:
+
+```python
+from veris_ai import init_observability, instrument_fastapi_app
+init_observability()
+app = FastAPI()
+instrument_fastapi_app(app)
+```
 
 ## Development Notes
 

veris_ai/__init__.py

@@ -1,12 +1,63 @@
 """Veris AI Python SDK."""
 
+from typing import Any
+
 __version__ = "0.1.0"
 
 # Import lightweight modules that only use base dependencies
 from .jaeger_interface import JaegerClient
 from .models import ResponseExpectation
-from .tool_mock import veris
 from .observability import init_observability, instrument_fastapi_app
+from .tool_mock import veris
+
+# Lazy import for modules with heavy dependencies
+_veris_runner = None
+_VerisConfig = None
+
+
+def veris_runner(*args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
+    """Lazy loader for the veris_runner function from agents_wrapper.
+
+    This function wraps OpenAI agents Runner.run to intercept tool calls
+    through the Veris SDK's mocking infrastructure.
+
+    This function requires the 'agents' extra dependencies:
+    pip install veris-ai[agents]
+    """
+    global _veris_runner  # noqa: PLW0603
+    if _veris_runner is None:
+        try:
+            from .agents_wrapper import veris_runner as _veris_runner_impl  # noqa: PLC0415
+
+            _veris_runner = _veris_runner_impl
+        except ImportError as e:
+            error_msg = (
+                "The 'veris_runner' function requires additional dependencies. "
+                "Please install them with: pip install veris-ai[agents]"
+            )
+            raise ImportError(error_msg) from e
+    return _veris_runner(*args, **kwargs)
+
+
+def __getattr__(name: str) -> Any:  # noqa: ANN401
+    """Lazy load VerisConfig class."""
+    global _VerisConfig  # noqa: PLW0603
+    if name == "VerisConfig":
+        if _VerisConfig is None:
+            try:
+                from .agents_wrapper import VerisConfig as _VerisConfig_impl  # noqa: PLC0415
+
+                _VerisConfig = _VerisConfig_impl
+            except ImportError as e:
+                error_msg = (
+                    "The 'VerisConfig' class requires additional dependencies. "
+                    "Please install them with: pip install veris-ai[agents]"
+                )
+                raise ImportError(error_msg) from e
+        return _VerisConfig
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)
+
 
 __all__ = [
     "veris",
@@ -14,4 +65,6 @@ __all__ = [
     "ResponseExpectation",
     "init_observability",
     "instrument_fastapi_app",
+    "veris_runner",
+    "VerisConfig",
 ]

veris_ai/agents_wrapper.py

@@ -0,0 +1,266 @@
+"""OpenAI Agents wrapper for automatic tool mocking via Veris SDK."""
+
+import asyncio
+import inspect
+import json
+import logging
+from collections.abc import Callable
+from typing import Any
+
+from agents import RunResult, Runner
+from pydantic import BaseModel
+
+from veris_ai import veris
+
+logger = logging.getLogger(__name__)
+
+
+def _wrap(
+    include_tools: list[str] | None = None,
+    exclude_tools: list[str] | None = None,
+) -> Callable:
+    """Private wrapper for OpenAI agents Runner to intercept tool calls through Veris SDK.
+
+    This function transparently intercepts tool calls from OpenAI agents and
+    routes them through the Veris SDK's mocking infrastructure.
+
+    Args:
+        include_tools: Optional list of tool names to intercept (only these if provided)
+        exclude_tools: Optional list of tool names to NOT intercept (these run normally)
+
+    Returns:
+        A wrapped Runner.run function
+
+    Raises:
+        ValueError: If both include_tools and exclude_tools are specified
+        ImportError: If agents package is not installed
+    """
+    if include_tools and exclude_tools:
+        msg = "Cannot specify both include_tools and exclude_tools"
+        raise ValueError(msg)
+
+    def wrapped_run_func(run_func: Callable) -> Callable:
+        """Inner wrapper that takes the actual Runner.run function."""
+        try:
+            from agents import FunctionTool  # type: ignore[import-untyped] # noqa: PLC0415
+        except ImportError as e:
+            msg = "openai-agents package not installed. Install with: pip install veris-ai[agents]"
+            raise ImportError(msg) from e
+
+        async def wrapped_run(starting_agent: Any, input_text: str, **kwargs: Any) -> Any:  # noqa: ANN401
+            """Wrapped version of Runner.run that intercepts tool calls."""
+            # Patch all tools in the agent
+            original_tools = []
+
+            if hasattr(starting_agent, "tools") and starting_agent.tools:
+                for tool in starting_agent.tools:
+                    if isinstance(tool, FunctionTool):
+                        tool_name = getattr(tool, "name", None)
+
+                        # Check if we should patch this tool
+                        if tool_name and _should_intercept_tool(
+                            tool_name, include_tools, exclude_tools
+                        ):
+                            # Save the original invoke function
+                            original_tools.append((tool, tool.on_invoke_tool))  # type: ignore[attr-defined]
+
+                            # Create veris-wrapped version
+                            tool.on_invoke_tool = _create_veris_wrapped_invoke(  # type: ignore[attr-defined]
+                                tool,
+                                tool.on_invoke_tool,  # type: ignore[attr-defined]
+                            )
+
+            try:
+                # Call the original Runner.run with the patched agent
+                return await run_func(starting_agent, input_text, **kwargs)
+            finally:
+                # Restore all original tool functions
+                for tool, original_invoke in original_tools:
+                    tool.on_invoke_tool = original_invoke  # type: ignore[attr-defined]
+
+        # Preserve function metadata
+        wrapped_run.__name__ = getattr(run_func, "__name__", "wrapped_run")
+        wrapped_run.__doc__ = getattr(run_func, "__doc__", "Wrapped Runner.run function")
+
+        # Also provide a sync version
+        def wrapped_run_sync(starting_agent: Any, input_text: str, **kwargs: Any) -> Any:  # noqa: ANN401
+            """Sync version of wrapped Runner.run."""
+            return asyncio.run(wrapped_run(starting_agent, input_text, **kwargs))
+
+        # Add sync version as an attribute
+        wrapped_run.run_sync = wrapped_run_sync  # type: ignore[attr-defined]
+
+        return wrapped_run
+
+    return wrapped_run_func
+
+
+def _should_intercept_tool(
+    tool_name: str,
+    include_tools: list[str] | None,
+    exclude_tools: list[str] | None,
+) -> bool:
+    """Determine if a tool should be intercepted based on include/exclude lists.
+
+    Args:
+        tool_name: Name of the tool
+        include_tools: If provided, only these tools are intercepted
+        exclude_tools: If provided, these tools are NOT intercepted
+
+    Returns:
+        True if the tool should be intercepted, False otherwise
+    """
+    if include_tools:
+        return tool_name in include_tools
+    if exclude_tools:
+        return tool_name not in exclude_tools
+    return True
+
+
+def _create_veris_wrapped_invoke(  # noqa: C901
+    tool: Any,  # noqa: ANN401
+    original_invoke: Callable,
+) -> Callable:
+    """Create a wrapped invoke function that uses veris.mock().
+
+    Args:
+        tool: The FunctionTool instance
+        original_invoke: The original on_invoke_tool function
+
+    Returns:
+        A wrapped invoke function that routes through Veris SDK
+    """
+    # Extract tool metadata
+    tool_name = tool.name
+    tool_schema = tool.params_json_schema if hasattr(tool, "params_json_schema") else {}
+
+    # Create a function that will be decorated with veris.mock()
+    @veris.mock(mode="tool")
+    async def veris_tool_function(**_kwargs: Any) -> Any:  # noqa: ANN401
+        """Mock function for tool execution."""
+        # This function's signature doesn't matter as veris.mock()
+        # will intercept and send the metadata to the endpoint
+        return f"Mock response for {tool_name}"
+
+    async def wrapped_invoke(context: Any, arguments: str) -> Any:  # noqa: ANN401
+        """Wrapped invoke function that routes through Veris SDK."""
+        # Only intercept if we have a session ID
+        if not veris.session_id:
+            # No session, run original
+            return await original_invoke(context, arguments)
+
+        # Parse arguments
+        try:
+            args_dict = json.loads(arguments) if arguments else {}
+        except json.JSONDecodeError:
+            args_dict = {"raw_arguments": arguments}
+
+        # Set up the function with proper metadata for veris.mock()
+        veris_tool_function.__name__ = tool_name
+        veris_tool_function.__doc__ = getattr(tool, "description", "")
+
+        # Add type hints based on schema if available
+        if tool_schema and "properties" in tool_schema:
+            # Create a simple signature based on schema
+            params = []
+            for param_name, param_info in tool_schema["properties"].items():
+                # Simplified type mapping
+                param_type: type[Any] = Any
+                if "type" in param_info:
+                    type_map = {
+                        "string": str,
+                        "number": float,
+                        "integer": int,
+                        "boolean": bool,
+                        "array": list,
+                        "object": dict,
+                    }
+                    param_type = type_map.get(param_info["type"], Any)
+                params.append(
+                    inspect.Parameter(
+                        param_name,
+                        inspect.Parameter.KEYWORD_ONLY,
+                        annotation=param_type,
+                    )
+                )
+
+            if params:
+                veris_tool_function.__signature__ = inspect.Signature(params)
+
+        # Call the veris-wrapped function with the arguments
+        try:
+            return await veris_tool_function(**args_dict)
+        except Exception as e:
+            # If mocking fails, fall back to original
+            logger.warning(f"Veris mock failed for {tool_name}, falling back to original: {e}")
+            return await original_invoke(context, arguments)
+
+    # Handle sync version if original is sync
+    if not asyncio.iscoroutinefunction(original_invoke):
+
+        def sync_wrapped_invoke(context: Any, arguments: str) -> Any:  # noqa: ANN401
+            """Sync version of wrapped invoke."""
+            return asyncio.run(wrapped_invoke(context, arguments))
+
+        return sync_wrapped_invoke
+
+    return wrapped_invoke
+
+
+class VerisConfig(BaseModel):
+    """Configuration for the Veris SDK."""
+
+    include_tools: list[str] | None = None
+    exclude_tools: list[str] | None = None
+
+
+def veris_runner(
+    starting_agent: Any,  # noqa: ANN401
+    input_text: str,
+    veris_config: VerisConfig | None = None,
+    **kwargs: Any,  # noqa: ANN401
+) -> RunResult:  # noqa: ANN401
+    """Veris-wrapped version of OpenAI agents Runner.run.
+
+    This function wraps the OpenAI agents Runner.run to intercept tool calls
+    and route them through the Veris SDK's mocking infrastructure. It can be
+    used as a drop-in replacement for Runner.run with an additional veris_config parameter.
+
+    Args:
+        starting_agent: The OpenAI agent to run
+        input_text: The input text to process
+        veris_config: Optional configuration for Veris SDK tool interception
+        **kwargs: Additional arguments to pass to Runner.run
+
+    Returns:
+        The result from Runner.run
+
+    Example:
+        ```python
+        from veris_ai import veris_runner, VerisConfig
+        from agents import Agent, FunctionTool
+
+        # Define your agent with tools
+        agent = Agent(...)
+
+        # Use veris_runner instead of Runner.run
+        result = await veris_runner(agent, "Process this input")
+
+        # Or with specific tool configuration
+        config = VerisConfig(include_tools=["calculator", "search"])
+        result = await veris_runner(agent, "Calculate 2+2", veris_config=config)
+        ```
+    """
+
+    # Extract config values
+    include_tools = None
+    exclude_tools = None
+    if veris_config:
+        include_tools = veris_config.include_tools
+        exclude_tools = veris_config.exclude_tools
+
+    # Create the wrapped version of Runner.run with the config
+    wrapped_run = _wrap(include_tools=include_tools, exclude_tools=exclude_tools)(Runner.run)
+
+    # Execute the wrapped run function
+    return wrapped_run(starting_agent, input_text, **kwargs)

veris_ai/api_client.py

@@ -0,0 +1,68 @@
+"""Centralized API client for VERIS simulation endpoints."""
+
+import logging
+import os
+from typing import Any
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+class SimulatorAPIClient:
+    """Centralized client for making requests to VERIS simulation endpoints."""
+
+    def __init__(self) -> None:
+        """Initialize the API client with configuration from environment variables."""
+        self.base_url = os.getenv("VERIS_API_URL", "https://simulation.api.veris.ai/")
+        self.api_key = os.getenv("VERIS_API_KEY")
+        self.timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
+
+    def _build_headers(self) -> dict[str, str] | None:
+        """Build headers including OpenTelemetry tracing and API key."""
+        headers: dict[str, str] | None = None
+        # Add API key header if available
+        if self.api_key:
+            if headers is None:
+                headers = {}
+            headers["x-api-key"] = self.api_key
+
+        return headers
+
+    async def post_async(self, endpoint: str, payload: dict[str, Any]) -> Any:  # noqa: ANN401
+        """Make an async POST request to the specified endpoint."""
+        headers = self._build_headers()
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            response = await client.post(endpoint, json=payload, headers=headers)
+            response.raise_for_status()
+            return response.json() if response.content else None
+
+    def post_sync(self, endpoint: str, payload: dict[str, Any]) -> Any:  # noqa: ANN401
+        """Make a synchronous POST request to the specified endpoint."""
+        headers = self._build_headers()
+        with httpx.Client(timeout=self.timeout) as client:
+            response = client.post(endpoint, json=payload, headers=headers)
+            response.raise_for_status()
+            return response.json() if response.content else None
+
+    @property
+    def tool_mock_endpoint(self) -> str:
+        """Get the tool mock endpoint URL."""
+        return f"{self.base_url}/v2/tool_mock"
+
+    def get_log_tool_call_endpoint(self, session_id: str) -> str:
+        """Get the log tool call endpoint URL."""
+        return f"{self.base_url}/v2/simulations/{session_id}/log_tool_call"
+
+    def get_log_tool_response_endpoint(self, session_id: str) -> str:
+        """Get the log tool response endpoint URL."""
+        return f"{self.base_url}/v2/simulations/{session_id}/log_tool_response"
+
+
+# Global singleton instance
+_api_client = SimulatorAPIClient()
+
+
+def get_api_client() -> SimulatorAPIClient:
+    """Get the global API client instance."""
+    return _api_client

veris_ai/logging.py

@@ -2,10 +2,9 @@
 
 import json
 import logging
-import os
 from typing import Any
 
-import httpx
+from veris_ai.api_client import get_api_client
 
 logger = logging.getLogger(__name__)
 
@@ -17,35 +16,18 @@ async def log_tool_call_async(
     docstring: str,
 ) -> None:
     """Log tool call asynchronously to the VERIS logging endpoint."""
-    base_url = os.getenv("VERIS_ENDPOINT_URL")
-    if not base_url:
-        logger.warning("VERIS_ENDPOINT_URL not set, skipping tool call logging")
-        return
-    base_url = base_url.rstrip("/")
+    api_client = get_api_client()
+    endpoint = api_client.get_log_tool_call_endpoint(session_id)
 
-    endpoint = f"{base_url}/api/v2/simulations/{session_id}/log_tool_call"
     payload = {
         "function_name": function_name,
         "parameters": parameters,
         "docstring": docstring,
     }
 
-    timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
-
     try:
-        headers: dict[str, str] | None = None
-        try:
-            from opentelemetry.propagate import get_global_textmap
-
-            headers = {}
-            get_global_textmap().inject(headers)
-        except Exception:  # pragma: no cover - otel optional
-            headers = None
-
-        async with httpx.AsyncClient(timeout=timeout) as client:
-            response = await client.post(endpoint, json=payload, headers=headers)
-            response.raise_for_status()
-            logger.debug(f"Tool call logged for {function_name}")
+        await api_client.post_async(endpoint, payload)
+        logger.debug(f"Tool call logged for {function_name}")
     except Exception as e:
         logger.warning(f"Failed to log tool call for {function_name}: {e}")
 
@@ -57,97 +39,49 @@ def log_tool_call_sync(
     docstring: str,
 ) -> None:
     """Log tool call synchronously to the VERIS logging endpoint."""
-    base_url = os.getenv("VERIS_ENDPOINT_URL")
-    if not base_url:
-        logger.warning("VERIS_ENDPOINT_URL not set, skipping tool call logging")
-        return
+    api_client = get_api_client()
+    endpoint = api_client.get_log_tool_call_endpoint(session_id)
 
-    endpoint = f"{base_url}/api/v2/simulations/{session_id}/log_tool_call"
     payload = {
         "function_name": function_name,
         "parameters": parameters,
         "docstring": docstring,
     }
 
-    timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
-
     try:
-        headers: dict[str, str] | None = None
-        try:
-            from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
-
-            headers = {}
-            get_global_textmap().inject(headers)
-        except Exception:  # pragma: no cover - otel optional
-            headers = None
-
-        with httpx.Client(timeout=timeout) as client:
-            response = client.post(endpoint, json=payload, headers=headers)
-            response.raise_for_status()
-            logger.debug(f"Tool call logged for {function_name}")
+        api_client.post_sync(endpoint, payload)
+        logger.debug(f"Tool call logged for {function_name}")
     except Exception as e:
         logger.warning(f"Failed to log tool call for {function_name}: {e}")
 
 
 async def log_tool_response_async(session_id: str, response: Any) -> None:  # noqa: ANN401
     """Log tool response asynchronously to the VERIS logging endpoint."""
-    base_url = os.getenv("VERIS_ENDPOINT_URL")
-    if not base_url:
-        logger.warning("VERIS_ENDPOINT_URL not set, skipping tool response logging")
-        return
+    api_client = get_api_client()
+    endpoint = api_client.get_log_tool_response_endpoint(session_id)
 
-    endpoint = f"{base_url}/api/v2/simulations/{session_id}/log_tool_response"
     payload = {
         "response": json.dumps(response, default=str),
     }
 
-    timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
-
     try:
-        headers: dict[str, str] | None = None
-        try:
-            from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
-
-            headers = {}
-            get_global_textmap().inject(headers)
-        except Exception:  # pragma: no cover - otel optional
-            headers = None
-
-        async with httpx.AsyncClient(timeout=timeout) as client:
-            http_response = await client.post(endpoint, json=payload, headers=headers)
-            http_response.raise_for_status()
-            logger.debug("Tool response logged")
+        await api_client.post_async(endpoint, payload)
+        logger.debug("Tool response logged")
     except Exception as e:
         logger.warning(f"Failed to log tool response: {e}")
 
 
 def log_tool_response_sync(session_id: str, response: Any) -> None:  # noqa: ANN401
     """Log tool response synchronously to the VERIS logging endpoint."""
-    base_url = os.getenv("VERIS_ENDPOINT_URL")
-    if not base_url:
-        logger.warning("VERIS_ENDPOINT_URL not set, skipping tool response logging")
-        return
+    api_client = get_api_client()
+    endpoint = api_client.get_log_tool_response_endpoint(session_id)
 
-    endpoint = f"{base_url}/api/v2/simulations/{session_id}/log_tool_response"
     payload = {
         "response": json.dumps(response, default=str),
     }
 
-    timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
-
     try:
-        headers: dict[str, str] | None = None
-        try:
-            from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
-
-            headers = {}
-            get_global_textmap().inject(headers)
-        except Exception:  # pragma: no cover - otel optional
-            headers = None
-
-        with httpx.Client(timeout=timeout) as client:
-            http_response = client.post(endpoint, json=payload, headers=headers)
-            http_response.raise_for_status()
-            logger.debug("Tool response logged")
+        api_client.post_sync(endpoint, payload)
+        logger.debug("Tool response logged")
     except Exception as e:
         logger.warning(f"Failed to log tool response: {e}")

veris_ai/observability.py

@@ -7,12 +7,13 @@ enable consistent tracing without duplicating setup code.
 
 from __future__ import annotations
 
-import os
-
 from fastapi import FastAPI
+from logging import getLogger
+
+logger = getLogger(__name__)
 
 
-def init_observability(service_name: str | None = None) -> None:
+def init_observability() -> None:  # noqa: PLR0912
     """Initialize tracing/export and set W3C propagation.
 
     - Initializes Traceloop if available (acts as OTel bootstrap/exporter)
@@ -22,17 +23,14 @@ def init_observability(service_name: str | None = None) -> None:
 
     This function is safe to call even if instrumentation packages are not installed.
     """
-
-    resolved_service_name = service_name or os.getenv("VERIS_SERVICE_NAME", "veris-service")
-
-    # Initialize Traceloop SDK first (acts as OTel bootstrap)
     try:
-        from traceloop.sdk import Traceloop  # type: ignore[import-not-found, import-untyped]
+        import logfire
 
-        Traceloop.init(app_name=resolved_service_name, disable_batch=True)
+        logfire.configure(scrubbing=False)
+        logfire.instrument_openai_agents()
     except Exception as e:
         # Tracing is optional; continue without Traceloop
-        msg = "Traceloop not found: " + str(e)
+        msg = "Logfire not found: " + str(e)
         raise RuntimeError(msg) from e
 
     # Ensure W3C propagation (TraceContext + optional Baggage), tolerant to OTel versions

veris_ai/tool_mock.py

@@ -1,7 +1,6 @@
 import inspect
 import json
 import logging
-import os
 from collections.abc import Callable
 from contextlib import suppress
 from contextvars import ContextVar
@@ -13,8 +12,6 @@ from typing import (
     get_type_hints,
 )
 
-import httpx
-
 from veris_ai.logging import (
     log_tool_call_async,
     log_tool_call_sync,
@@ -22,7 +19,8 @@ from veris_ai.logging import (
     log_tool_response_sync,
 )
 from veris_ai.models import ResponseExpectation
-from veris_ai.utils import convert_to_type, extract_json_schema
+from veris_ai.api_client import get_api_client
+from veris_ai.utils import convert_to_type, extract_json_schema, get_function_parameters
 
 logger = logging.getLogger(__name__)
 
@@ -113,27 +111,15 @@ class VerisSDK:
 
             def create_mock_payload(
                 *args: tuple[object, ...],
-                **kwargs: dict[str, object],
+                **kwargs: Any,  # noqa: ANN401
             ) -> tuple[dict[str, Any], Any]:
                 """Create the mock payload - shared logic for both sync and async."""
-                sig = inspect.signature(func)
                 type_hints = get_type_hints(func)
 
                 # Extract return type object (not just the name)
                 return_type_obj = type_hints.pop("return", Any)
                 # Create parameter info
-                params_info = {}
-                bound_args = sig.bind(*args, **kwargs)
-                bound_args.apply_defaults()
-                _ = bound_args.arguments.pop("ctx", None)
-                _ = bound_args.arguments.pop("self", None)
-                _ = bound_args.arguments.pop("cls", None)
-
-                for param_name, param_value in bound_args.arguments.items():
-                    params_info[param_name] = {
-                        "value": str(param_value),
-                        "type": str(type_hints.get(param_name, Any)),
-                    }
+                parameters = get_function_parameters(func, args, kwargs)
                 # Get function docstring
                 docstring = inspect.getdoc(func) or ""
                 nonlocal expects_response
@@ -154,7 +140,7 @@ class VerisSDK:
                     "cache_response": bool(cache_response) if cache_response is not None else False,
                     "tool_call": {
                         "function_name": func.__name__,
-                        "parameters": params_info,
+                        "parameters": parameters,
                         "return_type": json.dumps(extract_json_schema(return_type_obj)),
                         "docstring": docstring,
                     },
@@ -165,7 +151,7 @@ class VerisSDK:
             @wraps(func)
             async def async_wrapper(
                 *args: tuple[object, ...],
-                **kwargs: dict[str, object],
+                **kwargs: Any,  # noqa: ANN401
             ) -> object:
                 # Check if we're in simulation mode
                 if not self.session_id:
@@ -178,17 +164,12 @@ class VerisSDK:
                         logger.info(f"Spying on function: {func.__name__}")
 
                         # Log the tool call
-                        sig = inspect.signature(func)
-                        bound_args = sig.bind(*args, **kwargs)
-                        bound_args.apply_defaults()
-                        _ = bound_args.arguments.pop("ctx", None)
-                        _ = bound_args.arguments.pop("self", None)
-                        _ = bound_args.arguments.pop("cls", None)
+                        parameters = get_function_parameters(func, args, kwargs)
 
                         await log_tool_call_async(
                             session_id=session_id,
                             function_name=func.__name__,
-                            parameters=bound_args.arguments,
+                            parameters=parameters,
                             docstring=inspect.getdoc(func) or "",
                         )
 
@@ -201,33 +182,15 @@ class VerisSDK:
                         return result
 
                     # Regular mock mode
-                    base_url = os.getenv("VERIS_ENDPOINT_URL")
-                    if not base_url:
-                        error_msg = "VERIS_ENDPOINT_URL environment variable is not set"
-                        raise ValueError(error_msg)
-                    endpoint = f"{base_url.rstrip('/')}/api/v2/tool_mock"
-                    # Default timeout of 30 seconds
-                    timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
+                    api_client = get_api_client()
+                    endpoint = api_client.tool_mock_endpoint
 
                     logger.info(f"Simulating function: {func.__name__}")
                     payload, return_type_obj = create_mock_payload(*args, **kwargs)
 
-                    # Send request to endpoint with timeout
-                    # Inject current trace context headers if OpenTelemetry is available
-                    headers: dict[str, str] | None = None
-                    try:
-                        from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
-
-                        headers = {}
-                        get_global_textmap().inject(headers)
-                    except Exception:  # pragma: no cover - otel optional
-                        headers = None
-
-                    async with httpx.AsyncClient(timeout=timeout) as client:
-                        response = await client.post(endpoint, json=payload, headers=headers)
-                        response.raise_for_status()
-                        mock_result = response.json()
-                        logger.info(f"Mock response: {mock_result}")
+                    # Send request to endpoint
+                    mock_result = await api_client.post_async(endpoint, payload)
+                    logger.info(f"Mock response: {mock_result}")
 
                     if isinstance(mock_result, str):
                         with suppress(json.JSONDecodeError):
@@ -252,7 +215,7 @@ class VerisSDK:
             @wraps(func)
             def sync_wrapper(
                 *args: tuple[object, ...],
-                **kwargs: dict[str, object],
+                **kwargs: Any,  # noqa: ANN401
             ) -> object:
                 # Check if we're in simulation mode
                 if not self.session_id:
@@ -265,17 +228,12 @@ class VerisSDK:
                         logger.info(f"Spying on function: {func.__name__}")
 
                         # Log the tool call
-                        sig = inspect.signature(func)
-                        bound_args = sig.bind(*args, **kwargs)
-                        bound_args.apply_defaults()
-                        _ = bound_args.arguments.pop("ctx", None)
-                        _ = bound_args.arguments.pop("self", None)
-                        _ = bound_args.arguments.pop("cls", None)
+                        parameters = get_function_parameters(func, args, kwargs)
 
                         log_tool_call_sync(
                             session_id=session_id,
                             function_name=func.__name__,
-                            parameters=bound_args.arguments,
+                            parameters=parameters,
                             docstring=inspect.getdoc(func) or "",
                         )
 
@@ -288,33 +246,15 @@ class VerisSDK:
                         return result
 
                     # Regular mock mode
-                    base_url = os.getenv("VERIS_ENDPOINT_URL")
-                    if not base_url:
-                        error_msg = "VERIS_ENDPOINT_URL environment variable is not set"
-                        raise ValueError(error_msg)
-                    endpoint = f"{base_url.rstrip('/')}/api/v2/tool_mock"
-                    # Default timeout of 30 seconds
-                    timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
+                    api_client = get_api_client()
+                    endpoint = api_client.tool_mock_endpoint
 
                     logger.info(f"Simulating function: {func.__name__}")
                     payload, return_type_obj = create_mock_payload(*args, **kwargs)
 
-                    # Send request to endpoint with timeout (synchronous)
-                    # Inject current trace context headers if OpenTelemetry is available
-                    headers: dict[str, str] | None = None
-                    try:
-                        from opentelemetry.propagate import get_global_textmap  # type: ignore[import-not-found]
-
-                        headers = {}
-                        get_global_textmap().inject(headers)
-                    except Exception:  # pragma: no cover - otel optional
-                        headers = None
-
-                    with httpx.Client(timeout=timeout) as client:
-                        response = client.post(endpoint, json=payload, headers=headers)
-                        response.raise_for_status()
-                        mock_result = response.json()
-                        logger.info(f"Mock response: {mock_result}")
+                    # Send request to endpoint
+                    mock_result = api_client.post_sync(endpoint, payload)
+                    logger.info(f"Mock response: {mock_result}")
 
                     if isinstance(mock_result, str):
                         with suppress(json.JSONDecodeError):
@@ -351,7 +291,7 @@ class VerisSDK:
             @wraps(func)
             async def async_wrapper(
                 *args: tuple[object, ...],
-                **kwargs: dict[str, object],
+                **kwargs: Any,  # noqa: ANN401
             ) -> object:
                 if not self.session_id:
                     # If not in simulation mode, execute the original function
@@ -360,7 +300,7 @@ class VerisSDK:
                 return return_value
 
             @wraps(func)
-            def sync_wrapper(*args: tuple[object, ...], **kwargs: dict[str, object]) -> object:
+            def sync_wrapper(*args: tuple[object, ...], **kwargs: Any) -> object:  # noqa: ANN401
                 if not self.session_id:
                     # If not in simulation mode, execute the original function
                     return func(*args, **kwargs)

veris_ai/utils.py

@@ -1,8 +1,10 @@
+import inspect
 import sys
 import types
 import typing
 from contextlib import suppress
 from typing import Any, ForwardRef, Literal, NotRequired, Required, Union, get_args, get_origin
+from collections.abc import Callable
 
 from pydantic import BaseModel
 
@@ -272,3 +274,16 @@ def extract_json_schema(target_type: Any) -> dict:  # noqa: PLR0911, PLR0912, C9
 
     # Default case for unknown types
     return {"type": "object"}
+
+
+def get_function_parameters(
+    func: Callable, args: tuple[object, ...], kwargs: dict[str, object]
+) -> dict[str, object]:
+    """Get the parameters for a function."""
+    sig = inspect.signature(func)
+    bound_args = sig.bind(*args, **kwargs)
+    bound_args.apply_defaults()
+    _ = bound_args.arguments.pop("ctx", None)
+    _ = bound_args.arguments.pop("self", None)
+    _ = bound_args.arguments.pop("cls", None)
+    return bound_args.arguments

{veris_ai-1.7.0.dist-info → veris_ai-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 1.7.0
+Version: 1.8.0
 Summary: A Python package for Veris AI tools
 Project-URL: Homepage, https://github.com/veris-ai/veris-python-sdk
 Project-URL: Bug Tracker, https://github.com/veris-ai/veris-python-sdk/issues
@@ -9,6 +9,7 @@ License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.24.0
+Requires-Dist: logfire>=4.3.3
 Requires-Dist: opentelemetry-api>=1.34.1
 Requires-Dist: opentelemetry-exporter-otlp>=1.34.1
 Requires-Dist: opentelemetry-instrumentation-fastapi>=0.55b1
@@ -19,11 +20,12 @@ Requires-Dist: opentelemetry-instrumentation>=0.55b1
 Requires-Dist: opentelemetry-sdk>=1.34.1
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: requests>=2.31.0
-Requires-Dist: traceloop-sdk>=0.45.4
+Provides-Extra: agents
+Requires-Dist: openai-agents>=0.0.1; extra == 'agents'
 Provides-Extra: dev
 Requires-Dist: black>=23.7.0; extra == 'dev'
 Requires-Dist: mypy>=1.5.1; extra == 'dev'
-Requires-Dist: openai-agents>=0.0.1; extra == 'dev'
+Requires-Dist: openai-agents>=0.2.5; extra == 'dev'
 Requires-Dist: pre-commit>=3.3.3; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21.1; extra == 'dev'
 Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
@@ -45,7 +47,7 @@ A Python package for Veris AI tools with simulation capabilities and FastAPI MCP
 ## Quick Reference
 
 **Purpose**: Tool mocking, tracing, and FastAPI MCP integration for AI agent development  
-**Core Components**: [`tool_mock`](#function-mocking) • [`observability`](#sdk-observability-helpers) • [`fastapi_mcp`](#fastapi-mcp-integration) • [`jaeger_interface`](#jaeger-trace-interface)  
+**Core Components**: [`tool_mock`](#function-mocking) • [`api_client`](src/veris_ai/api_client.py) • [`observability`](#sdk-observability-helpers) • [`fastapi_mcp`](#fastapi-mcp-integration) • [`jaeger_interface`](#jaeger-trace-interface)  
 **Deep Dive**: [`Module Architecture`](src/veris_ai/README.md) • [`Testing Guide`](tests/README.md) • [`Usage Examples`](examples/README.md)  
 **Source of Truth**: Implementation details in [`src/veris_ai/`](src/veris_ai/) source code
 
@@ -84,13 +86,14 @@ from veris_ai import init_observability, instrument_fastapi_app  # Provided by S
 
 | Variable | Purpose | Default |
 |----------|---------|---------|
-| `VERIS_ENDPOINT_URL` | Mock server endpoint | *Required* |
+| `VERIS_API_KEY` | API authentication key | None |
 | `VERIS_MOCK_TIMEOUT` | Request timeout (seconds) | `90.0` |
 | `ENV` | Set to `"simulation"` for mock mode | Production |
-| `VERIS_SERVICE_NAME` | Tracing service name | Auto-detected |
-| `VERIS_OTLP_ENDPOINT` | OpenTelemetry collector | *Required for tracing* |
 
-**Configuration Details**: See [`src/veris_ai/tool_mock.py`](src/veris_ai/tool_mock.py) for environment handling logic.
+**Advanced Configuration** (rarely needed):
+- `VERIS_API_URL`: Override default API endpoint (defaults to production)
+
+**Configuration Details**: See [`src/veris_ai/api_client.py`](src/veris_ai/api_client.py) for API configuration and [`src/veris_ai/tool_mock.py`](src/veris_ai/tool_mock.py) for environment handling logic.
 
 
 ### SDK Observability Helpers
@@ -102,7 +105,7 @@ from fastapi import FastAPI
 from veris_ai import init_observability, instrument_fastapi_app
 
 # Initialize tracing/export early (no-op if dependencies are absent)
-init_observability(service_name="my-customer-service")
+init_observability()
 
 app = FastAPI()
 
@@ -110,6 +113,35 @@ app = FastAPI()
 instrument_fastapi_app(app)
 ```
 
+#### Observability Environment
+
+Set these environment variables to enable exporting traces via OTLP (Logfire) and ensure consistent service naming:
+
+| Variable | Example | Notes |
+|----------|---------|-------|
+| `OTEL_SERVICE_NAME` | `simulation-server` | Should match `VERIS_SERVICE_NAME` used elsewhere to keep traces aligned |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | `https://logfire-api.pydantic.dev` | OTLP HTTP endpoint |
+| `LOGFIRE_TOKEN` | `FILL_IN` | Logfire API token used by the exporter |
+| `OTEL_EXPORTER_OTLP_HEADERS` | `'Authorization=FILL_IN'` | Include quotes to preserve the `=`; often `Authorization=Bearer <LOGFIRE_TOKEN>` |
+
+Quick setup example:
+
+```bash
+export OTEL_SERVICE_NAME="simulation-server"
+export OTEL_EXPORTER_OTLP_ENDPOINT="https://logfire-api.pydantic.dev"
+export LOGFIRE_TOKEN="<your-token>"
+export OTEL_EXPORTER_OTLP_HEADERS="Authorization=${LOGFIRE_TOKEN}"
+```
+
+Then initialize in code early in your process:
+
+```python
+from veris_ai import init_observability, instrument_fastapi_app
+init_observability()
+app = FastAPI()
+instrument_fastapi_app(app)
+```
+
 What this enables:
 - Sets global W3C propagator (TraceContext + Baggage)
 - Optionally instruments FastAPI, requests, httpx, MCP client if installed
@@ -222,7 +254,7 @@ pytest --cov=veris_ai # Test with coverage
 
 **Semantic Tag**: `module-architecture`
 
-**Core Modules**: `tool_mock` (mocking), `jaeger_interface` (trace queries), `utils` (schema conversion)
+**Core Modules**: `tool_mock` (mocking), `api_client` (centralized API), `jaeger_interface` (trace queries), `utils` (schema conversion)
 
 **Complete Architecture**: See [`src/veris_ai/README.md`](src/veris_ai/README.md) for module overview, implementation flows, and configuration details. 
 

veris_ai-1.8.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+veris_ai/README.md,sha256=0EC-yWB8FtqAhtcE5Q204bS1JWJPIvfpp1bPDo6iwwc,3601
+veris_ai/__init__.py,sha256=mFEF2pHXOAXoXuBh9IOQgqpKGvzLOsy8b0vUpMRJggU,2260
+veris_ai/agents_wrapper.py,sha256=-8R2yTkEQjHQJxkWBK5tqMHzmlPjfDpybD9_UpsSjLk,9971
+veris_ai/api_client.py,sha256=afvVvg9DXSHgnr0p411yXo3_8UM7EeiIoqm1q_goYgI,2602
+veris_ai/logging.py,sha256=Dr7dQtTK_WvUAtSpif79Srf5YpSLwDVlWs0XsQGOdu4,2595
+veris_ai/models.py,sha256=6HINPxNFCakCVPcyEbUswWkXwb2K4lF0A8g8EvTMal4,213
+veris_ai/observability.py,sha256=fDtWeUexfzaIQArE5YbWsja8Y-bcE_h0dXQWYbXbupY,4929
+veris_ai/tool_mock.py,sha256=77KxBy0mAxC58sXYs_jPHBT_2oEkXybsUGKzOOLH93w,13334
+veris_ai/utils.py,sha256=bSutoMYQAboo9nHZ4yAsOGIDEoc1zaoIXCoJr4yTvBw,9771
+veris_ai/jaeger_interface/README.md,sha256=kd9rKcE5xf3EyNaiHu0tjn-0oES9sfaK6Ih-OhhTyCM,2821
+veris_ai/jaeger_interface/__init__.py,sha256=KD7NSiMYRG_2uF6dOLKkGG5lNQe4K9ptEwucwMT4_aw,1128
+veris_ai/jaeger_interface/client.py,sha256=yJrh86wRR0Dk3Gq12DId99WogcMIVbL0QQFqVSevvlE,8772
+veris_ai/jaeger_interface/models.py,sha256=e64VV6IvOEFuzRUgvDAMQFyOZMRb56I-PUPZLBZ3rX0,1864
+veris_ai-1.8.0.dist-info/METADATA,sha256=r79b39D4sUnlT2sJWNxbMk2Y1ES4pRVLkaO0K7BYsDc,9935
+veris_ai-1.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+veris_ai-1.8.0.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
+veris_ai-1.8.0.dist-info/RECORD,,

veris_ai-1.7.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-veris_ai/README.md,sha256=iMSwSIrBO2zEdUhImkhZucUnTNO0kSQ-_zxWjZCmp4I,2730
-veris_ai/__init__.py,sha256=Gh52-XfFpsxX37uqp8vuX0V3Np7f-Rlf5k3MMANu6e0,425
-veris_ai/logging.py,sha256=srEdVimcQSCsnwGhyzCydehD2JW1cQmwSRd3X20NQs0,5233
-veris_ai/models.py,sha256=6HINPxNFCakCVPcyEbUswWkXwb2K4lF0A8g8EvTMal4,213
-veris_ai/observability.py,sha256=fG5ixAiVDykLCdHUScKQNCsePLphKQ7PcaKkAGBVdF0,5113
-veris_ai/tool_mock.py,sha256=C1BANT3LCMKOIwJm_nOFuNdHnaO9_tbjeDTtBcI41RI,16512
-veris_ai/utils.py,sha256=aqFFNuNiBehil6874nOHtU7G_bWHbFpVuubcz2AIx6I,9267
-veris_ai/jaeger_interface/README.md,sha256=kd9rKcE5xf3EyNaiHu0tjn-0oES9sfaK6Ih-OhhTyCM,2821
-veris_ai/jaeger_interface/__init__.py,sha256=KD7NSiMYRG_2uF6dOLKkGG5lNQe4K9ptEwucwMT4_aw,1128
-veris_ai/jaeger_interface/client.py,sha256=yJrh86wRR0Dk3Gq12DId99WogcMIVbL0QQFqVSevvlE,8772
-veris_ai/jaeger_interface/models.py,sha256=e64VV6IvOEFuzRUgvDAMQFyOZMRb56I-PUPZLBZ3rX0,1864
-veris_ai-1.7.0.dist-info/METADATA,sha256=dmWFBpwU2MK9tjnJtlrkQdqnR9C0yn0Lhb1TMWb-XvA,8679
-veris_ai-1.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-veris_ai-1.7.0.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
-veris_ai-1.7.0.dist-info/RECORD,,