veris-ai 1.12.1__py3-none-any.whl → 1.12.3__py3-none-any.whl

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__)
@@ -83,14 +84,26 @@ def _wrap(
                                 ) -> Any:  # noqa: ANN401
                                     """Wrapped on_invoke_tool that intercepts the tool function."""
                                     session_id = veris.session_id
+                                    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,
                                             json.loads(parameters),
                                             tool_options.get(tool_name_inner),
+                                            thread_id=thread_id,
                                         )
                                     # Fall back to original if we couldn't extract the function
                                     return await orig_invoke(ctx, parameters)
@@ -189,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/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/tool_mock.py

@@ -206,14 +206,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)
@@ -275,7 +275,7 @@ class VerisSDK:
                     return await func(*args, **kwargs)
                 parameters = get_function_parameters(func, args, kwargs)
                 thread_id = _thread_id_context.get()
-                return mock_tool_call(
+                return await mock_tool_call_async(
                     func,
                     session_id,
                     parameters,
@@ -358,7 +358,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 +424,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 +534,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 +582,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.1.dist-info → veris_ai-1.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 1.12.1
+Version: 1.12.3
 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
@@ -41,6 +41,13 @@ Description-Content-Type: text/markdown
 
 # Veris AI Python SDK
 
+[![PyPI version](https://badge.fury.io/py/veris-ai.svg)](https://badge.fury.io/py/veris-ai)
+[![Python Versions](https://img.shields.io/pypi/pyversions/veris-ai.svg)](https://pypi.org/project/veris-ai/)
+[![Downloads](https://static.pepy.tech/badge/veris-ai)](https://pepy.tech/project/veris-ai)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/veris-ai/veris-python-sdk/actions/workflows/test.yml/badge.svg)](https://github.com/veris-ai/veris-python-sdk/actions/workflows/test.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
 For more information visit us at https://veris.ai
 
 A Python package for Veris AI tools with simulation capabilities and FastAPI MCP (Model Context Protocol) integration.

{veris_ai-1.12.1.dist-info → veris_ai-1.12.3.dist-info}/RECORD

@@ -1,16 +1,16 @@
 veris_ai/README.md,sha256=Mxg9fyNt6hFkQaFBYZq85Kw9akw4cN2uu6j_mXZtNCs,3871
 veris_ai/__init__.py,sha256=enl_gEa6BQAjWvzCtsn_hFVJVVlJZ_dMsLL--E5W3nU,1907
-veris_ai/agents_wrapper.py,sha256=N-YZ0qvIEJ8rlFZAzVKg6eWKa7I_qIt-khlg_zL-qY8,11931
-veris_ai/api_client.py,sha256=BQ2Fn5pO7uaWmWNcLOoZO8o-D39OPRmclPROwJvXBUc,3199
+veris_ai/agents_wrapper.py,sha256=gLUd_0TyCVsqqilQLvsSJIpsU5uu2CdjjWOQ4QJjoJk,12786
+veris_ai/api_client.py,sha256=I1XyQ7J0ZU_JK9sZjF3XqFv5gGsrdKF38euOZmW8BG0,4150
 veris_ai/models.py,sha256=xKeheSJQle2tBeJG1DsGJzMDwv24p5jECjX6RAa39n4,495
 veris_ai/observability.py,sha256=eSIXmk6fpOAoWM-sDbsvzyUASh1ZwU6tRIPduy09RxY,4206
-veris_ai/tool_mock.py,sha256=h_nS0tTOl8eI_Hb-HNuurjbBPp0ThdMnJwsMXfRyT7I,17489
+veris_ai/tool_mock.py,sha256=wqklgub07C9zon25P9XMAXTXUsRVKAnZo6nv4lJROCo,21850
 veris_ai/utils.py,sha256=hJetCiN8Bubhy0nqSoS1C2awN9cdkKuHM1v7YhtwtTs,10066
 veris_ai/jaeger_interface/README.md,sha256=kd9rKcE5xf3EyNaiHu0tjn-0oES9sfaK6Ih-OhhTyCM,2821
 veris_ai/jaeger_interface/__init__.py,sha256=KD7NSiMYRG_2uF6dOLKkGG5lNQe4K9ptEwucwMT4_aw,1128
 veris_ai/jaeger_interface/client.py,sha256=yJrh86wRR0Dk3Gq12DId99WogcMIVbL0QQFqVSevvlE,8772
 veris_ai/jaeger_interface/models.py,sha256=e64VV6IvOEFuzRUgvDAMQFyOZMRb56I-PUPZLBZ3rX0,1864
-veris_ai-1.12.1.dist-info/METADATA,sha256=NdXH_sXX2K9mcV2qRQLulBcJlCsG2wnE_fkrtT7qHyg,15960
-veris_ai-1.12.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-veris_ai-1.12.1.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
-veris_ai-1.12.1.dist-info/RECORD,,
+veris_ai-1.12.3.dist-info/METADATA,sha256=P6ZtsocGvpf7cifFzmvQLUZnFaYb5bVGiaYggn9KkC8,16684
+veris_ai-1.12.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+veris_ai-1.12.3.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
+veris_ai-1.12.3.dist-info/RECORD,,