veris-ai 1.9.0__tar.gz → 1.10.0__tar.gz

{veris_ai-1.9.0 → veris_ai-1.10.0}/CLAUDE.md

@@ -6,11 +6,12 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 This is the Veris AI Python SDK - a package that provides simulation capabilities through decorator-based function mocking and FastAPI MCP (Model Context Protocol) integration. The core functionality revolves around:
 - `VerisSDK` class in `src/veris_ai/tool_mock.py:27` - enables environment-aware execution where functions can be mocked in simulation mode, spied on, or executed normally in production
-- Spy mode (`@veris.mock(mode="spy")`) - executes original functions while logging calls and responses to Redis via logging endpoints
+- `@veris.spy()` decorator - executes original functions while logging calls and responses via logging endpoints
 - `convert_to_type()` function in `src/veris_ai/utils.py:5` - handles sophisticated type conversion from mock responses
 - `FastApiMCPParams` model in `src/veris_ai/models.py:1` - provides configuration for integrating FastAPI applications with the Model Context Protocol
 - `set_fastapi_mcp()` method in `src/veris_ai/tool_mock.py:54` - configures FastAPI MCP server with automatic OAuth2-based session management
 - Logging utilities in `src/veris_ai/logging.py` - provide async and sync functions for logging tool calls and responses to VERIS endpoints
+- `SimulatorAPIClient` class in `src/veris_ai/api_client.py` - centralized client for making requests to VERIS simulation endpoints with automatic authentication
 
 ## Development Commands
 
@@ -18,12 +19,18 @@ This project uses `uv` as the package manager and follows modern Python tooling
 
 ### Setup
 ```bash
+# Install base package
+uv add veris-ai
+
 # Install with development dependencies
 uv add "veris-ai[dev]"
 
 # Install with FastAPI MCP integration
 uv add "veris-ai[fastapi]"
 
+# Install with all extras
+uv add "veris-ai[dev,fastapi,observability,agents]"
+
 # Set Python version (requires 3.11+)
 pyenv local 3.11.0
 ```
@@ -75,10 +82,12 @@ uv build
 - Main SDK class that provides decorator functionality:
   - `@veris.mock()`: Dynamic mocking that calls external endpoints for responses
   - `@veris.stub()`: Simple stubbing with fixed return values
-- Environment detection: Uses `ENV` environment variable to determine simulation vs production mode
+  - `@veris.spy()`: Logging decorator that executes original function and logs the call/response
+- Session-based activation: Uses session ID presence to determine mocking behavior
 - HTTP communication with mock endpoints via `httpx` (for mock decorator)
 - Context extraction for session management via context variables
 - Delegates type conversion to the utils module
+- Automatic API endpoint configuration with production defaults
 
 **API Surface** (`src/veris_ai/__init__.py:5`)
 - Exports single `veris` instance for public use
@@ -101,10 +110,18 @@ uv build
 
 ### Environment Configuration
 
-Required environment variables:
-- `VERIS_ENDPOINT_URL`: Base endpoint URL (required)
-- `VERIS_MOCK_TIMEOUT`: Request timeout in seconds (optional, default: 30.0)
-- `ENV`: Set to "simulation" to enable mocking, anything else runs original functions
+Environment variables:
+- `VERIS_API_KEY`: API authentication key for VERIS services (optional, but recommended for production)
+- `VERIS_MOCK_TIMEOUT`: Request timeout in seconds (optional, default: 90.0)
+
+**Note**: The SDK automatically connects to the production VERIS API endpoint (`https://simulation.api.veris.ai/`). Only override `VERIS_API_URL` if you need to use a custom endpoint (rarely needed).
+
+### Session-Based Activation
+
+The SDK activates mocking based on session ID presence:
+- **With session ID**: Routes calls to mock/simulator endpoint
+- **Without session ID**: Executes original function
+- Session IDs can be set manually via `veris.set_session_id()` or extracted automatically from OAuth2 tokens in FastAPI MCP integration
 
 ### Type System
 
@@ -123,8 +140,8 @@ The SDK handles sophisticated type conversion from mock responses:
 
 **Key Test Fixtures**:
 - `mock_context`: Provides mock context with session ID
-- `simulation_env`: Sets up simulation environment variables  
-- `production_env`: Sets up production environment variables
+- `simulation_env`: Sets up simulation mode with session ID  
+- `production_env`: Sets up production mode without session ID
 
 **Test Coverage Areas**:
 - Environment-based behavior switching
@@ -164,9 +181,14 @@ The SDK handles sophisticated type conversion from mock responses:
 ## Key Implementation Details
 
 - **Decorator Pattern**: Functions are wrapped to intercept calls in simulation mode
-  - `mock()`: Sends function metadata to external endpoint for dynamic responses
-  - `stub()`: Returns predetermined values without external calls
+  - `@veris.mock()`: Sends function metadata to external endpoint for dynamic responses
+  - `@veris.stub()`: Returns predetermined values without external calls
+  - `@veris.spy()`: Executes original function while logging calls and responses
 - **Session Management**: Extracts session ID from context for request correlation
+- **API Client**: Centralized `SimulatorAPIClient` handles all API communication
+  - Automatic endpoint configuration with production defaults
+  - Built-in authentication via `VERIS_API_KEY` header
+  - Configurable timeout with `VERIS_MOCK_TIMEOUT`
 - **Error Handling**: Comprehensive HTTP and type conversion error handling
 - **Async Support**: Built with async/await pattern throughout
 - **Type Safety**: Full type hints and runtime type conversion validation

{veris_ai-1.9.0 → veris_ai-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 1.9.0
+Version: 1.10.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
@@ -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)
@@ -158,29 +158,57 @@ End-to-end propagation with the simulator:
 
 **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.
 

{veris_ai-1.9.0 → veris_ai-1.10.0}/README.md

@@ -48,7 +48,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)
@@ -116,29 +115,57 @@ End-to-end propagation with the simulator:
 
 **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.
 

{veris_ai-1.9.0 → veris_ai-1.10.0}/examples/README.md

@@ -63,9 +63,9 @@ if os.getenv("USE_FASTAPI") == "true":
 **Semantic Tag**: `integration-patterns`
 
 ### Decorator Usage
-- **Function Mocking**: `@veris.mock()` for simulation mode
-- **Spy Mode**: `@veris.spy()` for logging
-- **Stub Mode**: `@veris.stub(return_value={})` for fixed responses
+- **Mock Decorator**: `@veris.mock()` for simulation mode
+- **Spy Decorator**: `@veris.spy()` for logging calls and responses
+- **Stub Decorator**: `@veris.stub(return_value={})` for fixed responses
 
 ### Error Handling
 - **Graceful Import Failures**: Try/catch blocks for optional features
@@ -73,7 +73,8 @@ if os.getenv("USE_FASTAPI") == "true":
 - **Feature Detection**: Runtime capability checking
 
 ### Configuration Management  
-- **Environment Variables**: `VERIS_ENDPOINT_URL`, `ENV=simulation`
+- **Environment Variables**: `VERIS_API_KEY` for authentication, `VERIS_MOCK_TIMEOUT` for request timeout
+- **Session Management**: Use `veris.set_session_id()` to enable mocking
 - **Conditional Setup**: Feature flags for optional components
 - **Service Configuration**: Dynamic service naming and endpoints
 
@@ -86,13 +87,15 @@ if os.getenv("USE_FASTAPI") == "true":
 cd examples/
 python import_options.py
 
-# With specific environment setup
-ENV=simulation VERIS_ENDPOINT_URL=http://localhost:8000 python import_options.py
+# With API key for production
+VERIS_API_KEY=your-api-key python import_options.py
 
 # Testing with different feature flags
 ENABLE_TRACING=true USE_FASTAPI=true python import_options.py
 ```
 
+**Note**: To enable mocking in your code, call `veris.set_session_id("your-session-id")`.
+
 w### Observability Environment (optional)
 
 If you want traces exported while running examples, set the following before execution:

{veris_ai-1.9.0 → veris_ai-1.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "veris-ai"
-version = "1.9.0"
+version = "1.10.0"
 description = "A Python package for Veris AI tools"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -25,6 +25,7 @@ dependencies = [
     "opentelemetry-instrumentation-mcp>=0.44.1",
     "opentelemetry-api>=1.34.1",
     "logfire>=4.3.3",
+    "tenacity>=9.1.2",
 ]
 
 [project.optional-dependencies]

{veris_ai-1.9.0 → veris_ai-1.10.0}/src/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 |
 
@@ -26,16 +27,16 @@ 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`
+2. **Session Check**: Presence of session ID determines behavior  
+3. **API Call**: POST to VERIS API endpoint `/v2/tool_mock` (auto-configured)
 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/simulations/{session_id}/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/simulations/{session_id}/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-1.9.0 → veris_ai-1.10.0}/src/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-1.9.0 → veris_ai-1.10.0}/src/veris_ai/observability.py

@@ -28,6 +28,12 @@ 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)
@@ -96,25 +102,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 +109,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-1.9.0 → veris_ai-1.10.0}/src/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-1.9.0 → veris_ai-1.10.0}/src/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 → veris_ai-1.10.0}/tests/README.md

@@ -14,7 +14,7 @@ Test suite for the Veris AI Python SDK with comprehensive coverage of mocking, t
 
 | Test File | Coverage | Key Areas | Lines |
 |-----------|----------|-----------|-------|
-| [`test_tool_mock.py`](test_tool_mock.py) | VerisSDK, decorators | Mock/spy modes, FastAPI MCP | 530 |
+| [`test_tool_mock.py`](test_tool_mock.py) | VerisSDK, decorators | Mock/spy/stub decorators, FastAPI MCP | 530 |
 | [`test_utils.py`](test_utils.py) | Type conversion utilities | JSON schema extraction | 438 |
 | [`test_mcp_protocol_server_mocked.py`](test_mcp_protocol_server_mocked.py) | MCP integration | Protocol server mocking | 215 |
 | [`conftest.py`](conftest.py) | Test configuration | Pytest fixtures, setup | 60 |
@@ -24,7 +24,7 @@ Test suite for the Veris AI Python SDK with comprehensive coverage of mocking, t
 **Semantic Tag**: `test-fixtures`
 
 ### Core Fixtures (conftest.py)
-- **Environment setup**: Mock `VERIS_ENDPOINT_URL` and `ENV` variables
+- **Environment setup**: Mock environment variables and session IDs
 - **Async client**: HTTP client for testing API interactions
 - **Session management**: Isolation between test runs
 

{veris_ai-1.9.0 → veris_ai-1.10.0}/tests/test_mcp_protocol_server_mocked.py

@@ -23,8 +23,6 @@ SERVER_NAME = "Test MCP Server"
 
 def run_server_with_mock(server_port: int) -> None:  # noqa: C901
     """Run server with mocked veris API client methods."""
-    # Ensure we're in simulation mode
-    os.environ["ENV"] = "simulation"
     os.environ["VERIS_API_URL"] = "http://test-endpoint"
 
     # Create a mock function for the API client

{veris_ai-1.9.0 → veris_ai-1.10.0}/tests/test_tool_mock.py

@@ -257,7 +257,10 @@ async def test_spy_decorator_with_session(simulation_env):
         mock_log_call.assert_called_once_with(
             session_id="spy-session-123",
             function_name="test_func",
-            parameters='{"x": 42, "y": "hello"}',
+            parameters={
+                "x": {"value": "42", "type": "<class 'int'>"},
+                "y": {"value": "hello", "type": "<class 'str'>"},
+            },
             docstring="A test function that returns a dict.",
         )
         mock_log_response.assert_called_once_with(
@@ -312,7 +315,10 @@ def test_spy_decorator_sync_function(simulation_env):
         mock_log_call.assert_called_once_with(
             session_id="sync-spy-session",
             function_name="sync_func",
-            parameters='{"a": 10, "b": 20}',
+            parameters={
+                "a": {"value": "10", "type": "<class 'int'>"},
+                "b": {"value": "20", "type": "<class 'int'>"},
+            },
             docstring="Adds two numbers.",
         )
         mock_log_response.assert_called_once_with(session_id="sync-spy-session", response=30)

{veris_ai-1.9.0 → veris_ai-1.10.0}/tests/test_veris_runner_tool_options.py

@@ -131,8 +131,7 @@ def mock_api_client_with_options():
 @pytest.mark.asyncio
 async def test_tool_options_passed_to_mock_call(mock_api_client_with_options, multi_tool_agent):
     """Verify that ToolCallOptions are correctly passed to the mock_tool_call function."""
-    # Set up simulation environment
-    os.environ["ENV"] = "simulation"
+    # Set up session for mocking
     veris.set_session_id("test-session-tool-options")
 
     try:

{veris_ai-1.9.0 → veris_ai-1.10.0}/uv.lock

@@ -1433,6 +1433,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f7/1f/b876b1f83aef204198a42dc101613fefccb32258e5428b5f9259677864b4/starlette-0.47.2-py3-none-any.whl", hash = "sha256:c5847e96134e5c5371ee9fac6fdf1a67336d5815e09eb2a01fdb57a351ef915b", size = 72984, upload-time = "2025-07-20T17:31:56.738Z" },
 ]
 
+[[package]]
+name = "tenacity"
+version = "9.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036, upload-time = "2025-04-02T08:25:09.966Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248, upload-time = "2025-04-02T08:25:07.678Z" },
+]
+
 [[package]]
 name = "tomli"
 version = "2.2.1"
@@ -1556,7 +1565,7 @@ wheels = [
 
 [[package]]
 name = "veris-ai"
-version = "1.8.2"
+version = "1.9.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },
@@ -1571,6 +1580,7 @@ dependencies = [
     { name = "opentelemetry-sdk" },
     { name = "pydantic" },
     { name = "requests" },
+    { name = "tenacity" },
 ]
 
 [package.optional-dependencies]
@@ -1637,6 +1647,7 @@ requires-dist = [
     { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.1.0" },
     { name = "requests", specifier = ">=2.31.0" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.11.4" },
+    { name = "tenacity", specifier = ">=9.1.2" },
     { name = "wrapt", marker = "extra == 'instrument'" },
 ]
 provides-extras = ["dev", "fastapi", "agents", "instrument"]

veris_ai-1.9.0/src/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}")