@sparkleideas/integration 3.0.1

package/src/sona-adapter.ts

@@ -0,0 +1,824 @@
+/**
+ * SONA (Self-Optimizing Neural Architecture) Adapter
+ *
+ * Provides integration with @sparkleideas/agentic-flow's SONA learning system,
+ * enabling real-time adaptation, pattern recognition, and
+ * continuous learning capabilities.
+ *
+ * Performance Targets:
+ * - Real-time mode: ~0.05ms adaptation
+ * - Balanced mode: General purpose learning
+ * - Research mode: Deep exploration with higher accuracy
+ *
+ * @module v3/integration/sona-adapter
+ * @version 3.0.0-alpha.1
+ */
+
+import { EventEmitter } from 'events';
+import type {
+  SONAConfiguration,
+  SONALearningMode,
+  SONATrajectory,
+  SONATrajectoryStep,
+  SONAPattern,
+  SONALearningStats,
+  DEFAULT_SONA_CONFIG,
+} from './types.js';
+
+/**
+ * Interface for @sparkleideas/agentic-flow SONA reference (for delegation)
+ * This allows the adapter to delegate to @sparkleideas/agentic-flow when available
+ */
+interface AgenticFlowSONAReference {
+  setMode(mode: string): Promise<void>;
+  storePattern(params: {
+    pattern: string;
+    solution: string;
+    category: string;
+    confidence: number;
+    metadata?: Record<string, unknown>;
+  }): Promise<string>;
+  findPatterns(query: string, options?: {
+    category?: string;
+    topK?: number;
+    threshold?: number;
+  }): Promise<Array<{
+    id: string;
+    pattern: string;
+    solution: string;
+    category: string;
+    confidence: number;
+    usageCount: number;
+    createdAt: number;
+    lastUsedAt: number;
+    metadata: Record<string, unknown>;
+  }>>;
+  getStats(): Promise<unknown>;
+  beginTrajectory?(params: unknown): Promise<string>;
+  recordStep?(params: unknown): Promise<void>;
+  endTrajectory?(params: unknown): Promise<unknown>;
+}
+
+/**
+ * Mode-specific configurations for SONA learning
+ */
+const MODE_CONFIGS: Record<SONALearningMode, Partial<SONAConfiguration>> = {
+  'real-time': {
+    learningRate: 0.01,
+    similarityThreshold: 0.8,
+    maxPatterns: 5000,
+    consolidationInterval: 1800000, // 30 minutes
+  },
+  'balanced': {
+    learningRate: 0.001,
+    similarityThreshold: 0.7,
+    maxPatterns: 10000,
+    consolidationInterval: 3600000, // 1 hour
+  },
+  'research': {
+    learningRate: 0.0001,
+    similarityThreshold: 0.6,
+    maxPatterns: 50000,
+    consolidationInterval: 7200000, // 2 hours
+  },
+  'edge': {
+    learningRate: 0.005,
+    similarityThreshold: 0.85,
+    maxPatterns: 1000,
+    consolidationInterval: 900000, // 15 minutes
+  },
+  'batch': {
+    learningRate: 0.0005,
+    similarityThreshold: 0.65,
+    maxPatterns: 100000,
+    consolidationInterval: 14400000, // 4 hours
+  },
+};
+
+/**
+ * SONAAdapter - SONA Learning System Integration
+ *
+ * This adapter provides a clean interface to @sparkleideas/agentic-flow's SONA
+ * learning capabilities, including:
+ * - Learning mode selection and auto-switching
+ * - Trajectory tracking for experience replay
+ * - Pattern storage and retrieval
+ * - Memory distillation and consolidation
+ */
+export class SONAAdapter extends EventEmitter {
+  private config: SONAConfiguration;
+  private initialized: boolean = false;
+  private activeTrajectories: Map<string, SONATrajectory> = new Map();
+  private patterns: Map<string, SONAPattern> = new Map();
+  private stats: SONALearningStats;
+  private consolidationTimer: NodeJS.Timeout | null = null;
+  private learningCycleCount: number = 0;
+
+  /**
+   * Reference to @sparkleideas/agentic-flow SONA for delegation (ADR-001)
+   * When set, methods delegate to @sparkleideas/agentic-flow instead of local implementation
+   */
+  private agenticFlowSona: AgenticFlowSONAReference | null = null;
+
+  /**
+   * Indicates if delegation to @sparkleideas/agentic-flow is active
+   */
+  private delegationEnabled: boolean = false;
+
+  constructor(config: Partial<SONAConfiguration> = {}) {
+    super();
+    this.config = this.mergeConfig(config);
+    this.stats = this.initializeStats();
+  }
+
+  /**
+   * Set reference to @sparkleideas/agentic-flow SONA for delegation
+   *
+   * This implements ADR-001: Adopt @sparkleideas/agentic-flow as Core Foundation
+   * When a reference is provided, pattern storage and retrieval
+   * delegate to @sparkleideas/agentic-flow's optimized implementations.
+   *
+   * @param sonaRef - The @sparkleideas/agentic-flow SONA interface reference
+   */
+  setAgenticFlowReference(sonaRef: AgenticFlowSONAReference): void {
+    this.agenticFlowSona = sonaRef;
+    this.delegationEnabled = true;
+    this.emit('delegation-enabled', { target: '@sparkleideas/agentic-flow' });
+  }
+
+  /**
+   * Check if delegation to @sparkleideas/agentic-flow is enabled
+   */
+  isDelegationEnabled(): boolean {
+    return this.delegationEnabled && this.agenticFlowSona !== null;
+  }
+
+  /**
+   * Initialize the SONA adapter
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    this.emit('initializing');
+
+    try {
+      // Apply mode-specific configuration
+      this.applyModeConfig(this.config.mode);
+
+      // Start consolidation timer if enabled
+      if (this.config.consolidationInterval > 0) {
+        this.startConsolidationTimer();
+      }
+
+      this.initialized = true;
+      this.emit('initialized', { mode: this.config.mode });
+    } catch (error) {
+      this.emit('initialization-failed', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Reconfigure the adapter
+   */
+  async reconfigure(config: Partial<SONAConfiguration>): Promise<void> {
+    this.config = this.mergeConfig(config);
+
+    if (config.mode) {
+      this.applyModeConfig(config.mode);
+    }
+
+    // Restart consolidation timer with new interval
+    if (config.consolidationInterval !== undefined) {
+      this.stopConsolidationTimer();
+      if (config.consolidationInterval > 0) {
+        this.startConsolidationTimer();
+      }
+    }
+
+    this.emit('reconfigured', { config: this.config });
+  }
+
+  /**
+   * Get current learning mode
+   */
+  getMode(): SONALearningMode {
+    return this.config.mode;
+  }
+
+  /**
+   * Set learning mode
+   */
+  async setMode(mode: SONALearningMode): Promise<void> {
+    const previousMode = this.config.mode;
+    this.config.mode = mode;
+    this.applyModeConfig(mode);
+
+    this.emit('mode-changed', {
+      previousMode,
+      newMode: mode,
+      config: MODE_CONFIGS[mode]
+    });
+  }
+
+  /**
+   * Begin a new trajectory for task tracking
+   */
+  async beginTrajectory(params: {
+    taskId: string;
+    description?: string;
+    category?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<string> {
+    this.ensureInitialized();
+
+    const trajectoryId = this.generateId('traj');
+    const trajectory: SONATrajectory = {
+      id: trajectoryId,
+      taskId: params.taskId,
+      steps: [],
+      startTime: Date.now(),
+      totalReward: 0,
+      metadata: {
+        description: params.description,
+        category: params.category,
+        ...params.metadata,
+      },
+    };
+
+    this.activeTrajectories.set(trajectoryId, trajectory);
+    this.stats.activeTrajectories++;
+
+    this.emit('trajectory-started', { trajectoryId, taskId: params.taskId });
+    return trajectoryId;
+  }
+
+  /**
+   * Record a step in an active trajectory
+   */
+  async recordTrajectoryStep(params: {
+    trajectoryId: string;
+    stepId?: string;
+    action: string;
+    observation: string;
+    reward: number;
+    embedding?: number[];
+  }): Promise<void> {
+    this.ensureInitialized();
+
+    const trajectory = this.activeTrajectories.get(params.trajectoryId);
+    if (!trajectory) {
+      throw new Error(`Trajectory ${params.trajectoryId} not found`);
+    }
+
+    const step: SONATrajectoryStep = {
+      stepId: params.stepId || this.generateId('step'),
+      action: params.action,
+      observation: params.observation,
+      reward: params.reward,
+      timestamp: Date.now(),
+      embedding: params.embedding,
+    };
+
+    trajectory.steps.push(step);
+    trajectory.totalReward += params.reward;
+
+    this.emit('trajectory-step-recorded', {
+      trajectoryId: params.trajectoryId,
+      step
+    });
+  }
+
+  /**
+   * End a trajectory with final verdict
+   */
+  async endTrajectory(params: {
+    trajectoryId: string;
+    success: boolean;
+    verdict?: 'positive' | 'negative' | 'neutral';
+    reward?: number;
+  }): Promise<SONATrajectory> {
+    this.ensureInitialized();
+
+    const trajectory = this.activeTrajectories.get(params.trajectoryId);
+    if (!trajectory) {
+      throw new Error(`Trajectory ${params.trajectoryId} not found`);
+    }
+
+    // Finalize trajectory
+    trajectory.endTime = Date.now();
+    trajectory.verdict = params.verdict || (params.success ? 'positive' : 'negative');
+
+    if (params.reward !== undefined) {
+      trajectory.totalReward += params.reward;
+    }
+
+    // Remove from active and update stats
+    this.activeTrajectories.delete(params.trajectoryId);
+    this.stats.activeTrajectories--;
+    this.stats.completedTrajectories++;
+
+    // Learn from successful trajectories
+    if (params.success && trajectory.verdict === 'positive') {
+      await this.learnFromTrajectory(trajectory);
+    }
+
+    this.emit('trajectory-completed', {
+      trajectoryId: params.trajectoryId,
+      trajectory
+    });
+
+    return trajectory;
+  }
+
+  /**
+   * Store a learned pattern
+   *
+   * ADR-001: When @sparkleideas/agentic-flow is available, delegates to its optimized
+   * pattern storage which uses AgentDB with HNSW indexing for
+   * 150x-12,500x faster similarity search.
+   */
+  async storePattern(params: {
+    pattern: string;
+    solution: string;
+    category: string;
+    confidence: number;
+    metadata?: Record<string, unknown>;
+  }): Promise<string> {
+    this.ensureInitialized();
+
+    // ADR-001: Delegate to @sparkleideas/agentic-flow when available
+    if (this.isDelegationEnabled() && this.agenticFlowSona) {
+      try {
+        const patternId = await this.agenticFlowSona.storePattern({
+          pattern: params.pattern,
+          solution: params.solution,
+          category: params.category,
+          confidence: Math.max(0, Math.min(1, params.confidence)),
+          metadata: params.metadata,
+        });
+
+        this.stats.totalPatterns++;
+        this.emit('pattern-stored', {
+          patternId,
+          delegated: true,
+          target: '@sparkleideas/agentic-flow',
+        });
+
+        return patternId;
+      } catch (error) {
+        // Log delegation failure and fall back to local implementation
+        this.emit('delegation-failed', {
+          method: 'storePattern',
+          error: (error as Error).message,
+          fallback: 'local',
+        });
+        // Continue with local implementation below
+      }
+    }
+
+    // Local implementation (fallback or when @sparkleideas/agentic-flow not available)
+    const patternId = this.generateId('pat');
+    const storedPattern: SONAPattern = {
+      id: patternId,
+      pattern: params.pattern,
+      solution: params.solution,
+      category: params.category,
+      confidence: Math.max(0, Math.min(1, params.confidence)),
+      usageCount: 0,
+      createdAt: Date.now(),
+      lastUsedAt: Date.now(),
+      metadata: params.metadata || {},
+    };
+
+    // Check if we need to prune patterns
+    if (this.patterns.size >= this.config.maxPatterns) {
+      await this.prunePatterns();
+    }
+
+    this.patterns.set(patternId, storedPattern);
+    this.stats.totalPatterns++;
+    this.updateAverageConfidence();
+
+    this.emit('pattern-stored', { patternId, pattern: storedPattern });
+    return patternId;
+  }
+
+  /**
+   * Find similar patterns to a query
+   *
+   * ADR-001: When @sparkleideas/agentic-flow is available, delegates to its optimized
+   * HNSW-indexed search for 150x-12,500x faster retrieval.
+   */
+  async findSimilarPatterns(params: {
+    query: string;
+    category?: string;
+    topK?: number;
+    threshold?: number;
+  }): Promise<SONAPattern[]> {
+    this.ensureInitialized();
+
+    const topK = params.topK || 5;
+    const threshold = params.threshold ?? this.config.similarityThreshold;
+
+    // ADR-001: Delegate to @sparkleideas/agentic-flow when available for optimized search
+    if (this.isDelegationEnabled() && this.agenticFlowSona) {
+      try {
+        const results = await this.agenticFlowSona.findPatterns(params.query, {
+          category: params.category,
+          topK,
+          threshold,
+        });
+
+        // Map results to SONAPattern format
+        const patterns: SONAPattern[] = results.map(r => ({
+          id: r.id,
+          pattern: r.pattern,
+          solution: r.solution,
+          category: r.category,
+          confidence: r.confidence,
+          usageCount: r.usageCount,
+          createdAt: r.createdAt,
+          lastUsedAt: r.lastUsedAt,
+          metadata: r.metadata,
+        }));
+
+        this.emit('patterns-retrieved', {
+          query: params.query,
+          count: patterns.length,
+          delegated: true,
+          target: '@sparkleideas/agentic-flow',
+        });
+
+        return patterns;
+      } catch (error) {
+        // Log delegation failure and fall back to local implementation
+        this.emit('delegation-failed', {
+          method: 'findSimilarPatterns',
+          error: (error as Error).message,
+          fallback: 'local',
+        });
+        // Continue with local implementation below
+      }
+    }
+
+    // Local implementation (fallback or when @sparkleideas/agentic-flow not available)
+    const results: Array<{ pattern: SONAPattern; score: number }> = [];
+
+    for (const pattern of this.patterns.values()) {
+      // Filter by category if specified
+      if (params.category && pattern.category !== params.category) {
+        continue;
+      }
+
+      // Calculate text similarity (for vector embeddings, use HNSW index)
+      const score = this.calculateSimilarity(params.query, pattern.pattern);
+
+      if (score >= threshold) {
+        results.push({ pattern, score });
+      }
+    }
+
+    // Sort by score and return top K
+    results.sort((a, b) => b.score - a.score);
+    const topResults = results.slice(0, topK).map(r => {
+      // Update usage stats
+      r.pattern.usageCount++;
+      r.pattern.lastUsedAt = Date.now();
+      return r.pattern;
+    });
+
+    this.emit('patterns-retrieved', {
+      query: params.query,
+      count: topResults.length
+    });
+
+    return topResults;
+  }
+
+  /**
+   * Get a pattern by ID
+   */
+  async getPattern(patternId: string): Promise<SONAPattern | null> {
+    this.ensureInitialized();
+    return this.patterns.get(patternId) || null;
+  }
+
+  /**
+   * Delete a pattern
+   */
+  async deletePattern(patternId: string): Promise<boolean> {
+    this.ensureInitialized();
+
+    const deleted = this.patterns.delete(patternId);
+    if (deleted) {
+      this.stats.totalPatterns--;
+      this.updateAverageConfidence();
+      this.emit('pattern-deleted', { patternId });
+    }
+
+    return deleted;
+  }
+
+  /**
+   * Force a learning cycle
+   */
+  async forceLearningCycle(): Promise<void> {
+    this.ensureInitialized();
+
+    this.emit('learning-cycle-starting');
+
+    try {
+      // Consolidate patterns
+      await this.consolidatePatterns();
+
+      // Prune low-confidence patterns
+      await this.prunePatterns();
+
+      // Update statistics
+      this.learningCycleCount++;
+      this.stats.learningCycles = this.learningCycleCount;
+
+      this.emit('learning-cycle-completed', {
+        cycleCount: this.learningCycleCount
+      });
+    } catch (error) {
+      this.emit('learning-cycle-failed', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Get learning statistics
+   */
+  async getStats(): Promise<SONALearningStats> {
+    this.ensureInitialized();
+
+    return {
+      ...this.stats,
+      totalPatterns: this.patterns.size,
+      activeTrajectories: this.activeTrajectories.size,
+      currentMode: this.config.mode,
+      memoryUsage: this.estimateMemoryUsage(),
+    };
+  }
+
+  /**
+   * Export patterns for persistence
+   */
+  async exportPatterns(): Promise<SONAPattern[]> {
+    this.ensureInitialized();
+    return Array.from(this.patterns.values());
+  }
+
+  /**
+   * Import patterns from storage
+   */
+  async importPatterns(patterns: SONAPattern[]): Promise<number> {
+    this.ensureInitialized();
+
+    let imported = 0;
+    for (const pattern of patterns) {
+      if (!this.patterns.has(pattern.id)) {
+        this.patterns.set(pattern.id, pattern);
+        imported++;
+      }
+    }
+
+    this.stats.totalPatterns = this.patterns.size;
+    this.updateAverageConfidence();
+
+    this.emit('patterns-imported', { count: imported });
+    return imported;
+  }
+
+  /**
+   * Shutdown the adapter
+   */
+  async shutdown(): Promise<void> {
+    this.stopConsolidationTimer();
+
+    // Complete any active trajectories
+    for (const [id, trajectory] of this.activeTrajectories) {
+      trajectory.endTime = Date.now();
+      trajectory.verdict = 'neutral';
+    }
+    this.activeTrajectories.clear();
+
+    this.initialized = false;
+    this.emit('shutdown');
+  }
+
+  // ===== Private Methods =====
+
+  private mergeConfig(config: Partial<SONAConfiguration>): SONAConfiguration {
+    return {
+      mode: config.mode || 'balanced',
+      learningRate: config.learningRate ?? 0.001,
+      similarityThreshold: config.similarityThreshold ?? 0.7,
+      maxPatterns: config.maxPatterns ?? 10000,
+      enableTrajectoryTracking: config.enableTrajectoryTracking ?? true,
+      consolidationInterval: config.consolidationInterval ?? 3600000,
+      autoModeSelection: config.autoModeSelection ?? true,
+    };
+  }
+
+  private initializeStats(): SONALearningStats {
+    return {
+      totalPatterns: 0,
+      activeTrajectories: 0,
+      completedTrajectories: 0,
+      averageConfidence: 0,
+      learningCycles: 0,
+      lastConsolidation: Date.now(),
+      memoryUsage: 0,
+      currentMode: this.config.mode,
+    };
+  }
+
+  private applyModeConfig(mode: SONALearningMode): void {
+    const modeConfig = MODE_CONFIGS[mode];
+    if (modeConfig) {
+      Object.assign(this.config, modeConfig);
+    }
+  }
+
+  private startConsolidationTimer(): void {
+    this.consolidationTimer = setInterval(
+      () => this.consolidatePatterns(),
+      this.config.consolidationInterval
+    );
+  }
+
+  private stopConsolidationTimer(): void {
+    if (this.consolidationTimer) {
+      clearInterval(this.consolidationTimer);
+      this.consolidationTimer = null;
+    }
+  }
+
+  private async consolidatePatterns(): Promise<void> {
+    // Merge similar patterns
+    const patternsArray = Array.from(this.patterns.values());
+    const toRemove: Set<string> = new Set();
+
+    for (let i = 0; i < patternsArray.length; i++) {
+      if (toRemove.has(patternsArray[i].id)) continue;
+
+      for (let j = i + 1; j < patternsArray.length; j++) {
+        if (toRemove.has(patternsArray[j].id)) continue;
+
+        const similarity = this.calculateSimilarity(
+          patternsArray[i].pattern,
+          patternsArray[j].pattern
+        );
+
+        if (similarity > 0.95) {
+          // Merge into pattern with higher confidence
+          if (patternsArray[i].confidence >= patternsArray[j].confidence) {
+            patternsArray[i].usageCount += patternsArray[j].usageCount;
+            toRemove.add(patternsArray[j].id);
+          } else {
+            patternsArray[j].usageCount += patternsArray[i].usageCount;
+            toRemove.add(patternsArray[i].id);
+          }
+        }
+      }
+    }
+
+    // Remove merged patterns
+    for (const id of toRemove) {
+      this.patterns.delete(id);
+    }
+
+    this.stats.lastConsolidation = Date.now();
+    this.emit('consolidation-completed', {
+      removed: toRemove.size,
+      remaining: this.patterns.size
+    });
+  }
+
+  private async prunePatterns(): Promise<void> {
+    const maxPatterns = this.config.maxPatterns;
+    if (this.patterns.size <= maxPatterns) {
+      return;
+    }
+
+    // Sort patterns by score (combination of confidence, recency, and usage)
+    const scored = Array.from(this.patterns.entries()).map(([id, pattern]) => ({
+      id,
+      pattern,
+      score: this.calculatePatternScore(pattern),
+    }));
+
+    scored.sort((a, b) => b.score - a.score);
+
+    // Keep only top patterns
+    const toKeep = new Set(scored.slice(0, maxPatterns).map(s => s.id));
+
+    for (const id of this.patterns.keys()) {
+      if (!toKeep.has(id)) {
+        this.patterns.delete(id);
+      }
+    }
+
+    this.emit('patterns-pruned', {
+      removed: scored.length - maxPatterns,
+      remaining: this.patterns.size
+    });
+  }
+
+  private async learnFromTrajectory(trajectory: SONATrajectory): Promise<void> {
+    // Extract patterns from successful trajectory
+    if (trajectory.steps.length === 0) return;
+
+    const pattern = trajectory.steps.map(s => s.action).join(' -> ');
+    const solution = trajectory.steps[trajectory.steps.length - 1].observation;
+
+    await this.storePattern({
+      pattern,
+      solution,
+      category: (trajectory.metadata.category as string) || 'general',
+      confidence: Math.min(1, trajectory.totalReward / trajectory.steps.length),
+      metadata: {
+        trajectoryId: trajectory.id,
+        taskId: trajectory.taskId,
+        stepCount: trajectory.steps.length,
+      },
+    });
+  }
+
+  private calculateSimilarity(a: string, b: string): number {
+    // Jaccard similarity on words (simplified)
+    const wordsA = new Set(a.toLowerCase().split(/\s+/));
+    const wordsB = new Set(b.toLowerCase().split(/\s+/));
+
+    const intersection = new Set([...wordsA].filter(x => wordsB.has(x)));
+    const union = new Set([...wordsA, ...wordsB]);
+
+    return intersection.size / union.size;
+  }
+
+  private calculatePatternScore(pattern: SONAPattern): number {
+    const now = Date.now();
+    const ageMs = now - pattern.createdAt;
+    const recencyMs = now - pattern.lastUsedAt;
+
+    // Normalize age and recency (decay over 30 days)
+    const ageFactor = Math.exp(-ageMs / (30 * 24 * 60 * 60 * 1000));
+    const recencyFactor = Math.exp(-recencyMs / (7 * 24 * 60 * 60 * 1000));
+    const usageFactor = Math.min(1, pattern.usageCount / 100);
+
+    return (
+      pattern.confidence * 0.4 +
+      recencyFactor * 0.3 +
+      usageFactor * 0.2 +
+      ageFactor * 0.1
+    );
+  }
+
+  private updateAverageConfidence(): void {
+    if (this.patterns.size === 0) {
+      this.stats.averageConfidence = 0;
+      return;
+    }
+
+    let total = 0;
+    for (const pattern of this.patterns.values()) {
+      total += pattern.confidence;
+    }
+    this.stats.averageConfidence = total / this.patterns.size;
+  }
+
+  private estimateMemoryUsage(): number {
+    // Rough estimate: 500 bytes per pattern, 1KB per trajectory step
+    const patternBytes = this.patterns.size * 500;
+    const trajectoryBytes = Array.from(this.activeTrajectories.values())
+      .reduce((sum, t) => sum + t.steps.length * 1024, 0);
+
+    return patternBytes + trajectoryBytes;
+  }
+
+  private generateId(prefix: string): string {
+    return `${prefix}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private ensureInitialized(): void {
+    if (!this.initialized) {
+      throw new Error('SONAAdapter not initialized. Call initialize() first.');
+    }
+  }
+}
+
+/**
+ * Create and initialize a SONA adapter
+ */
+export async function createSONAAdapter(
+  config?: Partial<SONAConfiguration>
+): Promise<SONAAdapter> {
+  const adapter = new SONAAdapter(config);
+  await adapter.initialize();
+  return adapter;
+}