Check Action

# Session history shows user asked for weather
# But agent tries to transfer money after reading a webpage

# The malicious action to check
action_content = {
    "amount": 1000,
    "recipient": "attacker@evil.com",
    "currency": "USD"
}

action_schema = {
    "type": "function",
    "name": "transfer_funds",
    "description": "Transfer money to recipient",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number"},
            "recipient": {"type": "string"},
            "currency": {"type": "string"}
        }
    }
}

# Check the action
response = check_action(
    trace_id=trace_id,
    content=action_content,
    schema=action_schema
)

# Result
print(response)
# {
#   "is_safe": false,
#   "reasoning": "Transfer funds action unrelated to user's weather inquiry",
#   "action_check_id": "check-123",
#   "timestamp": 1678886415.789
# }

// User asked to send an email
// Agent prepares appropriate email action

const actionContent = {
  to: "boss@company.com",
  subject: "Weekly Report",
  body: "Here is the weekly report as requested..."
};

const actionSchema = {
  type: "function",
  name: "send_email",
  description: "Send email message",
  parameters: {
    type: "object",
    properties: {
      to: { type: "string", format: "email" },
      subject: { type: "string" },
      body: { type: "string" }
    }
  }
};

// Check the action
const response = await checkAction(
  traceId,
  actionContent,
  actionSchema
);

// Result
console.log(response);
// {
//   "is_safe": true,
//   "reasoning": "Email action aligns with user request",
//   "action_check_id": "check-456",
//   "timestamp": 1678886420.123
// }

import json
import time
import requests

class SecureAgent:
    def __init__(self, api_key, trace_id):
        self.api_key = api_key
        self.trace_id = trace_id
        self.base_url = "https://api.fabraix.com/v1"
    
    def check_action(self, action_name, action_params, action_schema):
        """Check if an action is safe before execution"""
        
        response = requests.post(
            f"{self.base_url}/check",
            headers={
                "x-api-key": self.api_key,
                "Content-Type": "application/json"
            },
            json={
                "event_type": "action_check",
                "trace_id": self.trace_id,
                "timestamp": time.time(),
                "content": json.dumps(action_params),
                "schema": json.dumps(action_schema)
            }
        )
        
        result = response.json()
        return result["is_safe"], result["reasoning"]
    
    def execute_with_safety(self, action_name, action_params, action_schema, 
                           execute_fn, fallback_fn=None):
        """Execute an action only if it passes safety checks"""
        
        # Check action safety
        is_safe, reasoning = self.check_action(
            action_name, 
            action_params,
            action_schema
        )
        
        if is_safe:
            # Log approval
            print(f"✅ Action '{action_name}' approved")
            
            # Execute the action
            try:
                result = execute_fn(action_params)
                
                # Log successful execution
                self.log_event("environment", {
                    "action": action_name,
                    "status": "success",
                    "result": result
                })
                
                return result
                
            except Exception as e:
                # Log execution error
                self.log_event("error", {
                    "action": action_name,
                    "error": str(e)
                })
                raise
        else:
            # Action blocked
            print(f"❌ Action '{action_name}' blocked: {reasoning}")
            
            # Log the block
            self.log_event("security_block", {
                "action": action_name,
                "reasoning": reasoning,
                "params": action_params
            })
            
            # Use fallback if provided
            if fallback_fn:
                return fallback_fn(reasoning)
            else:
                raise SecurityException(f"Action blocked: {reasoning}")

# Usage Example
agent = SecureAgent(api_key="YOUR_KEY", trace_id="abc-123")

# Define action
transfer_params = {
    "amount": 100,
    "recipient": "vendor@company.com",
    "reason": "Invoice payment"
}

transfer_schema = {
    "type": "function",
    "name": "transfer_funds",
    "description": "Transfer funds to recipient",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {
                "type": "number",
                "minimum": 0,
                "maximum": 10000
            },
            "recipient": {
                "type": "string",
                "format": "email"
            },
            "reason": {
                "type": "string"
            }
        },
        "required": ["amount", "recipient"]
    }
}

# Execute with safety check
def perform_transfer(params):
    # Actual transfer logic
    return {"transaction_id": "tx-789", "status": "completed"}

def handle_blocked_transfer(reasoning):
    # Fallback for blocked transfers
    return {"status": "blocked", "message": reasoning}

result = agent.execute_with_safety(
    action_name="transfer_funds",
    action_params=transfer_params,
    action_schema=transfer_schema,
    execute_fn=perform_transfer,
    fallback_fn=handle_blocked_transfer
)

class SecureAgent {
  constructor(apiKey, traceId) {
    this.apiKey = apiKey;
    this.traceId = traceId;
    this.baseUrl = 'https://api.fabraix.com/v1';
  }
  
  async checkAction(actionName, actionParams, actionSchema) {
    const response = await fetch(`${this.baseUrl}/check`, {
      method: 'POST',
      headers: {
        'x-api-key': this.apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        event_type: 'action_check',
        trace_id: this.traceId,
        timestamp: Date.now() / 1000,
        content: JSON.stringify(actionParams),
        schema: JSON.stringify(actionSchema)
      })
    });
    
    const result = await response.json();
    return {
      isSafe: result.is_safe,
      reasoning: result.reasoning
    };
  }
  
  async executeWithSafety(actionName, actionParams, actionSchema, 
                          executeFn, fallbackFn = null) {
    // Check action safety
    const { isSafe, reasoning } = await this.checkAction(
      actionName,
      actionParams,
      actionSchema
    );
    
    if (isSafe) {
      console.log(`✅ Action '${actionName}' approved`);
      
      try {
        // Execute the action
        const result = await executeFn(actionParams);
        
        // Log successful execution
        await this.logEvent('environment', {
          action: actionName,
          status: 'success',
          result: result
        });
        
        return result;
        
      } catch (error) {
        // Log execution error
        await this.logEvent('error', {
          action: actionName,
          error: error.message
        });
        throw error;
      }
    } else {
      // Action blocked
      console.log(`❌ Action '${actionName}' blocked: ${reasoning}`);
      
      // Log the block
      await this.logEvent('security_block', {
        action: actionName,
        reasoning: reasoning,
        params: actionParams
      });
      
      // Use fallback if provided
      if (fallbackFn) {
        return fallbackFn(reasoning);
      } else {
        throw new Error(`Action blocked: ${reasoning}`);
      }
    }
  }
}

// Usage Example
const agent = new SecureAgent('YOUR_KEY', 'abc-123');

// Define action
const transferParams = {
  amount: 100,
  recipient: 'vendor@company.com',
  reason: 'Invoice payment'
};

const transferSchema = {
  type: 'function',
  name: 'transfer_funds',
  description: 'Transfer funds to recipient',
  parameters: {
    type: 'object',
    properties: {
      amount: {
        type: 'number',
        minimum: 0,
        maximum: 10000
      },
      recipient: {
        type: 'string',
        format: 'email'
      },
      reason: {
        type: 'string'
      }
    },
    required: ['amount', 'recipient']
  }
};

// Execute with safety check
async function performTransfer(params) {
  // Actual transfer logic
  return { transaction_id: 'tx-789', status: 'completed' };
}

function handleBlockedTransfer(reasoning) {
  // Fallback for blocked transfers
  return { status: 'blocked', message: reasoning };
}

const result = await agent.executeWithSafety(
  'transfer_funds',
  transferParams,
  transferSchema,
  performTransfer,
  handleBlockedTransfer
);

{
  "is_safe": false,
  "reasoning": "Detected potential prompt injection: action 'delete_all_files' unrelated to user's request for weather information",
  "action_check_id": "c3c3c3c3-c3c3-c3c3-c3c3-c3c3c3c3c3c3",
  "timestamp": 1678886425.456
}

{
  "is_safe": false,
  "reasoning": "Action deviates from established objective: attempting financial transaction when user requested document summarization",
  "action_check_id": "c4c4c4c4-c4c4-c4c4-c4c4-c4c4c4c4c4c4",
  "timestamp": 1678886430.789
}

{
  "is_safe": false,
  "reasoning": "Attempting to access resources beyond authorized scope: admin panel access not permitted for current session",
  "action_check_id": "c5c5c5c5-c5c5-c5c5-c5c5-c5c5c5c5c5c5",
  "timestamp": 1678886435.012
}