agentic-flow 1.10.1 → 2.0.0-alpha

package/agentic-flow/dist/config/quic.js

@@ -0,0 +1,207 @@
+// QUIC Configuration Schema
+// Validates and manages QUIC transport configuration
+import { logger } from '../utils/logger.js';
+/**
+ * Default QUIC configuration
+ */
+export const DEFAULT_QUIC_CONFIG = {
+    enabled: false,
+    autoDetect: true,
+    fallbackToHttp2: true,
+    // Connection settings
+    host: '0.0.0.0',
+    port: 4433,
+    serverHost: 'localhost',
+    serverPort: 4433,
+    verifyPeer: true,
+    // TLS certificates
+    certPath: './certs/cert.pem',
+    keyPath: './certs/key.pem',
+    // Connection pool
+    maxConnections: 100,
+    connectionTimeout: 30000,
+    idleTimeout: 60000,
+    // Stream multiplexing
+    maxConcurrentStreams: 100,
+    streamTimeout: 30000,
+    // Performance tuning
+    initialCongestionWindow: 10,
+    maxDatagramSize: 1200,
+    enableEarlyData: true,
+    // Health check
+    healthCheck: {
+        enabled: true,
+        interval: 30000, // 30 seconds
+        timeout: 5000 // 5 seconds
+    },
+    // Monitoring
+    monitoring: {
+        enabled: true,
+        logInterval: 60000 // 1 minute
+    }
+};
+/**
+ * Load QUIC configuration from environment and config file
+ */
+export function loadQuicConfig(overrides = {}) {
+    const config = {
+        ...DEFAULT_QUIC_CONFIG,
+        ...overrides
+    };
+    // Environment variable overrides
+    if (process.env.AGENTIC_FLOW_ENABLE_QUIC !== undefined) {
+        config.enabled = process.env.AGENTIC_FLOW_ENABLE_QUIC === 'true';
+    }
+    if (process.env.QUIC_PORT) {
+        config.port = parseInt(process.env.QUIC_PORT);
+    }
+    if (process.env.QUIC_HOST) {
+        config.host = process.env.QUIC_HOST;
+    }
+    if (process.env.QUIC_SERVER_HOST) {
+        config.serverHost = process.env.QUIC_SERVER_HOST;
+    }
+    if (process.env.QUIC_SERVER_PORT) {
+        config.serverPort = parseInt(process.env.QUIC_SERVER_PORT);
+    }
+    if (process.env.QUIC_CERT_PATH) {
+        config.certPath = process.env.QUIC_CERT_PATH;
+    }
+    if (process.env.QUIC_KEY_PATH) {
+        config.keyPath = process.env.QUIC_KEY_PATH;
+    }
+    if (process.env.QUIC_MAX_CONNECTIONS) {
+        config.maxConnections = parseInt(process.env.QUIC_MAX_CONNECTIONS);
+    }
+    if (process.env.QUIC_MAX_STREAMS) {
+        config.maxConcurrentStreams = parseInt(process.env.QUIC_MAX_STREAMS);
+    }
+    if (process.env.QUIC_VERIFY_PEER !== undefined) {
+        config.verifyPeer = process.env.QUIC_VERIFY_PEER === 'true';
+    }
+    // Validate configuration
+    validateQuicConfig(config);
+    logger.info('QUIC configuration loaded', {
+        enabled: config.enabled,
+        host: config.host,
+        port: config.port,
+        maxConnections: config.maxConnections,
+        healthCheckEnabled: config.healthCheck.enabled
+    });
+    return config;
+}
+/**
+ * Validate QUIC configuration
+ */
+export function validateQuicConfig(config) {
+    const errors = [];
+    // Port validation
+    if (config.port < 1 || config.port > 65535) {
+        errors.push(`Invalid port: ${config.port}. Must be between 1 and 65535.`);
+    }
+    if (config.serverPort < 1 || config.serverPort > 65535) {
+        errors.push(`Invalid server port: ${config.serverPort}. Must be between 1 and 65535.`);
+    }
+    // Connection limits
+    if (config.maxConnections < 1) {
+        errors.push(`Invalid maxConnections: ${config.maxConnections}. Must be at least 1.`);
+    }
+    if (config.maxConcurrentStreams < 1) {
+        errors.push(`Invalid maxConcurrentStreams: ${config.maxConcurrentStreams}. Must be at least 1.`);
+    }
+    // Timeouts
+    if (config.connectionTimeout < 1000) {
+        errors.push(`Invalid connectionTimeout: ${config.connectionTimeout}. Must be at least 1000ms.`);
+    }
+    if (config.idleTimeout < 1000) {
+        errors.push(`Invalid idleTimeout: ${config.idleTimeout}. Must be at least 1000ms.`);
+    }
+    if (config.streamTimeout < 1000) {
+        errors.push(`Invalid streamTimeout: ${config.streamTimeout}. Must be at least 1000ms.`);
+    }
+    // Performance tuning
+    if (config.initialCongestionWindow < 1) {
+        errors.push(`Invalid initialCongestionWindow: ${config.initialCongestionWindow}. Must be at least 1.`);
+    }
+    if (config.maxDatagramSize < 1200 || config.maxDatagramSize > 65527) {
+        errors.push(`Invalid maxDatagramSize: ${config.maxDatagramSize}. Must be between 1200 and 65527.`);
+    }
+    // TLS certificates (warn only)
+    if (config.enabled && config.verifyPeer) {
+        const fs = require('fs');
+        if (!fs.existsSync(config.certPath)) {
+            logger.warn(`Certificate not found: ${config.certPath}`);
+        }
+        if (!fs.existsSync(config.keyPath)) {
+            logger.warn(`Private key not found: ${config.keyPath}`);
+        }
+    }
+    if (errors.length > 0) {
+        const errorMessage = `QUIC configuration validation failed:\n${errors.join('\n')}`;
+        logger.error(errorMessage);
+        throw new Error(errorMessage);
+    }
+}
+/**
+ * Get QUIC configuration for router integration
+ */
+export function getQuicRouterConfig(config) {
+    return {
+        transport: {
+            quic: {
+                enabled: config.enabled,
+                port: config.port,
+                host: config.host,
+                maxConnections: config.maxConnections,
+                certPath: config.certPath,
+                keyPath: config.keyPath
+            },
+            fallback: {
+                enabled: config.fallbackToHttp2,
+                protocol: 'http2'
+            }
+        }
+    };
+}
+/**
+ * Check if QUIC is available and properly configured
+ */
+export async function checkQuicAvailability() {
+    try {
+        // Check if WASM module is available
+        // This will be implemented when WASM module is integrated
+        const wasmAvailable = true; // Placeholder
+        if (!wasmAvailable) {
+            return {
+                available: false,
+                reason: 'QUIC WASM module not available'
+            };
+        }
+        // Check if certificates exist (for server mode)
+        const config = loadQuicConfig();
+        if (config.enabled && config.verifyPeer) {
+            const fs = require('fs');
+            if (!fs.existsSync(config.certPath) || !fs.existsSync(config.keyPath)) {
+                return {
+                    available: false,
+                    reason: 'TLS certificates not found'
+                };
+            }
+        }
+        return { available: true };
+    }
+    catch (error) {
+        logger.error('Error checking QUIC availability', { error });
+        return {
+            available: false,
+            reason: error.message
+        };
+    }
+}
+/**
+ * Simplified config getter (alias for loadQuicConfig)
+ */
+export function getQuicConfig(overrides = {}) {
+    return loadQuicConfig(overrides);
+}
+//# sourceMappingURL=quic.js.map

package/agentic-flow/dist/config/quic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quic.js","sourceRoot":"","sources":["../../src/config/quic.ts"],"names":[],"mappings":"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","sourcesContent":["// QUIC Configuration Schema\n// Validates and manages QUIC transport configuration\n\nimport { QuicConfig } from '../transport/quic.js';\nimport { logger } from '../utils/logger.js';\n\nexport interface QuicConfigSchema extends QuicConfig {\n  enabled: boolean;\n  autoDetect: boolean;\n  fallbackToHttp2: boolean;\n  healthCheck: {\n    enabled: boolean;\n    interval: number;\n    timeout: number;\n  };\n  monitoring: {\n    enabled: boolean;\n    logInterval: number;\n  };\n}\n\n/**\n * Default QUIC configuration\n */\nexport const DEFAULT_QUIC_CONFIG: QuicConfigSchema = {\n  enabled: false,\n  autoDetect: true,\n  fallbackToHttp2: true,\n\n  // Connection settings\n  host: '0.0.0.0',\n  port: 4433,\n  serverHost: 'localhost',\n  serverPort: 4433,\n  verifyPeer: true,\n\n  // TLS certificates\n  certPath: './certs/cert.pem',\n  keyPath: './certs/key.pem',\n\n  // Connection pool\n  maxConnections: 100,\n  connectionTimeout: 30000,\n  idleTimeout: 60000,\n\n  // Stream multiplexing\n  maxConcurrentStreams: 100,\n  streamTimeout: 30000,\n\n  // Performance tuning\n  initialCongestionWindow: 10,\n  maxDatagramSize: 1200,\n  enableEarlyData: true,\n\n  // Health check\n  healthCheck: {\n    enabled: true,\n    interval: 30000, // 30 seconds\n    timeout: 5000 // 5 seconds\n  },\n\n  // Monitoring\n  monitoring: {\n    enabled: true,\n    logInterval: 60000 // 1 minute\n  }\n};\n\n/**\n * Load QUIC configuration from environment and config file\n */\nexport function loadQuicConfig(overrides: Partial<QuicConfigSchema> = {}): QuicConfigSchema {\n  const config: QuicConfigSchema = {\n    ...DEFAULT_QUIC_CONFIG,\n    ...overrides\n  };\n\n  // Environment variable overrides\n  if (process.env.AGENTIC_FLOW_ENABLE_QUIC !== undefined) {\n    config.enabled = process.env.AGENTIC_FLOW_ENABLE_QUIC === 'true';\n  }\n\n  if (process.env.QUIC_PORT) {\n    config.port = parseInt(process.env.QUIC_PORT);\n  }\n\n  if (process.env.QUIC_HOST) {\n    config.host = process.env.QUIC_HOST;\n  }\n\n  if (process.env.QUIC_SERVER_HOST) {\n    config.serverHost = process.env.QUIC_SERVER_HOST;\n  }\n\n  if (process.env.QUIC_SERVER_PORT) {\n    config.serverPort = parseInt(process.env.QUIC_SERVER_PORT);\n  }\n\n  if (process.env.QUIC_CERT_PATH) {\n    config.certPath = process.env.QUIC_CERT_PATH;\n  }\n\n  if (process.env.QUIC_KEY_PATH) {\n    config.keyPath = process.env.QUIC_KEY_PATH;\n  }\n\n  if (process.env.QUIC_MAX_CONNECTIONS) {\n    config.maxConnections = parseInt(process.env.QUIC_MAX_CONNECTIONS);\n  }\n\n  if (process.env.QUIC_MAX_STREAMS) {\n    config.maxConcurrentStreams = parseInt(process.env.QUIC_MAX_STREAMS);\n  }\n\n  if (process.env.QUIC_VERIFY_PEER !== undefined) {\n    config.verifyPeer = process.env.QUIC_VERIFY_PEER === 'true';\n  }\n\n  // Validate configuration\n  validateQuicConfig(config);\n\n  logger.info('QUIC configuration loaded', {\n    enabled: config.enabled,\n    host: config.host,\n    port: config.port,\n    maxConnections: config.maxConnections,\n    healthCheckEnabled: config.healthCheck.enabled\n  });\n\n  return config;\n}\n\n/**\n * Validate QUIC configuration\n */\nexport function validateQuicConfig(config: QuicConfigSchema): void {\n  const errors: string[] = [];\n\n  // Port validation\n  if (config.port! < 1 || config.port! > 65535) {\n    errors.push(`Invalid port: ${config.port}. Must be between 1 and 65535.`);\n  }\n\n  if (config.serverPort! < 1 || config.serverPort! > 65535) {\n    errors.push(`Invalid server port: ${config.serverPort}. Must be between 1 and 65535.`);\n  }\n\n  // Connection limits\n  if (config.maxConnections! < 1) {\n    errors.push(`Invalid maxConnections: ${config.maxConnections}. Must be at least 1.`);\n  }\n\n  if (config.maxConcurrentStreams! < 1) {\n    errors.push(`Invalid maxConcurrentStreams: ${config.maxConcurrentStreams}. Must be at least 1.`);\n  }\n\n  // Timeouts\n  if (config.connectionTimeout! < 1000) {\n    errors.push(`Invalid connectionTimeout: ${config.connectionTimeout}. Must be at least 1000ms.`);\n  }\n\n  if (config.idleTimeout! < 1000) {\n    errors.push(`Invalid idleTimeout: ${config.idleTimeout}. Must be at least 1000ms.`);\n  }\n\n  if (config.streamTimeout! < 1000) {\n    errors.push(`Invalid streamTimeout: ${config.streamTimeout}. Must be at least 1000ms.`);\n  }\n\n  // Performance tuning\n  if (config.initialCongestionWindow! < 1) {\n    errors.push(`Invalid initialCongestionWindow: ${config.initialCongestionWindow}. Must be at least 1.`);\n  }\n\n  if (config.maxDatagramSize! < 1200 || config.maxDatagramSize! > 65527) {\n    errors.push(`Invalid maxDatagramSize: ${config.maxDatagramSize}. Must be between 1200 and 65527.`);\n  }\n\n  // TLS certificates (warn only)\n  if (config.enabled && config.verifyPeer) {\n    const fs = require('fs');\n    if (!fs.existsSync(config.certPath)) {\n      logger.warn(`Certificate not found: ${config.certPath}`);\n    }\n    if (!fs.existsSync(config.keyPath)) {\n      logger.warn(`Private key not found: ${config.keyPath}`);\n    }\n  }\n\n  if (errors.length > 0) {\n    const errorMessage = `QUIC configuration validation failed:\\n${errors.join('\\n')}`;\n    logger.error(errorMessage);\n    throw new Error(errorMessage);\n  }\n}\n\n/**\n * Get QUIC configuration for router integration\n */\nexport function getQuicRouterConfig(config: QuicConfigSchema) {\n  return {\n    transport: {\n      quic: {\n        enabled: config.enabled,\n        port: config.port,\n        host: config.host,\n        maxConnections: config.maxConnections,\n        certPath: config.certPath,\n        keyPath: config.keyPath\n      },\n      fallback: {\n        enabled: config.fallbackToHttp2,\n        protocol: 'http2'\n      }\n    }\n  };\n}\n\n/**\n * Check if QUIC is available and properly configured\n */\nexport async function checkQuicAvailability(): Promise<{\n  available: boolean;\n  reason?: string;\n}> {\n  try {\n    // Check if WASM module is available\n    // This will be implemented when WASM module is integrated\n    const wasmAvailable = true; // Placeholder\n\n    if (!wasmAvailable) {\n      return {\n        available: false,\n        reason: 'QUIC WASM module not available'\n      };\n    }\n\n    // Check if certificates exist (for server mode)\n    const config = loadQuicConfig();\n    if (config.enabled && config.verifyPeer) {\n      const fs = require('fs');\n      if (!fs.existsSync(config.certPath) || !fs.existsSync(config.keyPath)) {\n        return {\n          available: false,\n          reason: 'TLS certificates not found'\n        };\n      }\n    }\n\n    return { available: true };\n  } catch (error) {\n    logger.error('Error checking QUIC availability', { error });\n    return {\n      available: false,\n      reason: (error as Error).message\n    };\n  }\n}\n\n/**\n * Simplified config getter (alias for loadQuicConfig)\n */\nexport function getQuicConfig(overrides: Partial<QuicConfigSchema> = {}): QuicConfigSchema {\n  return loadQuicConfig(overrides);\n}\n"]}

package/agentic-flow/dist/config/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/config/tools.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,qFASf,CAAC;AAKX,eAAO,MAAM,UAAU;;;;;;;;;;;;;;CAqBtB,CAAC"}

package/agentic-flow/dist/config/tools.js

@@ -0,0 +1,34 @@
+// Tool configuration for Claude Agent SDK
+import { getClaudeFlowTools, defaultClaudeFlowConfig } from './claudeFlow.js';
+export const enabledTools = [
+    'Read',
+    'Write',
+    'Edit',
+    'Bash',
+    'Glob',
+    'Grep',
+    'WebFetch',
+    'WebSearch'
+];
+// Get claude-flow tools dynamically
+const claudeFlowTools = getClaudeFlowTools(defaultClaudeFlowConfig);
+export const toolConfig = {
+    // Enable all standard tools for full capability
+    enableAllTools: true,
+    // MCP servers configuration
+    mcpServers: {
+        'claude-flow': {
+            command: 'npx',
+            args: ['claude-flow@alpha', 'mcp', 'start'],
+            env: {
+                CLAUDE_FLOW_MEMORY_ENABLED: 'true',
+                CLAUDE_FLOW_COORDINATION_ENABLED: 'true'
+            }
+        }
+    },
+    // Permission mode
+    permissionMode: 'default',
+    // Additional enabled tools from claude-flow
+    additionalTools: claudeFlowTools
+};
+//# sourceMappingURL=tools.js.map

package/agentic-flow/dist/config/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../src/config/tools.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE9E,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,MAAM;IACN,OAAO;IACP,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,UAAU;IACV,WAAW;CACH,CAAC;AAEX,oCAAoC;AACpC,MAAM,eAAe,GAAG,kBAAkB,CAAC,uBAAuB,CAAC,CAAC;AAEpE,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,gDAAgD;IAChD,cAAc,EAAE,IAAI;IAEpB,4BAA4B;IAC5B,UAAU,EAAE;QACV,aAAa,EAAE;YACb,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,CAAC,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC;YAC3C,GAAG,EAAE;gBACH,0BAA0B,EAAE,MAAM;gBAClC,gCAAgC,EAAE,MAAM;aACzC;SACF;KACF;IAED,kBAAkB;IAClB,cAAc,EAAE,SAAkB;IAElC,4CAA4C;IAC5C,eAAe,EAAE,eAAe;CACjC,CAAC","sourcesContent":["// Tool configuration for Claude Agent SDK\nimport { getClaudeFlowTools, defaultClaudeFlowConfig } from './claudeFlow.js';\n\nexport const enabledTools = [\n  'Read',\n  'Write',\n  'Edit',\n  'Bash',\n  'Glob',\n  'Grep',\n  'WebFetch',\n  'WebSearch'\n] as const;\n\n// Get claude-flow tools dynamically\nconst claudeFlowTools = getClaudeFlowTools(defaultClaudeFlowConfig);\n\nexport const toolConfig = {\n  // Enable all standard tools for full capability\n  enableAllTools: true,\n\n  // MCP servers configuration\n  mcpServers: {\n    'claude-flow': {\n      command: 'npx',\n      args: ['claude-flow@alpha', 'mcp', 'start'],\n      env: {\n        CLAUDE_FLOW_MEMORY_ENABLED: 'true',\n        CLAUDE_FLOW_COORDINATION_ENABLED: 'true'\n      }\n    }\n  },\n\n  // Permission mode\n  permissionMode: 'default' as const,\n\n  // Additional enabled tools from claude-flow\n  additionalTools: claudeFlowTools\n};\n"]}

package/agentic-flow/dist/coordination/attention-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attention-coordinator.d.ts","sourceRoot":"","sources":["../../src/coordination/attention-coordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAEV,aAAa,EACb,YAAY,EACb,MAAM,qBAAqB,CAAC;AAE7B;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,YAAY,CAAC;IACxB,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,YAAY,CAAC;IAC7B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,YAAY,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,GAAG,CAAC;IACf,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,SAAS,EAAE,aAAa,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,gBAAgB,EAAE,CAAC;IACpC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,KAAK,GAAG,WAAW,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,gBAAgB,CAAM;gBAElB,gBAAgB,EAAE,GAAG;IAIjC;;;;;;;;;OASG;IACG,gBAAgB,CACpB,YAAY,EAAE,WAAW,EAAE,EAC3B,SAAS,GAAE,aAAuB,GACjC,OAAO,CAAC,kBAAkB,CAAC;IAoD9B;;;;;;;;;;OAUG;IACG,cAAc,CAClB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,gBAAgB,EAAE,EAC1B,IAAI,GAAE,MAAU,GACf,OAAO,CAAC,mBAAmB,CAAC;IAiD/B;;;;;;;;;;OAUG;IACG,yBAAyB,CAC7B,YAAY,EAAE,WAAW,EAAE,EAC3B,QAAQ,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,YAAY,GAC5B,OAAO,CAAC,kBAAkB,CAAC;IAiD9B;;;;;;;;;;OAUG;IACG,wBAAwB,CAC5B,YAAY,EAAE,WAAW,EAAE,EAC3B,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,GAAE,MAAa,GACvB,OAAO,CAAC,kBAAkB,CAAC;IA4D9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAavB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAW5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAyBzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwC1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAoB1B;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,gBAAgB,EAAE,GAAG,GAAG,oBAAoB,CAEtF"}

package/agentic-flow/dist/coordination/attention-coordinator.js

@@ -0,0 +1,361 @@
+/**
+ * Attention-Based Multi-Agent Coordination
+ *
+ * Uses attention mechanisms for intelligent agent consensus, task routing,
+ * and topology-aware coordination in multi-agent swarms.
+ *
+ * @module attention-coordinator
+ * @version 2.0.0-alpha
+ */
+/**
+ * Attention-based multi-agent coordinator
+ *
+ * @example Basic Consensus
+ * ```typescript
+ * const coordinator = new AttentionCoordinator(attentionService);
+ *
+ * const agentOutputs = [
+ *   { agentId: 'agent-1', embedding: emb1, value: result1 },
+ *   { agentId: 'agent-2', embedding: emb2, value: result2 },
+ *   // ... more agents
+ * ];
+ *
+ * const result = await coordinator.coordinateAgents(agentOutputs);
+ * console.log(`Consensus: ${result.consensus}`);
+ * console.log(`Top agents: ${result.topAgents}`);
+ * ```
+ *
+ * @example Expert Routing (MoE)
+ * ```typescript
+ * const task = {
+ *   id: 'task-1',
+ *   embedding: taskEmbedding,
+ *   description: 'Optimize database queries'
+ * };
+ *
+ * const experts = await coordinator.routeToExperts(task, allAgents, 3);
+ * console.log(`Selected experts: ${experts.selectedExperts.map(e => e.type)}`);
+ * ```
+ *
+ * @example Topology-Aware Coordination
+ * ```typescript
+ * const result = await coordinator.topologyAwareCoordination(
+ *   agentOutputs,
+ *   'mesh', // or 'hierarchical', 'ring', 'star'
+ *   graphStructure
+ * );
+ * ```
+ */
+export class AttentionCoordinator {
+    attentionService;
+    constructor(attentionService) {
+        this.attentionService = attentionService;
+    }
+    /**
+     * Coordinate agents using attention-based consensus
+     *
+     * Uses multi-head attention to weight agent contributions based on
+     * relevance and confidence. Better than simple voting or averaging.
+     *
+     * @param agentOutputs - Outputs from multiple agents
+     * @param mechanism - Attention mechanism to use (default: 'flash')
+     * @returns Coordination result with weighted consensus
+     */
+    async coordinateAgents(agentOutputs, mechanism = 'flash') {
+        if (agentOutputs.length === 0) {
+            throw new Error('No agent outputs to coordinate');
+        }
+        const startTime = Date.now();
+        // Stack embeddings into tensors
+        const Q = this.stackEmbeddings(agentOutputs.map((o) => o.embedding));
+        const K = Q; // Self-attention over agent outputs
+        const V = Q;
+        // Run attention mechanism
+        let attentionResult;
+        switch (mechanism) {
+            case 'flash':
+                attentionResult = await this.attentionService.flashAttention(Q, K, V);
+                break;
+            case 'multi-head':
+                attentionResult = await this.attentionService.multiHeadAttention(Q, K, V);
+                break;
+            default:
+                attentionResult = await this.attentionService.flashAttention(Q, K, V);
+        }
+        // Extract attention weights for each agent
+        const weights = this.extractAttentionWeights(attentionResult.attentionWeights || attentionResult.output, agentOutputs.length);
+        // Compute weighted consensus
+        const consensus = this.weightedConsensus(agentOutputs, weights);
+        // Identify top contributing agents
+        const topAgents = agentOutputs
+            .map((output, i) => ({ agentId: output.agentId, weight: weights[i] }))
+            .sort((a, b) => b.weight - a.weight)
+            .slice(0, 3)
+            .map((a) => a.agentId);
+        const executionTimeMs = Date.now() - startTime;
+        return {
+            consensus,
+            attentionWeights: weights,
+            mechanism,
+            executionTimeMs,
+            topAgents,
+        };
+    }
+    /**
+     * Route tasks to specialized experts using MoE attention
+     *
+     * Uses Mixture-of-Experts attention to select top-k agents
+     * best suited for a given task.
+     *
+     * @param task - Task to route
+     * @param agents - Available specialized agents
+     * @param topK - Number of experts to select (default: 3)
+     * @returns Selected experts with routing scores
+     */
+    async routeToExperts(task, agents, topK = 3) {
+        if (agents.length === 0) {
+            throw new Error('No agents available for routing');
+        }
+        const startTime = Date.now();
+        // Task embedding as query
+        const Q = task.embedding;
+        // Agent specializations as keys and values
+        const K = this.stackEmbeddings(agents.map((a) => a.specialization));
+        const V = K;
+        // MoE attention for expert selection
+        const attentionResult = await this.attentionService.moeAttention(Q, K, V, agents.length);
+        // Extract routing scores
+        const scores = this.extractRoutingScores(attentionResult.attentionWeights || attentionResult.output, agents.length);
+        // Select top-k experts
+        const expertsWithScores = agents.map((agent, i) => ({
+            agent,
+            score: scores[i],
+        }));
+        expertsWithScores.sort((a, b) => b.score - a.score);
+        const selectedExperts = expertsWithScores.slice(0, topK).map((e) => e.agent);
+        const routingScores = expertsWithScores.slice(0, topK).map((e) => e.score);
+        const executionTimeMs = Date.now() - startTime;
+        return {
+            selectedExperts,
+            routingScores,
+            mechanism: 'moe',
+            executionTimeMs,
+        };
+    }
+    /**
+     * Topology-aware agent coordination using GraphRoPE
+     *
+     * Uses graph-aware positional embeddings to coordinate agents
+     * based on their position in the swarm topology (mesh, hierarchical, etc.)
+     *
+     * @param agentOutputs - Agent outputs
+     * @param topology - Swarm topology type
+     * @param graphStructure - Graph structure of agent network
+     * @returns Coordination result with topology-aware weights
+     */
+    async topologyAwareCoordination(agentOutputs, topology, graphStructure) {
+        const startTime = Date.now();
+        // Build graph structure from topology if not provided
+        const graph = graphStructure || this.buildTopologyGraph(agentOutputs, topology);
+        // Stack embeddings
+        const Q = this.stackEmbeddings(agentOutputs.map((o) => o.embedding));
+        const K = Q;
+        const V = Q;
+        // GraphRoPE attention preserves topological relationships
+        const attentionResult = await this.attentionService.graphRoPEAttention(Q, K, V, graph);
+        // Extract topology-aware weights
+        const weights = this.extractAttentionWeights(attentionResult.attentionWeights || attentionResult.output, agentOutputs.length);
+        // Apply topology bias (agents closer in topology get higher weights)
+        const biasedWeights = this.applyTopologyBias(weights, topology, graph);
+        // Weighted consensus
+        const consensus = this.weightedConsensus(agentOutputs, biasedWeights);
+        // Top agents
+        const topAgents = agentOutputs
+            .map((output, i) => ({ agentId: output.agentId, weight: biasedWeights[i] }))
+            .sort((a, b) => b.weight - a.weight)
+            .slice(0, 3)
+            .map((a) => a.agentId);
+        const executionTimeMs = Date.now() - startTime;
+        return {
+            consensus,
+            attentionWeights: biasedWeights,
+            mechanism: 'graph-rope',
+            executionTimeMs,
+            topAgents,
+        };
+    }
+    /**
+     * Hierarchical coordination for queen-worker swarms
+     *
+     * Uses hyperbolic attention to model hierarchical relationships
+     * where queen/coordinator agents have higher curvature.
+     *
+     * @param queenOutputs - Outputs from queen/coordinator agents
+     * @param workerOutputs - Outputs from worker agents
+     * @param curvature - Hyperbolic curvature (-1.0 = strong hierarchy)
+     * @returns Hierarchical coordination result
+     */
+    async hierarchicalCoordination(queenOutputs, workerOutputs, curvature = -1.0) {
+        const startTime = Date.now();
+        // Queens and workers in separate groups
+        const allOutputs = [...queenOutputs, ...workerOutputs];
+        // Stack embeddings
+        const Q = this.stackEmbeddings(queenOutputs.map((o) => o.embedding)); // Queens query
+        const K = this.stackEmbeddings(allOutputs.map((o) => o.embedding)); // All agents as keys
+        const V = K;
+        // Hyperbolic attention models hierarchical relationships
+        const attentionResult = await this.attentionService.hyperbolicAttention(Q, K, V, curvature);
+        // Extract weights
+        const weights = this.extractAttentionWeights(attentionResult.attentionWeights || attentionResult.output, allOutputs.length);
+        // Queens have higher influence in hierarchical structure
+        const hierarchicalWeights = weights.map((w, i) => {
+            const isQueen = i < queenOutputs.length;
+            return isQueen ? w * 1.5 : w; // Boost queen weights
+        });
+        // Normalize
+        const sumWeights = hierarchicalWeights.reduce((a, b) => a + b, 0);
+        const normalizedWeights = hierarchicalWeights.map((w) => w / sumWeights);
+        // Weighted consensus
+        const consensus = this.weightedConsensus(allOutputs, normalizedWeights);
+        // Top agents
+        const topAgents = allOutputs
+            .map((output, i) => ({ agentId: output.agentId, weight: normalizedWeights[i] }))
+            .sort((a, b) => b.weight - a.weight)
+            .slice(0, 3)
+            .map((a) => a.agentId);
+        const executionTimeMs = Date.now() - startTime;
+        return {
+            consensus,
+            attentionWeights: normalizedWeights,
+            mechanism: 'hyperbolic',
+            executionTimeMs,
+            topAgents,
+        };
+    }
+    // ============================================
+    // UTILITY FUNCTIONS
+    // ============================================
+    /**
+     * Stack multiple embeddings into single tensor
+     */
+    stackEmbeddings(embeddings) {
+        const total = embeddings.reduce((sum, e) => sum + e.length, 0);
+        const stacked = new Float32Array(total);
+        let offset = 0;
+        for (const emb of embeddings) {
+            stacked.set(emb, offset);
+            offset += emb.length;
+        }
+        return stacked;
+    }
+    /**
+     * Extract attention weights from attention output
+     */
+    extractAttentionWeights(output, numAgents) {
+        // Simplified: average across dimensions
+        const dim = output.length / numAgents;
+        const weights = [];
+        for (let i = 0; i < numAgents; i++) {
+            const slice = output.slice(i * dim, (i + 1) * dim);
+            const avgWeight = slice.reduce((a, b) => a + b, 0) / slice.length;
+            weights.push(avgWeight);
+        }
+        // Normalize to sum to 1
+        const sum = weights.reduce((a, b) => a + b, 0);
+        return weights.map((w) => w / sum);
+    }
+    /**
+     * Extract routing scores for expert selection
+     */
+    extractRoutingScores(output, numAgents) {
+        // For MoE, use softmax-like scoring
+        const scores = this.extractAttentionWeights(output, numAgents);
+        // Apply softmax for clearer expert selection
+        const expScores = scores.map((s) => Math.exp(s * 10)); // Temperature = 10
+        const sumExp = expScores.reduce((a, b) => a + b, 0);
+        return expScores.map((s) => s / sumExp);
+    }
+    /**
+     * Compute weighted consensus from agent outputs
+     */
+    weightedConsensus(outputs, weights) {
+        // If outputs are numeric, compute weighted average
+        if (typeof outputs[0].value === 'number') {
+            return outputs.reduce((sum, output, i) => sum + output.value * weights[i], 0);
+        }
+        // If outputs are arrays, compute element-wise weighted average
+        if (Array.isArray(outputs[0].value)) {
+            const length = outputs[0].value.length;
+            const weighted = new Array(length).fill(0);
+            for (let i = 0; i < outputs.length; i++) {
+                for (let j = 0; j < length; j++) {
+                    weighted[j] += outputs[i].value[j] * weights[i];
+                }
+            }
+            return weighted;
+        }
+        // For objects or complex types, return most weighted output
+        const maxWeightIndex = weights.indexOf(Math.max(...weights));
+        return outputs[maxWeightIndex].value;
+    }
+    /**
+     * Build graph structure from swarm topology
+     */
+    buildTopologyGraph(outputs, topology) {
+        const nodes = outputs.map((o) => o.embedding);
+        const edges = [];
+        switch (topology) {
+            case 'mesh':
+                // Fully connected mesh
+                for (let i = 0; i < outputs.length; i++) {
+                    for (let j = i + 1; j < outputs.length; j++) {
+                        edges.push([i, j]);
+                    }
+                }
+                break;
+            case 'hierarchical':
+                // Queen (0) connects to all workers
+                for (let i = 1; i < outputs.length; i++) {
+                    edges.push([0, i]);
+                }
+                break;
+            case 'ring':
+                // Ring topology
+                for (let i = 0; i < outputs.length; i++) {
+                    edges.push([i, (i + 1) % outputs.length]);
+                }
+                break;
+            case 'star':
+                // Star topology (central coordinator)
+                const center = 0;
+                for (let i = 1; i < outputs.length; i++) {
+                    edges.push([center, i]);
+                }
+                break;
+        }
+        return { nodes, edges };
+    }
+    /**
+     * Apply topology bias to attention weights
+     */
+    applyTopologyBias(weights, topology, graph) {
+        // Agents with more connections get slight boost
+        const connectionCounts = new Array(weights.length).fill(0);
+        for (const [src, dst] of graph.edges) {
+            connectionCounts[src]++;
+            connectionCounts[dst]++;
+        }
+        const maxConnections = Math.max(...connectionCounts);
+        return weights.map((w, i) => {
+            const connectivityBoost = connectionCounts[i] / maxConnections;
+            return w * (1 + connectivityBoost * 0.1); // 10% boost for well-connected agents
+        });
+    }
+}
+/**
+ * Create attention coordinator from attention service
+ */
+export function createAttentionCoordinator(attentionService) {
+    return new AttentionCoordinator(attentionService);
+}
+//# sourceMappingURL=attention-coordinator.js.map