maigp-client 5.0.0__tar.gz

maigp_client-5.0.0/.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.eggs/
+
+# Node
+node_modules/
+dist/
+
+# Go
+bin/
+
+# Rust
+target/
+
+# .NET
+bin/
+obj/
+
+# Java
+*.class
+out/
+
+# IDE
+.idea/
+.vscode/
+.kiro/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Secrets (never commit)
+.env
+*.pem
+*.key
+*.pdf
+BACKLOG/
+patent/
+docs/.archive/

maigp_client-5.0.0/Makefile

@@ -0,0 +1,13 @@
+.PHONY: wheel clean install test
+
+wheel:
+	python3 -m build --wheel --outdir dist/
+
+clean:
+	rm -rf dist/ build/ *.egg-info aigp_client/__pycache__
+
+install:
+	pip install dist/aigp_client-1.0.0-py3-none-any.whl
+
+test:
+	pytest tests/ -v

maigp_client-5.0.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: maigp-client
+Version: 5.0.0
+Summary: MAIGP (Mediated AI Governance Protocol) client — consent-based runtime AI governance
+Project-URL: Homepage, https://github.com/owner-spec/aigp-protocol
+Project-URL: Documentation, https://github.com/owner-spec/aigp-protocol/tree/main/specification
+Project-URL: Repository, https://github.com/owner-spec/aigp-protocol
+Author-email: Evan Erwee <evan@erwee.com>
+License: Proprietary
+Keywords: ai,aigp,bedrock,governance,llm,maigp,mediated,protocol
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.25.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: respx; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# aigp-client
+
+Universal AI Governance Protocol (AIGP) client v4.0 — consent-based runtime AI governance with jurisdictional enforcement.
+
+## Install
+
+```bash
+pip install aigp-client
+```
+
+## Quick Start
+
+```python
+from aigp_client import AigpClient
+
+client = AigpClient("https://your-gov-server.com", "my-app", "hmac-secret")
+
+# Declare governance context (once at startup)
+client.declare_universal_context({"active": True, "principles": "ALL"})
+
+# Every AI call: CHECK → invoke → RECORD
+decision = await client.check("chat", "claude-4")
+# ... invoke your model ...
+await client.record(use_case="chat", model_id="claude-4", input_tokens=500, output_tokens=200, duration_ms=1200)
+```
+
+## One-Line Governance
+
+```python
+from aigp_client import govern
+
+aigp = govern("https://gov-server.com", "my-app", "secret")
+result = await aigp.wrap(my_ai_function)  # CHECK + RECORD automatic
+```
+
+## Jurisdictional Governance (v4.0)
+
+Declare which legal frameworks govern your AI system:
+
+```python
+from aigp_client import (
+    AigpClient, HumanitarianContext, RegulatoryContext,
+    AfricanContext, JapaneseContext,
+)
+
+client = AigpClient("https://gov.example.com", "my-app", "secret")
+
+# Universal baseline (RFC-031) — all apps should declare this
+client.declare_universal_context({"active": True, "principles": "ALL", "accountability_required": True})
+
+# EU AI Act (RFC-028)
+client.declare_regulatory_context(RegulatoryContext(
+    active=True, framework="EU_AI_ACT", risk_classification="HIGH_RISK",
+    deployer_jurisdiction="DE",
+))
+
+# Japan AI Promotion Act (RFC-030)
+client.declare_japanese_context(JapaneseContext(
+    active=True, governance_framework="JAPAN_AI_PROMOTION_ACT",
+    sector="HEALTHCARE", innovation_priority=True,
+))
+
+# AU Continental AI Strategy (RFC-029)
+client.declare_african_context(AfricanContext(
+    active=True, governance_framework="AU_CONTINENTAL_AI_STRATEGY",
+    member_state="KE", ubuntu_principle=True,
+))
+
+# IHL — conflict zones (RFC-027)
+client.declare_humanitarian_context(HumanitarianContext(
+    active=True, legal_regime="IHL_GCIV", conflict_classification="NIAC",
+    operating_authority="ICRC",
+))
+```
+
+All subsequent CHECK requests are evaluated against declared contexts. Priority: IHL → EU → AU → Japan → Universal.
+
+## User Feedback (RFC-026)
+
+```python
+await client.feedback(request_id="req-123", session_id="ses-abc",
+                      rating="thumbs_up", pseudonym_id="user-hash")
+```
+
+## Multi-Agent Delegation
+
+```python
+from aigp_client import SessionContext, DelegationToken
+
+session = SessionContext(user_id="coordinator@company.com")
+child = session.child(scope=["search_only"])
+
+token = DelegationToken(issuer="coordinator", delegate="worker",
+                        allowed_models=["claude-4"], max_tokens=10000)
+encoded = token.encode("shared-secret")
+```
+
+## Token Tracking
+
+```python
+from aigp_client import TokenAccumulator
+
+tokens = TokenAccumulator()
+tokens.add_from_usage({"prompt_tokens": 500, "completion_tokens": 200})  # OpenAI
+tokens.add_from_usage({"inputTokens": 300, "outputTokens": 150})          # Bedrock
+print(f"Total: {tokens.total_input} in, {tokens.total_output} out")
+```
+
+## Full Lifecycle Trace
+
+```python
+from aigp_client import TraceBuilder
+
+tb = TraceBuilder(request_id="req-1")
+tb.start(1); tb.end(1, attributes={"user_id": "user@co.com"})  # Identity
+tb.start(3); tb.end(3, attributes={"decision": "ALLOW"})        # CHECK
+tb.start(9); tb.end(9, attributes={"model": "claude-4"})        # Invoke
+tb.add_tool_span("search_docs", duration_ms=45)                  # Tool
+tb.start(14); tb.end(14)                                         # RECORD
+spans, summary = tb.build()
+await client.trace(trace_id=tb.trace_id, spans=spans, summary=summary)
+```
+
+## Tool Governance
+
+```python
+from aigp_client import ToolGovernance
+
+tg = ToolGovernance(client=client)
+decision = await tg.check_tool("execute_sql", params={"query": "SELECT *"})
+```
+
+## Modes
+
+| Mode | Behavior | When server unreachable |
+|------|----------|:-:|
+| `REPORT` | Log all, allow all | Allow (fail-open) |
+| `REPORT-TRACE` | Log + stage-level spans | Allow (fail-open) |
+| `ENFORCE` | Check policies, block violations | Deny (fail-closed) |
+
+## Supported Languages
+
+| Python | TypeScript | Go | Java | C# | Rust | Ruby | Swift |
+|:------:|:----------:|:--:|:----:|:--:|:----:|:----:|:-----:|
+| ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+
+All 8 SDKs have: `declareHumanitarianContext`, `declareRegulatoryContext`, `declareAfricanContext`, `declareJapaneseContext`, `declareUniversalContext`.
+
+## License
+
+Proprietary — © 2025-2026 Evan Erwee. All rights reserved.

maigp_client-5.0.0/README.md

@@ -0,0 +1,151 @@
+# aigp-client
+
+Universal AI Governance Protocol (AIGP) client v4.0 — consent-based runtime AI governance with jurisdictional enforcement.
+
+## Install
+
+```bash
+pip install aigp-client
+```
+
+## Quick Start
+
+```python
+from aigp_client import AigpClient
+
+client = AigpClient("https://your-gov-server.com", "my-app", "hmac-secret")
+
+# Declare governance context (once at startup)
+client.declare_universal_context({"active": True, "principles": "ALL"})
+
+# Every AI call: CHECK → invoke → RECORD
+decision = await client.check("chat", "claude-4")
+# ... invoke your model ...
+await client.record(use_case="chat", model_id="claude-4", input_tokens=500, output_tokens=200, duration_ms=1200)
+```
+
+## One-Line Governance
+
+```python
+from aigp_client import govern
+
+aigp = govern("https://gov-server.com", "my-app", "secret")
+result = await aigp.wrap(my_ai_function)  # CHECK + RECORD automatic
+```
+
+## Jurisdictional Governance (v4.0)
+
+Declare which legal frameworks govern your AI system:
+
+```python
+from aigp_client import (
+    AigpClient, HumanitarianContext, RegulatoryContext,
+    AfricanContext, JapaneseContext,
+)
+
+client = AigpClient("https://gov.example.com", "my-app", "secret")
+
+# Universal baseline (RFC-031) — all apps should declare this
+client.declare_universal_context({"active": True, "principles": "ALL", "accountability_required": True})
+
+# EU AI Act (RFC-028)
+client.declare_regulatory_context(RegulatoryContext(
+    active=True, framework="EU_AI_ACT", risk_classification="HIGH_RISK",
+    deployer_jurisdiction="DE",
+))
+
+# Japan AI Promotion Act (RFC-030)
+client.declare_japanese_context(JapaneseContext(
+    active=True, governance_framework="JAPAN_AI_PROMOTION_ACT",
+    sector="HEALTHCARE", innovation_priority=True,
+))
+
+# AU Continental AI Strategy (RFC-029)
+client.declare_african_context(AfricanContext(
+    active=True, governance_framework="AU_CONTINENTAL_AI_STRATEGY",
+    member_state="KE", ubuntu_principle=True,
+))
+
+# IHL — conflict zones (RFC-027)
+client.declare_humanitarian_context(HumanitarianContext(
+    active=True, legal_regime="IHL_GCIV", conflict_classification="NIAC",
+    operating_authority="ICRC",
+))
+```
+
+All subsequent CHECK requests are evaluated against declared contexts. Priority: IHL → EU → AU → Japan → Universal.
+
+## User Feedback (RFC-026)
+
+```python
+await client.feedback(request_id="req-123", session_id="ses-abc",
+                      rating="thumbs_up", pseudonym_id="user-hash")
+```
+
+## Multi-Agent Delegation
+
+```python
+from aigp_client import SessionContext, DelegationToken
+
+session = SessionContext(user_id="coordinator@company.com")
+child = session.child(scope=["search_only"])
+
+token = DelegationToken(issuer="coordinator", delegate="worker",
+                        allowed_models=["claude-4"], max_tokens=10000)
+encoded = token.encode("shared-secret")
+```
+
+## Token Tracking
+
+```python
+from aigp_client import TokenAccumulator
+
+tokens = TokenAccumulator()
+tokens.add_from_usage({"prompt_tokens": 500, "completion_tokens": 200})  # OpenAI
+tokens.add_from_usage({"inputTokens": 300, "outputTokens": 150})          # Bedrock
+print(f"Total: {tokens.total_input} in, {tokens.total_output} out")
+```
+
+## Full Lifecycle Trace
+
+```python
+from aigp_client import TraceBuilder
+
+tb = TraceBuilder(request_id="req-1")
+tb.start(1); tb.end(1, attributes={"user_id": "user@co.com"})  # Identity
+tb.start(3); tb.end(3, attributes={"decision": "ALLOW"})        # CHECK
+tb.start(9); tb.end(9, attributes={"model": "claude-4"})        # Invoke
+tb.add_tool_span("search_docs", duration_ms=45)                  # Tool
+tb.start(14); tb.end(14)                                         # RECORD
+spans, summary = tb.build()
+await client.trace(trace_id=tb.trace_id, spans=spans, summary=summary)
+```
+
+## Tool Governance
+
+```python
+from aigp_client import ToolGovernance
+
+tg = ToolGovernance(client=client)
+decision = await tg.check_tool("execute_sql", params={"query": "SELECT *"})
+```
+
+## Modes
+
+| Mode | Behavior | When server unreachable |
+|------|----------|:-:|
+| `REPORT` | Log all, allow all | Allow (fail-open) |
+| `REPORT-TRACE` | Log + stage-level spans | Allow (fail-open) |
+| `ENFORCE` | Check policies, block violations | Deny (fail-closed) |
+
+## Supported Languages
+
+| Python | TypeScript | Go | Java | C# | Rust | Ruby | Swift |
+|:------:|:----------:|:--:|:----:|:--:|:----:|:----:|:-----:|
+| ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+
+All 8 SDKs have: `declareHumanitarianContext`, `declareRegulatoryContext`, `declareAfricanContext`, `declareJapaneseContext`, `declareUniversalContext`.
+
+## License
+
+Proprietary — © 2025-2026 Evan Erwee. All rights reserved.

maigp_client-5.0.0/aigp_client/__init__.py

@@ -0,0 +1,64 @@
+"""AIGP Client v4.0 — Universal AI Governance Protocol client.
+
+Provides:
+- Protocol transport (CHECK/RECORD/TRACE)
+- Session context for multi-agent linking
+- Token accumulation for streaming/multi-cycle
+- Tool governance (per-tool CHECK)
+- Delegation tokens (agent-to-agent scoping)
+- Stream accumulator (periodic RECORD during streaming)
+- Rate-limit backoff
+"""
+
+__version__ = "4.0.0"
+
+# Core protocol
+from .client import AigpClient, GovernanceDecision
+from .trace_builder import TraceBuilder, STAGE_NAMES
+from .context import HumanitarianContext
+from .regulatory import RegulatoryContext
+from .african_context import AfricanContext
+from .japanese_context import JapaneseContext
+
+# v3.0+ — Agent support
+from .session import SessionContext
+from .tokens import TokenAccumulator
+from .tools import ToolGovernance
+from .delegation import DelegationToken
+from .streaming import StreamAccumulator
+from .backoff import retry_on_rate_limit
+
+# One-line governance wrapper
+from .govern import govern
+
+# RFC-032: Anticipation
+from .anticipation import AnticipationBuilder, Criterion
+
+# Provider-based config
+from .config import ClientConfig, ClientComponents
+from .providers.model import ModelProviderBase
+from .providers.transport import TransportProviderBase
+from .providers.consent import ConsentHelperBase, TokenMap
+from .schemas import GeoContext
+
+__all__ = [
+    # Core
+    "AigpClient", "GovernanceDecision",
+    "TraceBuilder", "STAGE_NAMES",
+    "HumanitarianContext",
+    "RegulatoryContext",
+    "AfricanContext",
+    "JapaneseContext",
+    # v3.0+ Agent support
+    "SessionContext", "TokenAccumulator", "ToolGovernance",
+    "DelegationToken", "StreamAccumulator", "retry_on_rate_limit",
+    # Config/Providers
+    "ClientConfig", "ClientComponents",
+    "ModelProviderBase", "TransportProviderBase",
+    "ConsentHelperBase", "TokenMap",
+    "GeoContext",
+    # Governance wrapper
+    "govern",
+    # RFC-032: Anticipation
+    "AnticipationBuilder", "Criterion",
+]

maigp_client-5.0.0/aigp_client/african_context.py

@@ -0,0 +1,102 @@
+"""RFC-029: African Context — typed context for AU Continental AI Strategy alignment.
+
+Usage:
+    from aigp_client.african_context import AfricanContext
+
+    ctx = AfricanContext(
+        active=True,
+        governance_framework="AU_CONTINENTAL_AI_STRATEGY",
+        member_state="KE",
+        rec="EAC",
+    )
+    client.declare_african_context(ctx)
+"""
+
+from dataclasses import dataclass, field
+
+VALID_FRAMEWORKS = {"AU_CONTINENTAL_AI_STRATEGY"}
+VALID_RECS = {"EAC", "ECOWAS", "SADC", "COMESA", "AMU", "IGAD", "ECCAS", "CEN-SAD"}
+VALID_SECTORS = {"HEALTH", "AGRICULTURE", "EDUCATION", "PUBLIC_SERVICES", "FINANCE", "ENVIRONMENT"}
+VALID_BENEFICIARIES = {"YOUTH", "WOMEN", "RURAL_COMMUNITIES", "DISABLED", "ELDERLY"}
+VALID_CROSS_BORDER = {"MALABO_CONVENTION", "AU_DATA_POLICY_FRAMEWORK"}
+
+
+@dataclass
+class AfricanContext:
+    """AU Continental AI Strategy context declaration per RFC-029."""
+
+    active: bool
+    governance_framework: str
+    member_state: str
+    rec: str = ""
+    local_first: bool = False
+    ubuntu_principle: bool = False
+    priority_sector: str = ""
+    beneficiary_groups: list[str] = field(default_factory=list)
+    language_context: list[str] = field(default_factory=list)
+    data_sovereignty: dict = field(default_factory=dict)
+    cultural_sensitivity: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        self.validate()
+
+    def validate(self) -> None:
+        """Raise ValueError if context is invalid."""
+        if self.governance_framework not in VALID_FRAMEWORKS:
+            raise ValueError(f"Invalid governance_framework: {self.governance_framework}. Must be one of {VALID_FRAMEWORKS}")
+        if not self.member_state or len(self.member_state) != 2:
+            raise ValueError("member_state must be a 2-letter ISO 3166-1 alpha-2 code")
+        if self.rec and self.rec not in VALID_RECS:
+            raise ValueError(f"Invalid rec: {self.rec}. Must be one of {VALID_RECS}")
+        if self.priority_sector and self.priority_sector not in VALID_SECTORS:
+            raise ValueError(f"Invalid priority_sector: {self.priority_sector}. Must be one of {VALID_SECTORS}")
+        for bg in self.beneficiary_groups:
+            if bg not in VALID_BENEFICIARIES:
+                raise ValueError(f"Invalid beneficiary_group: {bg}. Must be one of {VALID_BENEFICIARIES}")
+        if self.data_sovereignty:
+            cbf = self.data_sovereignty.get("cross_border_framework")
+            if cbf and cbf not in VALID_CROSS_BORDER:
+                raise ValueError(f"Invalid cross_border_framework: {cbf}. Must be one of {VALID_CROSS_BORDER}")
+
+    def to_dict(self) -> dict:
+        """Serialize for protocol transmission."""
+        d = {
+            "active": self.active,
+            "governance_framework": self.governance_framework,
+            "member_state": self.member_state,
+            "local_first": self.local_first,
+            "ubuntu_principle": self.ubuntu_principle,
+        }
+        if self.rec:
+            d["rec"] = self.rec
+        if self.priority_sector:
+            d["priority_sector"] = self.priority_sector
+        if self.beneficiary_groups:
+            d["beneficiary_groups"] = self.beneficiary_groups
+        if self.language_context:
+            d["language_context"] = self.language_context
+        if self.data_sovereignty:
+            d["data_sovereignty"] = self.data_sovereignty
+        if self.cultural_sensitivity:
+            d["cultural_sensitivity"] = self.cultural_sensitivity
+        return d
+
+    def merge(self, request_level: dict) -> "AfricanContext":
+        """Merge request-level context. Escalation only — cannot downgrade."""
+        if not request_level:
+            return self
+        if request_level.get("active") is False:
+            request_level["active"] = True
+        return AfricanContext(
+            active=True,
+            governance_framework=request_level.get("governance_framework", self.governance_framework),
+            member_state=request_level.get("member_state", self.member_state),
+            rec=request_level.get("rec", self.rec),
+            local_first=request_level.get("local_first", self.local_first),
+            ubuntu_principle=request_level.get("ubuntu_principle", self.ubuntu_principle),
+            priority_sector=request_level.get("priority_sector", self.priority_sector),
+            beneficiary_groups=list(set(self.beneficiary_groups + request_level.get("beneficiary_groups", []))),
+            language_context=list(set(self.language_context + request_level.get("language_context", []))),
+            data_sovereignty=request_level.get("data_sovereignty", self.data_sovereignty),
+            cultural_sensitivity=request_level.get("cultural_sensitivity", self.cultural_sensitivity),
+        )