// Current: Agentic Flow Orchestrator
class AgenticFlowOrchestrator {
  async spawnAgent(profile: AgentProfile): Promise<string>;
  async assignTask(agentId: string, task: Task): Promise<void>;
  async getAgentStatus(agentId: string): Promise<AgentStatus>;
}

// Current: Swarm Coordinator
class SwarmCoordinator {
  async initSwarm(topology: Topology): Promise<string>;
  async scaleSwarm(swarmId: string, targetSize: number): Promise<void>;
  async coordinateTask(swarmId: string, task: Task): Promise<Result>;
}

/**
 * Updated Orchestrator with async operations
 */
export class AgenticFlowOrchestrator {
  private jobManager: JobManager;

  /**
   * Spawn agent asynchronously
   * Returns job handle immediately, agent initialization happens in background
   */
  async spawnAgentAsync(profile: AgentProfile): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'agent:spawn',
      profile,
      async (input, onProgress) => {
        onProgress(0);

        // Initialize agent
        const agent = await this.initializeAgent(input);
        onProgress(30);

        // Load capabilities
        await agent.loadCapabilities();
        onProgress(60);

        // Connect to memory store
        await agent.connectMemory();
        onProgress(80);

        // Register with swarm
        await this.registerAgent(agent);
        onProgress(100);

        return {
          agentId: agent.id,
          sessionId: agent.sessionId,
          status: 'ready',
        };
      }
    );
  }

  /**
   * Spawn multiple agents in parallel
   * Returns single job handle for batch operation
   */
  async spawnAgentSwarmAsync(
    profiles: AgentProfile[]
  ): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'agent:spawn-swarm',
      { profiles },
      async (input, onProgress) => {
        const total = input.profiles.length;
        let completed = 0;

        const agents = await Promise.all(
          input.profiles.map(async (profile) => {
            const agent = await this.initializeAgent(profile);
            completed++;
            onProgress((completed / total) * 100);
            return agent;
          })
        );

        return {
          swarmId: generateId(),
          agents: agents.map(a => ({ id: a.id, status: 'ready' })),
          topology: this.detectTopology(agents),
        };
      }
    );
  }

  /**
   * Execute swarm task asynchronously
   * Supports long-running coordination workflows
   */
  async executeSwarmTaskAsync(
    swarmId: string,
    task: Task
  ): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'swarm:execute-task',
      { swarmId, task },
      async (input, onProgress) => {
        const swarm = await this.getSwarm(input.swarmId);

        // Decompose task
        const subtasks = await this.decomposeTask(input.task);
        onProgress(10);

        // Assign to agents
        const assignments = await this.assignSubtasks(swarm, subtasks);
        onProgress(20);

        // Coordinate execution
        let completed = 0;
        const results = await Promise.all(
          assignments.map(async (assignment) => {
            const result = await this.executeAssignment(assignment);
            completed++;
            onProgress(20 + (completed / assignments.length) * 70);
            return result;
          })
        );

        // Synthesize results
        const finalResult = await this.synthesizeResults(results);
        onProgress(95);

        // Update memory
        await this.updateSwarmMemory(swarmId, finalResult);
        onProgress(100);

        return finalResult;
      }
    );
  }
}

/**
 * Updated Swarm Coordinator with async support
 */
export class SwarmCoordinator {
  private jobManager: JobManager;
  private registryClient: RegistryClient;

  /**
   * Initialize swarm with async topology optimization
   */
  async initSwarmAsync(config: SwarmConfig): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'swarm:init',
      config,
      async (input, onProgress) => {
        onProgress(0);

        // Analyze task complexity
        const complexity = await this.analyzeComplexity(input);
        onProgress(10);

        // Select optimal topology
        const topology = await this.selectTopology(complexity);
        onProgress(30);

        // Spawn agents
        const agents = await this.spawnAgents(topology, input);
        onProgress(60);

        // Establish coordination channels
        await this.setupCoordination(agents, topology);
        onProgress(80);

        // Initialize memory synchronization
        await this.initMemorySync(agents);
        onProgress(100);

        return {
          swarmId: generateId(),
          topology: topology.type,
          agentCount: agents.length,
          coordinationChannels: topology.channels,
        };
      }
    );
  }

  /**
   * Auto-scale swarm based on workload
   * Returns job handle for scaling operation
   */
  async autoScaleAsync(
    swarmId: string,
    targetLoad: number
  ): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'swarm:autoscale',
      { swarmId, targetLoad },
      async (input, onProgress) => {
        const swarm = await this.getSwarm(input.swarmId);
        onProgress(10);

        // Calculate optimal size
        const optimalSize = await this.calculateOptimalSize(
          swarm,
          input.targetLoad
        );
        onProgress(30);

        if (optimalSize > swarm.agents.length) {
          // Scale up
          const newAgents = await this.addAgents(
            swarm,
            optimalSize - swarm.agents.length
          );
          onProgress(70);

          await this.integrateAgents(swarm, newAgents);
        } else if (optimalSize < swarm.agents.length) {
          // Scale down
          const toRemove = swarm.agents.slice(optimalSize);
          await this.removeAgents(swarm, toRemove);
          onProgress(70);
        }

        onProgress(100);

        return {
          swarmId: input.swarmId,
          previousSize: swarm.agents.length,
          newSize: optimalSize,
          scalingAction: optimalSize > swarm.agents.length ? 'up' : 'down',
        };
      }
    );
  }

  /**
   * Register swarm capabilities in MCP Registry
   */
  async registerInRegistry(): Promise<void> {
    const metadata: ServerMetadata = {
      name: 'agentic-flow-swarm',
      version: this.version,
      description: 'Multi-agent swarm coordination with adaptive topologies',
      author: 'ruvnet',
      capabilities: {
        tools: true,
        resources: true,
        prompts: false,
        async: true,
        streaming: true,
      },
      categories: ['orchestration', 'swarm', 'coordination'],
      tags: [
        'swarm',
        'multi-agent',
        'coordination',
        'adaptive-topology',
        'load-balancing',
      ],
      transport: ['stdio', 'http'],
      security: {
        authRequired: true,
        authMethods: ['token', 'oauth'],
        piiHandling: 'none',
      },
    };

    await this.registryClient.publishServer(metadata);
  }
}

// Current: AgentDB Client
class AgentDB {
  async createCollection(name: string, schema: Schema): Promise<void>;
  async insert(collection: string, vectors: Vector[]): Promise<void>;
  async search(collection: string, query: Vector, k: number): Promise<Result[]>;
}

/**
 * Updated AgentDB with async operations and code execution pattern
 */
export class AgentDB {
  private jobManager: JobManager;
  private registryClient: RegistryClient;

  /**
   * Index large document corpus asynchronously
   * Processing happens in execution environment, only metadata returned
   */
  async indexCorpusAsync(
    collection: string,
    documents: AsyncIterable<Document>
  ): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'agentdb:index-corpus',
      { collection, documents },
      async (input, onProgress) => {
        let processed = 0;
        let totalVectors = 0;

        onProgress(0);

        // Process documents in batches (execution environment)
        for await (const batch of this.batchDocuments(input.documents, 100)) {
          // Generate embeddings locally (not in model context!)
          const vectors = await this.generateEmbeddings(batch);

          // Insert to AgentDB
          await this.insert(input.collection, vectors);

          processed += batch.length;
          totalVectors += vectors.length;
          onProgress(Math.min(95, (processed / 10000) * 100)); // Estimate progress
        }

        // Build HNSW index
        await this.buildIndex(input.collection);
        onProgress(100);

        return {
          collection: input.collection,
          documentsProcessed: processed,
          vectorsIndexed: totalVectors,
          indexType: 'hnsw',
          indexingTime: Date.now(),
        };
      }
    );
  }

  /**
   * Train neural model asynchronously
   * Training happens in execution environment with progress updates
   */
  async trainModelAsync(
    modelName: string,
    trainingData: TrainingDataset,
    config: TrainingConfig
  ): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'agentdb:train-model',
      { modelName, trainingData, config },
      async (input, onProgress) => {
        const { epochs, batchSize } = input.config;
        let currentEpoch = 0;

        // Initialize model
        const model = await this.initModel(input.modelName, input.config);
        onProgress(5);

        // Training loop (in execution environment)
        for (let epoch = 0; epoch < epochs; epoch++) {
          currentEpoch = epoch + 1;

          // Train one epoch
          const metrics = await model.trainEpoch(
            input.trainingData,
            batchSize
          );

          // Store checkpoint
          await this.saveCheckpoint(model, epoch, metrics);

          // Report progress
          onProgress(5 + ((currentEpoch / epochs) * 90));

          // Log metrics (not sent to model context)
          await this.logMetrics(input.modelName, epoch, metrics);
        }

        // Final evaluation
        const finalMetrics = await model.evaluate();
        onProgress(98);

        // Save final model
        await this.saveModel(model, input.modelName);
        onProgress(100);

        return {
          modelName: input.modelName,
          epochs: currentEpoch,
          finalLoss: finalMetrics.loss,
          finalAccuracy: finalMetrics.accuracy,
          modelPath: `models/${input.modelName}`,
          checkpoints: epochs,
        };
      }
    );
  }

  /**
   * Semantic search with data processing in execution environment
   * Returns only top-k results, not full vector space
   */
  async semanticSearchAsync(
    collection: string,
    query: string,
    options: SearchOptions
  ): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'agentdb:semantic-search',
      { collection, query, options },
      async (input, onProgress) => {
        onProgress(10);

        // Generate query embedding (execution environment)
        const queryVector = await this.generateEmbedding(input.query);
        onProgress(30);

        // Search AgentDB (local processing)
        const results = await this.vectorSearch(
          input.collection,
          queryVector,
          input.options.k || 10
        );
        onProgress(70);

        // Apply filters in execution environment
        const filtered = await this.applyFilters(results, input.options.filters);
        onProgress(85);

        // Rerank if requested
        const reranked = input.options.rerank
          ? await this.rerank(filtered, input.query)
          : filtered;
        onProgress(95);

        // Return only top results (not full dataset)
        const topResults = reranked.slice(0, input.options.k || 10);
        onProgress(100);

        return {
          query: input.query,
          collection: input.collection,
          results: topResults.map(r => ({
            id: r.id,
            score: r.score,
            metadata: r.metadata,
            // Content returned only if explicitly requested
            content: input.options.includeContent ? r.content : undefined,
          })),
          totalMatches: results.length,
          processingTime: Date.now(),
        };
      }
    );
  }

  /**
   * Register AgentDB in MCP Registry
   */
  async registerInRegistry(): Promise<void> {
    const metadata: ServerMetadata = {
      name: 'agentdb',
      version: this.version,
      description: 'High-performance vector database with 150x faster search and 9 RL algorithms',
      author: 'ruvnet',
      capabilities: {
        tools: true,
        resources: true,
        prompts: false,
        async: true,
        streaming: false,
      },
      categories: ['database', 'vector-search', 'machine-learning'],
      tags: [
        'vector-database',
        'semantic-search',
        'embeddings',
        'hnsw',
        'neural-training',
        'reinforcement-learning',
      ],
      transport: ['stdio', 'http'],
      security: {
        authRequired: true,
        authMethods: ['token'],
        piiHandling: 'encrypted',
      },
    };

    await this.registryClient.publishServer(metadata);
  }
}

/**
 * ReasoningBank with async trajectory processing
 */
export class ReasoningBank {
  private agentDB: AgentDB;
  private jobManager: JobManager;

  /**
   * Process and learn from trajectory asynchronously
   * Heavy distillation happens in execution environment
   */
  async processTrajectoryAsync(
    trajectory: Trajectory
  ): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'reasoningbank:process-trajectory',
      trajectory,
      async (input, onProgress) => {
        onProgress(0);

        // Extract action-outcome pairs
        const pairs = await this.extractPairs(input);
        onProgress(20);

        // Generate embeddings (execution environment)
        const embeddings = await this.generateTrajectoryEmbeddings(pairs);
        onProgress(40);

        // Store in AgentDB
        await this.agentDB.insert('trajectories', embeddings);
        onProgress(60);

        // Identify successful patterns
        const patterns = await this.identifyPatterns(pairs);
        onProgress(80);

        // Distill to memory
        const distilled = await this.distillMemory(patterns);
        await this.agentDB.insert('distilled-memory', distilled);
        onProgress(100);

        return {
          trajectoryId: input.id,
          pairsExtracted: pairs.length,
          patternsIdentified: patterns.length,
          memoryDistilled: distilled.length,
          verdict: await this.judgeVerdict(input),
        };
      }
    );
  }

  /**
   * Query reasoning patterns asynchronously
   * Returns only relevant patterns, not full memory
   */
  async queryPatternsAsync(
    query: string,
    context: ExecutionContext
  ): Promise<JobHandle> {
    return this.jobManager.submitJob(
      'reasoningbank:query-patterns',
      { query, context },
      async (input, onProgress) => {
        onProgress(10);

        // Generate query embedding
        const queryVector = await this.generateEmbedding(input.query);
        onProgress(30);

        // Search distilled memory
        const patterns = await this.agentDB.search(
          'distilled-memory',
          queryVector,
          10
        );
        onProgress(60);

        // Filter by context relevance
        const relevant = await this.filterByContext(patterns, input.context);
        onProgress(80);

        // Rank by historical success
        const ranked = await this.rankBySuccess(relevant);
        onProgress(100);

        return {
          query: input.query,
          patterns: ranked.map(p => ({
            id: p.id,
            description: p.metadata.description,
            successRate: p.metadata.successRate,
            usageCount: p.metadata.usageCount,
            // Full pattern details only if explicitly requested
          })),
          totalMatches: patterns.length,
        };
      }
    );
  }
}

// agentic-flow-tools.ts

export const agenticFlowTools: MCPTool[] = [
  // Async agent spawning
  {
    name: 'agentic-flow/spawn-agent:async',
    description: 'Spawn agent asynchronously with progress tracking',
    inputSchema: {
      type: 'object',
      properties: {
        profile: { type: 'object' },
        _async: { type: 'object' },
      },
    },
    handler: async (input, context) => {
      return await context.orchestrator.spawnAgentAsync(input.profile);
    },
  },

  // Async swarm initialization
  {
    name: 'agentic-flow/init-swarm:async',
    description: 'Initialize swarm with adaptive topology selection',
    inputSchema: {
      type: 'object',
      properties: {
        config: { type: 'object' },
        _async: { type: 'object' },
      },
    },
    handler: async (input, context) => {
      return await context.swarmCoordinator.initSwarmAsync(input.config);
    },
  },

  // Async task execution
  {
    name: 'agentic-flow/execute-task:async',
    description: 'Execute swarm task with coordination and progress tracking',
    inputSchema: {
      type: 'object',
      properties: {
        swarmId: { type: 'string' },
        task: { type: 'object' },
        _async: { type: 'object' },
      },
    },
    handler: async (input, context) => {
      return await context.orchestrator.executeSwarmTaskAsync(
        input.swarmId,
        input.task
      );
    },
  },
];

// agentdb-tools.ts

export const agentDBTools: MCPTool[] = [
  // Async corpus indexing
  {
    name: 'agentdb/index-corpus:async',
    description: 'Index large document corpus with progress tracking',
    inputSchema: {
      type: 'object',
      properties: {
        collection: { type: 'string' },
        documents: { type: 'array' },
        _async: { type: 'object' },
      },
    },
    handler: async (input, context) => {
      const docs = async function* () {
        for (const doc of input.documents) {
          yield doc;
        }
      };
      return await context.agentDB.indexCorpusAsync(input.collection, docs());
    },
  },

  // Async model training
  {
    name: 'agentdb/train-model:async',
    description: 'Train neural model with reinforcement learning algorithms',
    inputSchema: {
      type: 'object',
      properties: {
        modelName: { type: 'string' },
        algorithm: {
          type: 'string',
          enum: [
            'decision-transformer',
            'q-learning',
            'sarsa',
            'actor-critic',
            'ppo',
            'dqn',
            'a2c',
            'ddpg',
            'sac',
          ],
        },
        trainingData: { type: 'object' },
        config: { type: 'object' },
        _async: { type: 'object' },
      },
    },
    handler: async (input, context) => {
      return await context.agentDB.trainModelAsync(
        input.modelName,
        input.trainingData,
        input.config
      );
    },
  },

  // Async semantic search
  {
    name: 'agentdb/semantic-search:async',
    description: 'Semantic search with HNSW index (150x faster)',
    inputSchema: {
      type: 'object',
      properties: {
        collection: { type: 'string' },
        query: { type: 'string' },
        options: {
          type: 'object',
          properties: {
            k: { type: 'number', default: 10 },
            filters: { type: 'object' },
            rerank: { type: 'boolean', default: false },
            includeContent: { type: 'boolean', default: false },
          },
        },
        _async: { type: 'object' },
      },
    },
    handler: async (input, context) => {
      return await context.agentDB.semanticSearchAsync(
        input.collection,
        input.query,
        input.options
      );
    },
  },
];

// reasoningbank-tools.ts

export const reasoningBankTools: MCPTool[] = [
  // Async trajectory processing
  {
    name: 'reasoningbank/process-trajectory:async',
    description: 'Process trajectory and extract learning patterns',
    inputSchema: {
      type: 'object',
      properties: {
        trajectory: { type: 'object' },
        _async: { type: 'object' },
      },
    },
    handler: async (input, context) => {
      return await context.reasoningBank.processTrajectoryAsync(
        input.trajectory
      );
    },
  },

  // Async pattern query
  {
    name: 'reasoningbank/query-patterns:async',
    description: 'Query reasoning patterns from distilled memory',
    inputSchema: {
      type: 'object',
      properties: {
        query: { type: 'string' },
        context: { type: 'object' },
        _async: { type: 'object' },
      },
    },
    handler: async (input, context) => {
      return await context.reasoningBank.queryPatternsAsync(
        input.query,
        input.context
      );
    },
  },
];

// tests/e2e/async-workflow.test.ts

describe('Async Workflow - End-to-End', () => {
  describe('Scenario 1: Large-Scale Document Processing', () => {
    it('should index 10,000 documents with 98% token reduction', async () => {
      // 1. Submit indexing job
      const jobHandle = await mcpClient.callTool('agentdb/index-corpus:async', {
        collection: 'research-papers',
        documents: largePaperDataset, // 10,000 papers
        _async: { mode: 'poll' },
      });

      expect(jobHandle.jobHandle).toHaveProperty('jobId');

      // 2. Poll for progress
      let status = await mcpClient.callTool('jobs/status', {
        jobId: jobHandle.jobHandle.jobId,
      });

      while (status.job.status === 'running') {
        await sleep(1000);
        status = await mcpClient.callTool('jobs/status', {
          jobId: jobHandle.jobHandle.jobId,
        });

        console.log(`Progress: ${status.job.progress}%`);
      }

      // 3. Verify completion
      expect(status.job.status).toBe('completed');
      expect(status.job.result.documentsProcessed).toBe(10000);

      // 4. Verify token reduction
      const contextSize = JSON.stringify(jobHandle).length;
      expect(contextSize).toBeLessThan(2000); // < 2KB in context

      // Original dataset would be ~10MB in context
      // Achievement: 99.98% reduction
    });
  });

  describe('Scenario 2: Multi-Agent Swarm Coordination', () => {
    it('should spawn 20 agents and coordinate complex task', async () => {
      // 1. Initialize swarm asynchronously
      const swarmJob = await mcpClient.callTool('agentic-flow/init-swarm:async', {
        config: {
          agentCount: 20,
          topology: 'adaptive',
          taskComplexity: 'high',
        },
        _async: { mode: 'poll' },
      });

      // 2. Poll for swarm initialization
      let swarmStatus = await mcpClient.callTool('jobs/status', {
        jobId: swarmJob.jobHandle.jobId,
      });

      while (swarmStatus.job.status === 'running') {
        await sleep(2000);
        swarmStatus = await mcpClient.callTool('jobs/status', {
          jobId: swarmJob.jobHandle.jobId,
        });
      }

      expect(swarmStatus.job.status).toBe('completed');
      const swarmId = swarmStatus.job.result.swarmId;

      // 3. Execute task on swarm
      const taskJob = await mcpClient.callTool('agentic-flow/execute-task:async', {
        swarmId,
        task: {
          type: 'research-and-implement',
          description: 'Research and implement new feature',
          requirements: [...complexRequirements],
        },
        _async: { mode: 'poll' },
      });

      // 4. Monitor task execution
      let taskStatus = await mcpClient.callTool('jobs/status', {
        jobId: taskJob.jobHandle.jobId,
      });

      const startTime = Date.now();
      while (
        taskStatus.job.status === 'running' &&
        Date.now() - startTime < 600000 // 10 minute timeout
      ) {
        await sleep(5000);
        taskStatus = await mcpClient.callTool('jobs/status', {
          jobId: taskJob.jobHandle.jobId,
        });

        console.log(`Task progress: ${taskStatus.job.progress}%`);
      }

      // 5. Verify completion
      expect(taskStatus.job.status).toBe('completed');
      expect(taskStatus.job.result.subtasksCompleted).toBeGreaterThan(0);
    });
  });

  describe('Scenario 3: Neural Model Training with ReasoningBank', () => {
    it('should train model on trajectories and improve over time', async () => {
      // 1. Process initial trajectories
      const trajectories = generateTestTrajectories(1000);

      const processingJobs = await Promise.all(
        trajectories.map(t =>
          mcpClient.callTool('reasoningbank/process-trajectory:async', {
            trajectory: t,
            _async: { mode: 'fire-and-forget' },
          })
        )
      );

      // 2. Start model training
      const trainingJob = await mcpClient.callTool('agentdb/train-model:async', {
        modelName: 'reasoning-agent-v1',
        algorithm: 'decision-transformer',
        trainingData: {
          source: 'reasoningbank',
          collection: 'trajectories',
        },
        config: {
          epochs: 50,
          batchSize: 32,
          learningRate: 0.001,
        },
        _async: { mode: 'poll' },
      });

      // 3. Monitor training progress
      let trainingStatus = await mcpClient.callTool('jobs/status', {
        jobId: trainingJob.jobHandle.jobId,
      });

      while (trainingStatus.job.status === 'running') {
        await sleep(10000); // Poll every 10 seconds
        trainingStatus = await mcpClient.callTool('jobs/status', {
          jobId: trainingJob.jobHandle.jobId,
        });

        if (trainingStatus.job.progress) {
          console.log(`Training progress: ${trainingStatus.job.progress}%`);
        }
      }

      // 4. Verify training completed
      expect(trainingStatus.job.status).toBe('completed');
      expect(trainingStatus.job.result.epochs).toBe(50);
      expect(trainingStatus.job.result.finalAccuracy).toBeGreaterThan(0.8);

      // 5. Query learned patterns
      const patternJob = await mcpClient.callTool('reasoningbank/query-patterns:async', {
        query: 'How to handle API rate limiting?',
        context: { domain: 'backend-development' },
        _async: { mode: 'wait', timeout: 30000 },
      });

      expect(patternJob.completed).toBe(true);
      expect(patternJob.result.patterns.length).toBeGreaterThan(0);
    });
  });

  describe('Scenario 4: Token Reduction Validation', () => {
    it('should achieve 98%+ token reduction across all operations', async () => {
      // Measure token usage for old pattern (sync, full data in context)
      const oldPattern = {
        documents: largePaperDataset, // 10MB
        agents: [...20agentProfiles], // 500KB
        trainingData: trajectories, // 2MB
      };

      const oldTokens = estimateTokens(JSON.stringify(oldPattern));
      expect(oldTokens).toBeGreaterThan(150000);

      // Measure token usage for new pattern (async, job handles only)
      const newPattern = {
        indexJob: { jobHandle: { jobId: 'uuid', pollUrl: '/jobs/uuid' } },
        swarmJob: { jobHandle: { jobId: 'uuid2', pollUrl: '/jobs/uuid2' } },
        trainingJob: { jobHandle: { jobId: 'uuid3', pollUrl: '/jobs/uuid3' } },
      };

      const newTokens = estimateTokens(JSON.stringify(newPattern));
      expect(newTokens).toBeLessThan(2000);

      // Verify reduction
      const reduction = ((oldTokens - newTokens) / oldTokens) * 100;
      expect(reduction).toBeGreaterThan(98);

      console.log(`Token reduction: ${reduction.toFixed(2)}%`);
      console.log(`Old: ${oldTokens} tokens, New: ${newTokens} tokens`);
    });
  });
});

// tests/benchmarks/async-performance.bench.ts

import { benchmark, describe } from 'vitest';

describe('Async Performance Benchmarks', () => {
  benchmark('spawn-agent:async vs spawn-agent:sync', async () => {
    // Async version
    const asyncStart = Date.now();
    const asyncJob = await orchestrator.spawnAgentAsync(profile);
    const asyncLatency = Date.now() - asyncStart;

    // Sync version (for comparison)
    const syncStart = Date.now();
    const syncResult = await orchestrator.spawnAgent(profile);
    const syncLatency = Date.now() - syncStart;

    console.log(`Async latency: ${asyncLatency}ms`);
    console.log(`Sync latency: ${syncLatency}ms`);
    console.log(`Speedup: ${(syncLatency / asyncLatency).toFixed(2)}x`);
  });

  benchmark('agentdb:index-corpus token reduction', async () => {
    // Measure token usage
    const documents = generateDocuments(10000);

    // Old pattern: Full documents in context
    const oldContextSize = new Blob([JSON.stringify(documents)]).size;

    // New pattern: Job handle only
    const jobHandle = await agentDB.indexCorpusAsync('test', documents);
    const newContextSize = new Blob([JSON.stringify(jobHandle)]).size;

    const reduction = ((oldContextSize - newContextSize) / oldContextSize) * 100;

    console.log(`Old context: ${(oldContextSize / 1024).toFixed(2)} KB`);
    console.log(`New context: ${(newContextSize / 1024).toFixed(2)} KB`);
    console.log(`Reduction: ${reduction.toFixed(2)}%`);
  });
});

npm install
npm install uuid @types/uuid
npm install ioredis @types/ioredis  # For distributed job queue (optional)

// config.json
{
  "async": {
    "enabled": true,
    "maxJobs": 1000,
    "jobTTL": 86400000
  }
}

// Before (Sync)
const agent = await mcpClient.callTool('agents/spawn', {
  type: 'researcher',
  name: 'Research Agent',
});

// After (Async)
const jobHandle = await mcpClient.callTool('agents/spawn:async', {
  type: 'researcher',
  name: 'Research Agent',
  _async: { mode: 'poll' },
});

// Poll for completion
const status = await mcpClient.callTool('jobs/status', {
  jobId: jobHandle.jobHandle.jobId,
});

// Update orchestrator initialization
const orchestrator = new AgenticFlowOrchestrator({
  jobManager: new JobManager(),
  registryClient: new RegistryClient(process.env.MCP_REGISTRY_API_KEY),
});

// Register in MCP Registry
await orchestrator.registerInRegistry();

// Update AgentDB initialization
const agentDB = new AgentDB({
  jobManager: new JobManager(),
  registryClient: new RegistryClient(process.env.MCP_REGISTRY_API_KEY),
});

// Register in MCP Registry
await agentDB.registerInRegistry();