veris-ai 1.7.0__py3-none-any.whl → 1.8.1__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,283 @@
+"""OpenAI Agents wrapper for automatic tool mocking via Veris SDK."""
+
+import logging
+from collections.abc import Callable
+from typing import Any
+
+from agents import RunContextWrapper, RunResult, Runner
+from pydantic import BaseModel
+
+from veris_ai import veris
+from veris_ai.tool_mock import mock_tool_call
+
+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."""
+            # Store a mapping of tools to their original functions
+            tool_functions = {}
+
+            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
+                        ):
+                            # Extract the original function before patching
+                            original_func = _extract_the_func(tool.on_invoke_tool)
+                            if original_func:
+                                tool_functions[id(tool)] = original_func
+
+                            # Store original on_invoke_tool
+                            original_on_invoke = tool.on_invoke_tool
+
+                            def make_wrapped_on_invoke_tool(
+                                tool_id: int, orig_invoke: Callable
+                            ) -> Callable:
+                                """Create a wrapped on_invoke_tool with proper closure."""
+
+                                async def wrapped_on_invoke_tool(
+                                    ctx: RunContextWrapper[Any], parameters: str
+                                ) -> Any:  # noqa: ANN401
+                                    """Wrapped on_invoke_tool that intercepts the tool function."""
+                                    session_id = veris.session_id
+                                    the_func = tool_functions.get(tool_id)
+                                    if the_func and session_id:
+                                        # mock_tool_call is synchronous, don't await it
+                                        return mock_tool_call(
+                                            the_func, session_id, parameters, None
+                                        )
+                                    # Fall back to original if we couldn't extract the function
+                                    return await orig_invoke(ctx, parameters)
+
+                                return wrapped_on_invoke_tool
+
+                            tool.on_invoke_tool = make_wrapped_on_invoke_tool(
+                                id(tool), original_on_invoke
+                            )
+            return await run_func(starting_agent, input_text, **kwargs)
+
+        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 _extract_the_func(on_invoke_tool: Callable) -> Callable | None:
+    """Extract the original user function from the on_invoke_tool closure.
+
+    This function attempts multiple strategies to extract the original function:
+    1. Direct attribute access (if the tool stores it)
+    2. Closure inspection for known patterns
+    3. Deep closure traversal as a fallback
+
+    Args:
+        on_invoke_tool: The on_invoke_tool function from FunctionTool
+
+    Returns:
+        The original user function if found, None otherwise
+    """
+
+    # Strategy 1: Check if the tool has stored the original function as an attribute
+    # (This would be the cleanest approach if the agents library supported it)
+    if hasattr(on_invoke_tool, "__wrapped__"):
+        return on_invoke_tool.__wrapped__
+
+    # Strategy 2: Look for the function in the closure using known structure
+    # Based on the agents library implementation, we know:
+    # - on_invoke_tool has _on_invoke_tool_impl in its closure
+    # - _on_invoke_tool_impl has the_func in its closure
+
+    if not hasattr(on_invoke_tool, "__closure__") or not on_invoke_tool.__closure__:
+        return None
+
+    # Find _on_invoke_tool_impl by looking for a function with that name pattern
+    for cell in on_invoke_tool.__closure__:
+        try:
+            obj = cell.cell_contents
+            if not callable(obj):
+                continue
+
+            # Check if this looks like _on_invoke_tool_impl
+            if (
+                hasattr(obj, "__name__")
+                and "_on_invoke_tool_impl" in obj.__name__
+                and hasattr(obj, "__closure__")
+                and obj.__closure__
+            ):
+                # Now look for the_func in its closure
+                return _find_user_function_in_closure(obj.__closure__)
+        except (ValueError, AttributeError):
+            continue
+
+    # Strategy 3: Fallback - do a broader search in the closure
+    return _find_user_function_in_closure(on_invoke_tool.__closure__)
+
+
+def _find_user_function_in_closure(closure: tuple) -> Callable | None:
+    """Find the user function in a closure by filtering out known library functions.
+
+    Args:
+        closure: The closure tuple to search
+
+    Returns:
+        The user function if found, None otherwise
+    """
+    import inspect
+
+    # List of module prefixes that indicate library/framework code
+    library_modules = ("json", "inspect", "agents", "pydantic", "openai", "typing")
+
+    for cell in closure:
+        try:
+            obj = cell.cell_contents
+
+            # Must be callable but not a class
+            if not callable(obj) or isinstance(obj, type):
+                continue
+
+            # Skip private/internal functions
+            if hasattr(obj, "__name__") and obj.__name__.startswith("_"):
+                continue
+
+            # Check the module to filter out library code
+            module = inspect.getmodule(obj)
+            if module:
+                # Skip if it's from a known library
+                if module.__name__.startswith(library_modules):
+                    continue
+
+                # Skip if it's from site-packages (library code)
+                if (
+                    hasattr(module, "__file__")
+                    and module.__file__
+                    and "site-packages" in module.__file__
+                    # Unless it's user code installed as a package
+                    # (this is a heuristic - may need adjustment)
+                    and not any(pkg in module.__name__ for pkg in ["my_", "custom_", "app_"])
+                ):
+                    continue
+
+            # If we made it here, this is likely the user function
+            return obj
+
+        except (ValueError, AttributeError):
+            continue
+
+    return None
+
+
+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,60 @@
+"""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
+
+    def post(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,152 +2,45 @@
 
 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__)
 
 
-async def log_tool_call_async(
+def log_tool_call(
     session_id: str,
     function_name: str,
-    parameters: dict[str, Any],
-    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("/")
-
-    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}")
-    except Exception as e:
-        logger.warning(f"Failed to log tool call for {function_name}: {e}")
-
-
-def log_tool_call_sync(
-    session_id: str,
-    function_name: str,
-    parameters: dict[str, Any],
+    parameters: str,
     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
-
-    endpoint = f"{base_url}/api/v2/simulations/{session_id}/log_tool_call"
+    api_client = get_api_client()
+    endpoint = api_client.get_log_tool_call_endpoint(session_id)
     payload = {
         "function_name": function_name,
-        "parameters": parameters,
+        "parameters": json.loads(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(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
-
-    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")
-    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
+def log_tool_response(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(endpoint, payload)
+        logger.debug("Tool response logged")
     except Exception as e:
         logger.warning(f"Failed to log tool response: {e}")

veris_ai/models.py

@@ -1,6 +1,9 @@
 """Models for the VERIS SDK."""
 
 from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel
 
 
 class ResponseExpectation(str, Enum):
@@ -9,3 +12,11 @@ class ResponseExpectation(str, Enum):
     AUTO = "auto"
     REQUIRED = "required"
     NONE = "none"
+
+
+class ToolCallOptions(BaseModel):
+    """Options for tool call."""
+
+    response_expectation: ResponseExpectation = ResponseExpectation.AUTO
+    cache_response: bool = False
+    mode: Literal["tool", "function", "spy"] = "tool"

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,16 +12,14 @@ from typing import (
     get_type_hints,
 )
 
-import httpx
 
 from veris_ai.logging import (
-    log_tool_call_async,
-    log_tool_call_sync,
-    log_tool_response_async,
-    log_tool_response_sync,
+    log_tool_call,
+    log_tool_response,
 )
-from veris_ai.models import ResponseExpectation
-from veris_ai.utils import convert_to_type, extract_json_schema
+from veris_ai.models import ResponseExpectation, ToolCallOptions
+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__)
 
@@ -98,243 +95,109 @@ class VerisSDK:
             **params_dict,
         )
 
+    def spy(self) -> Callable:
+        """Decorator for spying on tool calls."""
+
+        def decorator(func: Callable) -> Callable:
+            """Decorator for spying on tool calls."""
+            is_async = inspect.iscoroutinefunction(func)
+
+            @wraps(func)
+            async def async_wrapper(*args: tuple[object, ...], **kwargs: Any) -> object:  # noqa: ANN401
+                """Async wrapper."""
+                session_id = _session_id_context.get()
+                if not session_id:
+                    return await func(*args, **kwargs)
+                parameters = get_function_parameters(func, args, kwargs)
+                logger.info(f"Spying on function: {func.__name__}")
+                log_tool_call(
+                    session_id=session_id,
+                    function_name=func.__name__,
+                    parameters=parameters,
+                    docstring=inspect.getdoc(func) or "",
+                )
+                result = await func(*args, **kwargs)
+                log_tool_response(session_id=session_id, response=result)
+                return result
+
+            @wraps(func)
+            def sync_wrapper(*args: tuple[object, ...], **kwargs: Any) -> object:  # noqa: ANN401
+                """Sync wrapper."""
+                session_id = _session_id_context.get()
+                if not session_id:
+                    return func(*args, **kwargs)
+                parameters = get_function_parameters(func, args, kwargs)
+                logger.info(f"Spying on function: {func.__name__}")
+                log_tool_call(
+                    session_id=session_id,
+                    function_name=func.__name__,
+                    parameters=parameters,
+                    docstring=inspect.getdoc(func) or "",
+                )
+                result = func(*args, **kwargs)
+                log_tool_response(session_id=session_id, response=result)
+                return result
+
+            return async_wrapper if is_async else sync_wrapper
+
+        return decorator
+
     def mock(  # noqa: C901, PLR0915
         self,
-        mode: Literal["tool", "function", "spy"] = "tool",
+        mode: Literal["tool", "function"] = "tool",
         expects_response: bool | None = None,
         cache_response: bool | None = None,
     ) -> Callable:
         """Decorator for mocking tool calls."""
+        response_expectation = (
+            ResponseExpectation.NONE
+            if (expects_response is False or (expects_response is None and mode == "function"))
+            else ResponseExpectation.REQUIRED
+            if expects_response is True
+            else ResponseExpectation.AUTO
+        )
+        cache_response = cache_response or False
+        options = ToolCallOptions(
+            mode=mode, response_expectation=response_expectation, cache_response=cache_response
+        )
 
         def decorator(func: Callable) -> Callable:  # noqa: C901, PLR0915
             """Decorator for mocking tool calls."""
-            # Check if the original function is async
             is_async = inspect.iscoroutinefunction(func)
 
-            def create_mock_payload(
-                *args: tuple[object, ...],
-                **kwargs: dict[str, object],
-            ) -> 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)),
-                    }
-                # Get function docstring
-                docstring = inspect.getdoc(func) or ""
-                nonlocal expects_response
-                if expects_response is None and mode == "function":
-                    expects_response = False
-                # Prepare payload
-                # Convert expects_response to response_expectation enum
-                if expects_response is False:
-                    response_expectation = ResponseExpectation.NONE
-                elif expects_response is True:
-                    response_expectation = ResponseExpectation.REQUIRED
-                else:
-                    response_expectation = ResponseExpectation.AUTO
-
-                payload = {
-                    "session_id": self.session_id,
-                    "response_expectation": response_expectation.value,
-                    "cache_response": bool(cache_response) if cache_response is not None else False,
-                    "tool_call": {
-                        "function_name": func.__name__,
-                        "parameters": params_info,
-                        "return_type": json.dumps(extract_json_schema(return_type_obj)),
-                        "docstring": docstring,
-                    },
-                }
-
-                return payload, return_type_obj
-
             @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:
-                    # If not in simulation mode, execute the original function
+                """Async wrapper."""
+                session_id = _session_id_context.get()
+                if not session_id:
                     return await func(*args, **kwargs)
-
-                async def _execute_mock_logic(session_id: str) -> object:
-                    # Handle spy mode - execute original function and log
-                    if mode == "spy":
-                        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)
-
-                        await log_tool_call_async(
-                            session_id=session_id,
-                            function_name=func.__name__,
-                            parameters=bound_args.arguments,
-                            docstring=inspect.getdoc(func) or "",
-                        )
-
-                        # Execute the original function
-                        result = await func(*args, **kwargs)
-
-                        # Log the response
-                        await log_tool_response_async(session_id=session_id, response=result)
-
-                        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"))
-
-                    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}")
-
-                    if isinstance(mock_result, str):
-                        with suppress(json.JSONDecodeError):
-                            mock_result = json.loads(mock_result)
-                            return convert_to_type(mock_result, return_type_obj)
-                    return convert_to_type(mock_result, return_type_obj)
-
-                # Create a top-level span for the simulated mock call if OpenTelemetry is available
-                try:
-                    from opentelemetry import trace  # type: ignore[import-not-found]
-
-                    tracer = trace.get_tracer("veris_ai.tool_mock")
-                    span_name = f"mock.{func.__name__}"
-                    with tracer.start_as_current_span(span_name) as span:  # type: ignore[attr-defined]
-                        span.set_attribute("veris_ai.session.id", self.session_id or "")  # type: ignore[attr-defined]
-                        span.set_attribute("veris_ai.mock.mode", mode)  # type: ignore[attr-defined]
-                        return await _execute_mock_logic(self.session_id)
-                except Exception:
-                    # If OpenTelemetry is not available, run without span
-                    return await _execute_mock_logic(self.session_id)
+                parameters = get_function_parameters(func, args, kwargs)
+                return mock_tool_call(
+                    func,
+                    session_id,
+                    parameters,
+                    options,
+                )
 
             @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:
-                    # If not in simulation mode, execute the original function
+                """Sync wrapper."""
+                session_id = _session_id_context.get()
+                if not session_id:
                     return func(*args, **kwargs)
-
-                def _execute_mock_logic(session_id: str) -> object:
-                    # Handle spy mode - execute original function and log
-                    if mode == "spy":
-                        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)
-
-                        log_tool_call_sync(
-                            session_id=session_id,
-                            function_name=func.__name__,
-                            parameters=bound_args.arguments,
-                            docstring=inspect.getdoc(func) or "",
-                        )
-
-                        # Execute the original function
-                        result = func(*args, **kwargs)
-
-                        # Log the response
-                        log_tool_response_sync(session_id=session_id, response=result)
-
-                        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"))
-
-                    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}")
-
-                    if isinstance(mock_result, str):
-                        with suppress(json.JSONDecodeError):
-                            mock_result = json.loads(mock_result)
-                            return convert_to_type(mock_result, return_type_obj)
-                    return convert_to_type(mock_result, return_type_obj)
-
-                # Create a top-level span for the simulated mock call if OpenTelemetry is available
-                try:
-                    from opentelemetry import trace  # type: ignore[import-not-found]
-
-                    tracer = trace.get_tracer("veris_ai.tool_mock")
-                    span_name = f"mock.{func.__name__}"
-                    with tracer.start_as_current_span(span_name) as span:  # type: ignore[attr-defined]
-                        span.set_attribute("veris_ai.session.id", self.session_id or "")  # type: ignore[attr-defined]
-                        span.set_attribute("veris_ai.mock.mode", mode)  # type: ignore[attr-defined]
-                        return _execute_mock_logic(self.session_id)
-                except Exception:
-                    # If OpenTelemetry is not available, run without span
-                    return _execute_mock_logic(self.session_id)
+                parameters = get_function_parameters(func, args, kwargs)
+                return mock_tool_call(
+                    func,
+                    session_id,
+                    parameters,
+                    options,
+                )
 
             # Return the appropriate wrapper based on whether the function is async
             return async_wrapper if is_async else sync_wrapper
@@ -351,7 +214,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 +223,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)
@@ -373,4 +236,46 @@ class VerisSDK:
         return decorator
 
 
+def mock_tool_call(
+    func: Callable,
+    session_id: str,
+    parameters: str,
+    options: ToolCallOptions | None = None,
+) -> object:
+    """Mock tool call."""
+    options = options or ToolCallOptions()
+    api_client = get_api_client()
+    endpoint = api_client.tool_mock_endpoint
+
+    logger.info(f"Simulating function: {func.__name__}")
+
+    type_hints = get_type_hints(func)
+
+    # Extract return type object (not just the name)
+    return_type_obj = type_hints.pop("return", Any)
+    # Get function docstring
+    docstring = inspect.getdoc(func) or ""
+    # Determine response expectation
+    payload = {
+        "session_id": session_id,
+        "response_expectation": options.response_expectation.value,
+        "cache_response": bool(options.cache_response),
+        "tool_call": {
+            "function_name": func.__name__,
+            "parameters": json.loads(parameters),
+            "return_type": json.dumps(extract_json_schema(return_type_obj)),
+            "docstring": docstring,
+        },
+    }
+
+    mock_result = api_client.post(endpoint, payload)
+    logger.info(f"Mock response: {mock_result}")
+
+    if isinstance(mock_result, str):
+        with suppress(json.JSONDecodeError):
+            mock_result = json.loads(mock_result)
+            return convert_to_type(mock_result, return_type_obj)
+    return convert_to_type(mock_result, return_type_obj)
+
+
 veris = VerisSDK()

veris_ai/utils.py

@@ -1,8 +1,11 @@
+import inspect
+import json
 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 +275,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]
+) -> str:
+    """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 json.dumps(bound_args.arguments)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 1.7.0
+Version: 1.8.1
 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
@@ -136,7 +168,7 @@ async def your_function(param1: str, param2: int) -> dict:
     return {"result": "actual implementation"}
 
 # Spy mode: Executes function but logs calls/responses
-@veris.mock(mode="spy")
+@veris.spy()
 async def monitored_function(data: str) -> dict:
     return process_data(data)
 
@@ -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.1.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=LmxPkOg3KLICgTrl0Bouy7enhyO4tF6_evq2cb8I_ig,10718
+veris_ai/api_client.py,sha256=lpokGrDqC222eM8J65814a85DfEL_iAlHRatf9BFy2Y,2136
+veris_ai/logging.py,sha256=ENduOHnc5UmzciTDZDJCZqUOXb5We-bdtwN9f9Qqwl0,1360
+veris_ai/models.py,sha256=TiQJuME2pGDE6EY5J8TYKNSeajaN2Xk9ISsLoIwgtgU,502
+veris_ai/observability.py,sha256=fDtWeUexfzaIQArE5YbWsja8Y-bcE_h0dXQWYbXbupY,4929
+veris_ai/tool_mock.py,sha256=L2p6Yg8S98floahDTrf6cnmDqC6Dq3YKA7Q6RRvv7BQ,10253
+veris_ai/utils.py,sha256=Ud4k2jKAJ6-nqSsFXIJWYrOmPGmvl5RSp36cQtgnMpg,9781
+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.1.dist-info/METADATA,sha256=SCSuZSupecfwozColHl09XlE4Hy5W_R7xqHw8Wco560,9924
+veris_ai-1.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+veris_ai-1.8.1.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
+veris_ai-1.8.1.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,,