API Reference Overview

npm install @agent-governance/node

import {
  AgentMonitor,
  AnthropicAgentMonitor,
  OpenAIAgentMonitor,
  ComplianceEngine
} from '@agent-governance/node';

interface AgentMonitoringConfig {
  apiKey: string;                    // Required: Your governance API key
  organizationId: string;            // Required: Your organization ID
  endpoint?: string;                 // Optional: Custom API endpoint
  environment?: 'production' | 'staging' | 'development';
  batchSize?: number;               // Events per batch (1-1000)
  flushInterval?: number;           // Flush interval in ms (min 100)
  enableComplianceChecks?: boolean; // Enable compliance monitoring
  enableLogging?: boolean;          // Enable SDK logging
  logLevel?: 'debug' | 'info' | 'warn' | 'error';
  retryAttempts?: number;           // Retry attempts for failed requests
  retryDelay?: number;              // Delay between retries in ms
}

await monitor.registerAgent({
  id: string;                       // Unique agent identifier
  name: string;                     // Human-readable agent name
  category: AgentCategory;          // Agent type classification
  specialty?: BankingSpecialty;     // Banking domain specialty
  version: string;                  // Agent version
  llmProvider: string;              // LLM provider name
  model: string;                    // Model name/version
  description: string;              // Agent description
  complianceSettings?: {            // Compliance configuration
    sr11_7_enabled: boolean;
    fair_lending_monitoring: boolean;
    bsa_aml_checks: boolean;
  };
});

// Conversation lifecycle
monitor.trackConversationStart(agentId, sessionId, userId?, metadata?);
monitor.trackUserMessage(agentId, sessionId, content, userId?, metadata?);
monitor.trackAgentResponse(agentId, sessionId, content, metadata?, options?);
monitor.trackConversationEnd(agentId, sessionId, metadata?);

// Tool usage
monitor.trackToolCall(agentId, sessionId, toolName, parameters, result?, executionTime?, metadata?);

// Error tracking
monitor.trackError(agentId, sessionId, error, metadata?);

// Generic event tracking
monitor.track(agentId, event, options?);

// Flush pending events immediately
await monitor.flush();

// Shutdown monitor and flush remaining events
await monitor.shutdown();

type AgentCategory = 'persona' | 'tool_calling' | 'workflow' | 'autonomous';

type BankingSpecialty =
  | 'generalist'
  | 'personal_banking'
  | 'business_banking'
  | 'wealth_management'
  | 'mortgage_lending'
  | 'investment_services'
  | 'fraud_detection'
  | 'customer_service'
  | 'compliance';

type EventType =
  | 'conversation_start'
  | 'user_message'
  | 'agent_response'
  | 'tool_call'
  | 'tool_result'
  | 'error'
  | 'conversation_end';

type ComplianceCategory =
  | 'sr_11_7'           // Model validation requirements
  | 'fair_lending'      // Anti-discrimination monitoring
  | 'bsa_aml'          // Anti-money laundering
  | 'privacy'          // PII protection
  | 'consumer_protection'
  | 'custom';          // Organization-specific rules

try {
  await monitor.registerAgent(agentInfo);
} catch (error) {
  if (error instanceof ValidationError) {
    console.error('Configuration error:', error.details);
  } else if (error instanceof NetworkError) {
    console.error('Network error:', error.message);
  } else {
    console.error('Unexpected error:', error);
  }
}

const monitor = new AgentMonitor({
  apiKey: 'dev-api-key',
  organizationId: 'test-org',
  environment: 'development',
  enableLogging: true,
  logLevel: 'debug',
  batchSize: 10,
  flushInterval: 1000
});

const monitor = new AgentMonitor({
  apiKey: process.env.AGENT_GOVERNANCE_API_KEY,
  organizationId: process.env.AGENT_GOVERNANCE_ORG_ID,
  environment: 'production',
  enableLogging: false,
  batchSize: 500,
  flushInterval: 10000,
  retryAttempts: 5,
  retryDelay: 2000
});

const monitor = new AgentMonitor({
  apiKey: process.env.AGENT_GOVERNANCE_API_KEY,
  organizationId: process.env.AGENT_GOVERNANCE_ORG_ID,
  environment: 'production',
  enableLogging: false,
  enableComplianceChecks: true,
  batchSize: 1000,
  flushInterval: 30000,
  retryAttempts: 3
});

await monitor.registerAgent({
  id: 'banking-agent',
  name: 'Banking Assistant',
  category: 'tool_calling',
  specialty: 'personal_banking',
  // ... other fields
  complianceSettings: {
    sr11_7_enabled: true,
    fair_lending_monitoring: true,
    bsa_aml_checks: true
  }
});

// Add custom compliance rule
monitor.complianceEngine?.addRule({
  id: 'custom-banking-rule',
  name: 'Banking Hours Compliance',
  description: 'Ensures banking hours are mentioned correctly',
  category: 'consumer_protection',
  severity: 'warning',
  isActive: true,
  ruleFunction: (context) => {
    // Custom rule implementation
    return {
      isCompliant: true,
      violations: [],
      riskScore: 0,
      requiresReview: false
    };
  }
});

function createMonitoringMiddleware(monitor, agentId) {
  return async (req, res, next) => {
    const sessionId = req.sessionID || `session-${Date.now()}`;

    req.monitoring = {
      trackUserMessage: (content) =>
        monitor.trackUserMessage(agentId, sessionId, content),
      trackAgentResponse: (content, metadata) =>
        monitor.trackAgentResponse(agentId, sessionId, content, metadata)
    };

    next();
  };
}

function withMonitoring(agentFunction, monitor, agentId) {
  return async (input, sessionId) => {
    const startTime = Date.now();

    try {
      monitor.trackUserMessage(agentId, sessionId, input);
      const result = await agentFunction(input);

      monitor.trackAgentResponse(agentId, sessionId, result, {
        latency: Date.now() - startTime
      });

      return result;
    } catch (error) {
      monitor.trackError(agentId, sessionId, error);
      throw error;
    }
  };
}