企业级 AI Agent 混沌工程与故障注入测试实战：应对大模型非确定性、外部接口抖动与级联失效的鲁棒性演练体系

/**
 * 企业级 AI Agent 混沌故障注入引擎核心实现
 * 遵循统一工具调用拦截规范与零业务侵入设计
 */

// 故障注入动作类型枚举
export enum ChaosFaultType {
  LATENCY = 'LATENCY',             // 延迟注入（模拟慢接口）
  SCHEMA_ERROR = 'SCHEMA_ERROR',   // 数据结构畸变注入
  HTTP_ERROR = 'HTTP_ERROR',       // 协议级网络错误注入
  BUSINESS_FAIL = 'BUSINESS_FAIL', // 业务层显式拒绝注入
  TOKEN_SPIKE = 'TOKEN_SPIKE',     // 虚假冗余长文本注入（消耗上下文）
}

// 混沌规则定义接口
export interface ChaosRule {
  id: string;                     // 规则唯一标识
  name: string;                   // 规则名称
  targetTool: string | RegExp;    // 目标工具名称（支持正则匹配）
  faultType: ChaosFaultType;      // 注入的故障类型
  probability: number;            // 触发概率 (0.0 ~ 1.0)
  enabled: boolean;               // 是否启用
  params: {
    delayMs?: number;             // 延迟毫秒数
    httpStatus?: number;          // 模拟的 HTTP 状态码
    errorMessage?: string;        // 错误提示文本
    corruptedPayload?: Record<string, any>; // 畸变数据载荷
  };
}

// 工具执行上下文与结果抽象
export interface ToolExecutionContext {
  agentId: string;
  sessionId: string;
  toolName: string;
  args: Record<string, any>;
  startTime: number;
}

export interface ToolExecutionResult {
  success: boolean;
  data?: any;
  error?: string;
  latencyMs: number;
  isChaosInjected: boolean;
  chaosRuleId?: string;
}

/**
 * 智能体混沌测试拦截器类
 */
export class AgentChaosInterceptor {
  private rules: Map<string, ChaosRule> = new Map();
  private experimentActive: boolean = false;

  constructor(rules: ChaosRule[] = []) {
    rules.forEach(rule => this.rules.set(rule.id, rule));
  }

  /**
   * 启动混沌演练会话
   */
  public startExperiment(): void {
    this.experimentActive = true;
    console.info('[ChaosEngine] 混沌实验已启动，故障注入拦截已处于就绪状态。');
  }

  /**
   * 终止混沌演练会话并恢复所有拦截
   */
  public stopExperiment(): void {
    this.experimentActive = false;
    console.info('[ChaosEngine] 混沌实验已停止，恢复常规安全执行通道。');
  }

  /**
   * 注册或更新故障规则
   */
  public registerRule(rule: ChaosRule): void {
    this.rules.set(rule.id, rule);
  }

  /**
   * 工具调用执行包装器（装饰器/中间件核心）
   */
  public async executeWithChaos(
    ctx: ToolExecutionContext,
    actualToolFn: (args: Record<string, any>) => Promise<any>
  ): Promise<ToolExecutionResult> {
    const startTime = Date.now();

    // 若未激活实验，直接执行正常真实逻辑
    if (!this.experimentActive) {
      const data = await actualToolFn(ctx.args);
      return {
        success: true,
        data,
        latencyMs: Date.now() - startTime,
        isChaosInjected: false,
      };
    }

    // 匹配当前工具的活动混沌规则
    const matchedRule = this.findMatchingRule(ctx.toolName);

    if (matchedRule && Math.random() < matchedRule.probability) {
      console.warn('[ChaosEngine] 命中故障注入规则: [' + matchedRule.name + '] 目标工具: ' + ctx.toolName);
      return await this.applyFault(matchedRule, ctx, actualToolFn);
    }

    // 未命中规则，放行执行正常工具调用
    try {
      const data = await actualToolFn(ctx.args);
      return {
        success: true,
        data,
        latencyMs: Date.now() - startTime,
        isChaosInjected: false,
      };
    } catch (err: any) {
      return {
        success: false,
        error: err.message || '原生工具执行异常',
        latencyMs: Date.now() - startTime,
        isChaosInjected: false,
      };
    }
  }

  /**
   * 执行特定故障注入逻辑
   */
  private async applyFault(
    rule: ChaosRule,
    ctx: ToolExecutionContext,
    actualToolFn: (args: Record<string, any>) => Promise<any>
  ): Promise<ToolExecutionResult> {
    const startTime = Date.now();

    switch (rule.faultType) {
      case ChaosFaultType.LATENCY: {
        const delay = rule.params.delayMs || 3000;
        await new Promise(resolve => setTimeout(resolve, delay));
        const data = await actualToolFn(ctx.args);
        return {
          success: true,
          data,
          latencyMs: Date.now() - startTime,
          isChaosInjected: true,
          chaosRuleId: rule.id,
        };
      }

      case ChaosFaultType.SCHEMA_ERROR: {
        return {
          success: true,
          data: rule.params.corruptedPayload || { _corrupted: true, invalid_token: null },
          latencyMs: Date.now() - startTime,
          isChaosInjected: true,
          chaosRuleId: rule.id,
        };
      }

      case ChaosFaultType.HTTP_ERROR: {
        const status = rule.params.httpStatus || 504;
        return {
          success: false,
          error: 'HTTP ' + status + ': Gateway Timeout or Bad Gateway (Injected Chaos)',
          latencyMs: Date.now() - startTime,
          isChaosInjected: true,
          chaosRuleId: rule.id,
        };
      }

      case ChaosFaultType.BUSINESS_FAIL: {
        return {
          success: false,
          error: rule.params.errorMessage || '业务拒绝：当前工单已被前序审批流程锁定',
          latencyMs: Date.now() - startTime,
          isChaosInjected: true,
          chaosRuleId: rule.id,
        };
      }

      default:
        throw new Error('未知的混沌故障类型: ' + rule.faultType);
    }
  }

  private findMatchingRule(toolName: string): ChaosRule | undefined {
    for (const rule of this.rules.values()) {
      if (!rule.enabled) continue;
      if (typeof rule.targetTool === 'string' && rule.targetTool === toolName) {
        return rule;
      }
      if (rule.targetTool instanceof RegExp && rule.targetTool.test(toolName)) {
        return rule;
      }
    }
    return undefined;
  }
}