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.
