veris-ai 1.11.1__tar.gz → 1.12.0__tar.gz

{veris_ai-1.11.1 → veris_ai-1.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 1.11.1
+Version: 1.12.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

{veris_ai-1.11.1 → veris_ai-1.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "veris-ai"
-version = "1.11.1"
+version = "1.12.0"
 description = "A Python package for Veris AI tools"
 readme = "README.md"
 requires-python = ">=3.11"

{veris_ai-1.11.1 → veris_ai-1.12.0}/src/veris_ai/tool_mock.py

@@ -1,3 +1,4 @@
+import base64
 import inspect
 import json
 import logging
@@ -22,8 +23,9 @@ logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
 
-# Context variable to store session_id for each call
+# Context variables to store session_id and thread_id for each call
 _session_id_context: ContextVar[str | None] = ContextVar("veris_session_id", default=None)
+_thread_id_context: ContextVar[str | None] = ContextVar("veris_thread_id", default=None)
 
 
 class VerisSDK:
@@ -38,15 +40,111 @@ class VerisSDK:
         """Get the session_id from context variable."""
         return _session_id_context.get()
 
-    def set_session_id(self, session_id: str) -> None:
-        """Set the session_id in context variable."""
+    @property
+    def thread_id(self) -> str | None:
+        """Get the thread_id from context variable."""
+        return _thread_id_context.get()
+
+    def _set_session_id(self, session_id: str) -> None:
+        """Set the session_id in context variable (private method)."""
         _session_id_context.set(session_id)
-        logger.info(f"Session ID set to {session_id}")
 
-    def clear_session_id(self) -> None:
-        """Clear the session_id from context variable."""
+    def _set_thread_id(self, thread_id: str) -> None:
+        """Set the thread_id in context variable (private method)."""
+        _thread_id_context.set(thread_id)
+
+    def parse_token(self, token: str) -> None:
+        """Parse and set session_id and thread_id from a base64-encoded token.
+
+        The token must be a base64-encoded JSON object containing:
+        {"session_id": "...", "thread_id": "..."}
+
+        Both session_id and thread_id are required fields.
+
+        Args:
+            token: Base64-encoded JSON token
+
+        Raises:
+            ValueError: If token is not valid or missing required fields
+        """
+        try:
+            # Decode base64 JSON token
+            decoded = base64.b64decode(token.encode("utf-8")).decode("utf-8")
+            token_data = json.loads(decoded)
+
+            if not isinstance(token_data, dict):
+                raise ValueError("Token must decode to a JSON object")
+
+            if "session_id" not in token_data:
+                raise ValueError("Token must contain 'session_id' field")
+
+            if "thread_id" not in token_data:
+                raise ValueError("Token must contain 'thread_id' field")
+
+            self._set_session_id(token_data["session_id"])
+            self._set_thread_id(token_data["thread_id"])
+            logger.info(
+                f"Session ID set to {token_data['session_id']}, "
+                f"Thread ID set to {token_data['thread_id']} - mocking enabled"
+            )
+
+        except (ValueError, json.JSONDecodeError) as e:
+            error_msg = f"Invalid token format: {e}"
+            raise ValueError(error_msg) from e
+
+    def set_session_id(self, token: str) -> None:
+        """DEPRECATED: Use parse_token() instead.
+
+        Set the session_id and thread_id from a base64-encoded token.
+
+        Args:
+            token: Base64-encoded JSON token
+        """
+        logger.warning(
+            "set_session_id() is deprecated. Use parse_token() instead. "
+            "This method will be removed in a future version."
+        )
+        # For backwards compatibility, allow tokens without thread_id
+        try:
+            decoded = base64.b64decode(token.encode("utf-8")).decode("utf-8")
+            token_data = json.loads(decoded)
+
+            if not isinstance(token_data, dict):
+                raise ValueError("Token must decode to a JSON object")
+
+            if "session_id" not in token_data:
+                raise ValueError("Token must contain 'session_id' field")
+
+            self._set_session_id(token_data["session_id"])
+            if "thread_id" in token_data:
+                self._set_thread_id(token_data["thread_id"])
+            logger.info(f"Session ID set to {token_data['session_id']}")
+
+        except (ValueError, json.JSONDecodeError) as e:
+            error_msg = f"Invalid token format: {e}"
+            raise ValueError(error_msg) from e
+
+    def _clear_session_id(self) -> None:
+        """Clear the session_id from context variable (private method)."""
         _session_id_context.set(None)
-        logger.info("Session ID cleared")
+
+    def _clear_thread_id(self) -> None:
+        """Clear the thread_id from context variable (private method)."""
+        _thread_id_context.set(None)
+
+    def clear_context(self) -> None:
+        """Clear the session_id and thread_id from context variables."""
+        self._clear_session_id()
+        self._clear_thread_id()
+        logger.info("Session ID and Thread ID cleared - mocking disabled")
+
+    def clear_session_id(self) -> None:
+        """DEPRECATED: Use clear_context() instead."""
+        logger.warning(
+            "clear_session_id() is deprecated. Use clear_context() instead. "
+            "This method will be removed in a future version."
+        )
+        self.clear_context()
 
     @property
     def fastapi_mcp(self) -> Any | None:  # noqa: ANN401
@@ -69,7 +167,7 @@ class VerisSDK:
             token: str | None = Depends(oauth2_scheme),
         ) -> None:
             if token:
-                self.set_session_id(token)
+                self.parse_token(token)
 
         # Create auth config with dependencies
         auth_config = AuthConfig(
@@ -176,11 +274,13 @@ class VerisSDK:
                     )
                     return await func(*args, **kwargs)
                 parameters = get_function_parameters(func, args, kwargs)
+                thread_id = _thread_id_context.get()
                 return mock_tool_call(
                     func,
                     session_id,
                     parameters,
                     options,
+                    thread_id,
                 )
 
             @wraps(func)
@@ -196,11 +296,13 @@ class VerisSDK:
                     )
                     return func(*args, **kwargs)
                 parameters = get_function_parameters(func, args, kwargs)
+                thread_id = _thread_id_context.get()
                 return mock_tool_call(
                     func,
                     session_id,
                     parameters,
                     options,
+                    thread_id,
                 )
 
             # Return the appropriate wrapper based on whether the function is async
@@ -251,11 +353,29 @@ class VerisSDK:
 )
 def mock_tool_call(
     func: Callable,
-    session_id: str,
+    session_id: str,  # noqa: ARG001
     parameters: dict[str, dict[str, str]],
     options: ToolCallOptions | None = None,
+    thread_id: str | None = None,
 ) -> object:
-    """Mock tool call."""
+    """Mock tool call.
+
+    Args:
+        func: Function being mocked
+        session_id: Session ID (kept for backwards compatibility, not used)
+        parameters: Function parameters
+        options: Tool call options
+        thread_id: Thread ID to use as session_id in API request (required)
+
+    Raises:
+        ValueError: If thread_id is not provided
+    """
+    if thread_id is None:
+        raise ValueError(
+            "thread_id is required for mocking. "
+            "Use parse_token() to set both session_id and thread_id."
+        )
+
     options = options or ToolCallOptions()
     api_client = get_api_client()
     endpoint = api_client.tool_mock_endpoint
@@ -269,6 +389,8 @@ def mock_tool_call(
     # Get function docstring
     docstring = inspect.getdoc(func) or ""
 
+    # Use thread_id as session_id in the payload
+    payload_session_id = thread_id
     # Clean up parameters for V3 - just send values, not the nested dict
     clean_params: dict[str, Any] = {}
     for key, value in parameters.items():
@@ -281,7 +403,7 @@ def mock_tool_call(
 
     # Determine response expectation
     payload = {
-        "session_id": session_id,
+        "session_id": payload_session_id,
         "response_expectation": options.response_expectation.value,
         "cache_response": bool(options.cache_response),
         "tool_call": {

{veris_ai-1.11.1 → veris_ai-1.12.0}/tests/conftest.py

@@ -27,10 +27,14 @@ def mock_context():
 
 @pytest.fixture
 def simulation_env():
+    import base64
+    import json
     from veris_ai import veris
 
-    # Set session_id to enable simulation mode
-    veris.set_session_id("test-session-123")
+    # Set session_id to enable simulation mode using proper token format
+    token_data = {"session_id": "test-session-123", "thread_id": "test-thread-123"}
+    token = base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")
+    veris.set_session_id(token)
 
     with patch.dict(
         os.environ,

{veris_ai-1.11.1 → veris_ai-1.12.0}/tests/test_agents_wrapper_simple.py

@@ -17,6 +17,7 @@ if sys.version_info >= (3, 13):
 from agents import Agent, FunctionTool
 
 from veris_ai import veris, Runner
+from tests.test_helpers import create_test_token
 
 # Skip tests if no API key is available
 if not os.environ.get("OPENAI_API_KEY"):
@@ -110,8 +111,9 @@ def simulation_env_with_session():
     # Set up simulation environment
     os.environ["VERIS_ENDPOINT_URL"] = "http://localhost:8000"
 
-    # Set session ID
-    veris.set_session_id("test-session-123")
+    # Set session ID using proper token format
+    token = create_test_token("test-session-123")
+    veris.set_session_id(token)
 
     yield
 

veris_ai-1.12.0/tests/test_helpers.py

@@ -0,0 +1,23 @@
+"""Helper functions for tests."""
+
+import base64
+import json
+
+
+def create_test_token(
+    session_id: str = "test-session", thread_id: str | None = "test-thread"
+) -> str:
+    """Create a base64-encoded test token.
+
+    Args:
+        session_id: Session ID to include in token
+        thread_id: Thread ID to include in token (optional)
+
+    Returns:
+        Base64-encoded JSON token
+    """
+    token_data = {"session_id": session_id}
+    if thread_id is not None:
+        token_data["thread_id"] = thread_id
+
+    return base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")

{veris_ai-1.11.1 → veris_ai-1.12.0}/tests/test_mcp_protocol_server_mocked.py

@@ -14,6 +14,7 @@ from mcp.client.streamable_http import streamablehttp_client
 from mcp.types import CallToolResult
 
 from veris_ai import veris
+from tests.test_helpers import create_test_token
 
 from .fixtures.simple_app import make_simple_fastapi_app
 
@@ -145,11 +146,13 @@ def server_mocked(server_port_mocked: int, simulation_env: None) -> Generator[No
 async def test_http_tool_call_mocked(server_mocked: None, server_url_mocked: str) -> None:
     """Test HTTP tool call with mocked HTTP endpoint."""
     session_id = "test-session-id"
+    # Create a proper base64-encoded token
+    token = create_test_token(session_id, "test-thread-id")
 
     async with (
         streamablehttp_client(
             server_url_mocked + "/mcp",
-            headers={"Authorization": f"Bearer {session_id}"},
+            headers={"Authorization": f"Bearer {token}"},
         ) as (read_stream, write_stream, _),
         ClientSession(read_stream, write_stream) as session,
     ):
@@ -175,8 +178,8 @@ async def test_http_tool_call_mocked(server_mocked: None, server_url_mocked: str
         payload_str = payloads[0].strip()
         payload = json.loads(payload_str)
 
-        # Verify the session_id was passed correctly
-        assert payload["session_id"] == session_id
+        # Verify the session_id was passed correctly (should use thread_id as value)
+        assert payload["session_id"] == "test-thread-id"
         assert payload["tool_call"]["function_name"] == "get_item"
 
         # Handle both direct value and nested value structure

veris_ai-1.12.0/tests/test_token_decoding.py

@@ -0,0 +1,132 @@
+"""Tests for token decoding functionality."""
+
+import base64
+import json
+
+import pytest
+
+from veris_ai import veris
+
+
+class TestTokenDecoding:
+    """Test token decoding and session/thread ID extraction."""
+
+    def test_decode_valid_token_with_both_ids(self):
+        """Test decoding a valid token with both session_id and thread_id."""
+        session_id = "test-session-123"
+        thread_id = "thread-456"
+        token_data = {"session_id": session_id, "thread_id": thread_id}
+        token = base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")
+
+        veris.set_session_id(token)
+
+        assert veris.session_id == session_id
+        assert veris.thread_id == thread_id
+
+        veris.clear_session_id()
+
+    def test_decode_valid_token_with_only_session_id(self):
+        """Test decoding a token with only session_id (no thread_id)."""
+        session_id = "test-session-789"
+        token_data = {"session_id": session_id}
+        token = base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")
+
+        veris.set_session_id(token)
+
+        assert veris.session_id == session_id
+        assert veris.thread_id is None
+
+        veris.clear_session_id()
+
+    def test_decode_token_with_uuid_format(self):
+        """Test decoding token with UUID-formatted IDs."""
+        session_id = "550e8400-e29b-41d4-a716-446655440000"
+        thread_id = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+        token_data = {"session_id": session_id, "thread_id": thread_id}
+        token = base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")
+
+        veris.set_session_id(token)
+
+        assert veris.session_id == session_id
+        assert veris.thread_id == thread_id
+
+        veris.clear_session_id()
+
+    def test_decode_invalid_base64_raises_error(self):
+        """Test that invalid base64 raises ValueError."""
+        invalid_token = "not-valid-base64!!!"
+
+        with pytest.raises(ValueError, match="Invalid token format"):
+            veris.set_session_id(invalid_token)
+
+    def test_decode_invalid_json_raises_error(self):
+        """Test that valid base64 but invalid JSON raises ValueError."""
+        invalid_json = base64.b64encode(b"not valid json").decode("utf-8")
+
+        with pytest.raises(ValueError, match="Invalid token format"):
+            veris.set_session_id(invalid_json)
+
+    def test_decode_non_object_json_raises_error(self):
+        """Test that JSON array instead of object raises ValueError."""
+        json_array = base64.b64encode(
+            json.dumps(["array", "not", "object"]).encode("utf-8")
+        ).decode("utf-8")
+
+        with pytest.raises(ValueError, match="Token must decode to a JSON object"):
+            veris.set_session_id(json_array)
+
+    def test_decode_missing_session_id_raises_error(self):
+        """Test that token without session_id raises ValueError."""
+        token_data = {"thread_id": "thread-only"}
+        token = base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")
+
+        with pytest.raises(ValueError, match="Token must contain 'session_id' field"):
+            veris.set_session_id(token)
+
+    def test_clear_session_id_clears_both_values(self):
+        """Test that clear_session_id clears both session_id and thread_id."""
+        session_id = "test-session"
+        thread_id = "test-thread"
+        token_data = {"session_id": session_id, "thread_id": thread_id}
+        token = base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")
+
+        veris.set_session_id(token)
+        assert veris.session_id == session_id
+        assert veris.thread_id == thread_id
+
+        veris.clear_session_id()
+        assert veris.session_id is None
+        assert veris.thread_id is None
+
+    def test_decode_token_with_additional_fields(self):
+        """Test that additional fields in token are ignored."""
+        session_id = "test-session"
+        thread_id = "test-thread"
+        token_data = {
+            "session_id": session_id,
+            "thread_id": thread_id,
+            "extra_field": "ignored",
+            "another": 123,
+        }
+        token = base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")
+
+        veris.set_session_id(token)
+
+        assert veris.session_id == session_id
+        assert veris.thread_id == thread_id
+
+        veris.clear_session_id()
+
+    def test_decode_token_with_empty_strings(self):
+        """Test decoding token with empty string values."""
+        session_id = ""
+        thread_id = ""
+        token_data = {"session_id": session_id, "thread_id": thread_id}
+        token = base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")
+
+        veris.set_session_id(token)
+
+        assert veris.session_id == session_id
+        assert veris.thread_id == thread_id
+
+        veris.clear_session_id()

{veris_ai-1.11.1 → veris_ai-1.12.0}/tests/test_tool_mock.py

@@ -1,4 +1,6 @@
 import asyncio
+import base64
+import json
 import os
 from typing import Any
 from unittest.mock import AsyncMock, Mock, patch
@@ -11,6 +13,16 @@ from veris_ai.api_client import get_api_client
 from veris_ai.tool_mock import _session_id_context
 
 
+def create_test_token(
+    session_id: str = "test-session", thread_id: str | None = "test-thread"
+) -> str:
+    """Create a base64-encoded test token."""
+    token_data = {"session_id": session_id}
+    if thread_id is not None:
+        token_data["thread_id"] = thread_id
+    return base64.b64encode(json.dumps(token_data).encode("utf-8")).decode("utf-8")
+
+
 @pytest.fixture
 def tool_mock():
     return veris
@@ -50,12 +62,15 @@ async def test_mock_with_context(simulation_env):
 
     with patch.object(get_api_client(), "post") as mock_request:
         mock_request.return_value = mock_response
-        veris.set_session_id("test-session-id")
+        token = create_test_token("test-session-id", "test-thread-id")
+        veris.parse_token(token)
         result = await test_func()
-        # Check that the mock was called with correct session_id
+        # Check that the mock was called with thread_id as session_id value
         mock_request.assert_called_once()
         call_args = mock_request.call_args
-        assert call_args[0][1]["session_id"] == "test-session-id"  # payload is second arg
+        assert (
+            call_args[0][1]["session_id"] == "test-thread-id"
+        )  # thread_id used as session_id value
         assert result == {"result": {"mocked": True}}
 
 
@@ -68,7 +83,7 @@ async def test_mock_without_context():
         return {"result": "real"}
 
     # Clear session_id to ensure production mode
-    veris.clear_session_id()
+    veris.clear_context()
 
     # In production mode, the original function should be called
     result = await test_func()
@@ -100,7 +115,8 @@ async def test_mock_missing_endpoint():
             return {"result": "real"}
 
         # Set session_id to enable simulation mode
-        veris.set_session_id("test-session")
+        token = create_test_token("test-session")
+        veris.parse_token(token)
 
         # Invalid domain will cause ConnectError
         with pytest.raises(httpx.ConnectError):
@@ -109,6 +125,7 @@ async def test_mock_missing_endpoint():
 
 @pytest.mark.asyncio
 async def test_mock_invalid_endpoint(simulation_env):
+    """Test that invalid endpoint URL raises ConnectError."""
     # Use invalid URL that will trigger ConnectError
     with (
         patch.dict(os.environ, {"VERIS_API_URL": "http://invalid-nonexistent-domain-67890.local"}),
@@ -141,7 +158,8 @@ async def test_context_var_isolation():
     """Test that session_id context vars are isolated between concurrent calls."""
 
     async def set_and_check_session(session_id: str):
-        veris.set_session_id(session_id)
+        token = create_test_token(session_id)
+        veris.parse_token(token)
         # Verify the session_id is set correctly
         assert veris.session_id == session_id
         # Simulate some async work
@@ -181,7 +199,8 @@ async def test_context_var_persistence_in_call(simulation_env):
 
     with patch.object(get_api_client(), "post", side_effect=mock_request_func) as mock_request:
         # Set session_id and call function
-        veris.set_session_id("test-session-123")
+        token = create_test_token("test-session-123", "test-thread-123")
+        veris.parse_token(token)
         await test_func()
 
         # Verify session_id was captured
@@ -189,21 +208,22 @@ async def test_context_var_persistence_in_call(simulation_env):
         assert len(captured_session_ids) >= 1
         assert captured_session_ids[0] == "test-session-123"
 
-        # Verify the HTTP client was called with correct session_id
+        # Verify the HTTP client was called with correct session_id (should use thread_id)
         mock_request.assert_called_once()
         call_args = mock_request.call_args
-        assert call_args[0][1]["session_id"] == "test-session-123"
+        assert call_args[0][1]["session_id"] == "test-thread-123"
 
 
 @pytest.mark.asyncio
 async def test_context_var_cleanup():
     """Test that clearing session_id works correctly."""
     # Set a session_id
-    veris.set_session_id("test-session")
+    token = create_test_token("test-session")
+    veris.parse_token(token)
     assert veris.session_id == "test-session"
 
     # Clear it
-    veris.clear_session_id()
+    veris.clear_context()
     assert veris.session_id is None
 
     # Verify it stays None
@@ -217,7 +237,8 @@ async def test_context_var_no_interference():
     results = []
 
     async def task1():
-        veris.set_session_id("task1-session")
+        token = create_test_token("task1-session")
+        veris.parse_token(token)
         await asyncio.sleep(0.02)
         results.append(("task1", veris.session_id))
 
@@ -225,7 +246,8 @@ async def test_context_var_no_interference():
         await asyncio.sleep(0.01)
         # Should be None since we didn't set it in this context
         results.append(("task2", veris.session_id))
-        veris.set_session_id("task2-session")
+        token = create_test_token("task2-session")
+        veris.parse_token(token)
         results.append(("task2-after", veris.session_id))
 
     await asyncio.gather(task1(), task2())
@@ -251,7 +273,8 @@ async def test_spy_decorator_with_session(simulation_env):
         patch("veris_ai.tool_mock.log_tool_call") as mock_log_call,
         patch("veris_ai.tool_mock.log_tool_response") as mock_log_response,
     ):
-        veris.set_session_id("spy-session-123")
+        token = create_test_token("spy-session-123")
+        veris.parse_token(token)
         result = await test_func(42, "hello")
 
         # Verify the original function was executed
@@ -281,7 +304,7 @@ async def test_spy_decorator_without_session():
         return x * 2
 
     # Clear session to ensure no spying
-    veris.clear_session_id()
+    veris.clear_context()
 
     with (
         patch("veris_ai.tool_mock.log_tool_call") as mock_log_call,
@@ -309,7 +332,8 @@ def test_spy_decorator_sync_function(simulation_env):
         patch("veris_ai.tool_mock.log_tool_call") as mock_log_call,
         patch("veris_ai.tool_mock.log_tool_response") as mock_log_response,
     ):
-        veris.set_session_id("sync-spy-session")
+        token = create_test_token("sync-spy-session")
+        veris.parse_token(token)
         result = sync_func(10, 20)
 
         # Verify the original function was executed
@@ -335,7 +359,7 @@ def test_spy_decorator_sync_without_session():
     def sync_func(x: str) -> str:
         return x.upper()
 
-    veris.clear_session_id()
+    veris.clear_context()
 
     with (
         patch("veris_ai.tool_mock.log_tool_call") as mock_log_call,
@@ -365,7 +389,8 @@ async def test_spy_decorator_preserves_metadata():
     assert documented_spy_function.__doc__ == "This is a documented spy function."
 
     # Test that it works correctly
-    veris.set_session_id("test-spy")
+    token = create_test_token("test-spy")
+    veris.parse_token(token)
     result = await documented_spy_function(100)
     assert result == "100: default"
 
@@ -385,7 +410,8 @@ async def test_spy_decorator_with_exception():
         patch("veris_ai.tool_mock.log_tool_call") as mock_log_call,
         patch("veris_ai.tool_mock.log_tool_response") as mock_log_response,
     ):
-        veris.set_session_id("exception-spy-session")
+        token = create_test_token("exception-spy-session")
+        veris.parse_token(token)
 
         # Test normal execution
         result = await failing_func(5)

{veris_ai-1.11.1 → veris_ai-1.12.0}/tests/test_veris_runner_tool_options.py

@@ -16,6 +16,7 @@ if sys.version_info >= (3, 13):
 from agents import Agent, FunctionTool
 
 from veris_ai import veris, Runner, VerisConfig, ToolCallOptions, ResponseExpectation
+from tests.test_helpers import create_test_token
 
 # Skip tests if no API key is available
 if not os.environ.get("OPENAI_API_KEY"):
@@ -131,8 +132,9 @@ 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 session for mocking
-    veris.set_session_id("test-session-tool-options")
+    # Set up session for mocking using proper token format
+    token = create_test_token("test-session-tool-options")
+    veris.set_session_id(token)
 
     try:
         config = VerisConfig(

{veris_ai-1.11.1 → veris_ai-1.12.0}/uv.lock

@@ -260,16 +260,16 @@ wheels = [
 
 [[package]]
 name = "fastapi"
-version = "0.118.0"
+version = "0.118.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "starlette" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/28/3c/2b9345a6504e4055eaa490e0b41c10e338ad61d9aeaae41d97807873cdf2/fastapi-0.118.0.tar.gz", hash = "sha256:5e81654d98c4d2f53790a7d32d25a7353b30c81441be7d0958a26b5d761fa1c8", size = 310536, upload-time = "2025-09-29T03:37:23.126Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/ad/31a59efecca3b584440cafac6f69634f4661295c858912c2b2905280a089/fastapi-0.118.2.tar.gz", hash = "sha256:d5388dbe76d97cb6ccd2c93b4dd981608062ebf6335280edfa9a11af82443e18", size = 311963, upload-time = "2025-10-08T14:52:17.796Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/20/54e2bdaad22ca91a59455251998d43094d5c3d3567c52c7c04774b3f43f2/fastapi-0.118.0-py3-none-any.whl", hash = "sha256:705137a61e2ef71019d2445b123aa8845bd97273c395b744d5a7dfe559056855", size = 97694, upload-time = "2025-09-29T03:37:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7c/97d033faf771c9fe960c7b51eb78ab266bfa64cbc917601978963f0c3c7b/fastapi-0.118.2-py3-none-any.whl", hash = "sha256:d1f842612e6a305f95abe784b7f8d3215477742e7c67a16fccd20bd79db68150", size = 97954, upload-time = "2025-10-08T14:52:16.166Z" },
 ]
 
 [[package]]
@@ -295,11 +295,11 @@ wheels = [
 
 [[package]]
 name = "filelock"
-version = "3.19.1"
+version = "3.20.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/40/bb/0ab3e58d22305b6f5440629d20683af28959bf793d98d11950e305c1c326/filelock-3.19.1.tar.gz", hash = "sha256:66eda1888b0171c998b35be2bcc0f6d75c388a7ce20c3f3f37aa8e96c2dddf58", size = 17687, upload-time = "2025-08-14T16:56:03.016Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/46/0028a82567109b5ef6e4d2a1f04a583fb513e6cf9527fcdd09afd817deeb/filelock-3.20.0.tar.gz", hash = "sha256:711e943b4ec6be42e1d4e6690b48dc175c822967466bb31c0c293f34334c13f4", size = 18922, upload-time = "2025-10-08T18:03:50.056Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/14/42b2651a2f46b022ccd948bca9f2d5af0fd8929c4eec235b8d6d844fbe67/filelock-3.19.1-py3-none-any.whl", hash = "sha256:d38e30481def20772f5baf097c122c3babc4fcdb7e14e57049eb9d88c6dc017d", size = 15988, upload-time = "2025-08-14T16:56:01.633Z" },
+    { url = "https://files.pythonhosted.org/packages/76/91/7216b27286936c16f5b4d0c530087e4a54eead683e6b0b73dd0c64844af6/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2", size = 16054, upload-time = "2025-10-08T18:03:48.35Z" },
 ]
 
 [[package]]
@@ -936,11 +936,11 @@ wheels = [
 
 [[package]]
 name = "platformdirs"
-version = "4.4.0"
+version = "4.5.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/23/e8/21db9c9987b0e728855bd57bff6984f67952bea55d6f75e055c46b5383e8/platformdirs-4.4.0.tar.gz", hash = "sha256:ca753cf4d81dc309bc67b0ea38fd15dc97bc30ce419a7f58d13eb3bf14c4febf", size = 21634, upload-time = "2025-08-26T14:32:04.268Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/61/33/9611380c2bdb1225fdef633e2a9610622310fed35ab11dac9620972ee088/platformdirs-4.5.0.tar.gz", hash = "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312", size = 21632, upload-time = "2025-10-08T17:44:48.791Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/40/4b/2028861e724d3bd36227adfa20d3fd24c3fc6d52032f4a93c133be5d17ce/platformdirs-4.4.0-py3-none-any.whl", hash = "sha256:abd01743f24e5287cd7a5db3752faf1a2d65353f38ec26d98e25a6db65958c85", size = 18654, upload-time = "2025-08-26T14:32:02.735Z" },
+    { url = "https://files.pythonhosted.org/packages/73/cb/ac7874b3e5d58441674fb70742e6c374b28b0c7cb988d37d991cde47166c/platformdirs-4.5.0-py3-none-any.whl", hash = "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3", size = 18651, upload-time = "2025-10-08T17:44:47.223Z" },
 ]
 
 [[package]]
@@ -1571,7 +1571,7 @@ wheels = [
 
 [[package]]
 name = "veris-ai"
-version = "1.11.0"
+version = "1.11.1"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },