veris-ai 1.9.0__py3-none-any.whl → 1.10.1__py3-none-any.whl

veris_ai/README.md

@@ -14,9 +14,10 @@ This module contains the core implementation of the Veris AI Python SDK. Each co
 
 | Module | Purpose | Key Classes/Functions | Lines |
 |--------|---------|----------------------|-------|
-| [`tool_mock.py`](tool_mock.py) | Function mocking & FastAPI MCP | `VerisSDK`, `@mock`, `@stub` | 327 |
-| [`utils.py`](utils.py) | Type utilities & JSON schema | `extract_json_schema()` | 272 |
-| [`logging.py`](logging.py) | Logging configuration | `setup_logging()` | 116 |
+| [`tool_mock.py`](tool_mock.py) | Function mocking & FastAPI MCP | `VerisSDK`, `@mock`, `@stub`, `@spy` | 327 |
+| [`utils.py`](utils.py) | Type utilities & JSON schema | `extract_json_schema()`, `convert_to_type()` | 272 |
+| [`api_client.py`](api_client.py) | Centralized API client | `SimulatorAPIClient` | 62 |
+| [`logging.py`](logging.py) | Tool call/response logging | `log_tool_call()`, `log_tool_response()` | 116 |
 | [`models.py`](models.py) | Data models | Type definitions | 12 |
 | [`jaeger_interface/`](jaeger_interface/) | Jaeger Query API wrapper | `JaegerClient` | See module README |
 
@@ -27,15 +28,15 @@ This module contains the core implementation of the Veris AI Python SDK. Each co
 ### Mock Flow
 1. **Decoration**: `@veris.mock()` captures function metadata
 2. **Environment Check**: `ENV=simulation` determines behavior  
-3. **API Call**: POST to `{VERIS_ENDPOINT_URL}/api/v2/tool_mock`
+3. **API Call**: POST to `{VERIS_ENDPOINT_URL}/v2/tool_mock`
 4. **Type Conversion**: Response converted using `extract_json_schema()`
 
 **Implementation**: [`tool_mock.py:200-250`](tool_mock.py)
 
 ### Spy Flow  
-1. **Pre-execution Logging**: Call details sent to `/api/v2/log_tool_call`
+1. **Pre-execution Logging**: Call details sent to `/v2/log_tool_call`
 2. **Function Execution**: Original function runs normally
-3. **Post-execution Logging**: Response sent to `/api/v2/log_tool_response`
+3. **Post-execution Logging**: Response sent to `/v2/log_tool_response`
 
 **Implementation**: [`tool_mock.py:250-300`](tool_mock.py)
 
@@ -44,11 +45,11 @@ This module contains the core implementation of the Veris AI Python SDK. Each co
 
 **Semantic Tag**: `module-config`
 
-Environment variables are processed in [`tool_mock.py`](tool_mock.py):
+Environment variables are processed in [`api_client.py`](api_client.py):
 
-- `VERIS_ENDPOINT_URL`: Mock server endpoint
-- `VERIS_MOCK_TIMEOUT`: Request timeout (default: 90s)  
-- `ENV`: Set to `"simulation"` for mock mode
+- `VERIS_API_KEY`: API authentication key (optional, but recommended)
+- `VERIS_MOCK_TIMEOUT`: Request timeout (default: 90s)
+- `VERIS_API_URL`: Override default API endpoint (rarely needed - defaults to production)
 
 ### Observability (OTLP / Logfire)
 

veris_ai/agents_wrapper.py

@@ -1,5 +1,6 @@
 """OpenAI Agents wrapper for automatic tool mocking via Veris SDK."""
 
+import json
 import logging
 from collections.abc import Callable
 from typing import Any
@@ -88,7 +89,7 @@ def _wrap(
                                         return mock_tool_call(
                                             the_func,
                                             session_id,
-                                            parameters,
+                                            json.loads(parameters),
                                             tool_options.get(tool_name_inner),
                                         )
                                     # Fall back to original if we couldn't extract the function

veris_ai/api_client.py

@@ -11,28 +11,50 @@ logger = logging.getLogger(__name__)
 
 
 class SimulatorAPIClient:
-    """Centralized client for making requests to VERIS simulation endpoints."""
+    """Centralized client for making requests to VERIS simulation endpoints.
+
+    Note:
+        This client intentionally reads configuration (base URL and API key)
+        from environment variables at call-time instead of at construction
+        time. This allows tests to patch environment variables and have those
+        changes reflected without recreating the singleton.
+    """
 
     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")
+        """Initialize the API client with static timeout configuration."""
         self.timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
 
+    def _get_base_url(self) -> str:
+        """Resolve the base URL from environment.
+
+        Behavior:
+            - If VERIS_API_URL is unset, default to the dev simulator URL.
+            - If VERIS_API_URL is set to an empty string, treat it as empty
+              (do not fall back). This supports tests expecting connection
+              failures when an invalid endpoint is provided.
+        """
+        return os.getenv("VERIS_API_URL") or "https://simulator.api.veris.ai"
+
     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:
+        api_key = os.getenv("VERIS_API_KEY")
+        if api_key:
             if headers is None:
                 headers = {}
-            headers["x-api-key"] = self.api_key
+            headers["x-api-key"] = 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()
+        # Validate endpoint URL; raise ConnectError for non-absolute URLs to
+        # mirror connection failures in tests when base URL is intentionally invalid.
+        if not endpoint.startswith(("http://", "https://")):
+            raise httpx.ConnectError("Invalid endpoint URL (not absolute): {endpoint}")
+
         with httpx.Client(timeout=self.timeout) as client:
             response = client.post(endpoint, json=payload, headers=headers)
             response.raise_for_status()
@@ -41,15 +63,15 @@ class SimulatorAPIClient:
     @property
     def tool_mock_endpoint(self) -> str:
         """Get the tool mock endpoint URL."""
-        return urljoin(self.base_url, "v2/tool_mock")
+        return urljoin(self._get_base_url(), "v2/tool_mock")
 
     def get_log_tool_call_endpoint(self, session_id: str) -> str:
         """Get the log tool call endpoint URL."""
-        return urljoin(self.base_url, f"v2/simulations/{session_id}/log_tool_call")
+        return urljoin(self._get_base_url(), f"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 urljoin(self.base_url, f"v2/simulations/{session_id}/log_tool_response")
+        return urljoin(self._get_base_url(), f"v2/simulations/{session_id}/log_tool_response")
 
 
 # Global singleton instance

veris_ai/observability.py

@@ -16,7 +16,7 @@ logger = getLogger(__name__)
 def init_observability() -> None:  # noqa: PLR0912
     """Initialize tracing/export and set W3C propagation.
 
-    - Initializes Traceloop if available (acts as OTel bootstrap/exporter)
+    - Initializes logfire if available (acts as OTel bootstrap/exporter)
     - Sets global propagator to TraceContext + Baggage (W3C)
     - Instruments MCP, requests, httpx if instrumentation packages are present
     - Adds a request hook to capture outbound traceparent for debugging
@@ -28,8 +28,13 @@ def init_observability() -> None:  # noqa: PLR0912
 
         logfire.configure(scrubbing=False)
         logfire.instrument_openai_agents()
+        try:
+            logfire.instrument_redis()
+        except Exception:
+            logger.warning("Failed to instrument redis")
+        logfire.instrument_mcp()
+
     except Exception as e:
-        # Tracing is optional; continue without Traceloop
         msg = "Logfire not found: " + str(e)
         raise RuntimeError(msg) from e
 
@@ -96,25 +101,6 @@ def init_observability() -> None:  # noqa: PLR0912
         msg = "OpenTelemetry not found: " + str(e)
         raise RuntimeError(msg) from e
 
-    try:
-        from opentelemetry.instrumentation.httpx import (
-            HTTPXClientInstrumentor,  # type: ignore[import-not-found]
-        )
-
-        HTTPXClientInstrumentor().instrument(request_hook=_log_request_headers)
-    except Exception as e:
-        msg = "OpenTelemetry not found: " + str(e)
-        raise RuntimeError(msg) from e
-
-    # Optionally enable MCP-specific spans
-    try:
-        from opentelemetry.instrumentation.mcp import McpInstrumentor  # type: ignore[import-not-found]
-
-        McpInstrumentor().instrument()
-    except Exception as e:
-        msg = "OpenTelemetry not found: " + str(e)
-        raise RuntimeError(msg) from e
-
 
 def instrument_fastapi_app(app: FastAPI) -> None:
     """Instrument a FastAPI app so inbound HTTP requests continue W3C traces.
@@ -122,10 +108,6 @@ def instrument_fastapi_app(app: FastAPI) -> None:
     Safe to call even if the fastapi instrumentation package is not installed.
     """
 
-    try:
-        from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor  # type: ignore[import-not-found]
+    import logfire
 
-        FastAPIInstrumentor.instrument_app(app)
-    except Exception as e:
-        msg = "OpenTelemetry not found: " + str(e)
-        raise RuntimeError(msg) from e
+    logfire.instrument_fastapi(app)

veris_ai/tool_mock.py

@@ -5,6 +5,7 @@ from collections.abc import Callable
 from contextlib import suppress
 from contextvars import ContextVar
 from functools import wraps
+import tenacity
 from typing import (
     Any,
     Literal,
@@ -13,10 +14,6 @@ from typing import (
 )
 
 
-from veris_ai.logging import (
-    log_tool_call,
-    log_tool_response,
-)
 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
@@ -173,6 +170,9 @@ class VerisSDK:
                 """Async wrapper."""
                 session_id = _session_id_context.get()
                 if not session_id:
+                    logger.info(
+                        f"No session ID found, executing original function: {func.__name__}"
+                    )
                     return await func(*args, **kwargs)
                 parameters = get_function_parameters(func, args, kwargs)
                 return mock_tool_call(
@@ -190,6 +190,9 @@ class VerisSDK:
                 """Sync wrapper."""
                 session_id = _session_id_context.get()
                 if not session_id:
+                    logger.info(
+                        f"No session ID found, executing original function: {func.__name__}"
+                    )
                     return func(*args, **kwargs)
                 parameters = get_function_parameters(func, args, kwargs)
                 return mock_tool_call(
@@ -217,7 +220,9 @@ class VerisSDK:
                 **kwargs: Any,  # noqa: ANN401
             ) -> object:
                 if not self.session_id:
-                    # If not in simulation mode, execute the original function
+                    logger.info(
+                        f"No session ID found, executing original function: {func.__name__}"
+                    )
                     return await func(*args, **kwargs)
                 logger.info(f"Stubbing function: {func.__name__}")
                 return return_value
@@ -225,7 +230,9 @@ class VerisSDK:
             @wraps(func)
             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
+                    logger.info(
+                        f"No session ID found, executing original function: {func.__name__}"
+                    )
                     return func(*args, **kwargs)
                 logger.info(f"Stubbing function: {func.__name__}")
                 return return_value
@@ -236,10 +243,15 @@ class VerisSDK:
         return decorator
 
 
+@tenacity.retry(
+    stop=tenacity.stop_after_attempt(3),
+    wait=tenacity.wait_exponential(multiplier=1, min=4, max=10),
+    reraise=True,
+)
 def mock_tool_call(
     func: Callable,
     session_id: str,
-    parameters: str,
+    parameters: dict[str, dict[str, str]],
     options: ToolCallOptions | None = None,
 ) -> object:
     """Mock tool call."""
@@ -262,7 +274,7 @@ def mock_tool_call(
         "cache_response": bool(options.cache_response),
         "tool_call": {
             "function_name": func.__name__,
-            "parameters": json.loads(parameters),
+            "parameters": parameters,
             "return_type": json.dumps(extract_json_schema(return_type_obj)),
             "docstring": docstring,
         },
@@ -278,4 +290,41 @@ def mock_tool_call(
     return convert_to_type(mock_result, return_type_obj)
 
 
+def log_tool_call(
+    session_id: str,
+    function_name: str,
+    parameters: dict[str, dict[str, str]],
+    docstring: str,
+) -> None:
+    """Log tool call synchronously to the VERIS logging endpoint."""
+    api_client = get_api_client()
+    endpoint = api_client.get_log_tool_call_endpoint(session_id)
+    payload = {
+        "function_name": function_name,
+        "parameters": parameters,
+        "docstring": docstring,
+    }
+    try:
+        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}")
+
+
+def log_tool_response(session_id: str, response: Any) -> None:  # noqa: ANN401
+    """Log tool response synchronously to the VERIS logging endpoint."""
+    api_client = get_api_client()
+    endpoint = api_client.get_log_tool_response_endpoint(session_id)
+
+    payload = {
+        "response": json.dumps(response, default=str),
+    }
+
+    try:
+        api_client.post(endpoint, payload)
+        logger.debug("Tool response logged")
+    except Exception as e:
+        logger.warning(f"Failed to log tool response: {e}")
+
+
 veris = VerisSDK()

veris_ai/utils.py

@@ -1,10 +1,19 @@
 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 typing import (
+    Any,
+    ForwardRef,
+    Literal,
+    NotRequired,
+    Required,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 from collections.abc import Callable
 
 from pydantic import BaseModel
@@ -279,12 +288,18 @@ def extract_json_schema(target_type: Any) -> dict:  # noqa: PLR0911, PLR0912, C9
 
 def get_function_parameters(
     func: Callable, args: tuple[object, ...], kwargs: dict[str, object]
-) -> str:
+) -> dict[str, dict[str, str]]:
     """Get the parameters for a function."""
+    params_info = {}
     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)
+    for param_name, param_value in bound_args.arguments.items():
+        params_info[param_name] = {
+            "value": str(param_value),
+            "type": str(get_type_hints(func).get(param_name, Any)),
+        }
+    return params_info

{veris_ai-1.9.0.dist-info → veris_ai-1.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 1.9.0
+Version: 1.10.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
@@ -20,6 +20,7 @@ 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: tenacity>=9.1.2
 Provides-Extra: agents
 Requires-Dist: openai-agents>=0.0.1; extra == 'agents'
 Provides-Extra: dev
@@ -90,7 +91,6 @@ from veris_ai import Runner, VerisConfig  # Requires agents extras
 |----------|---------|---------|
 | `VERIS_API_KEY` | API authentication key | None |
 | `VERIS_MOCK_TIMEOUT` | Request timeout (seconds) | `90.0` |
-| `ENV` | Set to `"simulation"` for mock mode | Production |
 
 **Advanced Configuration** (rarely needed):
 - `VERIS_API_URL`: Override default API endpoint (defaults to production)
@@ -151,39 +151,119 @@ What this enables:
 
 End-to-end propagation with the simulator:
 - The simulator injects W3C headers when connecting to your FastAPI MCP endpoints
-- The SDK injects W3C headers on `/api/v2/tool_mock` and logging requests back to the simulator
+- The SDK injects W3C headers on `/v2/tool_mock` and logging requests back to the simulator
 - Result: customer agent spans and tool mocks appear under the same distributed trace
 
 ## Function Mocking
 
 **Semantic Tag**: `tool-mocking`
 
+### Session-Based Activation
+
+The SDK uses session-based activation to determine when to enable mocking. Choose one of these methods to set a session ID:
+
+**Option 1: Manual Setting**
+```python
+from veris_ai import veris
+
+# Explicitly set a session ID
+veris.set_session_id("your-session-id")
+
+# Now decorated functions will use mock responses
+result = await your_mocked_function()
+
+# Clear session to disable mocking
+veris.clear_session_id()
+```
+
+**Option 2: Automatic Extraction (FastAPI MCP)**
+```python
+# When using FastAPI MCP integration, session IDs are 
+# automatically extracted from OAuth2 bearer tokens
+veris.set_fastapi_mcp(...)
+# No manual session management needed
+```
+
+**How it works internally**: Regardless of which method you use, session IDs are stored in Python context variables (`contextvars`). This ensures proper isolation between concurrent requests and automatic propagation through the call stack.
+
 ### Core Decorators
 
 ```python
 from veris_ai import veris
 
-# Mock mode: Returns simulated responses in ENV=simulation
+# Mock decorator: Returns simulated responses when session ID is set
 @veris.mock()
 async def your_function(param1: str, param2: int) -> dict:
     """Function documentation for LLM context."""
     return {"result": "actual implementation"}
 
-# Spy mode: Executes function but logs calls/responses
+# Spy decorator: Executes function and logs calls/responses
 @veris.spy()
 async def monitored_function(data: str) -> dict:
     return process_data(data)
 
-# Stub mode: Returns fixed value in simulation
+# Stub decorator: Returns fixed value in simulation
 @veris.stub(return_value={"status": "success"})
 async def get_data() -> dict:
     return await fetch_from_api()
 ```
 
-**Behavior**: In simulation mode, decorators intercept calls to mock endpoints. In production, functions execute normally.
+**Behavior**: When a session ID is set, decorators activate their respective behaviors (mock responses, logging, or stubbed values). Without a session ID, functions execute normally.
 
 **Implementation**: See [`src/veris_ai/tool_mock.py`](src/veris_ai/tool_mock.py) for decorator logic and API integration.
 
+### Core Instrument
+
+Instrument OpenAI agents without changing tool code by using the SDK's Runner (extends OpenAI's Runner) and an optional VerisConfig for fine control.
+
+Requirements:
+- Install extras: `uv add "veris-ai[agents]"`
+- Set `ENV=simulation` to enable mock behavior (otherwise passes through)
+
+Minimal usage:
+
+```python
+from veris_ai import Runner
+
+result = await Runner.run(agent, "What's 10 + 5?")
+```
+
+Select tools to intercept (include/exclude):
+
+```python
+from veris_ai import Runner, VerisConfig
+
+config = VerisConfig(include_tools=["calculator", "search_web"])  # or exclude_tools=[...]
+result = await Runner.run(agent, "Process this", veris_config=config)
+```
+
+Per‑tool behavior via ToolCallOptions:
+
+```python
+from veris_ai import Runner, VerisConfig, ToolCallOptions, ResponseExpectation
+
+config = VerisConfig(
+    tool_options={
+        "calculator": ToolCallOptions(
+            response_expectation=ResponseExpectation.REQUIRED,
+            cache_response=True,
+            mode="tool",
+        ),
+        "search_web": ToolCallOptions(
+            response_expectation=ResponseExpectation.NONE,
+            cache_response=False,
+            mode="spy",
+        ),
+    }
+)
+
+result = await Runner.run(agent, "Calculate and search", veris_config=config)
+```
+
+Notes:
+- Runner is a drop‑in enhancement over OpenAI's Runner (full details in [OpenAI Agents Integration](#openai-agents-integration))
+- See complete examples in [`examples/openai_agents_example.py`](examples/openai_agents_example.py)
+
 ## OpenAI Agents Integration
 
 **Semantic Tag**: `openai-agents`

veris_ai-1.10.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+veris_ai/README.md,sha256=g3yobd0u9kWEBDitowrYv49tavo8mTHXJkpuypBhZb8,3806
+veris_ai/__init__.py,sha256=enl_gEa6BQAjWvzCtsn_hFVJVVlJZ_dMsLL--E5W3nU,1907
+veris_ai/agents_wrapper.py,sha256=N-YZ0qvIEJ8rlFZAzVKg6eWKa7I_qIt-khlg_zL-qY8,11931
+veris_ai/api_client.py,sha256=385u11QuKq4Qk_WkI4Z5yOxAWJcV57VCGLYU5NIfnmo,3201
+veris_ai/models.py,sha256=xKeheSJQle2tBeJG1DsGJzMDwv24p5jECjX6RAa39n4,495
+veris_ai/observability.py,sha256=5E4ox8TFFmWTKaWFHz-5kdt58KDH8hfMMSWKBacnfzg,4146
+veris_ai/tool_mock.py,sha256=rU_ZwYWYIfgiOojEjmi5BdBsNzP3RphLPmMG1pyYUVw,11954
+veris_ai/utils.py,sha256=hJetCiN8Bubhy0nqSoS1C2awN9cdkKuHM1v7YhtwtTs,10066
+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.10.1.dist-info/METADATA,sha256=15xKxjJP4i8aJZihl4nzyDzEasyASlx-B_0Ox3ZMTfU,15991
+veris_ai-1.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+veris_ai-1.10.1.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
+veris_ai-1.10.1.dist-info/RECORD,,

veris_ai/logging.py

@@ -1,46 +0,0 @@
-"""Logging utilities for VERIS tool calls and responses."""
-
-import json
-import logging
-from typing import Any
-
-from veris_ai.api_client import get_api_client
-
-logger = logging.getLogger(__name__)
-
-
-def log_tool_call(
-    session_id: str,
-    function_name: str,
-    parameters: str,
-    docstring: str,
-) -> None:
-    """Log tool call synchronously to the VERIS logging endpoint."""
-    api_client = get_api_client()
-    endpoint = api_client.get_log_tool_call_endpoint(session_id)
-    payload = {
-        "function_name": function_name,
-        "parameters": json.loads(parameters),
-        "docstring": docstring,
-    }
-    try:
-        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}")
-
-
-def log_tool_response(session_id: str, response: Any) -> None:  # noqa: ANN401
-    """Log tool response synchronously to the VERIS logging endpoint."""
-    api_client = get_api_client()
-    endpoint = api_client.get_log_tool_response_endpoint(session_id)
-
-    payload = {
-        "response": json.dumps(response, default=str),
-    }
-
-    try:
-        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-1.9.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-veris_ai/README.md,sha256=0EC-yWB8FtqAhtcE5Q204bS1JWJPIvfpp1bPDo6iwwc,3601
-veris_ai/__init__.py,sha256=enl_gEa6BQAjWvzCtsn_hFVJVVlJZ_dMsLL--E5W3nU,1907
-veris_ai/agents_wrapper.py,sha256=L4llszfyZkG4Xjo8OTeVfm-IIdESAcW51ukxceKc88U,11907
-veris_ai/api_client.py,sha256=Gu_ovqaW-hZ6yPee2GVconMeg_xOxlt7IKu0HJQNiD0,2192
-veris_ai/logging.py,sha256=ENduOHnc5UmzciTDZDJCZqUOXb5We-bdtwN9f9Qqwl0,1360
-veris_ai/models.py,sha256=xKeheSJQle2tBeJG1DsGJzMDwv24p5jECjX6RAa39n4,495
-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.9.0.dist-info/METADATA,sha256=8c5TObTTfXNUiV0uTiTUu1sAZs7VOcrki1Q-00sGn_8,13495
-veris_ai-1.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-veris_ai-1.9.0.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
-veris_ai-1.9.0.dist-info/RECORD,,