aegiscore-ai 0.1.0__tar.gz

aegiscore_ai-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 AegisCore Contributors
+
+   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.

aegiscore_ai-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: aegiscore-ai
+Version: 0.1.0
+Summary: Deterministic Agent Governance Gateway - Zero-Trust Policy Enclave for AI Agents
+Author: Sandeep Hipparagi & AegisCore Contributors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Sandeep-Hipparagi/aegis-core
+Project-URL: Repository, https://github.com/Sandeep-Hipparagi/aegis-core.git
+Project-URL: Issues, https://github.com/Sandeep-Hipparagi/aegis-core/issues
+Keywords: ai-agent,governance,security,zero-trust,langgraph,openai,mcp,dpdp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# aegiscore-py
+
+Official, zero-dependency Python client for **AegisCore** — the Deterministic Zero-Trust Policy & Cryptographic WORM Audit Gateway for AI Agents.
+
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://pypi.org/project/aegiscore-ai/)
+
+## Installation
+
+```bash
+pip install aegiscore-ai
+```
+
+*Note: `aegiscore-ai` is 100% zero-dependency, implemented purely using Python's standard library (`urllib.request`, `json`, `dataclasses`).*
+
+## Quick Start
+
+### 1. Direct Tool Proposal Dispatch
+
+```python
+from aegiscore import AegisGateway
+
+gateway = AegisGateway("http://localhost:8080")
+
+# Dispatch tool intent: evaluates schema, invariants, tokenizes PII, logs WORM audit
+result = gateway.dispatch(
+    tool="transfer_funds",
+    arguments={"amount": 2500, "recipient": "ACC-PAYROLL"},
+    session_id="sess_01"
+)
+
+if result.is_success:
+    print("Action Approved & Executed:", result.output)
+elif result.requires_hitl:
+    print(f"Action escalated to human approval. Ticket ID: {result.ticket_id}")
+else:
+    print(f"Action BLOCKED: {result.reason}")
+    for violation in result.violations:
+        print(f" - {violation}")
+```
+
+### 2. LangGraph & LangChain Integration
+
+```python
+from aegiscore import AegisGateway
+from aegiscore.integrations import AegisLangGraphWrapper
+
+gateway = AegisGateway("http://localhost:8080")
+wrapper = AegisLangGraphWrapper(gateway=gateway)
+
+# Wrap any native function or tool
+@wrapper.wrap_tool("query_database", raw_query_func)
+def safe_query_database(query: str):
+    return raw_query_func(query)
+
+# Calls are intercepted and verified against policy invariants before invocation
+safe_query_database(query="SELECT * FROM users")
+```
+
+### 3. OpenAI Function Call Interception
+
+```python
+from aegiscore import AegisGateway
+from aegiscore.integrations import AegisOpenAIInterceptor
+
+gateway = AegisGateway("http://localhost:8080")
+interceptor = AegisOpenAIInterceptor(gateway=gateway)
+
+# In your chat completion loop:
+for tool_call in response.choices[0].message.tool_calls:
+    # Evaluates policy and returns tool response dict formatted for OpenAI
+    tool_message = interceptor.intercept_tool_call(tool_call)
+    messages.append(tool_message)
+```
+
+### 4. Human-in-the-Loop (HITL) Resolution
+
+```python
+# Check pending ticket and resolve with cryptographic signature
+gateway.resolve_hitl(
+    ticket_id="ticket-12345",
+    decision="APPROVED",
+    signature="sig-supervisor-ed25519"
+)
+```
+
+### 5. Forensic Cryptographic Ledger Verification
+
+```python
+# Verifies the tamper-evident WORM Merkle chain
+audit = gateway.verify_audit_integrity()
+print(f"Ledger Valid: {audit['isValid']}")
+```
+
+## License
+
+Apache-2.0

aegiscore_ai-0.1.0/README.md

@@ -0,0 +1,97 @@
+# aegiscore-py
+
+Official, zero-dependency Python client for **AegisCore** — the Deterministic Zero-Trust Policy & Cryptographic WORM Audit Gateway for AI Agents.
+
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://pypi.org/project/aegiscore-ai/)
+
+## Installation
+
+```bash
+pip install aegiscore-ai
+```
+
+*Note: `aegiscore-ai` is 100% zero-dependency, implemented purely using Python's standard library (`urllib.request`, `json`, `dataclasses`).*
+
+## Quick Start
+
+### 1. Direct Tool Proposal Dispatch
+
+```python
+from aegiscore import AegisGateway
+
+gateway = AegisGateway("http://localhost:8080")
+
+# Dispatch tool intent: evaluates schema, invariants, tokenizes PII, logs WORM audit
+result = gateway.dispatch(
+    tool="transfer_funds",
+    arguments={"amount": 2500, "recipient": "ACC-PAYROLL"},
+    session_id="sess_01"
+)
+
+if result.is_success:
+    print("Action Approved & Executed:", result.output)
+elif result.requires_hitl:
+    print(f"Action escalated to human approval. Ticket ID: {result.ticket_id}")
+else:
+    print(f"Action BLOCKED: {result.reason}")
+    for violation in result.violations:
+        print(f" - {violation}")
+```
+
+### 2. LangGraph & LangChain Integration
+
+```python
+from aegiscore import AegisGateway
+from aegiscore.integrations import AegisLangGraphWrapper
+
+gateway = AegisGateway("http://localhost:8080")
+wrapper = AegisLangGraphWrapper(gateway=gateway)
+
+# Wrap any native function or tool
+@wrapper.wrap_tool("query_database", raw_query_func)
+def safe_query_database(query: str):
+    return raw_query_func(query)
+
+# Calls are intercepted and verified against policy invariants before invocation
+safe_query_database(query="SELECT * FROM users")
+```
+
+### 3. OpenAI Function Call Interception
+
+```python
+from aegiscore import AegisGateway
+from aegiscore.integrations import AegisOpenAIInterceptor
+
+gateway = AegisGateway("http://localhost:8080")
+interceptor = AegisOpenAIInterceptor(gateway=gateway)
+
+# In your chat completion loop:
+for tool_call in response.choices[0].message.tool_calls:
+    # Evaluates policy and returns tool response dict formatted for OpenAI
+    tool_message = interceptor.intercept_tool_call(tool_call)
+    messages.append(tool_message)
+```
+
+### 4. Human-in-the-Loop (HITL) Resolution
+
+```python
+# Check pending ticket and resolve with cryptographic signature
+gateway.resolve_hitl(
+    ticket_id="ticket-12345",
+    decision="APPROVED",
+    signature="sig-supervisor-ed25519"
+)
+```
+
+### 5. Forensic Cryptographic Ledger Verification
+
+```python
+# Verifies the tamper-evident WORM Merkle chain
+audit = gateway.verify_audit_integrity()
+print(f"Ledger Valid: {audit['isValid']}")
+```
+
+## License
+
+Apache-2.0

aegiscore_ai-0.1.0/aegiscore/__init__.py

@@ -0,0 +1,26 @@
+"""
+AegisCore Python Client SDK
+Zero-dependency client for deterministic agent governance.
+"""
+
+from .client import AegisGateway, AegisClient
+from .models import DispatchResult
+from .exceptions import (
+    AegisError,
+    AegisGatewayError,
+    AegisPolicyBlockedError,
+    AegisSchemaError,
+    AegisHitlRequiredError,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "AegisGateway",
+    "AegisClient",
+    "DispatchResult",
+    "AegisError",
+    "AegisGatewayError",
+    "AegisPolicyBlockedError",
+    "AegisSchemaError",
+    "AegisHitlRequiredError",
+]

aegiscore_ai-0.1.0/aegiscore/client.py

@@ -0,0 +1,222 @@
+"""
+AegisCore Python Client - Zero-dependency gateway wrapper
+"""
+
+import json
+import urllib.request
+import urllib.error
+from typing import Any, Dict, List, Optional, Union
+import uuid
+
+from .exceptions import (
+    AegisGatewayError,
+    AegisPolicyBlockedError,
+    AegisSchemaError,
+    AegisHitlRequiredError,
+)
+from .models import DispatchResult
+
+
+class AegisGateway:
+    """
+    Zero-dependency Python client for the AegisCore Deterministic Governance Gateway.
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8080",
+        agent_id: str = "python-agent",
+        role: str = "operator",
+        default_headers: Optional[Dict[str, str]] = None,
+        timeout: float = 30.0,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.agent_id = agent_id
+        self.role = role
+        self.default_headers = default_headers or {}
+        self.timeout = timeout
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        """Internal helper for standard HTTP requests using urllib."""
+        url = f"{self.base_url}{path}"
+        req_headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "aegiscore-python/0.1.0",
+            **self.default_headers,
+        }
+        if headers:
+            req_headers.update(headers)
+
+        body_bytes = json.dumps(data).encode("utf-8") if data is not None else None
+        req = urllib.request.Request(url, data=body_bytes, headers=req_headers, method=method)
+
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as response:
+                resp_text = response.read().decode("utf-8")
+                return json.loads(resp_text) if resp_text else {}
+        except urllib.error.HTTPError as err:
+            err_text = err.read().decode("utf-8") if err.fp else ""
+            try:
+                parsed = json.loads(err_text)
+            except Exception:
+                parsed = None
+
+            # 403 Forbidden is used for BLOCKED actions
+            if err.code == 403 and parsed and isinstance(parsed, dict):
+                return parsed
+
+            # 400 Bad Request is used for SCHEMA_ERROR
+            if err.code == 400 and parsed and isinstance(parsed, dict) and parsed.get("status") == "SCHEMA_ERROR":
+                return parsed
+
+            raise AegisGatewayError(
+                f"AegisCore Gateway HTTP {err.code}: {err.reason} - {err_text}",
+                status_code=err.code,
+                response_body=err_text,
+            ) from err
+        except urllib.error.URLError as err:
+            raise AegisGatewayError(f"Connection to AegisCore Gateway failed ({url}): {err.reason}") from err
+
+    def dispatch(
+        self,
+        tool: str,
+        arguments: Optional[Dict[str, Any]] = None,
+        session_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        role: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        raise_on_blocked: bool = False,
+    ) -> DispatchResult:
+        """
+        Dispatches a proposed tool invocation to AegisCore for invariant checking,
+        DPDP PII tokenization, policy evaluation, WORM audit logging, and sandbox execution.
+        """
+        sid = session_id or f"sess-{uuid.uuid4().hex[:12]}"
+        aid = agent_id or self.agent_id
+        r = role or self.role
+        params = arguments if arguments is not None else {}
+
+        payload = {
+            "tool": tool,
+            "parameters": params,
+            "metadata": metadata or {},
+            "context": {
+                "sessionId": sid,
+                "agentId": aid,
+                "role": r,
+            },
+        }
+
+        raw = self._request("POST", "/v1/gateway/dispatch", data=payload)
+        status = raw.get("status", "UNKNOWN")
+        reason = raw.get("reason")
+        violations = raw.get("violations", [])
+        challenge = raw.get("challenge")
+        audit_entry = raw.get("auditEntry")
+
+        output = None
+        if "execution" in raw and isinstance(raw["execution"], dict):
+            output = raw["execution"].get("output")
+
+        result = DispatchResult(
+            status=status,
+            intent_id=raw.get("intentId"),
+            session_id=sid,
+            tool=tool,
+            reason=reason,
+            output=output,
+            violations=violations,
+            challenge=challenge,
+            audit_entry=audit_entry,
+            raw=raw,
+        )
+
+        if raise_on_blocked and status == "BLOCKED":
+            raise AegisPolicyBlockedError(
+                f"Tool invocation '{tool}' was BLOCKED: {reason}",
+                violations=violations,
+                raw_result=raw,
+            )
+
+        if raise_on_blocked and status == "SCHEMA_ERROR":
+            raise AegisSchemaError(
+                f"Tool invocation '{tool}' failed schema validation: {reason}",
+                raw_result=raw,
+            )
+
+        return result
+
+    def evaluate_intent(
+        self,
+        tool: str,
+        parameters: Optional[Dict[str, Any]] = None,
+        session_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        role: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Submits an intent to /v1/intent/evaluate returning canonical IntentEvaluationResponse."""
+        aid = agent_id or self.agent_id
+        payload = {
+            "tool": tool,
+            "parameters": parameters or {},
+            "metadata": metadata or {},
+            "agent": {
+                "agentId": aid,
+                "role": role or self.role,
+                "sessionId": session_id or f"sess-{uuid.uuid4().hex[:12]}",
+            },
+        }
+        return self._request("POST", "/v1/intent/evaluate", data=payload, headers={"X-Agent-Id": aid})
+
+    def execute_tool(
+        self,
+        tool_call_id: str,
+        name: str,
+        arguments: Union[str, Dict[str, Any]],
+        agent_id: Optional[str] = None,
+        role: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Proxies an OpenAI tool call to /v1/tools/execute."""
+        aid = agent_id or self.agent_id
+        payload = {
+            "tool_call_id": tool_call_id,
+            "name": name,
+            "arguments": arguments,
+            "agent_id": aid,
+            "role": role or self.role,
+        }
+        return self._request("POST", "/v1/tools/execute", data=payload, headers={"x-agent-id": aid})
+
+    def resolve_hitl(
+        self,
+        ticket_id: str,
+        decision: str = "APPROVED",
+        signature: str = "sig-officer-signature",
+        scoped_credentials: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        """Resolves an asynchronous Human-in-the-Loop challenge ticket."""
+        payload = {
+            "decision": decision,
+            "approverSignature": signature,
+            "scopedCredentials": scoped_credentials or {},
+        }
+        return self._request("POST", f"/v1/hitl/challenges/{ticket_id}/resolve", data=payload)
+
+    def verify_audit_integrity(self) -> Dict[str, Any]:
+        """Queries the cryptographic WORM ledger to verify Merkle chain integrity."""
+        return self._request("GET", "/v1/audit/integrity")
+
+    def health(self) -> Dict[str, Any]:
+        """Checks gateway daemon health."""
+        return self._request("GET", "/health")
+
+
+# Alias for developer ergonomics
+AegisClient = AegisGateway

aegiscore_ai-0.1.0/aegiscore/exceptions.py

@@ -0,0 +1,41 @@
+"""
+AegisCore Python Exceptions
+"""
+
+from typing import Any, Dict, List, Optional
+
+
+class AegisError(Exception):
+    """Base exception for all AegisCore errors."""
+    pass
+
+
+class AegisGatewayError(AegisError):
+    """Raised when the AegisCore gateway returns an HTTP or network error."""
+    def __init__(self, message: str, status_code: Optional[int] = None, response_body: Optional[str] = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_body = response_body
+
+
+class AegisPolicyBlockedError(AegisError):
+    """Raised when an action is blocked by a deterministic policy invariant."""
+    def __init__(self, message: str, violations: Optional[List[Dict[str, Any]]] = None, raw_result: Optional[Dict[str, Any]] = None):
+        super().__init__(message)
+        self.violations = violations or []
+        self.raw_result = raw_result or {}
+
+
+class AegisSchemaError(AegisError):
+    """Raised when a tool argument payload fails fail-closed schema validation."""
+    def __init__(self, message: str, raw_result: Optional[Dict[str, Any]] = None):
+        super().__init__(message)
+        self.raw_result = raw_result or {}
+
+
+class AegisHitlRequiredError(AegisError):
+    """Raised when an action requires human-in-the-loop escalation before execution."""
+    def __init__(self, message: str, ticket_id: str, challenge: Dict[str, Any]):
+        super().__init__(message)
+        self.ticket_id = ticket_id
+        self.challenge = challenge

aegiscore_ai-0.1.0/aegiscore/integrations/__init__.py

@@ -0,0 +1,4 @@
+from .langgraph import AegisLangGraphWrapper
+from .openai import AegisOpenAIInterceptor
+
+__all__ = ["AegisLangGraphWrapper", "AegisOpenAIInterceptor"]

aegiscore_ai-0.1.0/aegiscore/integrations/langgraph.py

@@ -0,0 +1,42 @@
+"""
+LangGraph and LangChain Integration for AegisCore
+"""
+
+from typing import Any, Callable, Dict, Optional
+from ..client import AegisGateway
+from ..exceptions import AegisPolicyBlockedError
+
+
+class AegisLangGraphWrapper:
+    """
+    Wraps standard LangChain/LangGraph tools with AegisCore deterministic governance.
+    """
+
+    def __init__(self, gateway: Optional[AegisGateway] = None, gateway_url: str = "http://localhost:8080"):
+        self.gateway = gateway or AegisGateway(base_url=gateway_url)
+
+    def wrap_tool(self, tool_name: str, tool_func: Callable[..., Any]) -> Callable[..., Any]:
+        """
+        Wraps a Python function/tool so that all calls are evaluated by AegisCore before execution.
+        """
+        gateway = self.gateway
+
+        def governed_tool(**kwargs: Any) -> Any:
+            # 1. Pre-flight evaluation
+            result = gateway.dispatch(tool=tool_name, arguments=kwargs, raise_on_blocked=False)
+            if not result.is_success:
+                raise AegisPolicyBlockedError(
+                    f"Action '{tool_name}' was rejected by AegisCore: {result.reason}",
+                    violations=result.violations,
+                    raw_result=result.raw
+                )
+            
+            # 2. If the gateway executed in sandbox, return that output; otherwise run the wrapped func
+            if result.output is not None:
+                return result.output
+
+            return tool_func(**kwargs)
+
+        governed_tool.__name__ = getattr(tool_func, "__name__", tool_name)
+        governed_tool.__doc__ = getattr(tool_func, "__doc__", "")
+        return governed_tool

aegiscore_ai-0.1.0/aegiscore/integrations/openai.py

@@ -0,0 +1,61 @@
+"""
+OpenAI Tool-Call Interceptor for AegisCore
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+from ..client import AegisGateway
+
+
+class AegisOpenAIInterceptor:
+    """
+    Intercepts and governs OpenAI-style function tool calls through AegisCore.
+    """
+
+    def __init__(self, gateway: Optional[AegisGateway] = None, gateway_url: str = "http://localhost:8080"):
+        self.gateway = gateway or AegisGateway(base_url=gateway_url)
+
+    def intercept_tool_call(self, tool_call: Any) -> Dict[str, Any]:
+        """
+        Intercepts a single OpenAI tool_call object and executes through AegisCore.
+        Returns a dict suitable for appending to OpenAI conversation messages.
+        """
+        # Support dict or pydantic/object structure
+        if isinstance(tool_call, dict):
+            tool_id = tool_call.get("id", "")
+            func = tool_call.get("function", {})
+            name = func.get("name", "")
+            arguments = func.get("arguments", "{}")
+        else:
+            tool_id = getattr(tool_call, "id", "")
+            func = getattr(tool_call, "function", None)
+            name = getattr(func, "name", "") if func else ""
+            arguments = getattr(func, "arguments", "{}") if func else "{}"
+
+        raw_resp = self.gateway.execute_tool(
+            tool_call_id=tool_id,
+            name=name,
+            arguments=arguments
+        )
+
+        allowed = raw_resp.get("allowed", False)
+        verdict = raw_resp.get("verdict", "BLOCKED")
+        reason = raw_resp.get("reason", "Policy invariant violation")
+        execution = raw_resp.get("execution")
+
+        if not allowed:
+            content = json.dumps({
+                "error": "AEGIS_GOVERNANCE_BLOCKED",
+                "verdict": verdict,
+                "message": reason
+            })
+        else:
+            output = execution.get("output") if isinstance(execution, dict) else {"status": "SUCCESS"}
+            content = json.dumps(output)
+
+        return {
+            "tool_call_id": tool_id,
+            "role": "tool",
+            "name": name,
+            "content": content
+        }

aegiscore_ai-0.1.0/aegiscore/models.py

@@ -0,0 +1,39 @@
+"""
+AegisCore Python Models & Dataclasses
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class DispatchResult:
+    """Represents the response of a tool dispatch through AegisCore Gateway."""
+    status: str  # 'SUCCESS', 'BLOCKED', 'REQUIRES_HITL', 'SCHEMA_ERROR', 'EXECUTION_FAILED'
+    intent_id: Optional[str] = None
+    session_id: Optional[str] = None
+    tool: Optional[str] = None
+    reason: Optional[str] = None
+    output: Optional[Any] = None
+    violations: List[Dict[str, Any]] = field(default_factory=list)
+    challenge: Optional[Dict[str, Any]] = None
+    audit_entry: Optional[Dict[str, Any]] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def is_success(self) -> bool:
+        return self.status == "SUCCESS"
+
+    @property
+    def is_blocked(self) -> bool:
+        return self.status == "BLOCKED"
+
+    @property
+    def requires_hitl(self) -> bool:
+        return self.status == "REQUIRES_HITL"
+
+    @property
+    def ticket_id(self) -> Optional[str]:
+        if self.challenge and isinstance(self.challenge, dict):
+            return self.challenge.get("ticketId")
+        return None

aegiscore_ai-0.1.0/aegiscore_ai.egg-info/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: aegiscore-ai
+Version: 0.1.0
+Summary: Deterministic Agent Governance Gateway - Zero-Trust Policy Enclave for AI Agents
+Author: Sandeep Hipparagi & AegisCore Contributors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Sandeep-Hipparagi/aegis-core
+Project-URL: Repository, https://github.com/Sandeep-Hipparagi/aegis-core.git
+Project-URL: Issues, https://github.com/Sandeep-Hipparagi/aegis-core/issues
+Keywords: ai-agent,governance,security,zero-trust,langgraph,openai,mcp,dpdp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# aegiscore-py
+
+Official, zero-dependency Python client for **AegisCore** — the Deterministic Zero-Trust Policy & Cryptographic WORM Audit Gateway for AI Agents.
+
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://pypi.org/project/aegiscore-ai/)
+
+## Installation
+
+```bash
+pip install aegiscore-ai
+```
+
+*Note: `aegiscore-ai` is 100% zero-dependency, implemented purely using Python's standard library (`urllib.request`, `json`, `dataclasses`).*
+
+## Quick Start
+
+### 1. Direct Tool Proposal Dispatch
+
+```python
+from aegiscore import AegisGateway
+
+gateway = AegisGateway("http://localhost:8080")
+
+# Dispatch tool intent: evaluates schema, invariants, tokenizes PII, logs WORM audit
+result = gateway.dispatch(
+    tool="transfer_funds",
+    arguments={"amount": 2500, "recipient": "ACC-PAYROLL"},
+    session_id="sess_01"
+)
+
+if result.is_success:
+    print("Action Approved & Executed:", result.output)
+elif result.requires_hitl:
+    print(f"Action escalated to human approval. Ticket ID: {result.ticket_id}")
+else:
+    print(f"Action BLOCKED: {result.reason}")
+    for violation in result.violations:
+        print(f" - {violation}")
+```
+
+### 2. LangGraph & LangChain Integration
+
+```python
+from aegiscore import AegisGateway
+from aegiscore.integrations import AegisLangGraphWrapper
+
+gateway = AegisGateway("http://localhost:8080")
+wrapper = AegisLangGraphWrapper(gateway=gateway)
+
+# Wrap any native function or tool
+@wrapper.wrap_tool("query_database", raw_query_func)
+def safe_query_database(query: str):
+    return raw_query_func(query)
+
+# Calls are intercepted and verified against policy invariants before invocation
+safe_query_database(query="SELECT * FROM users")
+```
+
+### 3. OpenAI Function Call Interception
+
+```python
+from aegiscore import AegisGateway
+from aegiscore.integrations import AegisOpenAIInterceptor
+
+gateway = AegisGateway("http://localhost:8080")
+interceptor = AegisOpenAIInterceptor(gateway=gateway)
+
+# In your chat completion loop:
+for tool_call in response.choices[0].message.tool_calls:
+    # Evaluates policy and returns tool response dict formatted for OpenAI
+    tool_message = interceptor.intercept_tool_call(tool_call)
+    messages.append(tool_message)
+```
+
+### 4. Human-in-the-Loop (HITL) Resolution
+
+```python
+# Check pending ticket and resolve with cryptographic signature
+gateway.resolve_hitl(
+    ticket_id="ticket-12345",
+    decision="APPROVED",
+    signature="sig-supervisor-ed25519"
+)
+```
+
+### 5. Forensic Cryptographic Ledger Verification
+
+```python
+# Verifies the tamper-evident WORM Merkle chain
+audit = gateway.verify_audit_integrity()
+print(f"Ledger Valid: {audit['isValid']}")
+```
+
+## License
+
+Apache-2.0

aegiscore_ai-0.1.0/aegiscore_ai.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+aegiscore/__init__.py
+aegiscore/client.py
+aegiscore/exceptions.py
+aegiscore/models.py
+aegiscore/integrations/__init__.py
+aegiscore/integrations/langgraph.py
+aegiscore/integrations/openai.py
+aegiscore_ai.egg-info/PKG-INFO
+aegiscore_ai.egg-info/SOURCES.txt
+aegiscore_ai.egg-info/dependency_links.txt
+aegiscore_ai.egg-info/top_level.txt
+tests/test_client.py

aegiscore_ai-0.1.0/aegiscore_ai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aegiscore_ai-0.1.0/aegiscore_ai.egg-info/top_level.txt

@@ -0,0 +1 @@
+aegiscore

aegiscore_ai-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aegiscore-ai"
+version = "0.1.0"
+description = "Deterministic Agent Governance Gateway - Zero-Trust Policy Enclave for AI Agents"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "Apache-2.0"
+authors = [
+    { name = "Sandeep Hipparagi & AegisCore Contributors" }
+]
+keywords = [
+    "ai-agent",
+    "governance",
+    "security",
+    "zero-trust",
+    "langgraph",
+    "openai",
+    "mcp",
+    "dpdp"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Security"
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/Sandeep-Hipparagi/aegis-core"
+Repository = "https://github.com/Sandeep-Hipparagi/aegis-core.git"
+Issues = "https://github.com/Sandeep-Hipparagi/aegis-core/issues"

aegiscore_ai-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aegiscore_ai-0.1.0/tests/test_client.py

@@ -0,0 +1,196 @@
+"""
+Unit tests for AegisCore Python SDK
+"""
+
+import json
+import unittest
+from unittest.mock import patch, MagicMock
+import io
+import urllib.error
+
+from aegiscore import (
+    AegisGateway,
+    AegisClient,
+    DispatchResult,
+    AegisPolicyBlockedError,
+    AegisSchemaError,
+)
+from aegiscore.integrations import (
+    AegisLangGraphWrapper,
+    AegisOpenAIInterceptor,
+)
+
+
+class TestAegisPythonSDK(unittest.TestCase):
+
+    def setUp(self):
+        self.gateway = AegisGateway(base_url="http://127.0.0.1:8080", agent_id="test-agent", role="tester")
+
+    def test_client_alias(self):
+        self.assertIs(AegisClient, AegisGateway)
+        client = AegisClient(base_url="http://localhost:9090")
+        self.assertEqual(client.base_url, "http://localhost:9090")
+
+    def test_dispatch_result_helpers(self):
+        res_success = DispatchResult(
+            status="SUCCESS",
+            tool="check_balance",
+            output={"balance": 5000}
+        )
+        self.assertTrue(res_success.is_success)
+        self.assertFalse(res_success.is_blocked)
+        self.assertFalse(res_success.requires_hitl)
+        self.assertIsNone(res_success.ticket_id)
+
+        res_hitl = DispatchResult(
+            status="REQUIRES_HITL",
+            tool="transfer_funds",
+            challenge={"ticketId": "tick-999", "status": "PENDING"}
+        )
+        self.assertFalse(res_hitl.is_success)
+        self.assertTrue(res_hitl.requires_hitl)
+        self.assertEqual(res_hitl.ticket_id, "tick-999")
+
+        res_blocked = DispatchResult(
+            status="BLOCKED",
+            tool="purge_data",
+            reason="Unauthorized role"
+        )
+        self.assertTrue(res_blocked.is_blocked)
+
+    @patch("urllib.request.urlopen")
+    def test_dispatch_success(self, mock_urlopen):
+        mock_response = MagicMock()
+        mock_response.read.return_value = json.dumps({
+            "status": "SUCCESS",
+            "intentId": "int-101",
+            "execution": {
+                "status": "SUCCESS",
+                "output": {"txId": "tx-12345", "amount": 100}
+            }
+        }).encode("utf-8")
+        mock_urlopen.return_value.__enter__.return_value = mock_response
+
+        res = self.gateway.dispatch("transfer_funds", {"amount": 100, "recipient": "bob"})
+        self.assertTrue(res.is_success)
+        self.assertEqual(res.output, {"txId": "tx-12345", "amount": 100})
+        self.assertEqual(res.intent_id, "int-101")
+
+    @patch("urllib.request.urlopen")
+    def test_dispatch_blocked_without_raise(self, mock_urlopen):
+        err_body = json.dumps({
+            "status": "BLOCKED",
+            "reason": "Exceeds daily budget",
+            "violations": [{"ruleId": "RULE-01", "message": "Limit exceeded"}]
+        }).encode("utf-8")
+        mock_fp = io.BytesIO(err_body)
+        http_err = urllib.error.HTTPError("http://127.0.0.1:8080/v1/gateway/dispatch", 403, "Forbidden", {}, mock_fp)
+        mock_urlopen.side_effect = http_err
+
+        res = self.gateway.dispatch("transfer_funds", {"amount": 1000000}, raise_on_blocked=False)
+        self.assertTrue(res.is_blocked)
+        self.assertEqual(res.reason, "Exceeds daily budget")
+        self.assertEqual(len(res.violations), 1)
+
+    @patch("urllib.request.urlopen")
+    def test_dispatch_blocked_with_raise(self, mock_urlopen):
+        err_body = json.dumps({
+            "status": "BLOCKED",
+            "reason": "Target table blacklisted",
+            "violations": [{"ruleId": "RULE-SENSITIVE"}]
+        }).encode("utf-8")
+        mock_fp = io.BytesIO(err_body)
+        http_err = urllib.error.HTTPError("http://127.0.0.1:8080/v1/gateway/dispatch", 403, "Forbidden", {}, mock_fp)
+        mock_urlopen.side_effect = http_err
+
+        with self.assertRaises(AegisPolicyBlockedError) as ctx:
+            self.gateway.dispatch("query_database", {"targetTable": "users.credentials"}, raise_on_blocked=True)
+
+        self.assertIn("Target table blacklisted", str(ctx.exception))
+
+    @patch("urllib.request.urlopen")
+    def test_evaluate_intent(self, mock_urlopen):
+        mock_response = MagicMock()
+        mock_response.read.return_value = json.dumps({
+            "decision": {"status": "APPROVED", "executionAllowed": True}
+        }).encode("utf-8")
+        mock_urlopen.return_value.__enter__.return_value = mock_response
+
+        res = self.gateway.evaluate_intent("check_balance", {"accountId": "ACC-01"})
+        self.assertEqual(res["decision"]["status"], "APPROVED")
+
+    @patch("urllib.request.urlopen")
+    def test_execute_tool(self, mock_urlopen):
+        mock_response = MagicMock()
+        mock_response.read.return_value = json.dumps({
+            "tool_call_id": "call_123",
+            "allowed": True,
+            "verdict": "APPROVED"
+        }).encode("utf-8")
+        mock_urlopen.return_value.__enter__.return_value = mock_response
+
+        res = self.gateway.execute_tool("call_123", "check_balance", {"accountId": "ACC-01"})
+        self.assertTrue(res["allowed"])
+
+    @patch("urllib.request.urlopen")
+    def test_resolve_hitl(self, mock_urlopen):
+        mock_response = MagicMock()
+        mock_response.read.return_value = json.dumps({
+            "resolution": {"status": "APPROVED"},
+            "execution": {"status": "SUCCESS"}
+        }).encode("utf-8")
+        mock_urlopen.return_value.__enter__.return_value = mock_response
+
+        res = self.gateway.resolve_hitl("ticket-01", "APPROVED", "sig-123")
+        self.assertEqual(res["resolution"]["status"], "APPROVED")
+
+    @patch("urllib.request.urlopen")
+    def test_audit_integrity(self, mock_urlopen):
+        mock_response = MagicMock()
+        mock_response.read.return_value = json.dumps({
+            "isValid": True,
+            "totalEntries": 42
+        }).encode("utf-8")
+        mock_urlopen.return_value.__enter__.return_value = mock_response
+
+        res = self.gateway.verify_audit_integrity()
+        self.assertTrue(res["isValid"])
+        self.assertEqual(res["totalEntries"], 42)
+
+    def test_langgraph_wrapper_approved(self):
+        wrapper = AegisLangGraphWrapper(gateway=self.gateway)
+        with patch.object(self.gateway, "dispatch") as mock_dispatch:
+            mock_dispatch.return_value = DispatchResult(
+                status="SUCCESS",
+                tool="calc",
+                output=42
+            )
+            raw_fn = MagicMock(return_value=42)
+            governed = wrapper.wrap_tool("calc", raw_fn)
+            output = governed(x=20, y=22)
+            self.assertEqual(output, 42)
+            mock_dispatch.assert_called_once()
+
+    def test_openai_interceptor_blocked(self):
+        interceptor = AegisOpenAIInterceptor(gateway=self.gateway)
+        with patch.object(self.gateway, "execute_tool") as mock_exec:
+            mock_exec.return_value = {
+                "tool_call_id": "tc_1",
+                "allowed": False,
+                "verdict": "BLOCKED",
+                "reason": "High risk action"
+            }
+            msg = interceptor.intercept_tool_call({
+                "id": "tc_1",
+                "function": {
+                    "name": "delete_all",
+                    "arguments": "{}"
+                }
+            })
+            self.assertEqual(msg["role"], "tool")
+            parsed = json.loads(msg["content"])
+            self.assertEqual(parsed["verdict"], "BLOCKED")
+
+
+if __name__ == "__main__":
+    unittest.main()