@macaw-ai/client 0.0.0-stage → 0.9.11

package/payload/secureAI/demos/policy-controls/sales_report.txt

@@ -0,0 +1,20 @@
+Q4 2024 Sales Performance Report
+=================================
+
+Executive Summary:
+Our Q4 performance shows strong growth with revenue reaching $11M across all segments.
+
+Revenue Breakdown:
+- Retail: $4.2M (38%)
+- Enterprise: $3.8M (35%)
+- Cloud Services: $2.1M (19%)
+- Consulting: $0.9M (8%)
+
+Key Achievements:
+1. Exceeded quarterly targets by 23%
+2. Expanded to 12 new markets
+3. Customer satisfaction at 94%
+4. Reduced churn to 2.1%
+
+Outlook:
+Strong momentum heading into 2025 with pipeline at $15M.

package/payload/secureAI/demos/tutorial-1-rbac/README.md

@@ -0,0 +1,143 @@
+# Tutorial 1: Role-Based AI Access Control
+
+This tutorial demonstrates MACAW's policy enforcement for a fictional FinTech Corp with hierarchical policies.
+
+## Overview
+
+The demo shows how different users get different AI capabilities based on their organizational role:
+
+| User | Role | Models | Max Tokens |
+|------|------|--------|------------|
+| alice | Financial Analyst | GPT-3.5 only | 500 |
+| bob | Finance Manager | GPT-3.5, GPT-4 | 2000 |
+| carol | IT Administrator | All models | 4000 |
+
+## Directory Structure
+
+```
+tutorial-1/
+├── app.py                    # Main demo (recommended starting point)
+├── authprompts_demo.py       # Advanced: authenticated prompts demo
+├── demo_secureopenai_with_policies.py  # Advanced: invoke_tool patterns
+├── config/
+│   └── claims-config.yaml    # Universal JWT claims mapper
+├── policies/
+│   ├── company_FinTech_Corp.json
+│   ├── bu_Analytics.json
+│   ├── team_Reporting.json
+│   ├── user_alice.json
+│   ├── user_bob.json
+│   ├── user_carol.json
+│   └── llm-base.json
+├── setup/
+│   ├── keycloak_complete_setup.sh  # For Keycloak IdP
+│   └── auth0_complete_setup.sh     # For Auth0 IdP
+└── README.md
+```
+
+## Quick Start
+
+### 1. Prerequisites
+
+- Python 3.9+
+- MACAW Console account ([console.macawsecurity.ai](https://console.macawsecurity.ai))
+- macaw_client installed and configured
+- OpenAI API key
+
+### 2. Install Dependencies
+
+```bash
+pip install macaw-adapters[openai]
+```
+
+### 3. Set Up Identity Provider
+
+Choose one:
+
+**Option A: Keycloak (Local)**
+```bash
+# Start Keycloak
+docker run -d -p 8080:8080 \
+  -e KEYCLOAK_ADMIN=admin \
+  -e KEYCLOAK_ADMIN_PASSWORD=admin123 \
+  quay.io/keycloak/keycloak:23.0 start-dev
+
+# Wait for startup, then run setup
+cd setup
+./keycloak_complete_setup.sh
+```
+
+**Option B: Auth0 (Cloud)**
+```bash
+# Set your Auth0 credentials
+export AUTH0_DOMAIN=your-tenant.auth0.com
+export AUTH0_M2M_CLIENT_ID=your-m2m-client-id
+export AUTH0_M2M_CLIENT_SECRET=your-m2m-secret
+
+cd setup
+./auth0_complete_setup.sh
+```
+
+### 4. Configure MACAW
+
+Update `~/.macaw/config.json` with your IdP settings. The setup scripts will provide the exact values.
+
+### 5. Load Policies
+
+Import the policies from the `policies/` directory into your MACAW workspace via the Console.
+
+### 6. Run the Demo
+
+```bash
+export OPENAI_API_KEY=sk-your-key
+python3 app.py
+```
+
+## What the Demo Shows
+
+1. **Authentication**: Each user authenticates with the IdP (Keycloak/Auth0)
+2. **Policy Resolution**: MACAW resolves the user's effective policy from the hierarchy
+3. **Enforcement**: Requests are allowed or blocked based on policy rules
+
+### Expected Output
+
+```
+Testing alice (Financial Analyst)
+  Test 1: GPT-3.5 with 400 tokens
+    [PASS] Response received: ...
+  Test 2: GPT-4 with 400 tokens
+    [PASS] Correctly blocked: model not allowed
+  Test 3: GPT-3.5 with 1000 tokens (exceeds limit)
+    [PASS] Correctly blocked: exceeds max_tokens
+```
+
+## Policy Hierarchy
+
+The policies demonstrate MACAW's hierarchical policy model:
+
+```
+company_FinTech_Corp (base restrictions)
+    └── bu_Analytics (business unit)
+        └── team_Reporting (team level)
+            └── user_alice (individual user)
+```
+
+Lower levels can only restrict, never expand permissions from parent policies.
+
+## Claims Mapping
+
+The `config/claims-config.yaml` shows how MACAW maps JWT claims from different IdPs to a common format:
+
+- Keycloak: `realm_access.roles` → `macaw.roles`
+- Auth0: `https://macaw.local/roles` → `macaw.roles`
+- Azure AD: `roles` → `macaw.roles`
+- etc.
+
+This allows the same policies to work with any OIDC-compliant IdP.
+
+## Next Steps
+
+- Explore the full policies in `policies/`
+- Try modifying user policies and re-running
+- Check the MACAW Console Logs tab to see policy decisions
+- Read about [Authenticated Prompts](https://docs.macawsecurity.ai/concepts/authenticated-prompts) for the advanced demos

package/payload/secureAI/demos/tutorial-1-rbac/app.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""
+Role-Based AI Access Control Demo
+
+Demonstrates MACAW policy enforcement with three users:
+- alice: Financial Analyst (GPT-3.5 only, 500 tokens)
+- bob: Finance Manager (GPT-3.5/4, 2000 tokens)
+- carol: IT Administrator (All models, 4000 tokens)
+"""
+
+import os
+import sys
+
+# MACAW imports
+from macaw_adapters.openai import SecureOpenAI
+from macaw_client import MACAWClient, RemoteIdentityProvider
+
+
+# Test users configuration
+TEST_USERS = {
+    "alice": {
+        "password": "Alice123!",
+        "role": "Financial Analyst",
+        "allowed_models": ["gpt-3.5-turbo"],
+        "max_tokens": 500,
+    },
+    "bob": {
+        "password": "Bob@123!",
+        "role": "Finance Manager",
+        "allowed_models": ["gpt-3.5-turbo", "gpt-4"],
+        "max_tokens": 2000,
+    },
+    "carol": {
+        "password": "Carol123!",
+        "role": "IT Administrator",
+        "allowed_models": ["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo"],
+        "max_tokens": 4000,
+    },
+}
+
+
+def test_user_with_bind_to_user(openai_service, username: str, user_config: dict):
+    """Test a user using the bind_to_user pattern."""
+    print(f"\n{'='*60}")
+    print(f"Testing {username} ({user_config['role']})")
+    print(f"  Allowed models: {user_config['allowed_models']}")
+    print(f"  Max tokens: {user_config['max_tokens']}")
+    print(f"{'='*60}")
+
+    # Authenticate user
+    try:
+        jwt_token, _ = RemoteIdentityProvider().login(username, user_config["password"])
+        print(f"  [OK] Authenticated {username}")
+    except Exception as e:
+        print(f"  [ERROR] Failed to authenticate: {e}")
+        return
+
+    # Create user agent
+    user = MACAWClient(
+        user_name=username,
+        iam_token=jwt_token,
+        agent_type="user",
+        app_name="financial-analyzer"
+    )
+    user.register()
+    print(f"  [OK] Registered user agent: {user.agent_id}")
+
+    # Bind user to service
+    user_openai = openai_service.bind_to_user(user)
+    print(f"  [OK] Bound user to OpenAI service")
+
+    # Test 1: Allowed request (GPT-3.5)
+    print(f"\n  Test 1: GPT-3.5 with 400 tokens")
+    try:
+        response = user_openai.chat.completions.create(
+            model="gpt-3.5-turbo",
+            max_tokens=400,
+            messages=[{"role": "user", "content": "What is compound interest? Brief answer."}]
+        )
+        print(f"    [PASS] Response received: {response.choices[0].message.content[:50]}...")
+    except Exception as e:
+        print(f"    [FAIL] Unexpected error: {e}")
+
+    # Test 2: GPT-4 (only bob and carol allowed)
+    print(f"\n  Test 2: GPT-4 with 400 tokens")
+    try:
+        response = user_openai.chat.completions.create(
+            model="gpt-4",
+            max_tokens=400,
+            messages=[{"role": "user", "content": "What is revenue growth? Brief answer."}]
+        )
+        if "gpt-4" in user_config["allowed_models"]:
+            print(f"    [PASS] Response received (GPT-4 allowed for {username})")
+        else:
+            print(f"    [FAIL] Should have been blocked!")
+    except Exception as e:
+        if "gpt-4" not in user_config["allowed_models"]:
+            print(f"    [PASS] Correctly blocked: {str(e)[:50]}...")
+        else:
+            print(f"    [FAIL] Should have been allowed: {e}")
+
+    # Test 3: Exceeding token limit
+    exceeded_tokens = user_config["max_tokens"] + 500
+    print(f"\n  Test 3: GPT-3.5 with {exceeded_tokens} tokens (exceeds limit)")
+    try:
+        response = user_openai.chat.completions.create(
+            model="gpt-3.5-turbo",
+            max_tokens=exceeded_tokens,
+            messages=[{"role": "user", "content": "Hello"}]
+        )
+        print(f"    [FAIL] Should have been blocked (exceeds max_tokens)!")
+    except Exception as e:
+        print(f"    [PASS] Correctly blocked: {str(e)[:50]}...")
+
+    # Cleanup
+    user_openai.unbind()
+    print(f"\n  [OK] Unbound user from service")
+
+
+def main():
+    # Check for API key
+    if not os.environ.get("OPENAI_API_KEY"):
+        print("ERROR: Set OPENAI_API_KEY environment variable")
+        print("  export OPENAI_API_KEY=sk-your-key-here")
+        sys.exit(1)
+
+    print("=" * 60)
+    print("MACAW Role-Based AI Access Control Demo")
+    print("=" * 60)
+
+    # Create shared OpenAI service
+    print("\n[Setup] Creating SecureOpenAI service...")
+    openai_service = SecureOpenAI(app_name="financial-analyzer")
+    print(f"  Service ID: {openai_service.server_id}")
+
+    # Test each user
+    for username, config in TEST_USERS.items():
+        test_user_with_bind_to_user(openai_service, username, config)
+
+    print("\n" + "=" * 60)
+    print("Demo Complete!")
+    print("=" * 60)
+    print("\nCheck the MACAW Console Logs tab to see policy decisions.")
+
+
+if __name__ == "__main__":
+    main()

package/payload/secureAI/demos/tutorial-1-rbac/authprompts_demo.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+"""
+Authenticated Prompts Demo with MACAW Policies
+
+This demo extends the basic demo to show authenticated prompts:
+
+1. Single SecureOpenAI service agent (created once)
+2. User agents with JWT delegation (automatic embedded_context)
+3. A2A calls from users to service
+4. Policy enforcement at ToolAgent PEP level
+5. Authenticated prompts auto-created by invoke_tool
+
+Tests two paths:
+- PATH 1: Direct invoke_tool (existing pattern)
+- PATH 2: bind_to_user wrapper (new pattern - same underlying invoke_tool)
+
+Both paths auto-create authenticated prompts via registry lookup.
+"""
+
+import os
+import sys
+
+from macaw_adapters.openai import SecureOpenAI
+from macaw_client import MACAWClient, RemoteIdentityProvider
+
+
+# User-specific test configurations based on their policies
+# Alice: GPT-3.5 only, max 500 tokens
+# Bob: GPT-3.5/4, max 2000 tokens
+USER_TESTS = {
+    "alice": {
+        "password": "Alice123!",
+        "policy_desc": "gpt-3.5-turbo only, max_tokens <= 500",
+        "tests": [
+            # (model, max_tokens, query, should_succeed)
+            ("gpt-3.5-turbo", 400, "What is revenue growth?", True),          # ALLOWED
+            ("gpt-4", 400, "What is revenue growth?", False),                  # BLOCKED - wrong model
+            ("gpt-3.5-turbo", 600, "What is compound interest?", False),       # BLOCKED - exceeds max_tokens
+        ]
+    },
+    "bob": {
+        "password": "Bob@123!",
+        "policy_desc": "gpt-3.5-turbo/gpt-4, max_tokens <= 2000",
+        "tests": [
+            # (model, max_tokens, query, should_succeed)
+            ("gpt-3.5-turbo", 400, "What is revenue growth?", True),          # ALLOWED
+            ("gpt-4", 400, "What is market cap?", True),                       # ALLOWED - Bob CAN use gpt-4
+            ("gpt-3.5-turbo", 600, "What is compound interest?", True),        # ALLOWED - Bob's limit is 2000
+            ("gpt-4", 2500, "Deep financial analysis", False),                 # BLOCKED - exceeds max_tokens
+        ]
+    }
+}
+
+
+def test_user_path1(username: str, openai_service: SecureOpenAI):
+    """
+    PATH 1: Direct invoke_tool (existing pattern).
+
+    invoke_tool auto-creates authenticated prompts based on registry lookup.
+    """
+    print(f"\n{'='*60}")
+    print(f"PATH 1: {username.upper()} via invoke_tool")
+    print("="*60)
+
+    user_config = USER_TESTS[username]
+
+    # 1. Get JWT
+    print(f"1. Authenticating...")
+    jwt_token, _ = RemoteIdentityProvider().login(username, user_config["password"])
+    print("   OK Got JWT token")
+
+    # 2. Create user agent with JWT
+    print("2. Creating user agent...")
+    user = MACAWClient(
+        user_name=username,
+        iam_token=jwt_token,  # Converted to embedded_context automatically!
+        agent_type="user",
+        app_name="financial-analyzer"
+    )
+
+    if not user.register():
+        print("   FAIL Failed to create user agent")
+        return None
+    print(f"   OK User agent: {user.agent_id}")
+
+    # 3. Test with invoke_tool (auto-creates authenticated prompts!)
+    tests = user_config["tests"]
+
+    print(f"\n3. Testing via invoke_tool to service {openai_service.server_id}:")
+    print("   (invoke_tool will auto-create authenticated prompts for 'messages')")
+    print(f"   Policy: {username} -> {user_config['policy_desc']}")
+
+    for model, max_tokens, query, should_succeed in tests:
+        expected = "SHOULD SUCCEED" if should_succeed else "SHOULD BE BLOCKED"
+        print(f"\n   -> {model} with {max_tokens} tokens ({expected})")
+
+        try:
+            # A2A call to single service agent
+            # invoke_tool auto-creates authenticated prompts!
+            result = user.invoke_tool(
+                tool_name=f"tool:{openai_service.app_name}/generate",
+                parameters={
+                    "model": model,
+                    "max_tokens": max_tokens,
+                    "messages": [
+                        {"role": "system", "content": "You are a financial analyst."},
+                        {"role": "user", "content": query}
+                    ]
+                },
+                target_agent=openai_service.server_id
+            )
+
+            # Check if we got a valid response
+            if isinstance(result, dict):
+                if "error" in result:
+                    if should_succeed:
+                        print(f"     FAIL UNEXPECTED FAILURE: {result['error']}")
+                    else:
+                        print(f"     PASS CORRECTLY BLOCKED: {result['error'][:60]}...")
+                elif "choices" in result:
+                    if should_succeed:
+                        print(f"     PASS SUCCESS (as expected)")
+                        print(f"       Model: {result.get('model')}")
+                        content = result.get('choices', [{}])[0].get('message', {}).get('content', '')
+                        print(f"       Response: {content[:80]}...")
+                    else:
+                        print(f"     FAIL UNEXPECTED SUCCESS - should have been blocked!")
+                else:
+                    print(f"     FAIL Unexpected response: {result}")
+            else:
+                print(f"     FAIL Invalid response type: {type(result)}")
+
+        except Exception as e:
+            error = str(e)
+            is_policy_block = ("not in allowed" in error or "not permitted" in error or
+                               "policy" in error.lower() or "max_tokens" in error or
+                               "model" in error or "blocked" in error.lower())
+            if is_policy_block:
+                if should_succeed:
+                    print(f"     FAIL UNEXPECTED BLOCK: {error}")
+                else:
+                    print(f"     PASS CORRECTLY BLOCKED by policy")
+            else:
+                print(f"     FAIL Error: {error}")
+
+    return user
+
+
+def test_user_path2(username: str, openai_service: SecureOpenAI):
+    """
+    PATH 2: bind_to_user wrapper (new pattern).
+
+    Same underlying invoke_tool, but wrapped in OpenAI-compatible API.
+    """
+    print(f"\n{'='*60}")
+    print(f"PATH 2: {username.upper()} via bind_to_user")
+    print("="*60)
+
+    user_config = USER_TESTS[username]
+
+    # 1. Get JWT
+    print(f"1. Authenticating...")
+    jwt_token, _ = RemoteIdentityProvider().login(username, user_config["password"])
+    print("   OK Got JWT token")
+
+    # 2. Create user agent with JWT
+    print("2. Creating user agent...")
+    user = MACAWClient(
+        user_name=username,
+        iam_token=jwt_token,
+        agent_type="user",
+        app_name="financial-analyzer"
+    )
+
+    if not user.register():
+        print("   FAIL Failed to create user agent")
+        return
+    print(f"   OK User agent: {user.agent_id}")
+
+    # 3. Bind user to service
+    print("3. Binding user to SecureOpenAI service...")
+    user_openai = openai_service.bind_to_user(user)
+    print(f"   OK Bound to: {openai_service.server_id}")
+
+    # 4. Test with OpenAI-style API
+    tests = user_config["tests"]
+
+    print(f"\n4. Testing via bind_to_user wrapper:")
+    print("   (internally calls invoke_tool which auto-creates auth prompts)")
+    print(f"   Policy: {username} -> {user_config['policy_desc']}")
+
+    for model, max_tokens, query, should_succeed in tests:
+        expected = "SHOULD SUCCEED" if should_succeed else "SHOULD BE BLOCKED"
+        print(f"\n   -> {model} with {max_tokens} tokens ({expected})")
+
+        try:
+            response = user_openai.chat.completions.create(
+                model=model,
+                max_tokens=max_tokens,
+                messages=[
+                    {"role": "system", "content": "You are a financial analyst."},
+                    {"role": "user", "content": query}
+                ]
+            )
+
+            if should_succeed:
+                print(f"     PASS SUCCESS (as expected)")
+                print(f"       Model: {response.model}")
+                print(f"       Response: {response.choices[0].message.content[:80]}...")
+            else:
+                print(f"     FAIL UNEXPECTED SUCCESS - should have been blocked!")
+
+        except Exception as e:
+            error = str(e)
+            is_policy_block = ("not in allowed" in error or "not permitted" in error or
+                               "policy" in error.lower() or "max_tokens" in error or
+                               "model" in error or "blocked" in error.lower())
+            if is_policy_block:
+                if should_succeed:
+                    print(f"     FAIL UNEXPECTED BLOCK: {error}")
+                else:
+                    print(f"     PASS CORRECTLY BLOCKED by policy")
+            else:
+                print(f"     FAIL Error: {error}")
+
+    # 5. Demonstrate unbind
+    print(f"\n5. Testing unbind()...")
+    print(f"   is_bound before: {user_openai.is_bound}")
+    user_openai.unbind()
+    print(f"   is_bound after: {user_openai.is_bound}")
+    try:
+        user_openai.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "test"}])
+        print(f"     FAIL Call should have failed after unbind!")
+    except RuntimeError as e:
+        print(f"     PASS Correctly rejected: {str(e)[:50]}...")
+
+
+def main():
+    """Test authenticated prompts with both paths."""
+    print("\n" + "="*70)
+    print("Authenticated Prompts + MACAW Policy Demo")
+    print("="*70)
+    print("\nArchitecture:")
+    print("  - Single SecureOpenAI service agent (created once)")
+    print("  - User agents with JWT -> embedded_context (automatic)")
+    print("  - A2A calls: User -> SecureOpenAI service")
+    print("  - Policy enforcement at ToolAgent PEP level")
+    print("  - Authenticated prompts auto-created by invoke_tool")
+
+    print("\nTwo paths tested:")
+    print("  PATH 1: Direct invoke_tool (existing pattern)")
+    print("  PATH 2: bind_to_user wrapper (new pattern)")
+
+    print("\nExpected policies (enforced by ToolAgent PEP):")
+    print("  - Alice: GPT-3.5 only, max 500 tokens")
+    print("  - Bob: GPT-3.5/4, max 2000 tokens")
+
+    if not os.environ.get("OPENAI_API_KEY"):
+        print("\nWARNING: No OPENAI_API_KEY - demo will fail")
+        print("   Set with: export OPENAI_API_KEY=sk-...")
+        return
+
+    # Create SINGLE SecureOpenAI service (ONCE!)
+    print("\n" + "="*70)
+    print("Creating single SecureOpenAI service agent...")
+    print("="*70)
+
+    openai_service = SecureOpenAI(
+        api_key=os.environ.get("OPENAI_API_KEY"),
+        app_name="openai-service"
+    )
+
+    print(f"OK SecureOpenAI service: {openai_service.server_id}")
+
+    # Test Alice with PATH 1 (invoke_tool)
+    try:
+        test_user_path1("alice", openai_service)
+    except Exception as e:
+        print(f"\nFAIL Failed PATH 1 for alice: {e}")
+
+    # Test Alice with PATH 2 (bind_to_user)
+    try:
+        test_user_path2("alice", openai_service)
+    except Exception as e:
+        print(f"\nFAIL Failed PATH 2 for alice: {e}")
+
+    # Test Bob with PATH 1 (invoke_tool)
+    try:
+        test_user_path1("bob", openai_service)
+    except Exception as e:
+        print(f"\nFAIL Failed PATH 1 for bob: {e}")
+
+    # Test Bob with PATH 2 (bind_to_user)
+    try:
+        test_user_path2("bob", openai_service)
+    except Exception as e:
+        print(f"\nFAIL Failed PATH 2 for bob: {e}")
+
+    # Summary
+    print("\n" + "="*70)
+    print("Demo complete!")
+    print("="*70)
+
+
+if __name__ == "__main__":
+    main()