tollgate 1.0.0__tar.gz → 1.0.2__tar.gz

{tollgate-1.0.0 → tollgate-1.0.2}/LICENSE

@@ -1,3 +1,19 @@
+Copyright 2026 Ravi Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+--------------------------------------------------------------------------------
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/

tollgate-1.0.2/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: tollgate
+Version: 1.0.2
+Summary: Runtime enforcement layer for AI agent tool calls using Identity + Intent + Policy
+Author: Tollgate Maintainers
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agents,ai,enforcement,llm,policy,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: pyyaml>=6.0.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Requires-Dist: twine>=4.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# tollgate 🚪
+
+Runtime enforcement layer for AI agent tool calls using **Identity + Intent + Policy**.
+
+`tollgate` provides a deterministic safety boundary for AI agents. It ensures every tool call is validated against a policy before execution, with support for async human-in-the-loop approvals, framework interception (MCP, Strands, LangChain, OpenAI), and structured audit logging.
+
+**[🚀 Quickstart Guide](https://github.com/ravi-labs/tollgate/blob/main/QUICKSTART.md) | [📊 Integration Comparison](https://github.com/ravi-labs/tollgate/blob/main/COMPARISON.md)**
+
+```
+┌────────────┐     ┌─────────────────────┐     ┌──────────────────┐
+│  AI Agent  │────▶│ Tollgate Interceptor│────▶│ Policy + Registry│
+└────────────┘     └─────────────────────┘     └────────┬─────────┘
+                                                        │
+                   ┌────────────────────────────────────┼────────────────────────────────────┐
+                   │                                    │                                    │
+                   ▼                                    ▼                                    ▼
+            ┌───────────┐                        ┌───────────┐                        ┌───────────┐
+            │   ALLOW   │                        │    ASK    │                        │   DENY    │
+            └─────┬─────┘                        └─────┬─────┘                        └─────┬─────┘
+                  │                                    │                                    │
+                  ▼                                    ▼                                    ▼
+            ┌───────────┐                     ┌───────────────┐                      ┌───────────┐
+            │  Execute  │                     │Human Approval │                      │  Block &  │
+            │   Tool    │                     │  (Approved?)  │                      │   Audit   │
+            └─────┬─────┘                     └───────┬───────┘                      └─────┬─────┘
+                  │                              ▼         ▼                               │
+                  │                          Yes │         │ No                            │
+                  │                              ▼         ▼                               │
+                  │                        ┌─────────┐ ┌─────────┐                         │
+                  │                        │ Execute │ │  Block  │                         │
+                  │                        └────┬────┘ └────┬────┘                         │
+                  │                             │           │                              │
+                  └─────────────────────────────┴───────────┴──────────────────────────────┘
+                                                        │
+                                                        ▼
+                                                 ┌───────────┐
+                                                 │ Audit Log │
+                                                 └───────────┘
+```
+
+## ✨ v1 Core Principles
+
+1. **Interception-First**: Enforcement happens at the tool execution boundary via adapters.
+2. **Safe Defaults**: Any unknown tool effect or resource defaults to **DENY**.
+3. **Trust Model**: Tool metadata is trusted only if it comes from a developer-controlled **Tool Registry**.
+4. **Approval Integrity**: Approvals are bound to a request hash and correlation ID with replay protection.
+5. **Async-First**: Native support for asynchronous agent loops and non-blocking approvals.
+6. **Audit Integrity**: Every decision, approval, and outcome is recorded with full cryptographic context.
+
+## 🚀 v1 Integrations
+
+### MCP (Model Context Protocol)
+Wrap an MCP client to gate all tool calls:
+```python
+from tollgate import ControlTower, ToolRegistry
+from tollgate.integrations.mcp import TollgateMCPClient
+
+registry = ToolRegistry("manifest.yaml")
+tower = ControlTower(...)
+client = TollgateMCPClient(base_client, server_name="my_server", tower=tower, registry=registry)
+
+# Calls are now gated!
+await client.call_tool("read_data", {"id": 1}, agent_ctx=ctx, intent=intent)
+```
+
+### Strands Agents
+Gate Strands tools with minimal friction:
+```python
+from tollgate.integrations.strands import guard_tools
+
+guarded = guard_tools(my_strands_tools, tower, registry)
+
+# Use guarded tools in your agent
+await guarded[0]("input", agent_ctx=ctx, intent=intent)
+```
+
+## 📜 Development
+
+```bash
+# Install
+make install
+
+# Run Tests
+make test
+
+# Run Examples (non-interactive)
+python examples/mcp_minimal/demo.py
+python examples/strands_minimal/demo.py
+```
+
+## ⚖️ License
+Apache-2.0

tollgate-1.0.2/README.md

@@ -0,0 +1,92 @@
+# tollgate 🚪
+
+Runtime enforcement layer for AI agent tool calls using **Identity + Intent + Policy**.
+
+`tollgate` provides a deterministic safety boundary for AI agents. It ensures every tool call is validated against a policy before execution, with support for async human-in-the-loop approvals, framework interception (MCP, Strands, LangChain, OpenAI), and structured audit logging.
+
+**[🚀 Quickstart Guide](https://github.com/ravi-labs/tollgate/blob/main/QUICKSTART.md) | [📊 Integration Comparison](https://github.com/ravi-labs/tollgate/blob/main/COMPARISON.md)**
+
+```
+┌────────────┐     ┌─────────────────────┐     ┌──────────────────┐
+│  AI Agent  │────▶│ Tollgate Interceptor│────▶│ Policy + Registry│
+└────────────┘     └─────────────────────┘     └────────┬─────────┘
+                                                        │
+                   ┌────────────────────────────────────┼────────────────────────────────────┐
+                   │                                    │                                    │
+                   ▼                                    ▼                                    ▼
+            ┌───────────┐                        ┌───────────┐                        ┌───────────┐
+            │   ALLOW   │                        │    ASK    │                        │   DENY    │
+            └─────┬─────┘                        └─────┬─────┘                        └─────┬─────┘
+                  │                                    │                                    │
+                  ▼                                    ▼                                    ▼
+            ┌───────────┐                     ┌───────────────┐                      ┌───────────┐
+            │  Execute  │                     │Human Approval │                      │  Block &  │
+            │   Tool    │                     │  (Approved?)  │                      │   Audit   │
+            └─────┬─────┘                     └───────┬───────┘                      └─────┬─────┘
+                  │                              ▼         ▼                               │
+                  │                          Yes │         │ No                            │
+                  │                              ▼         ▼                               │
+                  │                        ┌─────────┐ ┌─────────┐                         │
+                  │                        │ Execute │ │  Block  │                         │
+                  │                        └────┬────┘ └────┬────┘                         │
+                  │                             │           │                              │
+                  └─────────────────────────────┴───────────┴──────────────────────────────┘
+                                                        │
+                                                        ▼
+                                                 ┌───────────┐
+                                                 │ Audit Log │
+                                                 └───────────┘
+```
+
+## ✨ v1 Core Principles
+
+1. **Interception-First**: Enforcement happens at the tool execution boundary via adapters.
+2. **Safe Defaults**: Any unknown tool effect or resource defaults to **DENY**.
+3. **Trust Model**: Tool metadata is trusted only if it comes from a developer-controlled **Tool Registry**.
+4. **Approval Integrity**: Approvals are bound to a request hash and correlation ID with replay protection.
+5. **Async-First**: Native support for asynchronous agent loops and non-blocking approvals.
+6. **Audit Integrity**: Every decision, approval, and outcome is recorded with full cryptographic context.
+
+## 🚀 v1 Integrations
+
+### MCP (Model Context Protocol)
+Wrap an MCP client to gate all tool calls:
+```python
+from tollgate import ControlTower, ToolRegistry
+from tollgate.integrations.mcp import TollgateMCPClient
+
+registry = ToolRegistry("manifest.yaml")
+tower = ControlTower(...)
+client = TollgateMCPClient(base_client, server_name="my_server", tower=tower, registry=registry)
+
+# Calls are now gated!
+await client.call_tool("read_data", {"id": 1}, agent_ctx=ctx, intent=intent)
+```
+
+### Strands Agents
+Gate Strands tools with minimal friction:
+```python
+from tollgate.integrations.strands import guard_tools
+
+guarded = guard_tools(my_strands_tools, tower, registry)
+
+# Use guarded tools in your agent
+await guarded[0]("input", agent_ctx=ctx, intent=intent)
+```
+
+## 📜 Development
+
+```bash
+# Install
+make install
+
+# Run Tests
+make test
+
+# Run Examples (non-interactive)
+python examples/mcp_minimal/demo.py
+python examples/strands_minimal/demo.py
+```
+
+## ⚖️ License
+Apache-2.0

{tollgate-1.0.0 → tollgate-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tollgate"
-version = "1.0.0"
+version = "1.0.2"
 description = "Runtime enforcement layer for AI agent tool calls using Identity + Intent + Policy"
 readme = "README.md"
 requires-python = ">=3.10"

{tollgate-1.0.0 → tollgate-1.0.2}/src/tollgate/__init__.py

@@ -31,7 +31,7 @@ from .types import (
     ToolRequest,
 )
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"
 
 __all__ = [
     "ControlTower",

tollgate-1.0.0/PKG-INFO

@@ -1,98 +0,0 @@
-Metadata-Version: 2.4
-Name: tollgate
-Version: 1.0.0
-Summary: Runtime enforcement layer for AI agent tool calls using Identity + Intent + Policy
-Author: Tollgate Maintainers
-License-Expression: Apache-2.0
-License-File: LICENSE
-Keywords: agents,ai,enforcement,llm,policy,security
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
-Requires-Dist: pyyaml>=6.0.0
-Provides-Extra: dev
-Requires-Dist: build>=1.0.0; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
-Requires-Dist: pytest>=7.0.0; extra == 'dev'
-Requires-Dist: ruff>=0.1.0; extra == 'dev'
-Requires-Dist: twine>=4.0.0; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# tollgate 🚪
-
-Runtime enforcement layer for AI agent tool calls using **Identity + Intent + Policy**.
-
-`tollgate` provides a deterministic safety boundary for AI agents. It ensures every tool call is validated against a policy before execution, with support for async human-in-the-loop approvals, framework interception (MCP, Strands, LangChain, OpenAI), and structured audit logging.
-
-**[🚀 Quickstart Guide](./QUICKSTART.md) | [📊 Integration Comparison](./COMPARISON.md)**
-
-```mermaid
-graph TD
-    A[AI Agent] -->|Tool Call| B(Tollgate Interceptor)
-    B --> C{Policy + Registry}
-    C -->|ALLOW| D[Execute Tool]
-    C -->|DENY| E[Block & Audit]
-    C -->|ASK| F{Human Approval}
-    F -->|Approved| D
-    F -->|Denied| E
-    D --> G[Audit Log]
-    E --> G
-```
-
-## ✨ v1 Core Principles
-
-1. **Interception-First**: Enforcement happens at the tool execution boundary via adapters.
-2. **Safe Defaults**: Any unknown tool effect or resource defaults to **DENY**.
-3. **Trust Model**: Tool metadata is trusted only if it comes from a developer-controlled **Tool Registry**.
-4. **Approval Integrity**: Approvals are bound to a request hash and correlation ID with replay protection.
-5. **Async-First**: Native support for asynchronous agent loops and non-blocking approvals.
-6. **Audit Integrity**: Every decision, approval, and outcome is recorded with full cryptographic context.
-
-## 🚀 v1 Integrations
-
-### MCP (Model Context Protocol)
-Wrap an MCP client to gate all tool calls:
-```python
-from tollgate import ControlTower, ToolRegistry
-from tollgate.integrations.mcp import TollgateMCPClient
-
-registry = ToolRegistry("manifest.yaml")
-tower = ControlTower(...)
-client = TollgateMCPClient(base_client, server_name="my_server", tower=tower, registry=registry)
-
-# Calls are now gated!
-await client.call_tool("read_data", {"id": 1}, agent_ctx=ctx, intent=intent)
-```
-
-### Strands Agents
-Gate Strands tools with minimal friction:
-```python
-from tollgate.integrations.strands import guard_tools
-
-guarded = guard_tools(my_strands_tools, tower, registry)
-
-# Use guarded tools in your agent
-await guarded[0]("input", agent_ctx=ctx, intent=intent)
-```
-
-## 📜 Development
-
-```bash
-# Install
-make install
-
-# Run Tests
-make test
-
-# Run Examples (non-interactive)
-python examples/mcp_minimal/demo.py
-python examples/strands_minimal/demo.py
-```
-
-## ⚖️ License
-Apache-2.0

tollgate-1.0.0/README.md

@@ -1,73 +0,0 @@
-# tollgate 🚪
-
-Runtime enforcement layer for AI agent tool calls using **Identity + Intent + Policy**.
-
-`tollgate` provides a deterministic safety boundary for AI agents. It ensures every tool call is validated against a policy before execution, with support for async human-in-the-loop approvals, framework interception (MCP, Strands, LangChain, OpenAI), and structured audit logging.
-
-**[🚀 Quickstart Guide](./QUICKSTART.md) | [📊 Integration Comparison](./COMPARISON.md)**
-
-```mermaid
-graph TD
-    A[AI Agent] -->|Tool Call| B(Tollgate Interceptor)
-    B --> C{Policy + Registry}
-    C -->|ALLOW| D[Execute Tool]
-    C -->|DENY| E[Block & Audit]
-    C -->|ASK| F{Human Approval}
-    F -->|Approved| D
-    F -->|Denied| E
-    D --> G[Audit Log]
-    E --> G
-```
-
-## ✨ v1 Core Principles
-
-1. **Interception-First**: Enforcement happens at the tool execution boundary via adapters.
-2. **Safe Defaults**: Any unknown tool effect or resource defaults to **DENY**.
-3. **Trust Model**: Tool metadata is trusted only if it comes from a developer-controlled **Tool Registry**.
-4. **Approval Integrity**: Approvals are bound to a request hash and correlation ID with replay protection.
-5. **Async-First**: Native support for asynchronous agent loops and non-blocking approvals.
-6. **Audit Integrity**: Every decision, approval, and outcome is recorded with full cryptographic context.
-
-## 🚀 v1 Integrations
-
-### MCP (Model Context Protocol)
-Wrap an MCP client to gate all tool calls:
-```python
-from tollgate import ControlTower, ToolRegistry
-from tollgate.integrations.mcp import TollgateMCPClient
-
-registry = ToolRegistry("manifest.yaml")
-tower = ControlTower(...)
-client = TollgateMCPClient(base_client, server_name="my_server", tower=tower, registry=registry)
-
-# Calls are now gated!
-await client.call_tool("read_data", {"id": 1}, agent_ctx=ctx, intent=intent)
-```
-
-### Strands Agents
-Gate Strands tools with minimal friction:
-```python
-from tollgate.integrations.strands import guard_tools
-
-guarded = guard_tools(my_strands_tools, tower, registry)
-
-# Use guarded tools in your agent
-await guarded[0]("input", agent_ctx=ctx, intent=intent)
-```
-
-## 📜 Development
-
-```bash
-# Install
-make install
-
-# Run Tests
-make test
-
-# Run Examples (non-interactive)
-python examples/mcp_minimal/demo.py
-python examples/strands_minimal/demo.py
-```
-
-## ⚖️ License
-Apache-2.0