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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 1.12.2
+Version: 1.13.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.12.2 → veris_ai-1.13.0}/pyproject.toml

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

{veris_ai-1.12.2 → veris_ai-1.13.0}/src/veris_ai/agents_wrapper.py

@@ -1,5 +1,6 @@
 """OpenAI Agents wrapper for automatic tool mocking via Veris SDK."""
 
+import inspect
 import json
 import logging
 from collections.abc import Callable
@@ -9,7 +10,7 @@ from agents import RunContextWrapper, RunResult, Runner as OpenAIRunner
 from pydantic import BaseModel
 
 from veris_ai import veris
-from veris_ai.tool_mock import mock_tool_call
+from veris_ai.tool_mock import mock_tool_call, mock_tool_call_async
 from veris_ai.models import ToolCallOptions
 
 logger = logging.getLogger(__name__)
@@ -86,7 +87,17 @@ def _wrap(
                                     thread_id = veris.thread_id
                                     the_func = tool_functions.get(tool_id)
                                     if the_func and session_id:
-                                        # mock_tool_call is synchronous, don't await it
+                                        # Check if async or sync, call appropriate version
+                                        if inspect.iscoroutinefunction(the_func):
+                                            # Use async version (non-blocking)
+                                            return await mock_tool_call_async(
+                                                the_func,
+                                                session_id,
+                                                json.loads(parameters),
+                                                tool_options.get(tool_name_inner),
+                                                thread_id=thread_id,
+                                            )
+                                        # Use sync version for sync functions
                                         return mock_tool_call(
                                             the_func,
                                             session_id,
@@ -191,8 +202,6 @@ def _find_user_function_in_closure(closure: tuple) -> Callable | None:
     Returns:
         The user function if found, None otherwise
     """
-    import inspect
-
     # List of module prefixes that indicate library/framework code
     library_modules = ("json", "inspect", "agents", "pydantic", "openai", "typing")
 

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

@@ -60,6 +60,24 @@ class SimulatorAPIClient:
             response.raise_for_status()
             return response.json() if response.content else None
 
+    async def post_async(self, endpoint: str, payload: dict[str, Any]) -> Any:  # noqa: ANN401
+        """Make an asynchronous POST request to the specified endpoint.
+
+        This method uses httpx.AsyncClient and is safe to call from async functions
+        without blocking the event loop.
+        """
+        headers = self._build_headers()
+        # Validate endpoint URL; raise ConnectError for non-absolute URLs to
+        # mirror connection failures in tests when base URL is intentionally invalid.
+        if not endpoint.startswith(("http://", "https://")):
+            error_msg = f"Invalid endpoint URL (not absolute): {endpoint}"
+            raise httpx.ConnectError(error_msg)
+
+        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
+
     @property
     def tool_mock_endpoint(self) -> str:
         """Get the tool mock endpoint URL."""

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

@@ -17,7 +17,14 @@ from typing import (
 
 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
+from veris_ai.utils import (
+    convert_to_type,
+    execute_callback,
+    extract_json_schema,
+    get_function_parameters,
+    get_input_parameters,
+    launch_callback_task,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -206,14 +213,14 @@ class VerisSDK:
                     return await func(*args, **kwargs)
                 parameters = get_function_parameters(func, args, kwargs)
                 logger.info(f"Spying on function: {func.__name__}")
-                log_tool_call(
+                await log_tool_call_async(
                     session_id=session_id,
                     function_name=func.__name__,
                     parameters=parameters,
                     docstring=inspect.getdoc(func) or "",
                 )
                 result = await func(*args, **kwargs)
-                log_tool_response(session_id=session_id, response=result)
+                await log_tool_response_async(session_id=session_id, response=result)
                 return result
 
             @wraps(func)
@@ -243,8 +250,18 @@ class VerisSDK:
         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,
     ) -> Callable:
-        """Decorator for mocking tool calls."""
+        """Decorator for mocking tool calls.
+
+        Args:
+            mode: Whether to treat the function as a tool or function
+            expects_response: Whether the function expects a response
+            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
+        """
         response_expectation = (
             ResponseExpectation.NONE
             if (expects_response is False or (expects_response is None and mode == "function"))
@@ -273,9 +290,11 @@ class VerisSDK:
                         f"No session ID found, executing original function: {func.__name__}"
                     )
                     return await func(*args, **kwargs)
+
+                # Perform the mock call first
                 parameters = get_function_parameters(func, args, kwargs)
                 thread_id = _thread_id_context.get()
-                return mock_tool_call(
+                result = await mock_tool_call_async(
                     func,
                     session_id,
                     parameters,
@@ -283,6 +302,13 @@ class VerisSDK:
                     thread_id,
                 )
 
+                # Launch callbacks as background tasks (non-blocking)
+                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)
+
+                return result
+
             @wraps(func)
             def sync_wrapper(
                 *args: tuple[object, ...],
@@ -295,9 +321,11 @@ class VerisSDK:
                         f"No session ID found, executing original function: {func.__name__}"
                     )
                     return func(*args, **kwargs)
+
+                # Perform the mock call first
                 parameters = get_function_parameters(func, args, kwargs)
                 thread_id = _thread_id_context.get()
-                return mock_tool_call(
+                result = mock_tool_call(
                     func,
                     session_id,
                     parameters,
@@ -305,13 +333,31 @@ class VerisSDK:
                     thread_id,
                 )
 
+                # Execute callbacks synchronously (can't use async tasks in sync context)
+                input_params = get_input_parameters(func, args, kwargs)
+                execute_callback(input_callback, input_params, unpack=True)
+                execute_callback(output_callback, result, unpack=False)
+
+                return result
+
             # Return the appropriate wrapper based on whether the function is async
             return async_wrapper if is_async else sync_wrapper
 
         return decorator
 
-    def stub(self, return_value: Any) -> Callable:  # noqa: ANN401
-        """Decorator for stubbing toolw calls."""
+    def stub(
+        self,
+        return_value: Any,  # noqa: ANN401
+        input_callback: Callable[..., Any] | None = None,
+        output_callback: Callable[[Any], Any] | None = None,
+    ) -> Callable:
+        """Decorator for stubbing tool calls.
+
+        Args:
+            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
+        """
 
         def decorator(func: Callable) -> Callable:
             # Check if the original function is async
@@ -327,7 +373,14 @@ class VerisSDK:
                         f"No session ID found, executing original function: {func.__name__}"
                     )
                     return await func(*args, **kwargs)
+
                 logger.info(f"Stubbing function: {func.__name__}")
+
+                # Launch callbacks as background tasks (non-blocking)
+                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)
+
                 return return_value
 
             @wraps(func)
@@ -337,7 +390,14 @@ class VerisSDK:
                         f"No session ID found, executing original function: {func.__name__}"
                     )
                     return func(*args, **kwargs)
+
                 logger.info(f"Stubbing function: {func.__name__}")
+
+                # Execute callbacks synchronously (can't use async tasks in sync context)
+                input_params = get_input_parameters(func, args, kwargs)
+                execute_callback(input_callback, input_params, unpack=True)
+                execute_callback(output_callback, return_value, unpack=False)
+
                 return return_value
 
             # Return the appropriate wrapper based on whether the function is async
@@ -358,7 +418,7 @@ def mock_tool_call(
     options: ToolCallOptions | None = None,
     thread_id: str | None = None,
 ) -> object:
-    """Mock tool call.
+    """Mock tool call (synchronous).
 
     Args:
         func: Function being mocked
@@ -424,6 +484,84 @@ def mock_tool_call(
     return convert_to_type(mock_result, return_type_obj)
 
 
+@tenacity.retry(
+    stop=tenacity.stop_after_attempt(3),
+    wait=tenacity.wait_exponential(multiplier=1, min=4, max=10),
+    reraise=True,
+)
+async def mock_tool_call_async(
+    func: Callable,
+    session_id: str,  # noqa: ARG001
+    parameters: dict[str, dict[str, str]],
+    options: ToolCallOptions | None = None,
+    thread_id: str | None = None,
+) -> object:
+    """Mock tool call (asynchronous).
+
+    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
+
+    logger.info(f"Simulating function: {func.__name__}")
+
+    type_hints = get_type_hints(func)
+
+    # Extract return type object (not just the name)
+    return_type_obj = type_hints.pop("return", Any)
+    # Get function docstring
+    docstring = inspect.getdoc(func) or ""
+
+    # 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():
+        if isinstance(value, dict) and "value" in value:
+            # Extract just the value from the nested structure
+            clean_params[key] = value["value"]
+        else:
+            # Already clean or unexpected format
+            clean_params[key] = value
+
+    # Determine response expectation
+    payload = {
+        "session_id": payload_session_id,
+        "response_expectation": options.response_expectation.value,
+        "cache_response": bool(options.cache_response),
+        "tool_call": {
+            "function_name": func.__name__,
+            "parameters": clean_params,
+            "return_type": json.dumps(extract_json_schema(return_type_obj)),
+            "docstring": docstring,
+        },
+    }
+
+    mock_result = await api_client.post_async(endpoint, payload)
+    logger.info(f"Mock response: {mock_result}")
+
+    if isinstance(mock_result, str):
+        with suppress(json.JSONDecodeError):
+            mock_result = json.loads(mock_result)
+            return convert_to_type(mock_result, return_type_obj)
+    return convert_to_type(mock_result, return_type_obj)
+
+
 def log_tool_call(
     session_id: str,
     function_name: str,
@@ -456,6 +594,38 @@ def log_tool_call(
         logger.warning(f"Failed to log tool call for {function_name}: {e}")
 
 
+async def log_tool_call_async(
+    session_id: str,
+    function_name: str,
+    parameters: dict[str, dict[str, str]],
+    docstring: str,
+) -> None:
+    """Log tool call asynchronously to the VERIS logging endpoint."""
+    api_client = get_api_client()
+    endpoint = api_client.get_log_tool_call_endpoint(session_id)
+
+    # Clean up parameters for V3 - just send values, not the nested dict
+    clean_params: dict[str, Any] = {}
+    for key, value in parameters.items():
+        if isinstance(value, dict) and "value" in value:
+            # Extract just the value from the nested structure
+            clean_params[key] = value["value"]
+        else:
+            # Already clean or unexpected format
+            clean_params[key] = value
+
+    payload = {
+        "function_name": function_name,
+        "parameters": clean_params,
+        "docstring": docstring,
+    }
+    try:
+        await api_client.post_async(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()
@@ -472,4 +642,20 @@ def log_tool_response(session_id: str, response: Any) -> None:  # noqa: ANN401
         logger.warning(f"Failed to log tool response: {e}")
 
 
+async def log_tool_response_async(session_id: str, response: Any) -> None:  # noqa: ANN401
+    """Log tool response asynchronously 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:
+        await api_client.post_async(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.12.2 → veris_ai-1.13.0}/src/veris_ai/utils.py

@@ -1,4 +1,6 @@
+import asyncio
 import inspect
+import logging
 import sys
 import types
 import typing
@@ -18,6 +20,8 @@ from collections.abc import Callable
 
 from pydantic import BaseModel
 
+logger = logging.getLogger(__name__)
+
 
 def convert_to_type(value: object, target_type: type) -> object:
     """Convert a value to the specified type."""
@@ -303,3 +307,185 @@ def get_function_parameters(
             "type": str(get_type_hints(func).get(param_name, Any)),
         }
     return params_info
+
+
+# Callback utility functions
+
+
+def get_input_parameters(func: Callable, args: tuple, kwargs: dict) -> dict[str, Any]:
+    """Get the actual input parameters for callbacks.
+
+    Args:
+        func: The function being called
+        args: Positional arguments
+        kwargs: Keyword arguments
+
+    Returns:
+        Dictionary of parameter names to their actual values (not stringified),
+        excluding self and cls parameters. Preserves ctx if present.
+    """
+    sig = inspect.signature(func)
+    bound_args = sig.bind(*args, **kwargs)
+    bound_args.apply_defaults()
+
+    # Remove only self and cls - preserve ctx and all other parameters
+    params = dict(bound_args.arguments)
+    params.pop("self", None)
+    params.pop("cls", None)
+
+    return params
+
+
+def filter_callback_parameters(callback: Callable, params: dict[str, Any]) -> dict[str, Any]:
+    """Filter parameters to match what the callback can accept.
+
+    Args:
+        callback: The callback function to inspect
+        params: Dictionary of all available parameters
+
+    Returns:
+        Filtered dictionary containing only parameters the callback accepts
+    """
+    try:
+        sig = inspect.signature(callback)
+
+        # Check if callback accepts **kwargs (VAR_KEYWORD parameter)
+        has_var_keyword = any(
+            p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
+        )
+
+        # If callback accepts **kwargs, pass all parameters
+        if has_var_keyword:
+            return params
+
+        # Otherwise, filter to only include parameters the callback accepts
+        accepted_params = {}
+        for param_name in sig.parameters:
+            if param_name in params:
+                accepted_params[param_name] = params[param_name]
+
+        return accepted_params
+    except (ValueError, TypeError):
+        # If we can't inspect the signature, pass all parameters
+        # and let the callback handle it (will fail if incompatible)
+        return params
+
+
+def execute_callback(
+    callback: Callable | None,
+    data: Any,  # noqa: ANN401
+    unpack: bool = False,
+) -> None:
+    """Execute a callback synchronously if provided.
+
+    Args:
+        callback: The callback callable to execute
+        data: The data to pass to the callback
+        unpack: If True and data is a dict, unpack it as keyword arguments
+
+    Note:
+        Exceptions in callbacks are caught and logged to prevent breaking the main flow.
+    """
+    if callback is None:
+        return
+
+    try:
+        if unpack and isinstance(data, dict):
+            # Filter parameters to match callback signature
+            filtered_data = filter_callback_parameters(callback, data)
+            callback(**filtered_data)
+        else:
+            callback(data)
+    except Exception as e:
+        logger.warning(f"Callback execution failed: {e}", exc_info=True)
+
+
+async def execute_callback_async(
+    callback: Callable | None,
+    data: Any,  # noqa: ANN401
+    unpack: bool = False,
+) -> None:
+    """Execute a callback asynchronously if provided.
+
+    Handles both sync and async callback callables.
+
+    Args:
+        callback: The callback callable to execute (can be sync or async)
+        data: The data to pass to the callback
+        unpack: If True and data is a dict, unpack it as keyword arguments
+
+    Note:
+        Exceptions in callbacks are caught and logged to prevent breaking the main flow.
+    """
+    if callback is None:
+        return
+
+    try:
+        if inspect.iscoroutinefunction(callback):
+            if unpack and isinstance(data, dict):
+                # Filter parameters to match callback signature
+                filtered_data = filter_callback_parameters(callback, data)
+                await callback(**filtered_data)
+            else:
+                await callback(data)
+        else:
+            if unpack and isinstance(data, dict):
+                # Filter parameters to match callback signature
+                filtered_data = filter_callback_parameters(callback, data)
+                result = callback(**filtered_data)
+            else:
+                result = callback(data)
+            # If the result is a coroutine (can happen with functools.partial), await it
+            if inspect.iscoroutine(result):
+                await result
+    except Exception as e:
+        logger.warning(f"Callback execution failed: {e}", exc_info=True)
+
+
+def launch_callback_task(
+    callback: Callable | None,
+    data: Any,  # noqa: ANN401
+    unpack: bool = False,
+) -> None:
+    """Launch a callback as a background task (fire-and-forget).
+
+    Args:
+        callback: The callback callable to execute (can be sync or async)
+        data: The data to pass to the callback
+        unpack: If True and data is a dict, unpack it as keyword arguments
+
+    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 callback with error handling."""
+        try:
+            if inspect.iscoroutinefunction(callback):
+                if unpack and isinstance(data, dict):
+                    # Filter parameters to match callback signature
+                    filtered_data = filter_callback_parameters(callback, data)
+                    await callback(**filtered_data)
+                else:
+                    await callback(data)
+            else:
+                if unpack and isinstance(data, dict):
+                    # Filter parameters to match callback signature
+                    filtered_data = filter_callback_parameters(callback, data)
+                    result = callback(**filtered_data)
+                else:
+                    result = callback(data)
+                if inspect.iscoroutine(result):
+                    await result
+        except Exception as e:
+            logger.warning(f"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 callback task: no event loop running")

{veris_ai-1.12.2 → veris_ai-1.13.0}/tests/test_agents_wrapper_simple.py

@@ -87,18 +87,29 @@ def mock_veris_endpoint():
     """Fixture that mocks the veris SDK's HTTP request method."""
     calls = []
 
-    def mock_request(endpoint, payload):
-        """Mock the post_sync method."""
+    async def mock_request_async(endpoint, payload):
+        """Mock the post_async method."""
         # Record the call
         calls.append({"endpoint": endpoint, "payload": payload})
 
         # Return a distinctive mocked value
         return {"result": 999}
 
-    # Patch the post_sync method of the API client
+    def mock_request_sync(endpoint, payload):
+        """Mock the post method."""
+        # Record the call
+        calls.append({"endpoint": endpoint, "payload": payload})
+
+        # Return a distinctive mocked value
+        return {"result": 999}
+
+    # Patch both sync and async methods of the API client
     from veris_ai.api_client import get_api_client
 
-    with patch.object(get_api_client(), "post_sync", side_effect=mock_request):
+    with (
+        patch.object(get_api_client(), "post", side_effect=mock_request_sync),
+        patch.object(get_api_client(), "post_async", side_effect=mock_request_async),
+    ):
         yield {"calls": calls}
 
 

{veris_ai-1.12.2 → veris_ai-1.13.0}/tests/test_mcp_protocol_server_mocked.py

@@ -62,10 +62,16 @@ def run_server_with_mock(server_port: int) -> None:  # noqa: C901
             # Return error response if something goes wrong
             return {"error": str(e)}
 
-    # Patch the API client's post method
+    # Patch the API client's post methods (both sync and async)
     from veris_ai.api_client import get_api_client
 
-    with patch.object(get_api_client(), "post", side_effect=mock_post):
+    async def mock_post_async(endpoint, payload):
+        return mock_post(endpoint, payload)
+
+    with (
+        patch.object(get_api_client(), "post", side_effect=mock_post),
+        patch.object(get_api_client(), "post_async", side_effect=mock_post_async),
+    ):
         # Configure the server
         fastapi = make_simple_fastapi_app()
         veris.set_fastapi_mcp(