modelfuzz 0.1.0__tar.gz → 0.1.2__tar.gz

modelfuzz-0.1.2/.claude/settings.local.json

@@ -0,0 +1,27 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git -C /Users/gagandeep/agentshield status --short --branch)",
+      "Bash(uv --version)",
+      "Bash(uv sync *)",
+      "Bash(uv run python -c ' *)",
+      "Bash(uv run *)",
+      "Bash(git add *)",
+      "Bash(python3 -c \"import modelfuzz; print\\(modelfuzz.__file__\\)\")",
+      "Bash(pip show *)",
+      "Bash(python3 test_agent.py)",
+      "Bash(python3 -c \"import sys; print\\(sys.path\\)\")",
+      "Bash(pip list *)",
+      "Bash(python3 -c \"import sys,site; print\\(site.getsitepackages\\(\\)\\)\")",
+      "Bash(find / -maxdepth 6 -iname \"modelfuzz*\" -not -path \"*/modelfuzz/*\")",
+      "Bash(./.venv/bin/pip show *)",
+      "Bash(./.venv/bin/python3 test_agent.py)",
+      "Bash(python3 -c ' *)",
+      "Bash(python3 -m pytest -q)",
+      "Bash(./.venv/bin/pip install *)",
+      "Bash(./.venv/bin/python test_agent.py)",
+      "Bash(python3 -m pip show build twine)",
+      "Bash(env)"
+    ]
+  }
+}

modelfuzz-0.1.2/CONTRIBUTING.md

@@ -0,0 +1,46 @@
+# Contributing to ModelFuzz
+
+Thanks for your interest in contributing. This document covers how to set up a development environment, run tests, and submit changes.
+
+## Development Setup
+
+ModelFuzz uses [uv](https://github.com/astral-sh/uv) for dependency management.
+
+```bash
+git clone https://github.com/higagan/modelfuzz.git
+cd modelfuzz
+uv sync
+```
+
+This installs the package and its dependencies, including dev tools (`pytest`, `ruff`), into a local virtual environment.
+
+## Running Tests
+
+```bash
+uv run pytest
+```
+
+Tests live under [tests/](tests/) and are organized by module (`test_decorator.py`, `test_engine.py`, `test_rules.py`). Add tests alongside the code they cover, and make sure new policies or behaviors are exercised by at least one test.
+
+## Linting
+
+```bash
+uv run ruff check .
+```
+
+CI runs lint and tests against Python 3.10, 3.11, and 3.12 on every push and pull request (see [.github/workflows/ci.yml](.github/workflows/ci.yml)). Please make sure both pass locally before opening a PR.
+
+## Submitting Changes
+
+1. Fork the repository and create a branch from `main`.
+2. Make your changes, with tests covering new behavior.
+3. Run `uv run ruff check .` and `uv run pytest` locally.
+4. Open a pull request describing the change and its motivation.
+
+## Reporting Issues
+
+Use [GitHub Issues](https://github.com/higagan/modelfuzz/issues) to report bugs or propose features. Include a minimal reproduction where possible.
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the project's [MIT License](LICENSE).

{modelfuzz-0.1.0 → modelfuzz-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelfuzz
-Version: 0.1.0
+Version: 0.1.2
 Summary: Runtime guardrails for AI agents.
 Project-URL: Homepage, https://github.com/higagan/modelfuzz
 Project-URL: Repository, https://github.com/higagan/modelfuzz

{modelfuzz-0.1.0 → modelfuzz-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "modelfuzz"
-version = "0.1.0"
+version = "0.1.2"
 description = "Runtime guardrails for AI agents."
 readme = "README.md"
 license = { text = "MIT" }

modelfuzz-0.1.2/src/modelfuzz/decorator.py

@@ -0,0 +1,64 @@
+"""Decorators for shielding agent tool functions."""
+
+import functools
+from collections.abc import Callable
+from typing import ParamSpec, TypeVar, overload
+
+from modelfuzz.engine import PolicyEngine
+from modelfuzz.exceptions import ModelFuzzBlockError
+from modelfuzz.rules import SensitiveDataFilter
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+# Default policy engine for the decorator
+default_policies = [SensitiveDataFilter()]
+_default_engine = PolicyEngine(default_policies)
+
+
+@overload
+def shield_tool(engine: Callable[P, R]) -> Callable[P, R]: ...
+@overload
+def shield_tool(
+    engine: PolicyEngine | None = None,
+) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
+
+
+def shield_tool(engine=None):
+    """Wrap a tool function so every call is intercepted before execution.
+
+    Usable bare (``@shield_tool``) or called (``@shield_tool()`` /
+    ``@shield_tool(engine)``).
+
+    Args:
+        engine: The policy engine to use for validation. If None, a default
+            engine with a SensitiveDataFilter is used. When applied bare,
+            this receives the function being decorated instead.
+
+    Returns:
+        The wrapped function, or a decorator that produces it.
+    """
+    if callable(engine) and not isinstance(engine, PolicyEngine):
+        return _wrap(engine, _default_engine)
+
+    actual_engine = engine if engine is not None else _default_engine
+
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
+        return _wrap(func, actual_engine)
+
+    return decorator
+
+
+def _wrap(func: Callable[P, R], actual_engine: PolicyEngine) -> Callable[P, R]:
+    @functools.wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        # Check all arguments against the policy engine
+        for arg in list(args) + list(kwargs.values()):
+            result = actual_engine.run(arg)
+            if not result.allowed:
+                raise ModelFuzzBlockError(result.reason or "Call blocked by policy")
+
+        print(f"ModelFuzz Intercepted: {func.__name__}")
+        return func(*args, **kwargs)
+
+    return wrapper

modelfuzz-0.1.0/.claude/settings.local.json

@@ -1,12 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git -C /Users/gagandeep/agentshield status --short --branch)",
-      "Bash(uv --version)",
-      "Bash(uv sync *)",
-      "Bash(uv run python -c ' *)",
-      "Bash(uv run *)",
-      "Bash(git add *)"
-    ]
-  }
-}

modelfuzz-0.1.0/src/modelfuzz/decorator.py

@@ -1,45 +0,0 @@
-"""Decorators for shielding agent tool functions."""
-
-import functools
-from collections.abc import Callable
-from typing import ParamSpec, TypeVar
-
-from modelfuzz.engine import PolicyEngine
-from modelfuzz.exceptions import ModelFuzzBlockError
-from modelfuzz.rules import SensitiveDataFilter
-
-P = ParamSpec("P")
-R = TypeVar("R")
-
-# Default policy engine for the decorator
-default_policies = [SensitiveDataFilter()]
-_default_engine = PolicyEngine(default_policies)
-
-
-def shield_tool(engine: PolicyEngine | None = None) -> Callable[[Callable[P, R]], Callable[P, R]]:
-    """Wrap a tool function so every call is intercepted before execution.
-
-    Args:
-        engine: The policy engine to use for validation. If None, a default
-            engine with a SensitiveDataFilter is used.
-
-    Returns:
-        A decorator that wraps the function.
-    """
-    actual_engine = engine if engine is not None else _default_engine
-
-    def decorator(func: Callable[P, R]) -> Callable[P, R]:
-        @functools.wraps(func)
-        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-            # Check all arguments against the policy engine
-            for arg in list(args) + list(kwargs.values()):
-                result = actual_engine.run(arg)
-                if not result.allowed:
-                    raise ModelFuzzBlockError(result.reason or "Call blocked by policy")
-
-            print(f"ModelFuzz Intercepted: {func.__name__}")
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    return decorator