veris-ai 0.2.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

veris_ai/tool_mock.py

@@ -4,65 +4,91 @@ import logging
 import os
 from collections.abc import Callable
 from contextlib import suppress
+from contextvars import ContextVar
 from functools import wraps
-from typing import Any, TypeVar, Union, get_args, get_origin, get_type_hints
+from typing import (
+    Any,
+    TypeVar,
+    get_type_hints,
+)
 
 import httpx
 
+from veris_ai.utils import convert_to_type
+
 logger = logging.getLogger(__name__)
 
-T = TypeVar("T")  # Generic type for return value
+T = TypeVar("T")
+
+# Context variable to store session_id for each call
+_session_id_context: ContextVar[str | None] = ContextVar("veris_session_id", default=None)
 
 
-class ToolMock:
+class VerisSDK:
     """Class for mocking tool calls."""
 
     def __init__(self) -> None:
         """Initialize the ToolMock class."""
-
-    def _convert_to_type(self, value: object, target_type: type) -> object:
-        """Convert a value to the specified type."""
-        if target_type is Any:
-            return value
-
-        # Handle basic types
-        if target_type in (str, int, float, bool):
-            return target_type(value)
-
-        # Handle List types
-        origin = get_origin(target_type)
-        if origin is list:
-            if not isinstance(value, list):
-                error_msg = f"Expected list but got {type(value)}"
-                raise ValueError(error_msg)
-            item_type = get_args(target_type)[0]
-            return [self._convert_to_type(item, item_type) for item in value]
-
-        # Handle Dict types
-        if origin is dict:
-            if not isinstance(value, dict):
-                error_msg = f"Expected dict but got {type(value)}"
-                raise ValueError(error_msg)
-            key_type, value_type = get_args(target_type)
-            return {
-                self._convert_to_type(k, key_type): self._convert_to_type(v, value_type)
-                for k, v in value.items()
-            }
-
-        # Handle Union types
-        if origin is Union:
-            error_msg = (
-                f"Could not convert {value} to any of the union types {get_args(target_type)}"
-            )
-            for possible_type in get_args(target_type):
-                try:
-                    return self._convert_to_type(value, possible_type)
-                except (ValueError, TypeError):
-                    continue
-            raise ValueError(error_msg)
-
-        # For other types, try direct conversion
-        return target_type(value)
+        self._mcp = None
+
+    @property
+    def session_id(self) -> str | None:
+        """Get the session_id from context variable."""
+        return _session_id_context.get()
+
+    def set_session_id(self, session_id: str) -> None:
+        """Set the session_id in context variable."""
+        _session_id_context.set(session_id)
+        logger.info(f"Session ID set to {session_id}")
+
+    def clear_session_id(self) -> None:
+        """Clear the session_id from context variable."""
+        _session_id_context.set(None)
+        logger.info("Session ID cleared")
+
+    @property
+    def fastapi_mcp(self) -> Any | None:  # noqa: ANN401
+        """Get the FastAPI MCP server."""
+        return self._mcp
+
+    def set_fastapi_mcp(self, **params_dict: Any) -> None:  # noqa: ANN401
+        """Set the FastAPI MCP server."""
+        from fastapi import Depends, Request  # noqa: PLC0415
+        from fastapi.security import OAuth2PasswordBearer  # noqa: PLC0415
+        from fastapi_mcp import (  # type: ignore[import-untyped] # noqa: PLC0415
+            AuthConfig,
+            FastApiMCP,
+        )
+
+        oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+        async def authenticate_request(
+            _: Request,
+            token: str = Depends(oauth2_scheme),  # noqa: ARG001
+        ) -> None:
+            self.set_session_id(token)
+
+        # Create auth config with dependencies
+        auth_config = AuthConfig(
+            dependencies=[Depends(authenticate_request)],
+        )
+
+        # Merge the provided params with our auth config
+        if "auth_config" in params_dict:
+            # Merge the provided auth config with our dependencies
+            provided_auth_config = params_dict.pop("auth_config")
+            if provided_auth_config.dependencies:
+                auth_config.dependencies.extend(provided_auth_config.dependencies)
+            # Copy other auth config properties if they exist
+            for field, value in provided_auth_config.model_dump(exclude_none=True).items():
+                if field != "dependencies" and hasattr(auth_config, field):
+                    setattr(auth_config, field, value)
+
+        # Create the FastApiMCP instance with merged parameters
+        self._mcp = FastApiMCP(
+            auth_config=auth_config,
+            **params_dict,
+        )
 
     def mock(self, func: Callable) -> Callable:
         """Decorator for mocking tool calls."""
@@ -83,7 +109,6 @@ class ToolMock:
             if env_mode != "simulation":
                 # If not in simulation mode, execute the original function
                 return await func(*args, **kwargs)
-
             logger.info(f"Simulating function: {func.__name__}")
             sig = inspect.signature(func)
             type_hints = get_type_hints(func)
@@ -96,14 +121,6 @@ class ToolMock:
             bound_args = sig.bind(*args, **kwargs)
             bound_args.apply_defaults()
 
-            ctx = bound_args.arguments.pop("ctx", None)
-            session_id = None
-            if ctx:
-                try:
-                    session_id = ctx.request_context.lifespan_context.session_id
-                except AttributeError:
-                    logger.warning("Cannot get session_id from context.")
-
             for param_name, param_value in bound_args.arguments.items():
                 params_info[param_name] = {
                     "value": param_value,
@@ -114,7 +131,7 @@ class ToolMock:
             docstring = inspect.getdoc(func) or ""
             # Prepare payload
             payload = {
-                "session_id": session_id,
+                "session_id": self.session_id,
                 "tool_call": {
                     "function_name": func.__name__,
                     "parameters": params_info,
@@ -130,15 +147,15 @@ class ToolMock:
                 mock_result = response.json()["result"]
                 logger.info(f"Mock response: {mock_result}")
 
-                # Parse the mock result if it's a string
-                if isinstance(mock_result, str):
-                    with suppress(json.JSONDecodeError):
-                        mock_result = json.loads(mock_result)
+            # Parse the mock result if it's a string
+            if isinstance(mock_result, str):
+                with suppress(json.JSONDecodeError):
+                    mock_result = json.loads(mock_result)
 
-                # Convert the mock result to the expected return type
-                return self._convert_to_type(mock_result, return_type_obj)
+            # Convert the mock result to the expected return type
+            return convert_to_type(mock_result, return_type_obj)
 
         return wrapper
 
 
-veris = ToolMock()
+veris = VerisSDK()

veris_ai/utils.py

@@ -0,0 +1,71 @@
+from contextlib import suppress
+from typing import Any, Union, get_args, get_origin
+
+
+def convert_to_type(value: object, target_type: type) -> object:
+    """Convert a value to the specified type."""
+    # Special case: Any type returns value as-is
+    if target_type is Any:
+        return value
+
+    origin = get_origin(target_type)
+
+    # Define conversion strategies for different type origins
+    converters = {
+        list: _convert_list,
+        dict: _convert_dict,
+        Union: _convert_union,
+    }
+
+    # Use appropriate converter based on origin
+    if origin in converters:
+        return converters[origin](value, target_type)
+
+    # Handle primitives and custom types
+    return _convert_simple_type(value, target_type)
+
+
+def _convert_list(value: object, target_type: type) -> list:
+    """Convert a value to a typed list."""
+    if not isinstance(value, list):
+        error_msg = f"Expected list but got {type(value)}"
+        raise ValueError(error_msg)
+
+    item_type = get_args(target_type)[0]
+    return [convert_to_type(item, item_type) for item in value]
+
+
+def _convert_dict(value: object, target_type: type) -> dict:
+    """Convert a value to a typed dict."""
+    if not isinstance(value, dict):
+        error_msg = f"Expected dict but got {type(value)}"
+        raise ValueError(error_msg)
+
+    key_type, value_type = get_args(target_type)
+    return {convert_to_type(k, key_type): convert_to_type(v, value_type) for k, v in value.items()}
+
+
+def _convert_union(value: object, target_type: type) -> object:
+    """Try to convert value to one of the union types."""
+    union_types = get_args(target_type)
+
+    for possible_type in union_types:
+        with suppress(ValueError, TypeError):
+            return convert_to_type(value, possible_type)
+
+    error_msg = f"Could not convert {value} to any of the union types {union_types}"
+    raise ValueError(error_msg)
+
+
+def _convert_simple_type(value: object, target_type: type) -> object:
+    """Convert to primitive or custom types."""
+    # Primitive types
+    if target_type in (str, int, float, bool):
+        return target_type(value)
+
+    # Custom types - try kwargs for dicts, then direct instantiation
+    if isinstance(value, dict):
+        with suppress(TypeError):
+            return target_type(**value)
+
+    return target_type(value)

{veris_ai-0.2.0.dist-info → veris_ai-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 0.2.0
+Version: 1.0.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
@@ -17,11 +17,14 @@ Requires-Dist: pytest-asyncio>=0.21.1; extra == 'dev'
 Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
 Requires-Dist: pytest>=7.4.0; extra == 'dev'
 Requires-Dist: ruff>=0.11.4; extra == 'dev'
+Provides-Extra: fastapi
+Requires-Dist: fastapi; extra == 'fastapi'
+Requires-Dist: fastapi-mcp; extra == 'fastapi'
 Description-Content-Type: text/markdown
 
 # Veris AI Python SDK
 
-A Python package for Veris AI tools with simulation capabilities.
+A Python package for Veris AI tools with simulation capabilities and FastAPI MCP (Model Context Protocol) integration.
 
 ## Installation
 
@@ -33,6 +36,9 @@ uv add veris-ai
 
 # Install with development dependencies
 uv add "veris-ai[dev]"
+
+# Install with FastAPI MCP integration
+uv add "veris-ai[fastapi]"
 ```
 
 ## Environment Setup
@@ -93,6 +99,78 @@ When `ENV=simulation` is set, the decorator will:
 
 When not in simulation mode, the original function will be executed normally.
 
+## FastAPI MCP Integration
+
+The SDK provides integration with FastAPI applications through the Model Context Protocol (MCP). This allows your FastAPI endpoints to be exposed as MCP tools that can be used by AI agents.
+
+```python
+from fastapi import FastAPI
+from veris_ai import veris
+
+app = FastAPI()
+
+# Set up FastAPI MCP with automatic session handling
+veris.set_fastapi_mcp(
+    fastapi=app,
+    name="My API Server",
+    description="My FastAPI application exposed as MCP tools",
+    describe_all_responses=True,
+    include_operations=["get_users", "create_user"],
+    exclude_tags=["internal"]
+)
+
+# The MCP server is now available at veris.fastapi_mcp
+mcp_server = veris.fastapi_mcp
+```
+
+### Configuration Options
+
+The `set_fastapi_mcp()` method accepts the following parameters:
+
+- **fastapi** (required): Your FastAPI application instance
+- **name**: Custom name for the MCP server (defaults to app.title)
+- **description**: Custom description (defaults to app.description)
+- **describe_all_responses**: Whether to include all response schemas in tool descriptions
+- **describe_full_response_schema**: Whether to include full JSON schema for responses
+- **http_client**: Optional custom httpx.AsyncClient instance
+- **include_operations**: List of operation IDs to include as MCP tools
+- **exclude_operations**: List of operation IDs to exclude (can't use with include_operations)
+- **include_tags**: List of tags to include as MCP tools
+- **exclude_tags**: List of tags to exclude (can't use with include_tags)
+- **auth_config**: Optional FastAPI MCP AuthConfig for custom authentication
+
+### Session Management
+
+The SDK automatically handles session management through OAuth2 authentication:
+- Session IDs are extracted from bearer tokens
+- Context is maintained across API calls
+- Sessions can be managed programmatically:
+
+```python
+# Get current session ID
+session_id = veris.session_id
+
+# Set a new session ID
+veris.set_session_id("new-session-123")
+
+# Clear the session
+veris.clear_session_id()
+```
+
+## Project Structure
+
+```
+src/veris_ai/
+├── __init__.py        # Main entry point, exports the veris instance
+├── tool_mock.py       # VerisSDK class with @veris.mock() decorator
+└── utils.py           # Type conversion utilities
+
+tests/
+├── conftest.py        # Pytest fixtures
+├── test_tool_mock.py  # Tests for VerisSDK functionality
+└── test_utils.py      # Tests for type conversion utilities
+```
+
 ## Development
 
 This project uses `pyproject.toml` for dependency management and `uv` for package installation.
@@ -121,16 +199,40 @@ This project uses [Ruff](https://github.com/charliermarsh/ruff) for linting and
 To run Ruff:
 
 ```bash
+# Lint code
 ruff check .
+
+# Auto-fix linting issues
+ruff check --fix .
+
+# Format code
+ruff format .
+
+# Check formatting only
+ruff format --check .
 ```
 
-To automatically fix issues:
+The Ruff configuration is defined in `pyproject.toml` under the `[tool.ruff]` section.
+
+### Running Tests
 
 ```bash
-ruff check --fix .
+# Run all tests with coverage
+pytest tests/ --cov=veris_ai --cov-report=xml --cov-report=term-missing
+
+# Run specific test file
+pytest tests/test_tool_mock.py
+
+# Run tests with verbose output
+pytest -v tests/
 ```
 
-The Ruff configuration is defined in `pyproject.toml` under the `[tool.ruff]` section.
+### Type Checking
+
+```bash
+# Run static type checking
+mypy src/veris_ai tests
+```
 
 ## License
 

veris_ai-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+veris_ai/__init__.py,sha256=7mEfVmqxQCn5FZN_1ua3iykCB1NUeJ4RfVXaAzdp4Hw,101
+veris_ai/tool_mock.py,sha256=Yr702kl9ggdRUnR_iL37UXFjz-drvQqVpp7JdT_qlb4,5665
+veris_ai/utils.py,sha256=-r4FZajHfrcjB0rhluQl2KDS68ER9pqHp8g_pmB1qAE,2322
+veris_ai-1.0.0.dist-info/METADATA,sha256=mnB4E-ZMjyfrxiVVM2BQ27Ie7SDd-AZK-LuVjHj0cjo,6503
+veris_ai-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+veris_ai-1.0.0.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
+veris_ai-1.0.0.dist-info/RECORD,,

veris_ai-0.2.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-veris_ai/__init__.py,sha256=7mEfVmqxQCn5FZN_1ua3iykCB1NUeJ4RfVXaAzdp4Hw,101
-veris_ai/tool_mock.py,sha256=7qFM35lz10k5i2X-XQVYcuFNF0bczEnHTr0vtineQrM,5172
-veris_ai-0.2.0.dist-info/METADATA,sha256=rD-TyXPbDZfJcQCtNuUUA4KGYD6PAFXQIhB5SL1lyNg,3419
-veris_ai-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-veris_ai-0.2.0.dist-info/licenses/LICENSE,sha256=2g4i20atAgtD5einaKzhQrIB-JrPhyQgD3bC0wkHcCI,1065
-veris_ai-0.2.0.dist-info/RECORD,,