veris-ai 1.8.0__py3-none-any.whl → 1.8.1__py3-none-any.whl

veris_ai/agents_wrapper.py

@@ -1,16 +1,14 @@
 """OpenAI Agents wrapper for automatic tool mocking via Veris SDK."""
 
-import asyncio
-import inspect
-import json
 import logging
 from collections.abc import Callable
 from typing import Any
 
-from agents import RunResult, Runner
+from agents import RunContextWrapper, RunResult, Runner
 from pydantic import BaseModel
 
 from veris_ai import veris
+from veris_ai.tool_mock import mock_tool_call
 
 logger = logging.getLogger(__name__)
 
@@ -49,8 +47,8 @@ def _wrap(
 
         async def wrapped_run(starting_agent: Any, input_text: str, **kwargs: Any) -> Any:  # noqa: ANN401
             """Wrapped version of Runner.run that intercepts tool calls."""
-            # Patch all tools in the agent
-            original_tools = []
+            # Store a mapping of tools to their original functions
+            tool_functions = {}
 
             if hasattr(starting_agent, "tools") and starting_agent.tools:
                 for tool in starting_agent.tools:
@@ -61,34 +59,39 @@ def _wrap(
                         if tool_name and _should_intercept_tool(
                             tool_name, include_tools, exclude_tools
                         ):
-                            # Save the original invoke function
-                            original_tools.append((tool, tool.on_invoke_tool))  # type: ignore[attr-defined]
-
-                            # Create veris-wrapped version
-                            tool.on_invoke_tool = _create_veris_wrapped_invoke(  # type: ignore[attr-defined]
-                                tool,
-                                tool.on_invoke_tool,  # type: ignore[attr-defined]
+                            # Extract the original function before patching
+                            original_func = _extract_the_func(tool.on_invoke_tool)
+                            if original_func:
+                                tool_functions[id(tool)] = original_func
+
+                            # Store original on_invoke_tool
+                            original_on_invoke = tool.on_invoke_tool
+
+                            def make_wrapped_on_invoke_tool(
+                                tool_id: int, orig_invoke: Callable
+                            ) -> Callable:
+                                """Create a wrapped on_invoke_tool with proper closure."""
+
+                                async def wrapped_on_invoke_tool(
+                                    ctx: RunContextWrapper[Any], parameters: str
+                                ) -> Any:  # noqa: ANN401
+                                    """Wrapped on_invoke_tool that intercepts the tool function."""
+                                    session_id = veris.session_id
+                                    the_func = tool_functions.get(tool_id)
+                                    if the_func and session_id:
+                                        # mock_tool_call is synchronous, don't await it
+                                        return mock_tool_call(
+                                            the_func, session_id, parameters, None
+                                        )
+                                    # Fall back to original if we couldn't extract the function
+                                    return await orig_invoke(ctx, parameters)
+
+                                return wrapped_on_invoke_tool
+
+                            tool.on_invoke_tool = make_wrapped_on_invoke_tool(
+                                id(tool), original_on_invoke
                             )
-
-            try:
-                # Call the original Runner.run with the patched agent
-                return await run_func(starting_agent, input_text, **kwargs)
-            finally:
-                # Restore all original tool functions
-                for tool, original_invoke in original_tools:
-                    tool.on_invoke_tool = original_invoke  # type: ignore[attr-defined]
-
-        # Preserve function metadata
-        wrapped_run.__name__ = getattr(run_func, "__name__", "wrapped_run")
-        wrapped_run.__doc__ = getattr(run_func, "__doc__", "Wrapped Runner.run function")
-
-        # Also provide a sync version
-        def wrapped_run_sync(starting_agent: Any, input_text: str, **kwargs: Any) -> Any:  # noqa: ANN401
-            """Sync version of wrapped Runner.run."""
-            return asyncio.run(wrapped_run(starting_agent, input_text, **kwargs))
-
-        # Add sync version as an attribute
-        wrapped_run.run_sync = wrapped_run_sync  # type: ignore[attr-defined]
+            return await run_func(starting_agent, input_text, **kwargs)
 
         return wrapped_run
 
@@ -117,94 +120,108 @@ def _should_intercept_tool(
     return True
 
 
-def _create_veris_wrapped_invoke(  # noqa: C901
-    tool: Any,  # noqa: ANN401
-    original_invoke: Callable,
-) -> Callable:
-    """Create a wrapped invoke function that uses veris.mock().
+def _extract_the_func(on_invoke_tool: Callable) -> Callable | None:
+    """Extract the original user function from the on_invoke_tool closure.
+
+    This function attempts multiple strategies to extract the original function:
+    1. Direct attribute access (if the tool stores it)
+    2. Closure inspection for known patterns
+    3. Deep closure traversal as a fallback
 
     Args:
-        tool: The FunctionTool instance
-        original_invoke: The original on_invoke_tool function
+        on_invoke_tool: The on_invoke_tool function from FunctionTool
 
     Returns:
-        A wrapped invoke function that routes through Veris SDK
+        The original user function if found, None otherwise
     """
-    # Extract tool metadata
-    tool_name = tool.name
-    tool_schema = tool.params_json_schema if hasattr(tool, "params_json_schema") else {}
-
-    # Create a function that will be decorated with veris.mock()
-    @veris.mock(mode="tool")
-    async def veris_tool_function(**_kwargs: Any) -> Any:  # noqa: ANN401
-        """Mock function for tool execution."""
-        # This function's signature doesn't matter as veris.mock()
-        # will intercept and send the metadata to the endpoint
-        return f"Mock response for {tool_name}"
-
-    async def wrapped_invoke(context: Any, arguments: str) -> Any:  # noqa: ANN401
-        """Wrapped invoke function that routes through Veris SDK."""
-        # Only intercept if we have a session ID
-        if not veris.session_id:
-            # No session, run original
-            return await original_invoke(context, arguments)
-
-        # Parse arguments
-        try:
-            args_dict = json.loads(arguments) if arguments else {}
-        except json.JSONDecodeError:
-            args_dict = {"raw_arguments": arguments}
-
-        # Set up the function with proper metadata for veris.mock()
-        veris_tool_function.__name__ = tool_name
-        veris_tool_function.__doc__ = getattr(tool, "description", "")
-
-        # Add type hints based on schema if available
-        if tool_schema and "properties" in tool_schema:
-            # Create a simple signature based on schema
-            params = []
-            for param_name, param_info in tool_schema["properties"].items():
-                # Simplified type mapping
-                param_type: type[Any] = Any
-                if "type" in param_info:
-                    type_map = {
-                        "string": str,
-                        "number": float,
-                        "integer": int,
-                        "boolean": bool,
-                        "array": list,
-                        "object": dict,
-                    }
-                    param_type = type_map.get(param_info["type"], Any)
-                params.append(
-                    inspect.Parameter(
-                        param_name,
-                        inspect.Parameter.KEYWORD_ONLY,
-                        annotation=param_type,
-                    )
-                )
-
-            if params:
-                veris_tool_function.__signature__ = inspect.Signature(params)
-
-        # Call the veris-wrapped function with the arguments
+
+    # Strategy 1: Check if the tool has stored the original function as an attribute
+    # (This would be the cleanest approach if the agents library supported it)
+    if hasattr(on_invoke_tool, "__wrapped__"):
+        return on_invoke_tool.__wrapped__
+
+    # Strategy 2: Look for the function in the closure using known structure
+    # Based on the agents library implementation, we know:
+    # - on_invoke_tool has _on_invoke_tool_impl in its closure
+    # - _on_invoke_tool_impl has the_func in its closure
+
+    if not hasattr(on_invoke_tool, "__closure__") or not on_invoke_tool.__closure__:
+        return None
+
+    # Find _on_invoke_tool_impl by looking for a function with that name pattern
+    for cell in on_invoke_tool.__closure__:
         try:
-            return await veris_tool_function(**args_dict)
-        except Exception as e:
-            # If mocking fails, fall back to original
-            logger.warning(f"Veris mock failed for {tool_name}, falling back to original: {e}")
-            return await original_invoke(context, arguments)
+            obj = cell.cell_contents
+            if not callable(obj):
+                continue
+
+            # Check if this looks like _on_invoke_tool_impl
+            if (
+                hasattr(obj, "__name__")
+                and "_on_invoke_tool_impl" in obj.__name__
+                and hasattr(obj, "__closure__")
+                and obj.__closure__
+            ):
+                # Now look for the_func in its closure
+                return _find_user_function_in_closure(obj.__closure__)
+        except (ValueError, AttributeError):
+            continue
+
+    # Strategy 3: Fallback - do a broader search in the closure
+    return _find_user_function_in_closure(on_invoke_tool.__closure__)
+
 
-    # Handle sync version if original is sync
-    if not asyncio.iscoroutinefunction(original_invoke):
+def _find_user_function_in_closure(closure: tuple) -> Callable | None:
+    """Find the user function in a closure by filtering out known library functions.
 
-        def sync_wrapped_invoke(context: Any, arguments: str) -> Any:  # noqa: ANN401
-            """Sync version of wrapped invoke."""
-            return asyncio.run(wrapped_invoke(context, arguments))
+    Args:
+        closure: The closure tuple to search
 
-        return sync_wrapped_invoke
+    Returns:
+        The user function if found, None otherwise
+    """
+    import inspect
 
-    return wrapped_invoke
+    # List of module prefixes that indicate library/framework code
+    library_modules = ("json", "inspect", "agents", "pydantic", "openai", "typing")
+
+    for cell in closure:
+        try:
+            obj = cell.cell_contents
+
+            # Must be callable but not a class
+            if not callable(obj) or isinstance(obj, type):
+                continue
+
+            # Skip private/internal functions
+            if hasattr(obj, "__name__") and obj.__name__.startswith("_"):
+                continue
+
+            # Check the module to filter out library code
+            module = inspect.getmodule(obj)
+            if module:
+                # Skip if it's from a known library
+                if module.__name__.startswith(library_modules):
+                    continue
+
+                # Skip if it's from site-packages (library code)
+                if (
+                    hasattr(module, "__file__")
+                    and module.__file__
+                    and "site-packages" in module.__file__
+                    # Unless it's user code installed as a package
+                    # (this is a heuristic - may need adjustment)
+                    and not any(pkg in module.__name__ for pkg in ["my_", "custom_", "app_"])
+                ):
+                    continue
+
+            # If we made it here, this is likely the user function
+            return obj
+
+        except (ValueError, AttributeError):
+            continue
+
+    return None
 
 
 class VerisConfig(BaseModel):

veris_ai/api_client.py

@@ -29,15 +29,7 @@ class SimulatorAPIClient:
 
         return headers
 
-    async def post_async(self, endpoint: str, payload: dict[str, Any]) -> Any:  # noqa: ANN401
-        """Make an async POST request to the specified endpoint."""
-        headers = self._build_headers()
-        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
-
-    def post_sync(self, endpoint: str, payload: dict[str, Any]) -> Any:  # noqa: ANN401
+    def post(self, endpoint: str, payload: dict[str, Any]) -> Any:  # noqa: ANN401
         """Make a synchronous POST request to the specified endpoint."""
         headers = self._build_headers()
         with httpx.Client(timeout=self.timeout) as client:

veris_ai/logging.py

@@ -9,69 +9,28 @@ from veris_ai.api_client import get_api_client
 logger = logging.getLogger(__name__)
 
 
-async def log_tool_call_async(
+def log_tool_call(
     session_id: str,
     function_name: str,
-    parameters: dict[str, Any],
-    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)
-
-    payload = {
-        "function_name": function_name,
-        "parameters": parameters,
-        "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_call_sync(
-    session_id: str,
-    function_name: str,
-    parameters: dict[str, Any],
+    parameters: str,
     docstring: str,
 ) -> None:
     """Log tool call synchronously to the VERIS logging endpoint."""
     api_client = get_api_client()
     endpoint = api_client.get_log_tool_call_endpoint(session_id)
-
     payload = {
         "function_name": function_name,
-        "parameters": parameters,
+        "parameters": json.loads(parameters),
         "docstring": docstring,
     }
-
     try:
-        api_client.post_sync(endpoint, payload)
+        api_client.post(endpoint, payload)
         logger.debug(f"Tool call logged for {function_name}")
     except Exception as e:
         logger.warning(f"Failed to log tool call for {function_name}: {e}")
 
 
-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}")
-
-
-def log_tool_response_sync(session_id: str, response: Any) -> None:  # noqa: ANN401
+def log_tool_response(session_id: str, response: Any) -> None:  # noqa: ANN401
     """Log tool response synchronously to the VERIS logging endpoint."""
     api_client = get_api_client()
     endpoint = api_client.get_log_tool_response_endpoint(session_id)
@@ -81,7 +40,7 @@ def log_tool_response_sync(session_id: str, response: Any) -> None:  # noqa: ANN
     }
 
     try:
-        api_client.post_sync(endpoint, payload)
+        api_client.post(endpoint, payload)
         logger.debug("Tool response logged")
     except Exception as e:
         logger.warning(f"Failed to log tool response: {e}")

veris_ai/models.py

@@ -1,6 +1,9 @@
 """Models for the VERIS SDK."""
 
 from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel
 
 
 class ResponseExpectation(str, Enum):
@@ -9,3 +12,11 @@ class ResponseExpectation(str, Enum):
     AUTO = "auto"
     REQUIRED = "required"
     NONE = "none"
+
+
+class ToolCallOptions(BaseModel):
+    """Options for tool call."""
+
+    response_expectation: ResponseExpectation = ResponseExpectation.AUTO
+    cache_response: bool = False
+    mode: Literal["tool", "function", "spy"] = "tool"

veris_ai/tool_mock.py

@@ -12,13 +12,12 @@ from typing import (
     get_type_hints,
 )
 
+
 from veris_ai.logging import (
-    log_tool_call_async,
-    log_tool_call_sync,
-    log_tool_response_async,
-    log_tool_response_sync,
+    log_tool_call,
+    log_tool_response,
 )
-from veris_ai.models import ResponseExpectation
+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
 
@@ -96,185 +95,109 @@ class VerisSDK:
             **params_dict,
         )
 
+    def spy(self) -> Callable:
+        """Decorator for spying on tool calls."""
+
+        def decorator(func: Callable) -> Callable:
+            """Decorator for spying on tool calls."""
+            is_async = inspect.iscoroutinefunction(func)
+
+            @wraps(func)
+            async def async_wrapper(*args: tuple[object, ...], **kwargs: Any) -> object:  # noqa: ANN401
+                """Async wrapper."""
+                session_id = _session_id_context.get()
+                if not session_id:
+                    return await func(*args, **kwargs)
+                parameters = get_function_parameters(func, args, kwargs)
+                logger.info(f"Spying on function: {func.__name__}")
+                log_tool_call(
+                    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)
+                return result
+
+            @wraps(func)
+            def sync_wrapper(*args: tuple[object, ...], **kwargs: Any) -> object:  # noqa: ANN401
+                """Sync wrapper."""
+                session_id = _session_id_context.get()
+                if not session_id:
+                    return func(*args, **kwargs)
+                parameters = get_function_parameters(func, args, kwargs)
+                logger.info(f"Spying on function: {func.__name__}")
+                log_tool_call(
+                    session_id=session_id,
+                    function_name=func.__name__,
+                    parameters=parameters,
+                    docstring=inspect.getdoc(func) or "",
+                )
+                result = func(*args, **kwargs)
+                log_tool_response(session_id=session_id, response=result)
+                return result
+
+            return async_wrapper if is_async else sync_wrapper
+
+        return decorator
+
     def mock(  # noqa: C901, PLR0915
         self,
-        mode: Literal["tool", "function", "spy"] = "tool",
+        mode: Literal["tool", "function"] = "tool",
         expects_response: bool | None = None,
         cache_response: bool | None = None,
     ) -> Callable:
         """Decorator for mocking tool calls."""
+        response_expectation = (
+            ResponseExpectation.NONE
+            if (expects_response is False or (expects_response is None and mode == "function"))
+            else ResponseExpectation.REQUIRED
+            if expects_response is True
+            else ResponseExpectation.AUTO
+        )
+        cache_response = cache_response or False
+        options = ToolCallOptions(
+            mode=mode, response_expectation=response_expectation, cache_response=cache_response
+        )
 
         def decorator(func: Callable) -> Callable:  # noqa: C901, PLR0915
             """Decorator for mocking tool calls."""
-            # Check if the original function is async
             is_async = inspect.iscoroutinefunction(func)
 
-            def create_mock_payload(
-                *args: tuple[object, ...],
-                **kwargs: Any,  # noqa: ANN401
-            ) -> tuple[dict[str, Any], Any]:
-                """Create the mock payload - shared logic for both sync and async."""
-                type_hints = get_type_hints(func)
-
-                # Extract return type object (not just the name)
-                return_type_obj = type_hints.pop("return", Any)
-                # Create parameter info
-                parameters = get_function_parameters(func, args, kwargs)
-                # Get function docstring
-                docstring = inspect.getdoc(func) or ""
-                nonlocal expects_response
-                if expects_response is None and mode == "function":
-                    expects_response = False
-                # Prepare payload
-                # Convert expects_response to response_expectation enum
-                if expects_response is False:
-                    response_expectation = ResponseExpectation.NONE
-                elif expects_response is True:
-                    response_expectation = ResponseExpectation.REQUIRED
-                else:
-                    response_expectation = ResponseExpectation.AUTO
-
-                payload = {
-                    "session_id": self.session_id,
-                    "response_expectation": response_expectation.value,
-                    "cache_response": bool(cache_response) if cache_response is not None else False,
-                    "tool_call": {
-                        "function_name": func.__name__,
-                        "parameters": parameters,
-                        "return_type": json.dumps(extract_json_schema(return_type_obj)),
-                        "docstring": docstring,
-                    },
-                }
-
-                return payload, return_type_obj
-
             @wraps(func)
             async def async_wrapper(
                 *args: tuple[object, ...],
                 **kwargs: Any,  # noqa: ANN401
             ) -> object:
-                # Check if we're in simulation mode
-                if not self.session_id:
-                    # If not in simulation mode, execute the original function
+                """Async wrapper."""
+                session_id = _session_id_context.get()
+                if not session_id:
                     return await func(*args, **kwargs)
-
-                async def _execute_mock_logic(session_id: str) -> object:
-                    # Handle spy mode - execute original function and log
-                    if mode == "spy":
-                        logger.info(f"Spying on function: {func.__name__}")
-
-                        # Log the tool call
-                        parameters = get_function_parameters(func, args, kwargs)
-
-                        await log_tool_call_async(
-                            session_id=session_id,
-                            function_name=func.__name__,
-                            parameters=parameters,
-                            docstring=inspect.getdoc(func) or "",
-                        )
-
-                        # Execute the original function
-                        result = await func(*args, **kwargs)
-
-                        # Log the response
-                        await log_tool_response_async(session_id=session_id, response=result)
-
-                        return result
-
-                    # Regular mock mode
-                    api_client = get_api_client()
-                    endpoint = api_client.tool_mock_endpoint
-
-                    logger.info(f"Simulating function: {func.__name__}")
-                    payload, return_type_obj = create_mock_payload(*args, **kwargs)
-
-                    # Send request to endpoint
-                    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)
-
-                # Create a top-level span for the simulated mock call if OpenTelemetry is available
-                try:
-                    from opentelemetry import trace  # type: ignore[import-not-found]
-
-                    tracer = trace.get_tracer("veris_ai.tool_mock")
-                    span_name = f"mock.{func.__name__}"
-                    with tracer.start_as_current_span(span_name) as span:  # type: ignore[attr-defined]
-                        span.set_attribute("veris_ai.session.id", self.session_id or "")  # type: ignore[attr-defined]
-                        span.set_attribute("veris_ai.mock.mode", mode)  # type: ignore[attr-defined]
-                        return await _execute_mock_logic(self.session_id)
-                except Exception:
-                    # If OpenTelemetry is not available, run without span
-                    return await _execute_mock_logic(self.session_id)
+                parameters = get_function_parameters(func, args, kwargs)
+                return mock_tool_call(
+                    func,
+                    session_id,
+                    parameters,
+                    options,
+                )
 
             @wraps(func)
             def sync_wrapper(
                 *args: tuple[object, ...],
                 **kwargs: Any,  # noqa: ANN401
             ) -> object:
-                # Check if we're in simulation mode
-                if not self.session_id:
-                    # If not in simulation mode, execute the original function
+                """Sync wrapper."""
+                session_id = _session_id_context.get()
+                if not session_id:
                     return func(*args, **kwargs)
-
-                def _execute_mock_logic(session_id: str) -> object:
-                    # Handle spy mode - execute original function and log
-                    if mode == "spy":
-                        logger.info(f"Spying on function: {func.__name__}")
-
-                        # Log the tool call
-                        parameters = get_function_parameters(func, args, kwargs)
-
-                        log_tool_call_sync(
-                            session_id=session_id,
-                            function_name=func.__name__,
-                            parameters=parameters,
-                            docstring=inspect.getdoc(func) or "",
-                        )
-
-                        # Execute the original function
-                        result = func(*args, **kwargs)
-
-                        # Log the response
-                        log_tool_response_sync(session_id=session_id, response=result)
-
-                        return result
-
-                    # Regular mock mode
-                    api_client = get_api_client()
-                    endpoint = api_client.tool_mock_endpoint
-
-                    logger.info(f"Simulating function: {func.__name__}")
-                    payload, return_type_obj = create_mock_payload(*args, **kwargs)
-
-                    # Send request to endpoint
-                    mock_result = api_client.post_sync(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)
-
-                # Create a top-level span for the simulated mock call if OpenTelemetry is available
-                try:
-                    from opentelemetry import trace  # type: ignore[import-not-found]
-
-                    tracer = trace.get_tracer("veris_ai.tool_mock")
-                    span_name = f"mock.{func.__name__}"
-                    with tracer.start_as_current_span(span_name) as span:  # type: ignore[attr-defined]
-                        span.set_attribute("veris_ai.session.id", self.session_id or "")  # type: ignore[attr-defined]
-                        span.set_attribute("veris_ai.mock.mode", mode)  # type: ignore[attr-defined]
-                        return _execute_mock_logic(self.session_id)
-                except Exception:
-                    # If OpenTelemetry is not available, run without span
-                    return _execute_mock_logic(self.session_id)
+                parameters = get_function_parameters(func, args, kwargs)
+                return mock_tool_call(
+                    func,
+                    session_id,
+                    parameters,
+                    options,
+                )
 
             # Return the appropriate wrapper based on whether the function is async
             return async_wrapper if is_async else sync_wrapper
@@ -313,4 +236,46 @@ class VerisSDK:
         return decorator
 
 
+def mock_tool_call(
+    func: Callable,
+    session_id: str,
+    parameters: str,
+    options: ToolCallOptions | None = None,
+) -> object:
+    """Mock tool call."""
+    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 ""
+    # Determine response expectation
+    payload = {
+        "session_id": session_id,
+        "response_expectation": options.response_expectation.value,
+        "cache_response": bool(options.cache_response),
+        "tool_call": {
+            "function_name": func.__name__,
+            "parameters": json.loads(parameters),
+            "return_type": json.dumps(extract_json_schema(return_type_obj)),
+            "docstring": docstring,
+        },
+    }
+
+    mock_result = api_client.post(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)
+
+
 veris = VerisSDK()

veris_ai/utils.py

@@ -1,4 +1,5 @@
 import inspect
+import json
 import sys
 import types
 import typing
@@ -278,7 +279,7 @@ def extract_json_schema(target_type: Any) -> dict:  # noqa: PLR0911, PLR0912, C9
 
 def get_function_parameters(
     func: Callable, args: tuple[object, ...], kwargs: dict[str, object]
-) -> dict[str, object]:
+) -> str:
     """Get the parameters for a function."""
     sig = inspect.signature(func)
     bound_args = sig.bind(*args, **kwargs)
@@ -286,4 +287,4 @@ def get_function_parameters(
     _ = bound_args.arguments.pop("ctx", None)
     _ = bound_args.arguments.pop("self", None)
     _ = bound_args.arguments.pop("cls", None)
-    return bound_args.arguments
+    return json.dumps(bound_args.arguments)

{veris_ai-1.8.0.dist-info → veris_ai-1.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 1.8.0
+Version: 1.8.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
@@ -168,7 +168,7 @@ async def your_function(param1: str, param2: int) -> dict:
     return {"result": "actual implementation"}
 
 # Spy mode: Executes function but logs calls/responses
-@veris.mock(mode="spy")
+@veris.spy()
 async def monitored_function(data: str) -> dict:
     return process_data(data)
 

veris_ai-1.8.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+veris_ai/README.md,sha256=0EC-yWB8FtqAhtcE5Q204bS1JWJPIvfpp1bPDo6iwwc,3601
+veris_ai/__init__.py,sha256=mFEF2pHXOAXoXuBh9IOQgqpKGvzLOsy8b0vUpMRJggU,2260
+veris_ai/agents_wrapper.py,sha256=LmxPkOg3KLICgTrl0Bouy7enhyO4tF6_evq2cb8I_ig,10718
+veris_ai/api_client.py,sha256=lpokGrDqC222eM8J65814a85DfEL_iAlHRatf9BFy2Y,2136
+veris_ai/logging.py,sha256=ENduOHnc5UmzciTDZDJCZqUOXb5We-bdtwN9f9Qqwl0,1360
+veris_ai/models.py,sha256=TiQJuME2pGDE6EY5J8TYKNSeajaN2Xk9ISsLoIwgtgU,502
+veris_ai/observability.py,sha256=fDtWeUexfzaIQArE5YbWsja8Y-bcE_h0dXQWYbXbupY,4929
+veris_ai/tool_mock.py,sha256=L2p6Yg8S98floahDTrf6cnmDqC6Dq3YKA7Q6RRvv7BQ,10253
+veris_ai/utils.py,sha256=Ud4k2jKAJ6-nqSsFXIJWYrOmPGmvl5RSp36cQtgnMpg,9781
+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.8.1.dist-info/METADATA,sha256=SCSuZSupecfwozColHl09XlE4Hy5W_R7xqHw8Wco560,9924
+veris_ai-1.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+veris_ai-1.8.1.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
+veris_ai-1.8.1.dist-info/RECORD,,

veris_ai-1.8.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-veris_ai/README.md,sha256=0EC-yWB8FtqAhtcE5Q204bS1JWJPIvfpp1bPDo6iwwc,3601
-veris_ai/__init__.py,sha256=mFEF2pHXOAXoXuBh9IOQgqpKGvzLOsy8b0vUpMRJggU,2260
-veris_ai/agents_wrapper.py,sha256=-8R2yTkEQjHQJxkWBK5tqMHzmlPjfDpybD9_UpsSjLk,9971
-veris_ai/api_client.py,sha256=afvVvg9DXSHgnr0p411yXo3_8UM7EeiIoqm1q_goYgI,2602
-veris_ai/logging.py,sha256=Dr7dQtTK_WvUAtSpif79Srf5YpSLwDVlWs0XsQGOdu4,2595
-veris_ai/models.py,sha256=6HINPxNFCakCVPcyEbUswWkXwb2K4lF0A8g8EvTMal4,213
-veris_ai/observability.py,sha256=fDtWeUexfzaIQArE5YbWsja8Y-bcE_h0dXQWYbXbupY,4929
-veris_ai/tool_mock.py,sha256=77KxBy0mAxC58sXYs_jPHBT_2oEkXybsUGKzOOLH93w,13334
-veris_ai/utils.py,sha256=bSutoMYQAboo9nHZ4yAsOGIDEoc1zaoIXCoJr4yTvBw,9771
-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.8.0.dist-info/METADATA,sha256=r79b39D4sUnlT2sJWNxbMk2Y1ES4pRVLkaO0K7BYsDc,9935
-veris_ai-1.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-veris_ai-1.8.0.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
-veris_ai-1.8.0.dist-info/RECORD,,