@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/mcp/tools/learning-optimization/optimize.ts

@@ -1,772 +0,0 @@
-/**
- * Agentic QE v3 - Learning Optimization MCP Tool
- *
- * qe/learning/optimize - Cross-domain learning and pattern optimization
- *
- * This tool wraps the learning-optimization domain services:
- * - LearningCoordinatorService for pattern learning and experience mining
- * - MetricsOptimizerService for strategy optimization
- * - TransferSpecialistService for knowledge transfer
- */
-
-import { MCPToolBase, MCPToolConfig, MCPToolContext, MCPToolSchema } from '../base.js';
-import { ToolResult } from '../../types.js';
-import { DomainName, AgentId } from '../../../shared/types/index.js';
-import { MemoryBackend, VectorSearchResult } from '../../../kernel/interfaces.js';
-import { TimeRange } from '../../../shared/value-objects/index.js';
-import { LearningCoordinatorService } from '../../../domains/learning-optimization/services/learning-coordinator.js';
-import { MetricsOptimizerService } from '../../../domains/learning-optimization/services/metrics-optimizer.js';
-import { TransferSpecialistService } from '../../../domains/learning-optimization/services/transfer-specialist.js';
-import {
-  Experience,
-  PatternContext,
-  Strategy as DomainStrategy,
-  OptimizationObjective as DomainObjective,
-  Constraint,
-} from '../../../domains/learning-optimization/interfaces.js';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface LearningOptimizeParams {
-  action: 'learn' | 'optimize' | 'transfer' | 'patterns' | 'dashboard';
-  domain?: DomainName;
-  experienceIds?: string[];
-  targetDomain?: DomainName;
-  objective?: OptimizationObjective;
-  [key: string]: unknown;
-}
-
-export interface OptimizationObjective {
-  metric: string;
-  direction: 'maximize' | 'minimize';
-  constraints?: { metric: string; operator: string; value: number }[];
-}
-
-export interface LearningOptimizeResult {
-  action: string;
-  learnResult?: LearnResult;
-  optimizeResult?: OptimizeResult;
-  transferResult?: TransferResult;
-  patternResult?: PatternResult;
-  dashboardResult?: DashboardResult;
-}
-
-export interface LearnResult {
-  experiencesProcessed: number;
-  patternsLearned: number;
-  newPatterns: LearnedPattern[];
-  improvement: number;
-}
-
-export interface LearnedPattern {
-  id: string;
-  type: string;
-  name: string;
-  description: string;
-  confidence: number;
-  usageCount: number;
-  successRate: number;
-}
-
-export interface OptimizeResult {
-  strategiesEvaluated: number;
-  bestStrategy: Strategy;
-  improvement: number;
-  confidence: number;
-  validationResults: ValidationResult[];
-}
-
-export interface Strategy {
-  name: string;
-  parameters: Record<string, unknown>;
-  expectedOutcome: Record<string, number>;
-}
-
-export interface ValidationResult {
-  testId: string;
-  passed: boolean;
-  metrics: Record<string, number>;
-}
-
-export interface TransferResult {
-  sourcePatterns: number;
-  transferredPatterns: number;
-  adaptedPatterns: number;
-  successRate: number;
-  targetDomainUpdated: boolean;
-}
-
-export interface PatternResult {
-  totalPatterns: number;
-  byType: Record<string, number>;
-  byDomain: Record<string, number>;
-  topPatterns: LearnedPattern[];
-  avgConfidence: number;
-  avgSuccessRate: number;
-}
-
-export interface DashboardResult {
-  overallLearningRate: number;
-  totalPatterns: number;
-  totalKnowledge: number;
-  experiencesLast24h: number;
-  topPerformingDomains: DomainName[];
-  learningTrend: TrendPoint[];
-  recentMilestones: Milestone[];
-}
-
-export interface TrendPoint {
-  timestamp: string;
-  metric: string;
-  value: number;
-}
-
-export interface Milestone {
-  name: string;
-  achievedAt: string;
-  domain: DomainName;
-}
-
-// ============================================================================
-// Minimal Memory Backend for Standalone Operation
-// ============================================================================
-
-function createMinimalMemoryBackend(): MemoryBackend {
-  const store = new Map<string, { value: unknown; ttl?: number; created: number }>();
-
-  return {
-    async initialize(): Promise<void> {
-      // No initialization needed
-    },
-    async dispose(): Promise<void> {
-      store.clear();
-    },
-    async get<T>(key: string): Promise<T | undefined> {
-      const entry = store.get(key);
-      if (!entry) return undefined;
-      if (entry.ttl && Date.now() - entry.created > entry.ttl * 1000) {
-        store.delete(key);
-        return undefined;
-      }
-      return entry.value as T;
-    },
-    async set(key: string, value: unknown, options?: { ttl?: number }): Promise<void> {
-      store.set(key, { value, ttl: options?.ttl, created: Date.now() });
-    },
-    async delete(key: string): Promise<boolean> {
-      return store.delete(key);
-    },
-    async has(key: string): Promise<boolean> {
-      const entry = store.get(key);
-      if (!entry) return false;
-      if (entry.ttl && Date.now() - entry.created > entry.ttl * 1000) {
-        store.delete(key);
-        return false;
-      }
-      return true;
-    },
-    async search(pattern: string, limit = 100): Promise<string[]> {
-      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-      const matches: string[] = [];
-      for (const key of store.keys()) {
-        if (regex.test(key)) {
-          matches.push(key);
-          if (matches.length >= limit) break;
-        }
-      }
-      return matches;
-    },
-    async vectorSearch(_embedding: number[], _limit = 10): Promise<VectorSearchResult[]> {
-      return [];
-    },
-    async storeVector(_key: string, _embedding: number[], _metadata?: Record<string, unknown>): Promise<void> {
-      // Minimal implementation - no vector storage
-    },
-  };
-}
-
-// ============================================================================
-// Tool Implementation
-// ============================================================================
-
-export class LearningOptimizeTool extends MCPToolBase<LearningOptimizeParams, LearningOptimizeResult> {
-  readonly config: MCPToolConfig = {
-    name: 'qe/learning/optimize',
-    description: 'Cross-domain learning, pattern recognition, strategy optimization, and knowledge transfer.',
-    domain: 'learning-optimization',
-    schema: LEARNING_OPTIMIZE_SCHEMA,
-    streaming: true,
-    timeout: 300000,
-  };
-
-  private learningCoordinator: LearningCoordinatorService | null = null;
-  private metricsOptimizer: MetricsOptimizerService | null = null;
-  private transferSpecialist: TransferSpecialistService | null = null;
-
-  private getServices(context: MCPToolContext): {
-    learningCoordinator: LearningCoordinatorService;
-    metricsOptimizer: MetricsOptimizerService;
-    transferSpecialist: TransferSpecialistService;
-  } {
-    if (!this.learningCoordinator || !this.metricsOptimizer || !this.transferSpecialist) {
-      const memory = (context as unknown as Record<string, unknown>).memory as MemoryBackend || createMinimalMemoryBackend();
-      this.learningCoordinator = new LearningCoordinatorService(memory);
-      this.metricsOptimizer = new MetricsOptimizerService(memory);
-      this.transferSpecialist = new TransferSpecialistService(memory);
-    }
-    return {
-      learningCoordinator: this.learningCoordinator,
-      metricsOptimizer: this.metricsOptimizer,
-      transferSpecialist: this.transferSpecialist,
-    };
-  }
-
-  async execute(
-    params: LearningOptimizeParams,
-    context: MCPToolContext
-  ): Promise<ToolResult<LearningOptimizeResult>> {
-    const { action, domain, experienceIds, targetDomain, objective } = params;
-
-    try {
-      this.emitStream(context, {
-        status: 'processing',
-        message: `Executing ${action} action`,
-      });
-
-      if (this.isAborted(context)) {
-        return { success: false, error: 'Operation aborted' };
-      }
-
-      let result: LearningOptimizeResult = { action };
-
-      switch (action) {
-        case 'learn':
-          result.learnResult = await this.executeLearn(domain, experienceIds, context);
-          break;
-        case 'optimize':
-          if (!objective) {
-            return { success: false, error: 'Objective is required for optimize action' };
-          }
-          result.optimizeResult = await this.executeOptimize(domain, objective, context);
-          break;
-        case 'transfer':
-          if (!domain || !targetDomain) {
-            return { success: false, error: 'Both domain and targetDomain are required for transfer action' };
-          }
-          result.transferResult = await this.executeTransfer(domain, targetDomain, context);
-          break;
-        case 'patterns':
-          result.patternResult = await this.executePatterns(domain, context);
-          break;
-        case 'dashboard':
-          result.dashboardResult = await this.executeDashboard(context);
-          break;
-        default:
-          return { success: false, error: `Unknown action: ${action}` };
-      }
-
-      this.emitStream(context, {
-        status: 'complete',
-        message: `${action} complete`,
-        progress: 100,
-      });
-
-      return { success: true, data: result };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Learning optimization failed: ${error instanceof Error ? error.message : String(error)}`,
-      };
-    }
-  }
-
-  private async executeLearn(
-    domain: DomainName | undefined,
-    experienceIds: string[] | undefined,
-    context: MCPToolContext
-  ): Promise<LearnResult> {
-    const targetDomain = domain || 'learning-optimization';
-
-    // Check if demo mode is explicitly requested
-    if (this.isDemoMode(context)) {
-      this.markAsDemoData(context, 'Demo mode explicitly requested');
-      return this.getDemoLearnResult(targetDomain);
-    }
-
-    const { learningCoordinator } = this.getServices(context);
-
-    this.emitStream(context, {
-      status: 'learning',
-      message: `Learning from ${experienceIds?.length || 'recent'} experiences`,
-    });
-
-    // Get experiences from memory or mine recent ones
-    const timeRange = TimeRange.lastNDays(7);
-    const mineResult = await learningCoordinator.mineExperiences(targetDomain, timeRange);
-
-    const newPatterns: LearnedPattern[] = [];
-    let experiencesProcessed = 0;
-    let improvement = 0;
-
-    if (mineResult.success) {
-      experiencesProcessed = mineResult.value.experienceCount;
-
-      // Convert mined patterns to result format
-      for (const pattern of mineResult.value.patterns) {
-        newPatterns.push({
-          id: pattern.id,
-          type: pattern.type,
-          name: pattern.name,
-          description: pattern.description,
-          confidence: pattern.confidence,
-          usageCount: pattern.usageCount,
-          successRate: pattern.successRate,
-        });
-      }
-
-      // Calculate improvement based on success rate vs baseline
-      improvement = mineResult.value.successRate > 0.5
-        ? (mineResult.value.successRate - 0.5) * 20 // Scale to percentage
-        : 0;
-    }
-
-    // If specific experience IDs provided, record them
-    if (experienceIds && experienceIds.length > 0) {
-      experiencesProcessed = experienceIds.length;
-    }
-
-    // If no patterns were learned, return empty result (not fake data)
-    // This is a valid state - no patterns discovered yet
-    if (newPatterns.length === 0) {
-      this.markAsRealData(); // Still real data, just empty
-      return {
-        experiencesProcessed,
-        patternsLearned: 0,
-        newPatterns: [],
-        improvement: 0,
-      };
-    }
-
-    // Mark as real data - we have actual learning results
-    this.markAsRealData();
-
-    return {
-      experiencesProcessed,
-      patternsLearned: newPatterns.length,
-      newPatterns,
-      improvement,
-    };
-  }
-
-  /**
-   * Return demo learn results when no real data available.
-   * Only used when demoMode is explicitly requested or as fallback with warning.
-   */
-  private getDemoLearnResult(domain: DomainName): LearnResult {
-    return {
-      experiencesProcessed: 150,
-      patternsLearned: 12,
-      newPatterns: [
-        {
-          id: `pattern-${domain}-001`,
-          type: 'optimization',
-          name: 'Parallel Execution Pattern',
-          description: `Optimal parallelism settings discovered for ${domain}`,
-          confidence: 0.92,
-          usageCount: 45,
-          successRate: 0.87,
-        },
-        {
-          id: `pattern-${domain}-002`,
-          type: 'retry',
-          name: 'Exponential Backoff Pattern',
-          description: 'Effective retry strategy for flaky operations',
-          confidence: 0.88,
-          usageCount: 32,
-          successRate: 0.91,
-        },
-        {
-          id: `pattern-${domain}-003`,
-          type: 'caching',
-          name: 'Result Caching Pattern',
-          description: 'Cache frequently computed results for faster access',
-          confidence: 0.85,
-          usageCount: 28,
-          successRate: 0.82,
-        },
-      ],
-      improvement: 15.5,
-    };
-  }
-
-  private async executeOptimize(
-    domain: DomainName | undefined,
-    objective: OptimizationObjective,
-    context: MCPToolContext
-  ): Promise<OptimizeResult> {
-    const { learningCoordinator, metricsOptimizer } = this.getServices(context);
-
-    this.emitStream(context, {
-      status: 'optimizing',
-      message: `Optimizing for ${objective.metric}`,
-    });
-
-    // Get recent experiences for optimization
-    const targetDomain = domain || 'learning-optimization';
-    const timeRange = TimeRange.lastNDays(30);
-    const mineResult = await learningCoordinator.mineExperiences(targetDomain, timeRange);
-
-    // Build experiences array from mined data
-    const experiences: Experience[] = [];
-    if (mineResult.success && mineResult.value.experienceCount > 0) {
-      // Mine experiences provides insights, so we construct dummy experiences for optimization
-      // Real implementation would fetch actual experiences from memory
-      const dummyAgentId: AgentId = { value: 'optimizer-agent', domain: targetDomain, type: 'optimizer' };
-      for (let i = 0; i < Math.min(mineResult.value.experienceCount, 20); i++) {
-        experiences.push({
-          id: `exp-${i}`,
-          agentId: dummyAgentId,
-          domain: targetDomain,
-          action: 'optimize',
-          state: { context: {}, metrics: {} },
-          result: {
-            success: Math.random() > 0.3,
-            outcome: { [objective.metric]: 70 + Math.random() * 30 },
-            duration: 1000 + Math.random() * 5000,
-          },
-          reward: mineResult.value.avgReward,
-          timestamp: new Date(),
-        });
-      }
-    }
-
-    // Create current strategy
-    const currentStrategy: DomainStrategy = {
-      name: `${targetDomain}-current`,
-      parameters: {
-        parallelism: 4,
-        retryCount: 3,
-        timeout: 30000,
-      },
-      expectedOutcome: { [objective.metric]: 70 },
-    };
-
-    // Convert objective to domain type, properly cast constraints
-    const domainConstraints: Constraint[] = (objective.constraints || []).map(c => ({
-      metric: c.metric,
-      operator: c.operator as 'lt' | 'gt' | 'lte' | 'gte' | 'eq',
-      value: c.value,
-    }));
-    const domainObjective: DomainObjective = {
-      metric: objective.metric,
-      direction: objective.direction,
-      constraints: domainConstraints,
-    };
-
-    // Run optimization if we have enough experiences
-    let bestStrategy: Strategy = currentStrategy;
-    let improvement = 0;
-    let confidence = 0.5;
-    let validationResults: ValidationResult[] = [];
-
-    if (experiences.length >= 20) {
-      const optimizeResult = await metricsOptimizer.optimizeStrategy(
-        currentStrategy,
-        domainObjective,
-        experiences
-      );
-
-      if (optimizeResult.success) {
-        bestStrategy = {
-          name: optimizeResult.value.optimizedStrategy.name,
-          parameters: optimizeResult.value.optimizedStrategy.parameters,
-          expectedOutcome: optimizeResult.value.optimizedStrategy.expectedOutcome,
-        };
-        improvement = optimizeResult.value.improvement * 100; // Convert to percentage
-        confidence = optimizeResult.value.confidence;
-        validationResults = optimizeResult.value.validationResults;
-      }
-    } else {
-      // Not enough data - recommend default strategy
-      const contextForRecommendation: PatternContext = {
-        tags: [targetDomain, objective.metric],
-      };
-      const recommendResult = await metricsOptimizer.recommendStrategy(contextForRecommendation);
-      if (recommendResult.success) {
-        bestStrategy = {
-          name: recommendResult.value.name,
-          parameters: recommendResult.value.parameters,
-          expectedOutcome: recommendResult.value.expectedOutcome,
-        };
-      }
-    }
-
-    return {
-      strategiesEvaluated: experiences.length > 0 ? Math.min(experiences.length, 12) : 1,
-      bestStrategy,
-      improvement,
-      confidence,
-      validationResults,
-    };
-  }
-
-  private async executeTransfer(
-    sourceDomain: DomainName,
-    targetDomain: DomainName,
-    context: MCPToolContext
-  ): Promise<TransferResult> {
-    const { transferSpecialist } = this.getServices(context);
-
-    this.emitStream(context, {
-      status: 'transferring',
-      message: `Transferring knowledge from ${sourceDomain} to ${targetDomain}`,
-    });
-
-    // Query knowledge from source domain
-    const queryResult = await transferSpecialist.queryKnowledge({
-      domain: sourceDomain,
-      minRelevance: 0.5,
-      limit: 50,
-    });
-
-    let sourcePatterns = 0;
-    let transferredPatterns = 0;
-    let adaptedPatterns = 0;
-    let totalRelevance = 0;
-
-    if (queryResult.success) {
-      sourcePatterns = queryResult.value.length;
-
-      // Transfer each piece of knowledge to target domain
-      for (const knowledge of queryResult.value) {
-        const transferResult = await transferSpecialist.transferKnowledge(
-          knowledge,
-          targetDomain
-        );
-
-        if (transferResult.success) {
-          transferredPatterns++;
-          totalRelevance += transferResult.value.relevanceScore;
-
-          // Count as adapted if relevance changed significantly
-          if (Math.abs(transferResult.value.relevanceScore - knowledge.relevanceScore) > 0.1) {
-            adaptedPatterns++;
-          }
-        }
-      }
-    }
-
-    const successRate = sourcePatterns > 0
-      ? transferredPatterns / sourcePatterns
-      : 0;
-
-    return {
-      sourcePatterns,
-      transferredPatterns,
-      adaptedPatterns,
-      successRate,
-      targetDomainUpdated: transferredPatterns > 0,
-    };
-  }
-
-  private async executePatterns(
-    domain: DomainName | undefined,
-    context: MCPToolContext
-  ): Promise<PatternResult> {
-    const { learningCoordinator } = this.getServices(context);
-
-    this.emitStream(context, {
-      status: 'analyzing',
-      message: `Analyzing patterns${domain ? ` for ${domain}` : ''}`,
-    });
-
-    // Get pattern statistics from the real service
-    const statsResult = await learningCoordinator.getPatternStats(domain);
-
-    if (!statsResult.success) {
-      // Return empty stats on failure
-      return {
-        totalPatterns: 0,
-        byType: {},
-        byDomain: {},
-        topPatterns: [],
-        avgConfidence: 0,
-        avgSuccessRate: 0,
-      };
-    }
-
-    const stats = statsResult.value;
-
-    // Convert top patterns to result format
-    const topPatterns: LearnedPattern[] = stats.topPatterns.map(p => ({
-      id: p.id,
-      type: p.type,
-      name: p.name,
-      description: p.description,
-      confidence: p.confidence,
-      usageCount: p.usageCount,
-      successRate: p.successRate,
-    }));
-
-    return {
-      totalPatterns: stats.totalPatterns,
-      byType: stats.byType,
-      byDomain: stats.byDomain,
-      topPatterns,
-      avgConfidence: stats.avgConfidence,
-      avgSuccessRate: stats.avgSuccessRate,
-    };
-  }
-
-  private async executeDashboard(context: MCPToolContext): Promise<DashboardResult> {
-    const { learningCoordinator, transferSpecialist } = this.getServices(context);
-
-    this.emitStream(context, {
-      status: 'aggregating',
-      message: 'Aggregating learning metrics',
-    });
-
-    // Get pattern stats across all domains
-    const statsResult = await learningCoordinator.getPatternStats();
-
-    // Get knowledge count
-    const knowledgeResult = await transferSpecialist.queryKnowledge({
-      minRelevance: 0,
-      limit: 1000,
-    });
-
-    // Get recent experiences (last 24h)
-    const recentTimeRange = TimeRange.lastNDays(1);
-    const domains: DomainName[] = [
-      'test-generation', 'test-execution', 'coverage-analysis',
-      'quality-assessment', 'defect-intelligence', 'learning-optimization'
-    ];
-
-    let experiencesLast24h = 0;
-    const domainPerformance: { domain: DomainName; successRate: number }[] = [];
-
-    for (const domain of domains) {
-      const mineResult = await learningCoordinator.mineExperiences(domain, recentTimeRange);
-      if (mineResult.success) {
-        experiencesLast24h += mineResult.value.experienceCount;
-        if (mineResult.value.experienceCount > 0) {
-          domainPerformance.push({
-            domain,
-            successRate: mineResult.value.successRate,
-          });
-        }
-      }
-    }
-
-    // Calculate top performing domains
-    domainPerformance.sort((a, b) => b.successRate - a.successRate);
-    const topPerformingDomains = domainPerformance
-      .slice(0, 3)
-      .map(d => d.domain);
-
-    // Calculate overall learning rate from pattern stats
-    const totalPatterns = statsResult.success ? statsResult.value.totalPatterns : 0;
-    const avgSuccessRate = statsResult.success ? statsResult.value.avgSuccessRate : 0;
-    const overallLearningRate = avgSuccessRate;
-
-    // Generate learning trend from weekly pattern mining
-    const learningTrend: TrendPoint[] = [];
-    const now = new Date();
-    for (let i = 6; i >= 0; i--) {
-      const dayStart = new Date(now.getTime() - i * 24 * 60 * 60 * 1000);
-      const dayEnd = new Date(dayStart.getTime() + 24 * 60 * 60 * 1000);
-      const dayRange = TimeRange.create(dayStart, dayEnd);
-
-      let dayPatterns = 0;
-      for (const domain of domains.slice(0, 3)) {
-        const dayResult = await learningCoordinator.mineExperiences(domain, dayRange);
-        if (dayResult.success) {
-          dayPatterns += dayResult.value.patterns.length;
-        }
-      }
-
-      learningTrend.push({
-        timestamp: dayStart.toISOString(),
-        metric: 'patterns-learned',
-        value: dayPatterns,
-      });
-    }
-
-    // Generate milestones based on actual achievements
-    const recentMilestones: Milestone[] = [];
-    if (totalPatterns >= 100) {
-      recentMilestones.push({
-        name: `Reached ${Math.floor(totalPatterns / 50) * 50} patterns`,
-        achievedAt: new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000).toISOString(),
-        domain: 'learning-optimization',
-      });
-    }
-    if (avgSuccessRate >= 0.8) {
-      recentMilestones.push({
-        name: `${Math.round(avgSuccessRate * 100)}% pattern success rate`,
-        achievedAt: new Date(now.getTime() - 5 * 24 * 60 * 60 * 1000).toISOString(),
-        domain: topPerformingDomains[0] || 'learning-optimization',
-      });
-    }
-
-    return {
-      overallLearningRate,
-      totalPatterns,
-      totalKnowledge: knowledgeResult.success ? knowledgeResult.value.length : 0,
-      experiencesLast24h,
-      topPerformingDomains: topPerformingDomains.length > 0 ? topPerformingDomains : ['test-generation'],
-      learningTrend,
-      recentMilestones,
-    };
-  }
-}
-
-// ============================================================================
-// Schema
-// ============================================================================
-
-const LEARNING_OPTIMIZE_SCHEMA: MCPToolSchema = {
-  type: 'object',
-  properties: {
-    action: {
-      type: 'string',
-      description: 'Learning action to perform',
-      enum: ['learn', 'optimize', 'transfer', 'patterns', 'dashboard'],
-    },
-    domain: {
-      type: 'string',
-      description: 'Source domain for learning/optimization',
-      enum: [
-        'test-generation', 'test-execution', 'coverage-analysis', 'quality-assessment',
-        'defect-intelligence', 'requirements-validation', 'code-intelligence',
-        'security-compliance', 'contract-testing', 'visual-accessibility',
-        'chaos-resilience', 'learning-optimization',
-      ],
-    },
-    experienceIds: {
-      type: 'array',
-      description: 'Specific experience IDs to learn from',
-      items: { type: 'string', description: 'Experience ID' },
-    },
-    targetDomain: {
-      type: 'string',
-      description: 'Target domain for knowledge transfer',
-    },
-    objective: {
-      type: 'object',
-      description: 'Optimization objective',
-      properties: {
-        metric: { type: 'string', description: 'Metric to optimize' },
-        direction: { type: 'string', description: 'maximize or minimize', enum: ['maximize', 'minimize'] },
-        constraints: {
-          type: 'array',
-          description: 'Optimization constraints',
-          items: { type: 'object', description: 'Constraint' },
-        },
-      },
-    },
-  },
-  required: ['action'],
-};