@macaw-ai/client 0.0.0-stage → 0.9.10

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()

package/payload/secureAI/demos/tutorial-1-rbac/config/claims-config.yaml

@@ -0,0 +1,152 @@
+# MACAW Identity Bridge Configuration
+# Universal translator for JWT tokens from any identity provider
+
+# MACAW Internal Security Context Model (READ-ONLY - DO NOT MODIFY)
+# These attributes are used by PolicyResolver for hierarchical policy lookup
+internal_model:
+  company: "Organization/company for policy hierarchy (maps from organization claim)"
+  business_unit: "Department or business unit"
+  team: "Team or group"
+  user: "User identifier for user-specific policies"
+  roles: "User roles for role-based access control"
+  email: "User email address"
+
+# Identity Provider Configurations
+# Each provider has detection rules, claim mappings, and role processing
+identity_providers:
+  keycloak:
+    name: "Keycloak (Red Hat SSO)"
+    detection:
+      iss_pattern: "*realms/*"
+      required_claims: ["realm_access"]
+    mappings:
+      # Core identity fields
+      subject_path: "sub"
+      email_path: "email"
+      name_path: "preferred_username"
+      # Organizational hierarchy (organization maps to company)
+      organization_path: "organization"
+      business_unit_path: "business_unit"
+      team_path: "team"
+      # Role extraction from Keycloak structure
+      roles_path: "realm_access.roles"
+    role_filter:
+      allowed: ["analyst", "manager", "admin", "viewer"]
+      case_sensitive: false
+
+  azure_ad:
+    name: "Azure Active Directory"
+    detection:
+      iss_pattern: "https://sts.windows.net/*"
+      required_claims: ["oid", "tid"]
+    mappings:
+      # Core identity fields
+      subject_path: "oid"
+      email_path: "upn"
+      name_path: "name"
+      # Organizational hierarchy (tid maps to company)
+      organization_path: "tid"
+      business_unit_path: "department"
+      team_path: "jobTitle"
+      # Role extraction
+      roles_path: "roles"
+    role_filter:
+      allowed: ["analyst", "manager", "admin", "viewer"]
+      case_sensitive: false
+
+  okta:
+    name: "Okta"
+    detection:
+      iss_pattern: "https://*.okta.com"
+      required_claims: ["groups"]
+    mappings:
+      # Core identity fields
+      subject_path: "sub"
+      email_path: "email"
+      name_path: "name"
+      # Organizational hierarchy (org maps to company)
+      organization_path: "org"
+      business_unit_path: "department"
+      team_path: "division"
+      # Role extraction from groups
+      roles_path: "groups"
+    role_filter:
+      allowed: ["analysts", "managers", "admins", "viewers"]  # Okta often uses plurals
+      case_sensitive: false
+      # Map Okta group names to standard MACAW roles
+      role_mapping:
+        analysts: analyst
+        managers: manager
+        admins: admin
+        viewers: viewer
+
+  auth0:
+    name: "Auth0"
+    detection:
+      iss_pattern: "auth0.com"  # Matches any Auth0 issuer (including regional like .us.auth0.com)
+      required_claims: []  # Auth0 access tokens use namespaced custom claims
+    mappings:
+      # Core identity fields (standard OIDC claims)
+      subject_path: "sub"
+      email_path: "email"  # Standard OIDC claim, not namespaced
+      name_path: "https://macaw.local/username"  # Added by our Action
+      # Organizational hierarchy from Auth0 Action custom claims
+      organization_path: "https://macaw.local/organization"
+      business_unit_path: "https://macaw.local/business_unit"
+      team_path: "https://macaw.local/team"
+      # Role extraction from Auth0 Action custom claims
+      roles_path: "https://macaw.local/roles"
+      # Additional MACAW-specific claims for policy enforcement
+      tier_path: "https://macaw.local/tier"
+      max_tokens_path: "https://macaw.local/max_tokens"
+      allowed_models_path: "https://macaw.local/allowed_models"
+    role_filter:
+      allowed: ["analyst", "manager", "admin", "viewer"]
+      case_sensitive: false
+
+  google_workspace:
+    name: "Google Workspace"
+    detection:
+      iss_pattern: "https://accounts.google.com"
+      required_claims: ["hd"]
+    mappings:
+      # Core identity fields
+      subject_path: "sub"
+      email_path: "email"
+      name_path: "name"
+      # Organizational hierarchy (hd = hosted domain maps to company)
+      organization_path: "hd"
+      business_unit_path: "department"
+      team_path: "team"
+      # Role extraction
+      roles_path: "custom_roles"
+    role_filter:
+      allowed: ["analyst", "manager", "admin", "viewer"]
+      case_sensitive: false
+
+# Default fallback for unknown providers
+default:
+  name: "Generic JWT Provider"
+  mappings:
+    subject_path: "sub"
+    email_path: "email"
+    name_path: "name"
+    organization_path: "org"
+    business_unit_path: "department"
+    team_path: "team"
+    roles_path: "roles"
+  role_filter:
+    allowed: ["analyst", "manager", "admin", "viewer"]
+    case_sensitive: false
+
+# Security and validation settings
+security:
+  require_roles: true
+  require_organization: true
+  max_token_age_minutes: 60
+
+# Audit and logging settings
+audit:
+  log_identity_mapping: true
+  log_role_filtering: true
+  log_provider_detection: true

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

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+SecureOpenAI Demo with MACAW Policies
+
+This demo shows the efficient architecture:
+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
+"""
+
+import os
+import sys
+
+from macaw_adapters.openai import SecureOpenAI
+from macaw_client import MACAWClient, RemoteIdentityProvider
+
+
+# User credentials
+USERS = {
+    "alice": "Alice123!",
+    "bob": "Bob@123!",
+    "carol": "Carol123!",
+}
+
+
+def test_user(username: str, password: str, openai_service: SecureOpenAI):
+    """Test what a user can access."""
+    print(f"\n{'='*60}")
+    print(f"Testing {username.upper()}")
+    print("="*60)
+
+    # 1. Get JWT
+    print(f"1. Authenticating...")
+    jwt_token, _ = RemoteIdentityProvider().login(username, 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
+    print(f"   OK User agent: {user.agent_id}")
+
+    # 3. Test different models and tokens
+    tests = [
+        ("gpt-3.5-turbo", 400, "Quick analysis"),
+        ("gpt-3.5-turbo", 600, "Detailed analysis"),
+        ("gpt-4", 1500, "Deep analysis"),
+    ]
+
+    print(f"\n3. Testing OpenAI access via A2A to service {openai_service.server_id}:")
+    for model, max_tokens, query in tests:
+        print(f"\n   -> {model} with {max_tokens} tokens")
+
+        try:
+            # A2A call to single service agent
+            result = user.invoke_tool(
+                tool_name="tool:openai-service/generate",  # MAPL-compliant resource name
+                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  # Same service for all users!
+            )
+
+            # Check if we got a valid response
+            if isinstance(result, dict):
+                if "error" in result:
+                    print(f"     FAIL Failed: {result['error']}")
+                elif "choices" in result:
+                    print(f"     PASS SUCCESS")
+                    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 response: {result}")
+            else:
+                print(f"     FAIL Invalid response type: {type(result)}")
+
+        except Exception as e:
+            error = str(e)
+            if "not in allowed" in error or "not permitted" in error or "policy" in error.lower():
+                print(f"     BLOCKED by policy")
+            elif "max_tokens" in error:
+                print(f"     BLOCKED: Exceeds token limit")
+            elif "model" in error:
+                print(f"     BLOCKED: Model not allowed")
+            else:
+                print(f"     Error: {error}")
+
+
+def main():
+    """Test all users."""
+    print("\n" + "="*70)
+    print("SecureOpenAI + 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("\nExpected results:")
+    print("  - Alice: GPT-3.5 only, max 500 tokens")
+    print("  - Bob: GPT-3.5/4, max 2000 tokens")
+    print("  - Carol: All models, max 4000 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 each user with same service
+    for username, password in USERS.items():
+        try:
+            test_user(username, password, openai_service)
+        except Exception as e:
+            print(f"\nFAIL Failed to test {username}: {e}")
+
+    print("\n" + "="*70)
+    print("Demo complete!")
+    print("="*70)
+
+
+if __name__ == "__main__":
+    main()

package/payload/secureAI/demos/tutorial-1-rbac/policies/bu_Analytics.json

@@ -0,0 +1,8 @@
+{
+  "description": "Policy for Analytics BU - passthrough to inherit from company",
+  "extends": "company:FinTech Corp",
+  "policy_id": "bu:Analytics",
+  "resources": ["**"],
+  "scope": "global",
+  "version": "1.0"
+}

package/payload/secureAI/demos/tutorial-1-rbac/policies/company_FinTech_Corp.json

@@ -0,0 +1,70 @@
+{
+  "constraints": {
+    "parameters": {
+      "tool:*/complete": {
+        "max_tokens": {
+          "max": 4000
+        },
+        "model": [
+          "gpt-3.5-turbo-instruct",
+          "davinci-002",
+          "babbage-002"
+        ],
+        "temperature": {
+          "max": 2,
+          "min": 0
+        }
+      },
+      "tool:*/embed": {
+        "model": [
+          "text-embedding-ada-002",
+          "text-embedding-3-small",
+          "text-embedding-3-large"
+        ]
+      },
+      "tool:*/generate": {
+        "frequency_penalty": {
+          "max": 2,
+          "min": -2
+        },
+        "max_tokens": {
+          "max": 4000
+        },
+        "model": [
+          "gpt-3.5-turbo",
+          "gpt-4",
+          "claude-3-haiku-20240307",
+          "claude-3-sonnet-20240229",
+          "claude-opus-4-5-20251101"
+        ],
+        "presence_penalty": {
+          "max": 2,
+          "min": -2
+        },
+        "temperature": {
+          "max": 1,
+          "min": 0
+        },
+        "top_p": {
+          "max": 1,
+          "min": 0
+        }
+      }
+    },
+    "rate_limit": 100
+  },
+  "denied_resources": [
+    "*.secret",
+    "*.password",
+    "*.key",
+    "*.pem"
+  ],
+  "description": "Company-wide base policy for FinTech Corp",
+  "policy_id": "company:FinTech Corp",
+  "resources": [
+    "tool:*/generate",
+    "tool:financial_analysis"
+  ],
+  "scope": "global",
+  "version": "1.0"
+}