veris-ai 1.13.0__tar.gz → 1.14.1__tar.gz

{veris_ai-1.13.0 → veris_ai-1.14.1}/PKG-INFO

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

{veris_ai-1.13.0 → veris_ai-1.14.1}/pyproject.toml

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

{veris_ai-1.13.0 → veris_ai-1.14.1}/src/veris_ai/api_client.py

@@ -20,9 +20,15 @@ class SimulatorAPIClient:
         changes reflected without recreating the singleton.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, timeout: float | None = None, base_url: str | None = None) -> None:
         """Initialize the API client with static timeout configuration."""
-        self.timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "90.0"))
+        self._timeout = timeout or float(os.getenv("VERIS_MOCK_TIMEOUT", "300.0"))
+        self._base_url = base_url
+
+    @property
+    def base_url(self) -> str:
+        """Get the resolved base URL."""
+        return self._get_base_url()
 
     def _get_base_url(self) -> str:
         """Resolve the base URL from environment.
@@ -33,7 +39,7 @@ class SimulatorAPIClient:
               (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"
+        return self._base_url or 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."""
@@ -55,7 +61,7 @@ class SimulatorAPIClient:
         if not endpoint.startswith(("http://", "https://")):
             raise httpx.ConnectError("Invalid endpoint URL (not absolute): {endpoint}")
 
-        with httpx.Client(timeout=self.timeout) as client:
+        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
@@ -73,7 +79,7 @@ class SimulatorAPIClient:
             error_msg = f"Invalid endpoint URL (not absolute): {endpoint}"
             raise httpx.ConnectError(error_msg)
 
-        async with httpx.AsyncClient(timeout=self.timeout) as client:
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
             response = await client.post(endpoint, json=payload, headers=headers)
             response.raise_for_status()
             return response.json() if response.content else None
@@ -81,15 +87,15 @@ class SimulatorAPIClient:
     @property
     def tool_mock_endpoint(self) -> str:
         """Get the tool mock endpoint URL."""
-        return urljoin(self._get_base_url(), "v3/tool_mock")
+        return urljoin(self.base_url, "v3/tool_mock")
 
     def get_log_tool_call_endpoint(self, session_id: str) -> str:
         """Get the log tool call endpoint URL."""
-        return urljoin(self._get_base_url(), f"v3/log_tool_call?session_id={session_id}")
+        return urljoin(self.base_url, f"v3/log_tool_call?session_id={session_id}")
 
     def get_log_tool_response_endpoint(self, session_id: str) -> str:
         """Get the log tool response endpoint URL."""
-        return urljoin(self._get_base_url(), f"v3/log_tool_response?session_id={session_id}")
+        return urljoin(self.base_url, f"v3/log_tool_response?session_id={session_id}")
 
 
 # Global singleton instance
@@ -99,3 +105,9 @@ _api_client = SimulatorAPIClient()
 def get_api_client() -> SimulatorAPIClient:
     """Get the global API client instance."""
     return _api_client
+
+
+def set_api_client_params(base_url: str | None = None, timeout: float | None = None) -> None:
+    """Set the global API client instance for testing purposes."""
+    global _api_client  # noqa: PLW0603
+    _api_client = SimulatorAPIClient(base_url=base_url, timeout=timeout)

{veris_ai-1.13.0 → veris_ai-1.14.1}/src/veris_ai/tool_mock.py

@@ -16,14 +16,16 @@ from typing import (
 
 
 from veris_ai.models import ResponseExpectation, ToolCallOptions
-from veris_ai.api_client import get_api_client
+from veris_ai.api_client import get_api_client, set_api_client_params
 from veris_ai.utils import (
     convert_to_type,
     execute_callback,
+    execute_combined_callback,
     extract_json_schema,
     get_function_parameters,
     get_input_parameters,
     launch_callback_task,
+    launch_combined_callback_task,
 )
 
 logger = logging.getLogger(__name__)
@@ -90,6 +92,8 @@ class VerisSDK:
 
             self._set_session_id(token_data["session_id"])
             self._set_thread_id(token_data["thread_id"])
+            if token_data.get("api_url"):
+                set_api_client_params(base_url=token_data["api_url"])
             logger.info(
                 f"Session ID set to {token_data['session_id']}, "
                 f"Thread ID set to {token_data['thread_id']} - mocking enabled"
@@ -245,13 +249,14 @@ class VerisSDK:
 
         return decorator
 
-    def mock(  # noqa: C901, PLR0915
+    def mock(  # noqa: C901, PLR0915, PLR0913
         self,
         mode: Literal["tool", "function"] = "tool",
         expects_response: bool | None = None,
         cache_response: bool | None = None,
         input_callback: Callable[..., Any] | None = None,
         output_callback: Callable[[Any], Any] | None = None,
+        combined_callback: Callable[..., Any] | None = None,
     ) -> Callable:
         """Decorator for mocking tool calls.
 
@@ -261,6 +266,7 @@ class VerisSDK:
             cache_response: Whether to cache the response
             input_callback: Callable that receives input parameters as individual arguments
             output_callback: Callable that receives the output value
+            combined_callback: Callable that receives both input parameters and mock_output
         """
         response_expectation = (
             ResponseExpectation.NONE
@@ -306,6 +312,7 @@ class VerisSDK:
                 input_params = get_input_parameters(func, args, kwargs)
                 launch_callback_task(input_callback, input_params, unpack=True)
                 launch_callback_task(output_callback, result, unpack=False)
+                launch_combined_callback_task(combined_callback, input_params, result)
 
                 return result
 
@@ -337,6 +344,7 @@ class VerisSDK:
                 input_params = get_input_parameters(func, args, kwargs)
                 execute_callback(input_callback, input_params, unpack=True)
                 execute_callback(output_callback, result, unpack=False)
+                execute_combined_callback(combined_callback, input_params, result)
 
                 return result
 
@@ -350,6 +358,7 @@ class VerisSDK:
         return_value: Any,  # noqa: ANN401
         input_callback: Callable[..., Any] | None = None,
         output_callback: Callable[[Any], Any] | None = None,
+        combined_callback: Callable[..., Any] | None = None,
     ) -> Callable:
         """Decorator for stubbing tool calls.
 
@@ -357,6 +366,7 @@ class VerisSDK:
             return_value: The value to return when the function is stubbed
             input_callback: Callable that receives input parameters as individual arguments
             output_callback: Callable that receives the output value
+            combined_callback: Callable that receives both input parameters and mock_output
         """
 
         def decorator(func: Callable) -> Callable:
@@ -380,6 +390,7 @@ class VerisSDK:
                 input_params = get_input_parameters(func, args, kwargs)
                 launch_callback_task(input_callback, input_params, unpack=True)
                 launch_callback_task(output_callback, return_value, unpack=False)
+                launch_combined_callback_task(combined_callback, input_params, return_value)
 
                 return return_value
 
@@ -397,6 +408,7 @@ class VerisSDK:
                 input_params = get_input_parameters(func, args, kwargs)
                 execute_callback(input_callback, input_params, unpack=True)
                 execute_callback(output_callback, return_value, unpack=False)
+                execute_combined_callback(combined_callback, input_params, return_value)
 
                 return return_value
 

{veris_ai-1.13.0 → veris_ai-1.14.1}/src/veris_ai/utils.py

@@ -489,3 +489,75 @@ def launch_callback_task(
     except RuntimeError:
         # If no event loop is running, log a warning
         logger.warning("Cannot launch callback task: no event loop running")
+
+
+def execute_combined_callback(
+    callback: Callable | None,
+    input_params: dict[str, Any],
+    mock_output: Any,  # noqa: ANN401
+) -> None:
+    """Execute a combined callback synchronously with input parameters and mock output.
+
+    Args:
+        callback: The callback callable to execute
+        input_params: Dictionary of input parameters
+        mock_output: The output from the mock/stub call
+
+    Note:
+        Exceptions in callbacks are caught and logged to prevent breaking the main flow.
+    """
+    if callback is None:
+        return
+
+    try:
+        # Combine input params with mock_output
+        combined_data = {**input_params, "mock_output": mock_output}
+        # Filter parameters to match callback signature
+        filtered_data = filter_callback_parameters(callback, combined_data)
+        callback(**filtered_data)
+    except Exception as e:
+        logger.warning(f"Combined callback execution failed: {e}", exc_info=True)
+
+
+def launch_combined_callback_task(
+    callback: Callable | None,
+    input_params: dict[str, Any],
+    mock_output: Any,  # noqa: ANN401
+) -> None:
+    """Launch a combined callback as a background task (fire-and-forget).
+
+    Args:
+        callback: The callback callable to execute (can be sync or async)
+        input_params: Dictionary of input parameters
+        mock_output: The output from the mock/stub call
+
+    Note:
+        This launches the callback without blocking. Errors are logged but won't
+        affect the main execution flow.
+    """
+    if callback is None:
+        return
+
+    async def _run_callback() -> None:
+        """Wrapper to run combined callback with error handling."""
+        try:
+            # Combine input params with mock_output
+            combined_data = {**input_params, "mock_output": mock_output}
+            # Filter parameters to match callback signature
+            filtered_data = filter_callback_parameters(callback, combined_data)
+
+            if inspect.iscoroutinefunction(callback):
+                await callback(**filtered_data)
+            else:
+                result = callback(**filtered_data)
+                if inspect.iscoroutine(result):
+                    await result
+        except Exception as e:
+            logger.warning(f"Combined callback execution failed: {e}", exc_info=True)
+
+    # Create task without awaiting (fire-and-forget)
+    try:
+        asyncio.create_task(_run_callback())
+    except RuntimeError:
+        # If no event loop is running, log a warning
+        logger.warning("Cannot launch combined callback task: no event loop running")

veris_ai-1.14.1/tests/test_api_client.py

@@ -0,0 +1,140 @@
+"""Tests for SimulatorAPIClient endpoint URL generation and configuration."""
+
+import os
+from unittest.mock import patch
+
+import pytest
+
+from veris_ai.api_client import SimulatorAPIClient, get_api_client, set_api_client_params
+
+
+def test_tool_mock_endpoint_default():
+    """Test that tool_mock_endpoint property returns correct URL with default base_url."""
+    client = SimulatorAPIClient()
+    endpoint = client.tool_mock_endpoint
+
+    # Should use default base URL
+    assert endpoint == "https://simulator.api.veris.ai/v3/tool_mock"
+
+
+def test_tool_mock_endpoint_custom_base_url():
+    """Test that tool_mock_endpoint uses cached base_url from constructor."""
+    client = SimulatorAPIClient(base_url="https://custom.api.com")
+    endpoint = client.tool_mock_endpoint
+
+    assert endpoint == "https://custom.api.com/v3/tool_mock"
+
+
+def test_tool_mock_endpoint_with_env_var():
+    """Test that tool_mock_endpoint respects VERIS_API_URL environment variable."""
+    with patch.dict(os.environ, {"VERIS_API_URL": "https://test.api.veris.ai"}):
+        client = SimulatorAPIClient()
+        endpoint = client.tool_mock_endpoint
+
+        assert endpoint == "https://test.api.veris.ai/v3/tool_mock"
+
+
+def test_log_tool_call_endpoint():
+    """Test get_log_tool_call_endpoint generates correct URL."""
+    client = SimulatorAPIClient(base_url="https://test.api.com")
+    endpoint = client.get_log_tool_call_endpoint("session-123")
+
+    assert endpoint == "https://test.api.com/v3/log_tool_call?session_id=session-123"
+
+
+def test_log_tool_response_endpoint():
+    """Test get_log_tool_response_endpoint generates correct URL."""
+    client = SimulatorAPIClient(base_url="https://test.api.com")
+    endpoint = client.get_log_tool_response_endpoint("session-456")
+
+    assert endpoint == "https://test.api.com/v3/log_tool_response?session_id=session-456"
+
+
+def test_base_url_without_protocol_behavior():
+    """Test that base_url without protocol is treated as relative path by urljoin."""
+    # Note: urljoin treats URLs without protocol as relative paths
+    client = SimulatorAPIClient(base_url="api.example.com")
+    endpoint = client.tool_mock_endpoint
+
+    # urljoin treats "api.example.com" as a relative path, so result is just the path component
+    assert endpoint == "v3/tool_mock"
+
+
+def test_base_url_with_trailing_slash():
+    """Test that base_url with trailing slash is handled correctly."""
+    client = SimulatorAPIClient(base_url="https://test.api.com/")
+    endpoint = client.tool_mock_endpoint
+
+    # urljoin should handle trailing slash correctly
+    assert endpoint == "https://test.api.com/v3/tool_mock"
+
+
+def test_custom_timeout():
+    """Test that custom timeout is set correctly."""
+    client = SimulatorAPIClient(timeout=30.0)
+    assert client._timeout == 30.0
+
+
+def test_default_timeout():
+    """Test that default timeout is used when not specified."""
+    with patch.dict(os.environ, {"VERIS_MOCK_TIMEOUT": "120.0"}):
+        client = SimulatorAPIClient()
+        assert client._timeout == 120.0
+
+
+def test_set_api_client_params():
+    """Test that set_api_client_params reconfigures the global client."""
+    # Get original client
+    original_client = get_api_client()
+    original_endpoint = original_client.tool_mock_endpoint
+
+    # Reconfigure with custom parameters
+    set_api_client_params(base_url="https://custom.test.api", timeout=60.0)
+
+    # Get new client and verify it's been updated
+    new_client = get_api_client()
+    assert new_client.tool_mock_endpoint == "https://custom.test.api/v3/tool_mock"
+    assert new_client._timeout == 60.0
+
+    # Restore original client
+    set_api_client_params()
+
+
+def test_set_api_client_params_partial():
+    """Test that set_api_client_params can set only base_url or timeout."""
+    # Set only base_url
+    set_api_client_params(base_url="https://partial.test")
+    client = get_api_client()
+    assert client.tool_mock_endpoint == "https://partial.test/v3/tool_mock"
+    assert client._timeout == 300  # Should use default
+
+    # Set only timeout
+    set_api_client_params(timeout=45.0)
+    client = get_api_client()
+    assert client._timeout == 45.0
+
+    # Restore defaults
+    set_api_client_params()
+
+
+def test_multiple_endpoint_calls_use_cached_base_url():
+    """Test that multiple endpoint property accesses use the same cached base_url."""
+    client = SimulatorAPIClient(base_url="https://cached.api")
+
+    # Call multiple endpoint methods
+    endpoint1 = client.tool_mock_endpoint
+    endpoint2 = client.get_log_tool_call_endpoint("session-1")
+    endpoint3 = client.get_log_tool_response_endpoint("session-2")
+
+    # All should use the same base URL
+    assert endpoint1.startswith("https://cached.api/")
+    assert endpoint2.startswith("https://cached.api/")
+    assert endpoint3.startswith("https://cached.api/")
+
+
+def test_empty_env_var_uses_default():
+    """Test that empty VERIS_API_URL falls back to default."""
+    with patch.dict(os.environ, {"VERIS_API_URL": ""}, clear=True):
+        client = SimulatorAPIClient()
+        # Empty string should NOT be used, should fall back to default
+        assert client._get_base_url() == "https://simulator.api.veris.ai"

{veris_ai-1.13.0 → veris_ai-1.14.1}/tests/test_side_effects.py

@@ -948,3 +948,357 @@ def test_callback_with_no_matching_parameters(simulation_env):
     result = some_func(1, "test")
     assert result == "result"
     assert len(called) == 1
+
+
+# Test combined_callback functionality
+
+
+@pytest.mark.asyncio
+async def test_mock_with_async_combined_callback(simulation_env):
+    """Test mock decorator with async combined_callback."""
+    captured_results = []
+
+    async def combined_handler(a: int, b: int, d: int = None, mock_output: int = None):
+        """Combined callback that uses both inputs and output."""
+        # Compute sum of inputs that are not None, then multiply by mock_output
+        total_input = a + b + (d if d is not None else 0)
+        result = total_input * (mock_output if mock_output is not None else 1)
+        captured_results.append(result)
+
+    @veris.mock(mode="function", combined_callback=combined_handler)
+    async def add(a: int, b: int, c: int = None, d: int = None) -> int:
+        """Add numbers together."""
+        return a + b + (c if c is not None else 0) + (d if d is not None else 0)
+
+    mock_response = 6
+
+    with patch.object(get_api_client(), "post_async", return_value=mock_response):
+        result = await add(1, 2, d=4)
+        assert result == 6
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.01)
+        assert len(captured_results) == 1
+        # (1 + 2 + 4) * 6 = 42
+        assert captured_results[0] == 42
+
+
+@pytest.mark.asyncio
+async def test_mock_with_sync_combined_callback_async_func(simulation_env):
+    """Test mock decorator with sync combined_callback on async function."""
+    captured_results = []
+
+    def multiply_by_result(a: int, b: int, mock_output: int = None):
+        """Multiply inputs by the mock output."""
+        result = (a + b) * (mock_output if mock_output is not None else 1)
+        captured_results.append(result)
+
+    @veris.mock(mode="function", combined_callback=multiply_by_result)
+    async def add(a: int, b: int) -> int:
+        return a + b
+
+    mock_response = 10
+
+    with patch.object(get_api_client(), "post_async", return_value=mock_response):
+        result = await add(3, 7)
+        assert result == 10
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.01)
+        assert len(captured_results) == 1
+        # (3 + 7) * 10 = 100
+        assert captured_results[0] == 100
+
+
+def test_mock_with_sync_combined_callback_sync_func(simulation_env):
+    """Test mock decorator with sync combined_callback on sync function."""
+    captured_results = []
+
+    def process_combined(x: int, y: str, mock_output: dict = None):
+        """Process both input and output."""
+        result = {
+            "input_x": x,
+            "input_y": y,
+            "output": mock_output,
+            "combined": f"{y}:{x}:{mock_output.get('value') if mock_output else 'none'}",
+        }
+        captured_results.append(result)
+
+    @veris.mock(mode="function", combined_callback=process_combined)
+    def test_func(x: int, y: str) -> dict:
+        return {"value": x}
+
+    mock_response = {"value": 999}
+
+    with patch.object(get_api_client(), "post", return_value=mock_response):
+        result = test_func(42, "test")
+        assert result == {"value": 999}
+        assert len(captured_results) == 1
+        assert captured_results[0]["input_x"] == 42
+        assert captured_results[0]["input_y"] == "test"
+        assert captured_results[0]["output"] == {"value": 999}
+        assert captured_results[0]["combined"] == "test:42:999"
+
+
+@pytest.mark.asyncio
+async def test_stub_with_async_combined_callback(simulation_env):
+    """Test stub decorator with async combined_callback."""
+    captured_results = []
+
+    async def combined_handler(name: str, count: int, mock_output: str = None):
+        """Combine input and output."""
+        result = f"{name}:{count}:{mock_output}"
+        captured_results.append(result)
+
+    @veris.stub(return_value="stubbed_value", combined_callback=combined_handler)
+    async def process(name: str, count: int) -> str:
+        return f"{name}_{count}"
+
+    result = await process("test", 5)
+    assert result == "stubbed_value"
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.01)
+    assert len(captured_results) == 1
+    assert captured_results[0] == "test:5:stubbed_value"
+
+
+def test_stub_with_sync_combined_callback_sync_func(simulation_env):
+    """Test stub decorator with sync combined_callback on sync function."""
+    captured_results = []
+
+    def multiply_inputs_by_output(a: int, b: int, mock_output: int = None):
+        """Multiply sum of inputs by output."""
+        result = (a + b) * (mock_output if mock_output is not None else 1)
+        captured_results.append(result)
+
+    @veris.stub(return_value=5, combined_callback=multiply_inputs_by_output)
+    def add(a: int, b: int) -> int:
+        return a + b
+
+    result = add(2, 3)
+    assert result == 5
+    assert len(captured_results) == 1
+    # (2 + 3) * 5 = 25
+    assert captured_results[0] == 25
+
+
+@pytest.mark.asyncio
+async def test_combined_callback_with_parameter_filtering(simulation_env):
+    """Test that combined callback only receives parameters it accepts."""
+    captured_results = []
+
+    async def selective_callback(a: int, mock_output: int = None):
+        """Callback that only accepts 'a' and 'mock_output', not 'b' or 'c'."""
+        result = a * (mock_output if mock_output is not None else 1)
+        captured_results.append(result)
+
+    @veris.mock(mode="function", combined_callback=selective_callback)
+    async def complex_func(a: int, b: int, c: str = "default") -> int:
+        return a + b
+
+    mock_response = 7
+
+    with patch.object(get_api_client(), "post_async", return_value=mock_response):
+        result = await complex_func(3, 5, c="ignored")
+        assert result == 7
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.01)
+        assert len(captured_results) == 1
+        # 3 * 7 = 21 (b and c are filtered out)
+        assert captured_results[0] == 21
+
+
+@pytest.mark.asyncio
+async def test_combined_callback_in_production_mode(production_env):
+    """Test that combined_callback is not called in production mode."""
+    callback_mock = Mock()
+
+    @veris.mock(mode="function", combined_callback=callback_mock)
+    async def test_func(x: int) -> int:
+        return x * 2
+
+    result = await test_func(21)
+    assert result == 42
+
+    # Combined callback should NOT have been called
+    callback_mock.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_combined_callback_exception_is_logged(simulation_env):
+    """Test that exceptions in combined callback are caught and logged."""
+
+    async def failing_combined_callback(x: int, mock_output: int = None):
+        raise ValueError("Combined callback error")
+
+    @veris.mock(mode="function", combined_callback=failing_combined_callback)
+    async def test_func(x: int) -> int:
+        return x * 2
+
+    mock_response = 100
+
+    with (
+        patch.object(get_api_client(), "post_async", return_value=mock_response),
+        patch("veris_ai.utils.logger.warning") as mock_logger,
+    ):
+        # Function should still work despite combined callback failure
+        result = await test_func(42)
+        assert result == 100
+
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.01)
+
+        # Error should have been logged
+        mock_logger.assert_called()
+        assert "Combined callback execution failed" in str(mock_logger.call_args)
+
+
+@pytest.mark.asyncio
+async def test_mock_with_all_three_callbacks(simulation_env):
+    """Test mock decorator with input, output, and combined callbacks."""
+    captured_inputs = []
+    captured_outputs = []
+    captured_combined = []
+
+    async def capture_input(**kwargs):
+        captured_inputs.append(kwargs)
+
+    async def capture_output(result: int):
+        captured_outputs.append(result)
+
+    async def capture_combined(a: int, b: int, mock_output: int = None):
+        combined = {"sum": a + b, "product": a * b, "mock": mock_output}
+        captured_combined.append(combined)
+
+    @veris.mock(
+        mode="function",
+        input_callback=capture_input,
+        output_callback=capture_output,
+        combined_callback=capture_combined,
+    )
+    async def add(a: int, b: int) -> int:
+        return a + b
+
+    mock_response = 50
+
+    with patch.object(get_api_client(), "post_async", return_value=mock_response):
+        result = await add(10, 20)
+        assert result == 50
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.01)
+
+        # All callbacks should have been called
+        assert len(captured_inputs) == 1
+        assert captured_inputs[0] == {"a": 10, "b": 20}
+
+        assert len(captured_outputs) == 1
+        assert captured_outputs[0] == 50
+
+        assert len(captured_combined) == 1
+        assert captured_combined[0] == {"sum": 30, "product": 200, "mock": 50}
+
+
+def test_stub_with_all_three_callbacks(simulation_env):
+    """Test stub decorator with input, output, and combined callbacks."""
+    captured_inputs = []
+    captured_outputs = []
+    captured_combined = []
+
+    def capture_input(**kwargs):
+        captured_inputs.append(kwargs)
+
+    def capture_output(result: str):
+        captured_outputs.append(result)
+
+    def capture_combined(name: str, value: int, mock_output: str = None):
+        combined = f"{name}_{value}_{mock_output}"
+        captured_combined.append(combined)
+
+    @veris.stub(
+        return_value="stubbed",
+        input_callback=capture_input,
+        output_callback=capture_output,
+        combined_callback=capture_combined,
+    )
+    def process(name: str, value: int) -> str:
+        return f"{name}:{value}"
+
+    result = process("test", 42)
+    assert result == "stubbed"
+
+    # All callbacks should have been called
+    assert len(captured_inputs) == 1
+    assert captured_inputs[0] == {"name": "test", "value": 42}
+
+    assert len(captured_outputs) == 1
+    assert captured_outputs[0] == "stubbed"
+
+    assert len(captured_combined) == 1
+    assert captured_combined[0] == "test_42_stubbed"
+
+
+@pytest.mark.asyncio
+async def test_combined_callback_with_kwargs_accepts_all(simulation_env):
+    """Test combined callback with **kwargs accepts all parameters including mock_output."""
+    captured_data = []
+
+    async def flexible_callback(**kwargs):
+        """Callback that accepts any parameters via **kwargs."""
+        captured_data.append(kwargs)
+
+    @veris.mock(mode="function", combined_callback=flexible_callback)
+    async def multi_param_func(a: int, b: str, c: float = 3.14) -> dict:
+        return {"result": a}
+
+    mock_response = {"result": 999}
+
+    with patch.object(get_api_client(), "post_async", return_value=mock_response):
+        result = await multi_param_func(10, "test", c=2.71)
+        assert result == {"result": 999}
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.01)
+
+        assert len(captured_data) == 1
+        # Should have all input params plus mock_output
+        assert captured_data[0]["a"] == 10
+        assert captured_data[0]["b"] == "test"
+        assert captured_data[0]["c"] == 2.71
+        assert captured_data[0]["mock_output"] == {"result": 999}
+
+
+def test_combined_callback_user_example(simulation_env):
+    """Test the exact example from the user: add function with multiply_by_result."""
+    multiplication_results = []
+
+    def multiply_by_result(a: int, b: int, d: int = None, mock_output: int = None):
+        """Multiply sum of provided inputs by the mock output."""
+        # Sum the inputs that are not None
+        input_sum = a + b + (d if d is not None else 0)
+        # Multiply by mock output
+        result = input_sum * (mock_output if mock_output is not None else 1)
+        multiplication_results.append(result)
+
+    @veris.mock(mode="function", combined_callback=multiply_by_result)
+    def add(a: int, b: int, c: int = None, d: int = None) -> int:
+        """Add numbers together."""
+        total = a + b
+        if c is not None:
+            total += c
+        if d is not None:
+            total += d
+        return total
+
+    # Mock the API to return 6 as the result
+    mock_response = 6
+
+    with patch.object(get_api_client(), "post", return_value=mock_response):
+        # Call add(1, 2, d=4)
+        # Expected: inputs are 1, 2, 4 (c is None)
+        # Mock returns 6
+        # Combined callback should compute: (1 + 2 + 4) * 6 = 42
+        result = add(1, 2, d=4)
+
+        # The function returns the mocked value
+        assert result == 6
+
+        # The combined callback computed (1+2+4)*6
+        assert len(multiplication_results) == 1
+        assert multiplication_results[0] == 42

{veris_ai-1.13.0 → veris_ai-1.14.1}/uv.lock

@@ -1571,7 +1571,7 @@ wheels = [
 
 [[package]]
 name = "veris-ai"
-version = "1.12.3"
+version = "1.14.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },