🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
checkpoint: Manual test
rUv9b33e1b2a0f0
diff --git a/v3/@claude-flow/hooks/src/llm/index.ts b/v3/@claude-flow/hooks/src/llm/index.tsnew file mode 100644index 0000000000..97ed673c9e--- /dev/null+++ b/v3/@claude-flow/hooks/src/llm/index.ts@@ -0,0 +1,11 @@+/**+ * V3 LLM Hooks Module+ *+ * Exports LLM-specific hooks for request caching,+ * optimization, cost tracking, and pattern learning.+ *+ * @module @claude-flow/hooks/llm+ */++export * from './llm-hooks.js';+export { llmHooks as default } from './llm-hooks.js';diff --git a/v3/@claude-flow/hooks/src/llm/llm-hooks.ts b/v3/@claude-flow/hooks/src/llm/llm-hooks.tsnew file mode 100644index 0000000000..cc5bfac5d7--- /dev/null+++ b/v3/@claude-flow/hooks/src/llm/llm-hooks.ts@@ -0,0 +1,549 @@+/**+ * V3 LLM Hooks System+ *+ * Provides pre/post operation hooks for all LLM calls with:+ * - Request caching with memory persistence+ * - Provider-specific optimizations+ * - Cost tracking and optimization+ * - Performance metrics+ * - Pattern learning+ *+ * @module @claude-flow/hooks/llm/llm-hooks+ */++import { reasoningBank } from '../reasoningbank/index.js';++// ===== TYPES =====++export interface LLMHookContext {+ correlationId: string;+ sessionId?: string;+ agentId?: string;+ timestamp: number;+ metadata?: Record<string, unknown>;+}++export interface LLMHookPayload {+ provider: string;+ model: string;+ operation: 'complete' | 'stream' | 'embed';+ request: LLMRequestPayload;+ response?: LLMResponsePayload;+ metrics?: LLMMetrics;+}++export interface LLMRequestPayload {+ messages: Array<{+ role: string;+ content: string;+ }>;+ temperature?: number;+ maxTokens?: number;+ [key: string]: unknown;+}++export interface LLMResponsePayload {+ content: string;+ usage?: {+ promptTokens: number;+ completionTokens: number;+ totalTokens: number;+ };+ cost?: {+ promptCost: number;+ completionCost: number;+ totalCost: number;+ };+ latency?: number;+ [key: string]: unknown;+}++export interface LLMMetrics {+ requestStart: number;+ responseEnd?: number;+ latency?: number;+ cacheHit?: boolean;+ tokenEstimate?: number;+ costEstimate?: number;+}++export interface LLMHookResult {+ continue: boolean;+ modified: boolean;+ payload?: LLMHookPayload;+ sideEffects?: LLMSideEffect[];+ cachedResponse?: LLMResponsePayload;+}++export interface LLMSideEffect {+ type: 'memory' | 'metric' | 'log' | 'pattern';+ action: string;+ data: Record<string, unknown>;+}++// ===== CACHE =====++interface CacheEntry {+ response: LLMResponsePayload;+ timestamp: number;+ hits: number;+ key: string;+}++const responseCache = new Map<string, CacheEntry>();+const DEFAULT_CACHE_TTL = 3600000; // 1 hour+const MAX_CACHE_SIZE = 1000;++function generateCacheKey(provider: string, model: string, request: LLMRequestPayload): string {+ const normalized = {+ provider,+ model,+ messages: request.messages,+ temperature: request.temperature,+ maxTokens: request.maxTokens,+ };+ return Buffer.from(JSON.stringify(normalized)).toString('base64').slice(0, 64);+}++function getCached(key: string): CacheEntry | undefined {+ const entry = responseCache.get(key);+ if (!entry) return undefined;++ if (Date.now() - entry.timestamp > DEFAULT_CACHE_TTL) {+ responseCache.delete(key);+ return undefined;+ }++ entry.hits++;+ return entry;+}++function setCache(key: string, response: LLMResponsePayload): void {+ // Enforce max size+ if (responseCache.size >= MAX_CACHE_SIZE) {+ const oldest = Array.from(responseCache.entries())+ .sort((a, b) => a[1].timestamp - b[1].timestamp)[0];+ if (oldest) responseCache.delete(oldest[0]);+ }++ responseCache.set(key, {+ response,+ timestamp: Date.now(),+ hits: 0,+ key,+ });+}++// ===== OPTIMIZATION =====++interface ProviderOptimization {+ preferredTemperature?: number;+ preferredMaxTokens?: number;+ systemPromptOptimizations?: string[];+ costReductionStrategies?: string[];+}++const providerOptimizations: Record<string, ProviderOptimization> = {+ anthropic: {+ preferredTemperature: 0.7,+ systemPromptOptimizations: [+ 'Be concise and direct',+ 'Use structured output when appropriate',+ ],+ costReductionStrategies: [+ 'Use claude-3-haiku for simple tasks',+ 'Batch similar requests',+ ],+ },+ openai: {+ preferredTemperature: 0.8,+ systemPromptOptimizations: [+ 'Respond in a structured format',+ ],+ costReductionStrategies: [+ 'Use gpt-4o-mini for simple tasks',+ 'Enable response caching',+ ],+ },+ google: {+ preferredTemperature: 0.7,+ costReductionStrategies: [+ 'Use gemini-1.5-flash for simple tasks',+ ],+ },+ ollama: {+ preferredTemperature: 0.7,+ costReductionStrategies: [+ 'Free - no cost optimization needed',+ ],+ },+};++function loadProviderOptimizations(provider: string): ProviderOptimization {+ return providerOptimizations[provider] || {};+}++function applyRequestOptimizations(+ request: LLMRequestPayload,+ optimizations: ProviderOptimization+): LLMRequestPayload {+ const optimized = { ...request };++ // Apply temperature if not set+ if (optimized.temperature === undefined && optimizations.preferredTemperature) {+ optimized.temperature = optimizations.preferredTemperature;+ }++ return optimized;+}++// ===== PRE-LLM HOOK =====++export async function preLLMCallHook(+ payload: LLMHookPayload,+ context: LLMHookContext+): Promise<LLMHookResult> {+ const { provider, model, request } = payload;+ const sideEffects: LLMSideEffect[] = [];++ // Check cache+ const cacheKey = generateCacheKey(provider, model, request);+ const cached = getCached(cacheKey);++ if (cached) {+ sideEffects.push({+ type: 'metric',+ action: 'increment',+ data: { name: 'llm.cache.hits', provider, model },+ });++ return {+ continue: false, // Skip LLM call+ modified: true,+ cachedResponse: cached.response,+ payload: {+ ...payload,+ metrics: {+ ...payload.metrics,+ requestStart: Date.now(),+ cacheHit: true,+ },+ },+ sideEffects,+ };+ }++ // Load and apply optimizations+ const optimizations = loadProviderOptimizations(provider);+ const optimizedRequest = applyRequestOptimizations(request, optimizations);++ // Track request+ sideEffects.push(+ {+ type: 'metric',+ action: 'increment',+ data: { name: `llm.calls.${provider}.${model}` },+ },+ {+ type: 'memory',+ action: 'store',+ data: {+ key: `llm:request:${context.correlationId}`,+ value: {+ provider,+ model,+ request: optimizedRequest,+ timestamp: Date.now(),+ },+ ttl: 3600,+ },+ }+ );++ return {+ continue: true,+ modified: optimizedRequest !== request,+ payload: {+ ...payload,+ request: optimizedRequest,+ metrics: {+ ...payload.metrics,+ requestStart: Date.now(),+ cacheHit: false,+ },+ },+ sideEffects,+ };+}++// ===== POST-LLM HOOK =====++export async function postLLMCallHook(+ payload: LLMHookPayload,+ context: LLMHookContext+): Promise<LLMHookResult> {+ const { provider, model, request, response, metrics } = payload;+ const sideEffects: LLMSideEffect[] = [];++ if (!response) {+ return { continue: true, modified: false };+ }++ const latency = metrics?.requestStart+ ? Date.now() - metrics.requestStart+ : undefined;++ // Cache response+ const cacheKey = generateCacheKey(provider, model, request);+ setCache(cacheKey, response);++ // Track metrics+ sideEffects.push(+ {+ type: 'metric',+ action: 'record',+ data: {+ name: `llm.latency.${provider}`,+ value: latency,+ },+ },+ {+ type: 'metric',+ action: 'record',+ data: {+ name: `llm.tokens.${provider}`,+ value: response.usage?.totalTokens,+ },+ }+ );++ if (response.cost) {+ sideEffects.push({+ type: 'metric',+ action: 'record',+ data: {+ name: `llm.cost.${provider}`,+ value: response.cost.totalCost,+ },+ });+ }++ // Learn patterns from successful responses+ if (response.content && response.content.length > 100) {+ const pattern = extractPatternFromResponse(request, response);+ if (pattern) {+ sideEffects.push({+ type: 'pattern',+ action: 'learn',+ data: {+ strategy: pattern.strategy,+ domain: pattern.domain,+ quality: pattern.quality,+ },+ });++ // Store in reasoning bank+ try {+ await reasoningBank.storePattern(pattern.strategy, pattern.domain);+ } catch {+ // Ignore storage errors+ }+ }+ }++ // Store response in memory+ sideEffects.push({+ type: 'memory',+ action: 'store',+ data: {+ key: `llm:response:${context.correlationId}`,+ value: {+ provider,+ model,+ response: {+ content: response.content.slice(0, 500), // Truncate+ usage: response.usage,+ cost: response.cost,+ latency,+ },+ timestamp: Date.now(),+ },+ ttl: 86400, // 24 hours+ },+ });++ return {+ continue: true,+ modified: false,+ payload: {+ ...payload,+ metrics: {+ ...metrics,+ responseEnd: Date.now(),+ latency,+ },+ },+ sideEffects,+ };+}++// ===== ERROR HOOK =====++export async function errorLLMCallHook(+ payload: LLMHookPayload,+ error: Error,+ context: LLMHookContext+): Promise<LLMHookResult> {+ const { provider, model, metrics } = payload;+ const sideEffects: LLMSideEffect[] = [];++ const latency = metrics?.requestStart+ ? Date.now() - metrics.requestStart+ : undefined;++ // Track error metrics+ sideEffects.push(+ {+ type: 'metric',+ action: 'increment',+ data: {+ name: `llm.errors.${provider}`,+ errorType: error.name,+ },+ },+ {+ type: 'log',+ action: 'error',+ data: {+ message: `LLM call failed: ${error.message}`,+ provider,+ model,+ latency,+ errorType: error.name,+ },+ }+ );++ // Store error for learning+ sideEffects.push({+ type: 'memory',+ action: 'store',+ data: {+ key: `llm:error:${context.correlationId}`,+ value: {+ provider,+ model,+ error: {+ name: error.name,+ message: error.message,+ },+ timestamp: Date.now(),+ },+ ttl: 86400,+ },+ });++ return {+ continue: true,+ modified: false,+ sideEffects,+ };+}++// ===== PATTERN EXTRACTION =====++interface ExtractedPattern {+ strategy: string;+ domain: string;+ quality: number;+}++function extractPatternFromResponse(+ request: LLMRequestPayload,+ response: LLMResponsePayload+): ExtractedPattern | null {+ // Simple heuristic pattern extraction+ const lastUserMessage = [...request.messages]+ .reverse()+ .find((m) => m.role === 'user');++ if (!lastUserMessage) return null;++ // Detect domain from content+ const content = lastUserMessage.content.toLowerCase();+ let domain = 'general';++ if (content.includes('code') || content.includes('function') || content.includes('implement')) {+ domain = 'code';+ } else if (content.includes('security') || content.includes('vulnerability')) {+ domain = 'security';+ } else if (content.includes('test') || content.includes('spec')) {+ domain = 'testing';+ } else if (content.includes('architecture') || content.includes('design')) {+ domain = 'architecture';+ } else if (content.includes('performance') || content.includes('optimize')) {+ domain = 'performance';+ }++ // Extract strategy from response+ const responseContent = response.content;+ const strategy = responseContent.length > 500+ ? responseContent.slice(0, 500)+ : responseContent;++ // Quality based on response length and structure+ const hasCodeBlocks = responseContent.includes('```');+ const hasLists = responseContent.includes('\n- ') || responseContent.includes('\n1.');+ const quality = Math.min(+ 0.9,+ 0.5 + (hasCodeBlocks ? 0.2 : 0) + (hasLists ? 0.1 : 0) + (responseContent.length > 1000 ? 0.1 : 0)+ );++ return {+ strategy: `[${domain}] ${strategy.slice(0, 200)}...`,+ domain,+ quality,+ };+}++// ===== CACHE MANAGEMENT =====++export function clearLLMCache(): void {+ responseCache.clear();+}++export function getLLMCacheStats(): {+ size: number;+ totalHits: number;+ entries: Array<{ key: string; hits: number; age: number }>;+} {+ let totalHits = 0;+ const entries: Array<{ key: string; hits: number; age: number }> = [];++ for (const [key, entry] of responseCache) {+ totalHits += entry.hits;+ entries.push({+ key,+ hits: entry.hits,+ age: Date.now() - entry.timestamp,+ });+ }++ return {+ size: responseCache.size,+ totalHits,+ entries: entries.slice(0, 10), // Top 10+ };+}++// ===== EXPORTS =====++export const llmHooks = {+ preLLMCall: preLLMCallHook,+ postLLMCall: postLLMCallHook,+ errorLLMCall: errorLLMCallHook,+ clearCache: clearLLMCache,+ getCacheStats: getLLMCacheStats,+};++export default llmHooks;diff --git a/v3/@claude-flow/mcp/README.md b/v3/@claude-flow/mcp/README.mdnew file mode 100644index 0000000000..471b34be04--- /dev/null+++ b/v3/@claude-flow/mcp/README.md@@ -0,0 +1,428 @@+# @claude-flow/mcp++[](https://www.npmjs.com/package/@claude-flow/mcp)+[](https://opensource.org/licenses/MIT)+[](https://www.typescriptlang.org/)+[](https://modelcontextprotocol.io)+[](https://github.com/ruvnet/claude-flow)++> **MCP 2025-11-25 Compliant** - Standalone Model Context Protocol server implementation with full Resources, Prompts, and Tasks support++## Features++- **MCP 2025-11-25 Compliant** - Full specification support+- **High-Performance Server** - <400ms startup time+- **Multiple Transports** - stdio, HTTP, WebSocket, in-process+- **Resources** - list, read, subscribe with caching+- **Prompts** - templates with arguments and embedded resources+- **Tasks** - Async operations with progress and cancellation+- **Pagination** - Cursor-based pagination for large datasets+- **Connection Pooling** - Max 10 connections, configurable+- **Fast Tool Registry** - O(1) lookup, <10ms registration+- **Session Management** - Timeout handling, authentication+- **Security** - CORS, Helmet, auth tokens+- **Zero Dependencies** - No @claude-flow/* dependencies++## Installation++```bash+npm install @claude-flow/mcp+```++## Quick Start++```typescript+import { quickStart, defineTool } from '@claude-flow/mcp';++// Create and start server+const server = await quickStart({+ transport: 'stdio',+ name: 'My MCP Server',+});++// Register custom tools+server.registerTool(defineTool(+ 'greet',+ 'Greet a user',+ {+ type: 'object',+ properties: {+ name: { type: 'string', description: 'User name' }+ },+ required: ['name']+ },+ async ({ name }) => ({ message: `Hello, ${name}!` })+));++// Start listening+await server.start();+```++## Transports++### Stdio (Default)++```typescript+import { createMCPServer } from '@claude-flow/mcp';++const server = createMCPServer({+ transport: 'stdio',+ name: 'Stdio Server',+}, logger);++await server.start();+```++### HTTP++```typescript+const server = createMCPServer({+ transport: 'http',+ host: 'localhost',+ port: 3000,+ corsEnabled: true,+ corsOrigins: ['http://localhost:8080'],+ auth: {+ enabled: true,+ method: 'token',+ tokens: ['secret-token'],+ },+}, logger);++await server.start();+// Server at http://localhost:3000+// WebSocket at ws://localhost:3000/ws+```++### WebSocket++```typescript+const server = createMCPServer({+ transport: 'websocket',+ host: 'localhost',+ port: 3001,+ maxConnections: 100,+ heartbeatInterval: 30000,+}, logger);++await server.start();+// WebSocket at ws://localhost:3001/ws+```++## Tool Registry++```typescript+import { createToolRegistry, defineTool } from '@claude-flow/mcp';++const registry = createToolRegistry(logger);++// Register tool+registry.register({+ name: 'calculate',+ description: 'Perform calculations',+ inputSchema: {+ type: 'object',+ properties: {+ expression: { type: 'string' }+ }+ },+ handler: async ({ expression }) => {+ return { result: eval(expression) };+ },+ category: 'math',+ tags: ['calculator'],+});++// Execute tool+const result = await registry.execute('calculate', { expression: '2 + 2' });++// Search tools+const mathTools = registry.getByCategory('math');+const stats = registry.getStats();+```++## Session Management++```typescript+import { createSessionManager } from '@claude-flow/mcp';++const sessions = createSessionManager(logger, {+ maxSessions: 100,+ sessionTimeout: 30 * 60 * 1000, // 30 minutes+});++// Create session+const session = sessions.createSession('http');++// Initialize with client info+sessions.initializeSession(session.id, {+ protocolVersion: { major: 2024, minor: 11, patch: 5 },+ capabilities: { tools: { listChanged: true } },+ clientInfo: { name: 'Claude', version: '1.0' },+});++// Get metrics+const metrics = sessions.getSessionMetrics();+// { total: 1, active: 1, authenticated: 0, expired: 0 }+```++## Connection Pool++```typescript+import { createConnectionPool } from '@claude-flow/mcp';++const pool = createConnectionPool({+ maxConnections: 10,+ minConnections: 2,+ idleTimeout: 30000,+ acquireTimeout: 5000,+}, logger, 'http');++// Acquire connection+const conn = await pool.acquire();++// Use connection...++// Release back to pool+pool.release(conn);++// Get stats+const stats = pool.getStats();+// { totalConnections: 5, idleConnections: 4, busyConnections: 1, ... }+```++## API Reference++### Server++```typescript+interface IMCPServer {+ start(): Promise<void>;+ stop(): Promise<void>;+ registerTool(tool: MCPTool): boolean;+ registerTools(tools: MCPTool[]): { registered: number; failed: string[] };+ getHealthStatus(): Promise<{ healthy: boolean; error?: string; metrics?: Record<string, number> }>;+ getMetrics(): MCPServerMetrics;+ getSessions(): MCPSession[];+ getSession(sessionId: string): MCPSession | undefined;+ terminateSession(sessionId: string): boolean;+}+```++### Tool++```typescript+interface MCPTool<TInput = unknown, TOutput = unknown> {+ name: string;+ description: string;+ inputSchema: JSONSchema;+ handler: (input: TInput, context?: ToolContext) => Promise<TOutput>;+ category?: string;+ tags?: string[];+ cacheable?: boolean;+ cacheTTL?: number;+ timeout?: number;+}+```++### Transport++```typescript+interface ITransport {+ readonly type: TransportType;+ start(): Promise<void>;+ stop(): Promise<void>;+ onRequest(handler: RequestHandler): void;+ onNotification(handler: NotificationHandler): void;+ sendNotification?(notification: MCPNotification): Promise<void>;+ getHealthStatus(): Promise<TransportHealthStatus>;+}+```++## Built-in Tools++The server automatically registers these system tools:++| Tool | Description |+|------|-------------|+| `system/info` | Get server information |+| `system/health` | Get health status |+| `system/metrics` | Get server metrics |+| `tools/list-detailed` | List all tools with details |++## Resources (MCP 2025-11-25)++```typescript+import { createMCPServer, createTextResource } from '@claude-flow/mcp';++const server = createMCPServer({ transport: 'stdio' }, logger);+const resourceRegistry = server.getResourceRegistry();++// Register a text resource+const { resource, handler } = createTextResource(+ 'file://readme.txt',+ 'README',+ 'Welcome to the application!',+ { mimeType: 'text/plain' }+);+resourceRegistry.registerResource(resource, handler);++// Register with custom handler+resourceRegistry.registerResource(+ {+ uri: 'db://users/{id}',+ name: 'User Data',+ description: 'Get user by ID',+ mimeType: 'application/json',+ },+ async (uri) => {+ const id = uri.split('/').pop();+ const user = await fetchUser(id);+ return [{ uri, mimeType: 'application/json', text: JSON.stringify(user) }];+ }+);++// Subscribe to updates+resourceRegistry.subscribe('file://readme.txt', (uri, content) => {+ console.log('Resource updated:', uri);+});+```++## Prompts (MCP 2025-11-25)++```typescript+import { createMCPServer, definePrompt, textMessage, interpolate } from '@claude-flow/mcp';++const server = createMCPServer({ transport: 'stdio' }, logger);+const promptRegistry = server.getPromptRegistry();++// Define a prompt with arguments+const codeReviewPrompt = definePrompt(+ 'code_review',+ 'Review code for quality and best practices',+ async (args) => [+ textMessage('user', `Please review this ${args.language} code:\n\n${args.code}`),+ ],+ {+ title: 'Code Review',+ arguments: [+ { name: 'code', description: 'The code to review', required: true },+ { name: 'language', description: 'Programming language', required: false },+ ],+ }+);++promptRegistry.register(codeReviewPrompt);++// Get prompt with arguments+const result = await promptRegistry.get('code_review', {+ code: 'function hello() { return "world"; }',+ language: 'JavaScript',+});+```++## Tasks (MCP 2025-11-25)++```typescript+import { createMCPServer } from '@claude-flow/mcp';++const server = createMCPServer({ transport: 'stdio' }, logger);+const taskManager = server.getTaskManager();++// Create a long-running task+const taskId = taskManager.createTask(async (reportProgress, signal) => {+ for (let i = 0; i <= 100; i += 10) {+ if (signal.aborted) throw new Error('Task cancelled');++ reportProgress({+ progress: i,+ total: 100,+ message: `Processing... ${i}%`,+ });++ await new Promise(r => setTimeout(r, 100));+ }++ return { success: true, processedItems: 100 };+});++// Get task status+const status = taskManager.getTask(taskId);++// Wait for completion+const result = await taskManager.waitForTask(taskId);++// Cancel a task+taskManager.cancelTask(taskId, 'User requested cancellation');+```++## MCP Methods Supported++| Method | Description |+|--------|-------------|+| `initialize` | Initialize connection |+| `tools/list` | List available tools |+| `tools/call` | Execute a tool |+| `resources/list` | List resources with pagination |+| `resources/read` | Read resource content |+| `resources/subscribe` | Subscribe to updates |+| `resources/unsubscribe` | Unsubscribe from updates |+| `prompts/list` | List prompts with pagination |+| `prompts/get` | Get prompt with arguments |+| `tasks/status` | Get task status |+| `tasks/cancel` | Cancel a running task |+| `completion/complete` | Auto-complete arguments |+| `logging/setLevel` | Set log level |+| `ping` | Keep-alive |++## Performance Targets++| Metric | Target |+|--------|--------|+| Server startup | <400ms |+| Tool registration | <10ms |+| Tool execution overhead | <50ms |+| Connection acquire | <5ms |+| Connection release | <1ms |++## Security++### Authentication++```typescript+const server = createMCPServer({+ auth: {+ enabled: true,+ method: 'token',+ tokens: ['your-secret-token'],+ },+}, logger);+```++### CORS++```typescript+const server = createMCPServer({+ transport: 'http',+ corsEnabled: true,+ corsOrigins: ['https://your-domain.com'],+}, logger);+```++## Error Codes++```typescript+const ErrorCodes = {+ PARSE_ERROR: -32700,+ INVALID_REQUEST: -32600,+ METHOD_NOT_FOUND: -32601,+ INVALID_PARAMS: -32602,+ INTERNAL_ERROR: -32603,+ SERVER_NOT_INITIALIZED: -32002,+ AUTHENTICATION_REQUIRED: -32001,+};+```++## License++MITdiff --git a/v3/@claude-flow/mcp/__tests__/mcp.test.ts b/v3/@claude-flow/mcp/__tests__/mcp.test.tsnew file mode 100644index 0000000000..3319affde1--- /dev/null+++ b/v3/@claude-flow/mcp/__tests__/mcp.test.ts@@ -0,0 +1,641 @@+/**+ * @claude-flow/mcp - Test Suite+ */++import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';+import {+ createMCPServer,+ createToolRegistry,+ createSessionManager,+ createConnectionPool,+ createResourceRegistry,+ createPromptRegistry,+ createTaskManager,+ defineTool,+ definePrompt,+ textMessage,+ createTextResource,+ interpolate,+ ErrorCodes,+ MCPServerError,+ VERSION,+ MODULE_NAME,+} from '../src/index.js';+import type { ILogger, MCPTool } from '../src/types.js';++// Mock logger+const createMockLogger = (): ILogger => ({+ debug: vi.fn(),+ info: vi.fn(),+ warn: vi.fn(),+ error: vi.fn(),+});++describe('@claude-flow/mcp', () => {+ describe('Module exports', () => {+ it('should export VERSION', () => {+ expect(VERSION).toBe('3.0.0');+ });++ it('should export MODULE_NAME', () => {+ expect(MODULE_NAME).toBe('@claude-flow/mcp');+ });++ it('should export ErrorCodes', () => {+ expect(ErrorCodes.PARSE_ERROR).toBe(-32700);+ expect(ErrorCodes.INVALID_REQUEST).toBe(-32600);+ expect(ErrorCodes.METHOD_NOT_FOUND).toBe(-32601);+ expect(ErrorCodes.INTERNAL_ERROR).toBe(-32603);+ });+ });++ describe('MCPServerError', () => {+ it('should create error with code', () => {+ const error = new MCPServerError('Test error', ErrorCodes.INVALID_REQUEST);+ expect(error.message).toBe('Test error');+ expect(error.code).toBe(ErrorCodes.INVALID_REQUEST);+ expect(error.name).toBe('MCPServerError');+ });++ it('should convert to MCP error format', () => {+ const error = new MCPServerError('Test error', ErrorCodes.PARSE_ERROR, { extra: 'data' });+ const mcpError = error.toMCPError();+ expect(mcpError.code).toBe(ErrorCodes.PARSE_ERROR);+ expect(mcpError.message).toBe('Test error');+ expect(mcpError.data).toEqual({ extra: 'data' });+ });+ });++ describe('ToolRegistry', () => {+ let registry: ReturnType<typeof createToolRegistry>;+ let logger: ILogger;++ beforeEach(() => {+ logger = createMockLogger();+ registry = createToolRegistry(logger);+ });++ it('should register a tool', () => {+ const tool: MCPTool = {+ name: 'test-tool',+ description: 'A test tool',+ inputSchema: { type: 'object', properties: {} },+ handler: async () => ({ result: 'success' }),+ };++ const result = registry.register(tool);+ expect(result).toBe(true);+ expect(registry.hasTool('test-tool')).toBe(true);+ expect(registry.getToolCount()).toBe(1);+ });++ it('should not register duplicate tools', () => {+ const tool: MCPTool = {+ name: 'test-tool',+ description: 'A test tool',+ inputSchema: { type: 'object', properties: {} },+ handler: async () => ({ result: 'success' }),+ };++ registry.register(tool);+ const result = registry.register(tool);+ expect(result).toBe(false);+ expect(registry.getToolCount()).toBe(1);+ });++ it('should override tool with option', () => {+ const tool1: MCPTool = {+ name: 'test-tool',+ description: 'First version',+ inputSchema: { type: 'object', properties: {} },+ handler: async () => ({ result: 'v1' }),+ };++ const tool2: MCPTool = {+ name: 'test-tool',+ description: 'Second version',+ inputSchema: { type: 'object', properties: {} },+ handler: async () => ({ result: 'v2' }),+ };++ registry.register(tool1);+ const result = registry.register(tool2, { override: true });+ expect(result).toBe(true);+ expect(registry.getTool('test-tool')?.description).toBe('Second version');+ });++ it('should unregister a tool', () => {+ const tool: MCPTool = {+ name: 'test-tool',+ description: 'A test tool',+ inputSchema: { type: 'object', properties: {} },+ handler: async () => ({ result: 'success' }),+ };++ registry.register(tool);+ const result = registry.unregister('test-tool');+ expect(result).toBe(true);+ expect(registry.hasTool('test-tool')).toBe(false);+ });++ it('should execute a tool', async () => {+ const tool: MCPTool = {+ name: 'test-tool',+ description: 'A test tool',+ inputSchema: { type: 'object', properties: {} },+ handler: async (input: unknown) => ({ received: input }),+ };++ registry.register(tool);+ const result = await registry.execute('test-tool', { test: 'data' });+ expect(result.isError).toBe(false);+ expect(result.content[0].type).toBe('text');+ });++ it('should return error for unknown tool', async () => {+ const result = await registry.execute('unknown-tool', {});+ expect(result.isError).toBe(true);+ expect(result.content[0].text).toContain('Tool not found');+ });++ it('should filter by category', () => {+ registry.register({+ name: 'tool-a',+ description: 'Tool A',+ inputSchema: { type: 'object' },+ handler: async () => ({}),+ category: 'category-1',+ });++ registry.register({+ name: 'tool-b',+ description: 'Tool B',+ inputSchema: { type: 'object' },+ handler: async () => ({}),+ category: 'category-2',+ });++ const tools = registry.getByCategory('category-1');+ expect(tools.length).toBe(1);+ expect(tools[0].name).toBe('tool-a');+ });++ it('should get stats', () => {+ registry.register({+ name: 'tool-a',+ description: 'Tool A',+ inputSchema: { type: 'object' },+ handler: async () => ({}),+ category: 'cat',+ tags: ['tag1', 'tag2'],+ });++ const stats = registry.getStats();+ expect(stats.totalTools).toBe(1);+ expect(stats.totalCategories).toBe(1);+ expect(stats.totalTags).toBe(2);+ });+ });++ describe('defineTool', () => {+ it('should create a tool definition', () => {+ const tool = defineTool(+ 'my-tool',+ 'My tool description',+ { type: 'object', properties: { input: { type: 'string' } } },+ async (input) => ({ result: input }),+ { category: 'test', tags: ['tag1'] }+ );++ expect(tool.name).toBe('my-tool');+ expect(tool.description).toBe('My tool description');+ expect(tool.category).toBe('test');+ expect(tool.tags).toEqual(['tag1']);+ });+ });++ describe('SessionManager', () => {+ let manager: ReturnType<typeof createSessionManager>;+ let logger: ILogger;++ beforeEach(() => {+ logger = createMockLogger();+ manager = createSessionManager(logger, { sessionTimeout: 1000 });+ });++ afterEach(() => {+ manager.destroy();+ });++ it('should create a session', () => {+ const session = manager.createSession('stdio');+ expect(session.id).toBeDefined();+ expect(session.state).toBe('created');+ expect(session.transport).toBe('stdio');+ expect(session.isInitialized).toBe(false);+ });++ it('should initialize a session', () => {+ const session = manager.createSession('stdio');+ manager.initializeSession(session.id, {+ protocolVersion: { major: 2024, minor: 11, patch: 5 },+ capabilities: { tools: { listChanged: true } },+ clientInfo: { name: 'test-client', version: '1.0.0' },+ });++ const updated = manager.getSession(session.id);+ expect(updated?.isInitialized).toBe(true);+ expect(updated?.state).toBe('ready');+ expect(updated?.clientInfo?.name).toBe('test-client');+ });++ it('should close a session', () => {+ const session = manager.createSession('stdio');+ const result = manager.closeSession(session.id, 'test reason');+ expect(result).toBe(true);+ expect(manager.getSession(session.id)).toBeUndefined();+ });++ it('should get session metrics', () => {+ manager.createSession('stdio');+ manager.createSession('http');++ const metrics = manager.getSessionMetrics();+ expect(metrics.total).toBe(2);+ });++ it('should update session activity', () => {+ const session = manager.createSession('stdio');+ const originalTime = session.lastActivityAt;++ // Small delay to ensure time difference+ const result = manager.updateActivity(session.id);+ expect(result).toBe(true);+ });+ });++ describe('ConnectionPool', () => {+ let pool: ReturnType<typeof createConnectionPool>;+ let logger: ILogger;++ beforeEach(() => {+ logger = createMockLogger();+ pool = createConnectionPool(+ { maxConnections: 5, minConnections: 0, idleTimeout: 100, evictionRunInterval: 60000 },+ logger,+ 'in-process'+ );+ });++ afterEach(async () => {+ // Release all connections first to allow fast drain+ for (const conn of pool.getConnections()) {+ if (conn.state === 'busy') {+ pool.release(conn);+ }+ }+ await pool.clear();+ }, 5000);++ it('should acquire a connection', async () => {+ const connection = await pool.acquire();+ expect(connection.id).toBeDefined();+ expect(connection.state).toBe('busy');+ });++ it('should release a connection', async () => {+ const connection = await pool.acquire();+ pool.release(connection);++ const stats = pool.getStats();+ expect(stats.idleConnections).toBeGreaterThan(0);+ });++ it('should get stats', async () => {+ const connection = await pool.acquire();+ const stats = pool.getStats();++ expect(stats.totalConnections).toBeGreaterThan(0);+ expect(stats.totalAcquired).toBe(1);++ // Release for cleanup+ pool.release(connection);+ });++ it('should check health', () => {+ // Pool is healthy when not shutting down and has >= minConnections (0 in this test)+ expect(pool.isHealthy()).toBe(true);+ });+ });++ describe('MCPServer', () => {+ let server: ReturnType<typeof createMCPServer>;+ let logger: ILogger;++ beforeEach(() => {+ logger = createMockLogger();+ server = createMCPServer(+ { name: 'Test Server', transport: 'in-process' },+ logger+ );+ });++ afterEach(async () => {+ await server.stop();+ });++ it('should create server with config', () => {+ expect(server).toBeDefined();+ });++ it('should register a tool', () => {+ const result = server.registerTool({+ name: 'test-tool',+ description: 'Test tool',+ inputSchema: { type: 'object' },+ handler: async () => ({}),+ });+ expect(result).toBe(true);+ });++ it('should register multiple tools', () => {+ const result = server.registerTools([+ {+ name: 'tool-1',+ description: 'Tool 1',+ inputSchema: { type: 'object' },+ handler: async () => ({}),+ },+ {+ name: 'tool-2',+ description: 'Tool 2',+ inputSchema: { type: 'object' },+ handler: async () => ({}),+ },+ ]);+ expect(result.registered).toBe(2);+ expect(result.failed).toHaveLength(0);+ });++ it('should start and stop', async () => {+ await server.start();+ const health = await server.getHealthStatus();+ expect(health.healthy).toBe(true);++ await server.stop();+ const healthAfter = await server.getHealthStatus();+ expect(healthAfter.healthy).toBe(false);+ });++ it('should get metrics', async () => {+ await server.start();+ const metrics = server.getMetrics();++ expect(metrics.totalRequests).toBeDefined();+ expect(metrics.activeSessions).toBeDefined();+ });++ it('should expose resource registry', () => {+ const registry = server.getResourceRegistry();+ expect(registry).toBeDefined();+ expect(typeof registry.registerResource).toBe('function');+ });++ it('should expose prompt registry', () => {+ const registry = server.getPromptRegistry();+ expect(registry).toBeDefined();+ expect(typeof registry.register).toBe('function');+ });++ it('should expose task manager', () => {+ const taskManager = server.getTaskManager();+ expect(taskManager).toBeDefined();+ expect(typeof taskManager.createTask).toBe('function');+ });+ });++ // ============================================================================+ // MCP 2025-11-25 Features+ // ============================================================================++ describe('ResourceRegistry (MCP 2025-11-25)', () => {+ let registry: ReturnType<typeof createResourceRegistry>;+ let logger: ILogger;++ beforeEach(() => {+ logger = createMockLogger();+ registry = createResourceRegistry(logger);+ });++ it('should register a resource', () => {+ const { resource, handler } = createTextResource(+ 'file://test.txt',+ 'Test File',+ 'Hello World'+ );++ const result = registry.registerResource(resource, handler);+ expect(result).toBe(true);+ expect(registry.hasResource('file://test.txt')).toBe(true);+ });++ it('should list resources with pagination', () => {+ for (let i = 0; i < 5; i++) {+ const { resource, handler } = createTextResource(+ `file://test${i}.txt`,+ `Test File ${i}`,+ `Content ${i}`+ );+ registry.registerResource(resource, handler);+ }++ const result = registry.list(undefined, 3);+ expect(result.resources.length).toBe(3);+ expect(result.nextCursor).toBeDefined();++ const nextResult = registry.list(result.nextCursor, 3);+ expect(nextResult.resources.length).toBe(2);+ });++ it('should read resource content', async () => {+ const { resource, handler } = createTextResource(+ 'file://test.txt',+ 'Test File',+ 'Hello World'+ );+ registry.registerResource(resource, handler);++ const result = await registry.read('file://test.txt');+ expect(result.contents[0].text).toBe('Hello World');+ });++ it('should subscribe to resource updates', () => {+ const { resource, handler } = createTextResource(+ 'file://test.txt',+ 'Test File',+ 'Hello World'+ );+ registry.registerResource(resource, handler);++ const callback = vi.fn();+ const subscriptionId = registry.subscribe('file://test.txt', callback);+ expect(subscriptionId).toBeDefined();+ expect(registry.getSubscriptionCount('file://test.txt')).toBe(1);+ });++ it('should get stats', () => {+ const { resource, handler } = createTextResource(+ 'file://test.txt',+ 'Test File',+ 'Hello World'+ );+ registry.registerResource(resource, handler);++ const stats = registry.getStats();+ expect(stats.totalResources).toBe(1);+ });+ });++ describe('PromptRegistry (MCP 2025-11-25)', () => {+ let registry: ReturnType<typeof createPromptRegistry>;+ let logger: ILogger;++ beforeEach(() => {+ logger = createMockLogger();+ registry = createPromptRegistry(logger);+ });++ it('should register a prompt', () => {+ const prompt = definePrompt(+ 'code_review',+ 'Review code for quality',+ async (args) => [textMessage('user', `Review: ${args.code}`)],+ { arguments: [{ name: 'code', required: true }] }+ );++ const result = registry.register(prompt);+ expect(result).toBe(true);+ expect(registry.hasPrompt('code_review')).toBe(true);+ });++ it('should list prompts with pagination', () => {+ for (let i = 0; i < 5; i++) {+ const prompt = definePrompt(+ `prompt_${i}`,+ `Prompt ${i}`,+ async () => [textMessage('user', `Message ${i}`)]+ );+ registry.register(prompt);+ }++ const result = registry.list(undefined, 3);+ expect(result.prompts.length).toBe(3);+ expect(result.nextCursor).toBeDefined();+ });++ it('should get prompt with arguments', async () => {+ const prompt = definePrompt(+ 'greeting',+ 'Greet a user',+ async (args) => [textMessage('user', `Hello, ${args.name}!`)],+ { arguments: [{ name: 'name', required: true }] }+ );+ registry.register(prompt);++ const result = await registry.get('greeting', { name: 'World' });+ expect(result.messages[0].content.type).toBe('text');+ expect((result.messages[0].content as any).text).toBe('Hello, World!');+ });++ it('should validate required arguments', async () => {+ const prompt = definePrompt(+ 'greeting',+ 'Greet a user',+ async (args) => [textMessage('user', `Hello, ${args.name}!`)],+ { arguments: [{ name: 'name', required: true }] }+ );+ registry.register(prompt);++ await expect(registry.get('greeting', {})).rejects.toThrow('Missing required argument');+ });++ it('should interpolate template strings', () => {+ const template = 'Hello, {name}! Your score is {score}.';+ const result = interpolate(template, { name: 'Alice', score: '100' });+ expect(result).toBe('Hello, Alice! Your score is 100.');+ });+ });++ describe('TaskManager (MCP 2025-11-25)', () => {+ let taskManager: ReturnType<typeof createTaskManager>;+ let logger: ILogger;++ beforeEach(() => {+ logger = createMockLogger();+ taskManager = createTaskManager(logger, { cleanupInterval: 60000 });+ });++ afterEach(() => {+ taskManager.destroy();+ });++ it('should create a task', () => {+ const taskId = taskManager.createTask(async (reportProgress, signal) => {+ return { result: 'success' };+ });++ expect(taskId).toBeDefined();+ expect(taskId.startsWith('task-')).toBe(true);+ });++ it('should get task status', () => {+ const taskId = taskManager.createTask(async () => 'done');+ const status = taskManager.getTask(taskId);++ expect(status).toBeDefined();+ expect(status?.taskId).toBe(taskId);+ });++ it('should track task progress', async () => {+ const taskId = taskManager.createTask(async (reportProgress) => {+ reportProgress({ progress: 50, total: 100, message: 'Halfway' });+ return 'done';+ });++ // Wait for task to complete+ const result = await taskManager.waitForTask(taskId, 5000);+ expect(result.state).toBe('completed');+ });++ it('should cancel a task', () => {+ const taskId = taskManager.createTask(async (reportProgress, signal) => {+ // Long running task+ await new Promise((resolve, reject) => {+ const timeout = setTimeout(resolve, 10000);+ signal.addEventListener('abort', () => {+ clearTimeout(timeout);+ reject(new Error('Cancelled'));+ });+ });+ });++ const cancelled = taskManager.cancelTask(taskId, 'User requested');+ expect(cancelled).toBe(true);+ });++ it('should get all tasks', () => {+ taskManager.createTask(async () => 'task1');+ taskManager.createTask(async () => 'task2');++ const tasks = taskManager.getAllTasks();+ expect(tasks.length).toBe(2);+ });++ it('should get stats', () => {+ taskManager.createTask(async () => 'done');++ const stats = taskManager.getStats();+ expect(stats.totalTasks).toBeGreaterThan(0);+ });+ });+});diff --git a/v3/@claude-flow/mcp/package.json b/v3/@claude-flow/mcp/package.jsonnew file mode 100644index 0000000000..cfea7c367b--- /dev/null+++ b/v3/@claude-flow/mcp/package.json@@ -0,0 +1,38 @@+{+ "name": "@claude-flow/mcp",+ "version": "3.0.0-alpha.1",+ "type": "module",+ "description": "Standalone MCP (Model Context Protocol) server - stdio/http/websocket transports, connection pooling, tool registry",+ "main": "src/index.ts",+ "types": "src/index.ts",+ "exports": {+ ".": "./src/index.ts",+ "./*": "./src/*.ts"+ },+ "scripts": {+ "test": "vitest run",+ "build": "tsc"+ },+ "dependencies": {+ "cors": "^2.8.5",+ "express": "^4.18.2",+ "helmet": "^7.1.0",+ "ws": "^8.14.2"+ },+ "devDependencies": {+ "@types/cors": "^2.8.17",+ "@types/express": "^4.17.21",+ "@types/ws": "^8.5.10",+ "vitest": "^1.0.0"+ },+ "keywords": [+ "mcp",+ "model-context-protocol",+ "claude",+ "ai-agents",+ "json-rpc",+ "stdio",+ "websocket",+ "tool-registry"+ ]+}diff --git a/v3/@claude-flow/mcp/pnpm-lock.yaml b/v3/@claude-flow/mcp/pnpm-lock.yamlnew file mode 100644index 0000000000..22c95c5cc0--- /dev/null+++ b/v3/@claude-flow/mcp/pnpm-lock.yaml@@ -0,0 +1,1646 @@+lockfileVersion: '6.0'++settings:+ autoInstallPeers: true+ excludeLinksFromLockfile: false++dependencies:+ cors:+ specifier: ^2.8.5+ version: 2.8.5+ express:+ specifier: ^4.18.2+ version: 4.22.1+ helmet:+ specifier: ^7.1.0+ version: 7.2.0+ ws:+ specifier: ^8.14.2+ version: 8.19.0++devDependencies:+ '@types/cors':+ specifier: ^2.8.17+ version: 2.8.19+ '@types/express':+ specifier: ^4.17.21+ version: 4.17.25+ '@types/ws':+ specifier: ^8.5.10+ version: 8.18.1+ vitest:+ specifier: ^1.0.0+ version: 1.6.1++packages:++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==}+ engines: {node: '>=12'}+ cpu: [ppc64]+ os: [aix]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==}+ engines: {node: '>=12'}+ cpu: [arm64]+ os: [android]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==}+ engines: {node: '>=12'}+ cpu: [arm]+ os: [android]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==}+ engines: {node: '>=12'}+ cpu: [x64]+ os: [android]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==}+ engines: {node: '>=12'}+ cpu: [arm64]+ os: [darwin]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==}+ engines: {node: '>=12'}+ cpu: [x64]+ os: [darwin]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==}+ engines: {node: '>=12'}+ cpu: [arm64]+ os: [freebsd]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==}+ engines: {node: '>=12'}+ cpu: [x64]+ os: [freebsd]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==}+ engines: {node: '>=12'}+ cpu: [arm64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==}+ engines: {node: '>=12'}+ cpu: [arm]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==}+ engines: {node: '>=12'}+ cpu: [ia32]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==}+ engines: {node: '>=12'}+ cpu: [loong64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==}+ engines: {node: '>=12'}+ cpu: [mips64el]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==}+ engines: {node: '>=12'}+ cpu: [ppc64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==}+ engines: {node: '>=12'}+ cpu: [riscv64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==}+ engines: {node: '>=12'}+ cpu: [s390x]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==}+ engines: {node: '>=12'}+ cpu: [x64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==}+ engines: {node: '>=12'}+ cpu: [x64]+ os: [netbsd]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==}+ engines: {node: '>=12'}+ cpu: [x64]+ os: [openbsd]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==}+ engines: {node: '>=12'}+ cpu: [x64]+ os: [sunos]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==}+ engines: {node: '>=12'}+ cpu: [arm64]+ os: [win32]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==}+ engines: {node: '>=12'}+ cpu: [ia32]+ os: [win32]+ requiresBuild: true+ dev: true+ optional: true++ /@esbuild/[email protected]:+ resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==}+ engines: {node: '>=12'}+ cpu: [x64]+ os: [win32]+ requiresBuild: true+ dev: true+ optional: true++ /@jest/[email protected]:+ resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==}+ engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}+ dependencies:+ '@sinclair/typebox': 0.27.8+ dev: true++ /@jridgewell/[email protected]:+ resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}+ dev: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-9R0DM/ykwfGIlNu6+2U09ga0WXeZ9MRC2Ter8jnz8415VbuIykVuc6bhdrbORFZANDmTDvq26mJrEVTl8TdnDg==}+ cpu: [arm]+ os: [android]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-eFZCb1YUqhTysgW3sj/55du5cG57S7UTNtdMjCW7LwVcj3dTTcowCsC8p7uBdzKsZYa8J7IDE8lhMI+HX1vQvg==}+ cpu: [arm64]+ os: [android]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-p3grE2PHcQm2e8PSGZdzIhCKbMCw/xi9XvMPErPhwO17vxtvCN5FEA2mSLgmKlCjHGMQTP6phuQTYWUnKewwGg==}+ cpu: [arm64]+ os: [darwin]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-rDUjG25C9qoTm+e02Esi+aqTKSBYwVTaoS1wxcN47/Luqef57Vgp96xNANwt5npq9GDxsH7kXxNkJVEsWEOEaQ==}+ cpu: [x64]+ os: [darwin]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-+JiU7Jbp5cdxekIgdte0jfcu5oqw4GCKr6i3PJTlXTCU5H5Fvtkpbs4XJHRmWNXF+hKmn4v7ogI5OQPaupJgOg==}+ cpu: [arm64]+ os: [freebsd]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-V5xC1tOVWtLLmr3YUk2f6EJK4qksksOYiz/TCsFHu/R+woubcLWdC9nZQmwjOAbmExBIVKsm1/wKmEy4z4u4Bw==}+ cpu: [x64]+ os: [freebsd]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-Rn3n+FUk2J5VWx+ywrG/HGPTD9jXNbicRtTM11e/uorplArnXZYsVifnPPqNNP5BsO3roI4n8332ukpY/zN7rQ==}+ cpu: [arm]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-grPNWydeKtc1aEdrJDWk4opD7nFtQbMmV7769hiAaYyUKCT1faPRm2av8CX1YJsZ4TLAZcg9gTR1KvEzoLjXkg==}+ cpu: [arm]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-a59mwd1k6x8tXKcUxSyISiquLwB5pX+fJW9TkWU46lCqD/GRDe9uDN31jrMmVP3feI3mhAdvcCClhV8V5MhJFQ==}+ cpu: [arm64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-puS1MEgWX5GsHSoiAsF0TYrpomdvkaXm0CofIMG5uVkP6IBV+ZO9xhC5YEN49nsgYo1DuuMquF9+7EDBVYu4uA==}+ cpu: [arm64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-r3Wv40in+lTsULSb6nnoudVbARdOwb2u5fpeoOAZjFLznp6tDU8kd+GTHmJoqZ9lt6/Sys33KdIHUaQihFcu7g==}+ cpu: [loong64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-MR8c0+UxAlB22Fq4R+aQSPBayvYa3+9DrwG/i1TKQXFYEaoW3B5b/rkSRIypcZDdWjWnpcvxbNaAJDcSbJU3Lw==}+ cpu: [loong64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-3KhoECe1BRlSYpMTeVrD4sh2Pw2xgt4jzNSZIIPLFEsnQn9gAnZagW9+VqDqAHgm1Xc77LzJOo2LdigS5qZ+gw==}+ cpu: [ppc64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-ziR1OuZx0vdYZZ30vueNZTg73alF59DicYrPViG0NEgDVN8/Jl87zkAPu4u6VjZST2llgEUjaiNl9JM6HH1Vdw==}+ cpu: [ppc64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-uW0Y12ih2XJRERZ4jAfKamTyIHVMPQnTZcQjme2HMVDAHY4amf5u414OqNYC+x+LzRdRcnIG1YodLrrtA8xsxw==}+ cpu: [riscv64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-u9yZ0jUkOED1BFrqu3BwMQoixvGHGZ+JhJNkNKY/hyoEgOwlqKb62qu+7UjbPSHYjiVy8kKJHvXKv5coH4wDeg==}+ cpu: [riscv64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-/0PenBCmqM4ZUd0190j7J0UsQ/1nsi735iPRakO8iPciE7BQ495Y6msPzaOmvx0/pn+eJVVlZrNrSh4WSYLxNg==}+ cpu: [s390x]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-a8G4wiQxQG2BAvo+gU6XrReRRqj+pLS2NGXKm8io19goR+K8lw269eTrPkSdDTALwMmJp4th2Uh0D8J9bEV1vg==}+ cpu: [x64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-bD+zjpFrMpP/hqkfEcnjXWHMw5BIghGisOKPj+2NaNDuVT+8Ds4mPf3XcPHuat1tz89WRL+1wbcxKY3WSbiT7w==}+ cpu: [x64]+ os: [linux]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-eLXw0dOiqE4QmvikfQ6yjgkg/xDM+MdU9YJuP4ySTibXU0oAvnEWXt7UDJmD4UkYialMfOGFPJnIHSe/kdzPxg==}+ cpu: [x64]+ os: [openbsd]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-xzm44KgEP11te3S2HCSyYf5zIzWmx3n8HDCc7EE59+lTcswEWNpvMLfd9uJvVX8LCg9QWG67Xt75AuHn4vgsXw==}+ cpu: [arm64]+ os: [openharmony]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-yR6Bl3tMC/gBok5cz/Qi0xYnVbIxGx5Fcf/ca0eB6/6JwOY+SRUcJfI0OpeTpPls7f194as62thCt/2BjxYN8g==}+ cpu: [arm64]+ os: [win32]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-3fZBidchE0eY0oFZBnekYCfg+5wAB0mbpCBuofh5mZuzIU/4jIVkbESmd2dOsFNS78b53CYv3OAtwqkZZmU5nA==}+ cpu: [ia32]+ os: [win32]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-xGGY5pXj69IxKb4yv/POoocPy/qmEGhimy/FoTpTSVju3FYXUQQMFCaZZXJVidsmGxRioZAwpThl/4zX41gRKg==}+ cpu: [x64]+ os: [win32]+ requiresBuild: true+ dev: true+ optional: true++ /@rollup/[email protected]:+ resolution: {integrity: sha512-SPEpaL6DX4rmcXtnhdrQYgzQ5W2uW3SCJch88lB2zImhJRhIIK44fkUrgIV/Q8yUNfw5oyZ5vkeQsZLhCb06lw==}+ cpu: [x64]+ os: [win32]+ requiresBuild: true+ dev: true+ optional: true++ /@sinclair/[email protected]:+ resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==}+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==}+ dependencies:+ '@types/connect': 3.4.38+ '@types/node': 25.0.3+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==}+ dependencies:+ '@types/node': 25.0.3+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==}+ dependencies:+ '@types/node': 25.0.3+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-FvPtiIf1LfhzsaIXhv/PHan/2FeQBbtBDtfX2QfvPxdUelMDEckK08SM6nqo1MIZY3RUlfA+HV8+hFUSio78qg==}+ dependencies:+ '@types/node': 25.0.3+ '@types/qs': 6.14.0+ '@types/range-parser': 1.2.7+ '@types/send': 1.2.1+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==}+ dependencies:+ '@types/body-parser': 1.19.6+ '@types/express-serve-static-core': 4.19.7+ '@types/qs': 6.14.0+ '@types/serve-static': 1.15.10+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==}+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==}+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA==}+ dependencies:+ undici-types: 7.16.0+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==}+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==}+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==}+ dependencies:+ '@types/mime': 1.3.5+ '@types/node': 25.0.3+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==}+ dependencies:+ '@types/node': 25.0.3+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==}+ dependencies:+ '@types/http-errors': 2.0.5+ '@types/node': 25.0.3+ '@types/send': 0.17.6+ dev: true++ /@types/[email protected]:+ resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}+ dependencies:+ '@types/node': 25.0.3+ dev: true++ /@vitest/[email protected]:+ resolution: {integrity: sha512-jXL+9+ZNIJKruofqXuuTClf44eSpcHlgj3CiuNihUF3Ioujtmc0zIa3UJOW5RjDK1YLBJZnWBlPuqhYycLioog==}+ dependencies:+ '@vitest/spy': 1.6.1+ '@vitest/utils': 1.6.1+ chai: 4.5.0+ dev: true++ /@vitest/[email protected]:+ resolution: {integrity: sha512-3nSnYXkVkf3mXFfE7vVyPmi3Sazhb/2cfZGGs0JRzFsPFvAMBEcrweV1V1GsrstdXeKCTXlJbvnQwGWgEIHmOA==}+ dependencies:+ '@vitest/utils': 1.6.1+ p-limit: 5.0.0+ pathe: 1.1.2+ dev: true++ /@vitest/[email protected]:+ resolution: {integrity: sha512-WvidQuWAzU2p95u8GAKlRMqMyN1yOJkGHnx3M1PL9Raf7AQ1kwLKg04ADlCa3+OXUZE7BceOhVZiuWAbzCKcUQ==}+ dependencies:+ magic-string: 0.30.21+ pathe: 1.1.2+ pretty-format: 29.7.0+ dev: true++ /@vitest/[email protected]:+ resolution: {integrity: sha512-MGcMmpGkZebsMZhbQKkAf9CX5zGvjkBTqf8Zx3ApYWXr3wG+QvEu2eXWfnIIWYSJExIp4V9FCKDEeygzkYrXMw==}+ dependencies:+ tinyspy: 2.2.1+ dev: true++ /@vitest/[email protected]:+ resolution: {integrity: sha512-jOrrUvXM4Av9ZWiG1EajNto0u96kWAhJ1LmPmJhXXQx/32MecEKd10pOLYgS2BQx1TgkGhloPU1ArDW2vvaY6g==}+ dependencies:+ diff-sequences: 29.6.3+ estree-walker: 3.0.3+ loupe: 2.3.7+ pretty-format: 29.7.0+ dev: true++ resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}+ engines: {node: '>= 0.6'}+ dependencies:+ mime-types: 2.1.35+ negotiator: 0.6.3+ dev: false++ resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==}+ engines: {node: '>=0.4.0'}+ dependencies:+ acorn: 8.15.0+ dev: true++ resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}+ engines: {node: '>=0.4.0'}+ hasBin: true+ dev: true++ resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==}+ engines: {node: '>=10'}+ dev: true++ resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==}+ dev: false++ resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==}+ dev: true++ resolution: {integrity: sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==}+ engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}+ dependencies:+ bytes: 3.1.2+ content-type: 1.0.5+ debug: 2.6.9+ depd: 2.0.0+ destroy: 1.2.0+ http-errors: 2.0.1+ iconv-lite: 0.4.24+ on-finished: 2.4.1+ qs: 6.14.1+ raw-body: 2.5.3+ type-is: 1.6.18+ unpipe: 1.0.0+ transitivePeerDependencies:+ - supports-color+ dev: false++ resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}+ engines: {node: '>= 0.8'}+ dev: false++ resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}+ engines: {node: '>=8'}+ dev: true++ resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}+ engines: {node: '>= 0.4'}+ dependencies:+ es-errors: 1.3.0+ function-bind: 1.1.2+ dev: false++ resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}+ engines: {node: '>= 0.4'}+ dependencies:+ call-bind-apply-helpers: 1.0.2+ get-intrinsic: 1.3.0+ dev: false++ resolution: {integrity: sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw==}+ engines: {node: '>=4'}+ dependencies:+ assertion-error: 1.1.0+ check-error: 1.0.3+ deep-eql: 4.1.4+ get-func-name: 2.0.2+ loupe: 2.3.7+ pathval: 1.1.1+ type-detect: 4.1.0+ dev: true++ resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==}+ dependencies:+ get-func-name: 2.0.2+ dev: true++ resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==}+ dev: true++ resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==}+ engines: {node: '>= 0.6'}+ dependencies:+ safe-buffer: 5.2.1+ dev: false++ resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==}+ dev: false++ resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==}+ engines: {node: '>= 0.10'}+ dependencies:+ object-assign: 4.1.1+ vary: 1.1.2+ dev: false++ resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}+ engines: {node: '>= 8'}+ dependencies:+ path-key: 3.1.1+ shebang-command: 2.0.0+ which: 2.0.2+ dev: true++ resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==}+ peerDependencies:+ supports-color: '*'+ peerDependenciesMeta:+ supports-color:+ optional: true+ dependencies:+ ms: 2.0.0+ dev: false++ resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}+ engines: {node: '>=6.0'}+ peerDependencies:+ supports-color: '*'+ peerDependenciesMeta:+ supports-color:+ optional: true+ dependencies:+ ms: 2.1.3+ dev: true++ resolution: {integrity: sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==}+ engines: {node: '>=6'}+ dependencies:+ type-detect: 4.1.0+ dev: true++ resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}+ engines: {node: '>= 0.8'}+ dev: false++ resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==}+ engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}+ dev: false++ resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==}+ engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}+ dev: true++ resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}+ engines: {node: '>= 0.4'}+ dependencies:+ call-bind-apply-helpers: 1.0.2+ es-errors: 1.3.0+ gopd: 1.2.0+ dev: false++ resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}+ dev: false++ resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}+ engines: {node: '>= 0.8'}+ dev: false++ resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}+ engines: {node: '>= 0.4'}+ dev: false++ resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}+ engines: {node: '>= 0.4'}+ dev: false++ resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}+ engines: {node: '>= 0.4'}+ dependencies:+ es-errors: 1.3.0+ dev: false++ resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==}+ engines: {node: '>=12'}+ hasBin: true+ requiresBuild: true+ optionalDependencies:+ '@esbuild/aix-ppc64': 0.21.5+ '@esbuild/android-arm': 0.21.5+ '@esbuild/android-arm64': 0.21.5+ '@esbuild/android-x64': 0.21.5+ '@esbuild/darwin-arm64': 0.21.5+ '@esbuild/darwin-x64': 0.21.5+ '@esbuild/freebsd-arm64': 0.21.5+ '@esbuild/freebsd-x64': 0.21.5+ '@esbuild/linux-arm': 0.21.5+ '@esbuild/linux-arm64': 0.21.5+ '@esbuild/linux-ia32': 0.21.5+ '@esbuild/linux-loong64': 0.21.5+ '@esbuild/linux-mips64el': 0.21.5+ '@esbuild/linux-ppc64': 0.21.5+ '@esbuild/linux-riscv64': 0.21.5+ '@esbuild/linux-s390x': 0.21.5+ '@esbuild/linux-x64': 0.21.5+ '@esbuild/netbsd-x64': 0.21.5+ '@esbuild/openbsd-x64': 0.21.5+ '@esbuild/sunos-x64': 0.21.5+ '@esbuild/win32-arm64': 0.21.5+ '@esbuild/win32-ia32': 0.21.5+ '@esbuild/win32-x64': 0.21.5+ dev: true++ resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==}+ dev: false++ resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}+ dependencies:+ '@types/estree': 1.0.8+ dev: true++ resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==}+ engines: {node: '>=16.17'}+ dependencies:+ cross-spawn: 7.0.6+ get-stream: 8.0.1+ human-signals: 5.0.0+ is-stream: 3.0.0+ merge-stream: 2.0.0+ npm-run-path: 5.3.0+ onetime: 6.0.0+ signal-exit: 4.1.0+ strip-final-newline: 3.0.0+ dev: true++ resolution: {integrity: sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==}+ engines: {node: '>= 0.10.0'}+ dependencies:+ accepts: 1.3.8+ array-flatten: 1.1.1+ body-parser: 1.20.4+ content-disposition: 0.5.4+ content-type: 1.0.5+ cookie: 0.7.2+ cookie-signature: 1.0.7+ debug: 2.6.9+ depd: 2.0.0+ encodeurl: 2.0.0+ escape-html: 1.0.3+ etag: 1.8.1+ finalhandler: 1.3.2+ fresh: 0.5.2+ http-errors: 2.0.1+ merge-descriptors: 1.0.3+ methods: 1.1.2+ on-finished: 2.4.1+ parseurl: 1.3.3+ path-to-regexp: 0.1.12+ proxy-addr: 2.0.7+ qs: 6.14.1+ range-parser: 1.2.1+ safe-buffer: 5.2.1+ send: 0.19.2+ serve-static: 1.16.3+ setprototypeof: 1.2.0+ statuses: 2.0.2+ type-is: 1.6.18+ utils-merge: 1.0.1+ vary: 1.1.2+ transitivePeerDependencies:+ - supports-color+ dev: false++ resolution: {integrity: sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==}+ engines: {node: '>= 0.8'}+ dependencies:+ debug: 2.6.9+ encodeurl: 2.0.0+ escape-html: 1.0.3+ on-finished: 2.4.1+ parseurl: 1.3.3+ statuses: 2.0.2+ unpipe: 1.0.0+ transitivePeerDependencies:+ - supports-color+ dev: false++ resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}+ engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}+ os: [darwin]+ requiresBuild: true+ dev: true+ optional: true++ resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}+ dev: false++ resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==}+ dev: true++ resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}+ engines: {node: '>= 0.4'}+ dependencies:+ call-bind-apply-helpers: 1.0.2+ es-define-property: 1.0.1+ es-errors: 1.3.0+ es-object-atoms: 1.1.1+ function-bind: 1.1.2+ get-proto: 1.0.1+ gopd: 1.2.0+ has-symbols: 1.1.0+ hasown: 2.0.2+ math-intrinsics: 1.1.0+ dev: false++ resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}+ engines: {node: '>= 0.4'}+ dependencies:+ dunder-proto: 1.0.1+ es-object-atoms: 1.1.1+ dev: false++ resolution: {integrity: sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==}+ engines: {node: '>=16'}+ dev: true++ resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}+ engines: {node: '>= 0.4'}+ dev: false++ resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}+ engines: {node: '>= 0.4'}+ dev: false++ resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}+ engines: {node: '>= 0.4'}+ dependencies:+ function-bind: 1.1.2+ dev: false++ resolution: {integrity: sha512-ZRiwvN089JfMXokizgqEPXsl2Guk094yExfoDXR0cBYWxtBbaSww/w+vT4WEJsBW2iTUi1GgZ6swmoug3Oy4Xw==}+ engines: {node: '>=16.0.0'}+ dev: false++ resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==}+ engines: {node: '>= 0.8'}+ dependencies:+ depd: 2.0.0+ inherits: 2.0.4+ setprototypeof: 1.2.0+ statuses: 2.0.2+ toidentifier: 1.0.1+ dev: false++ resolution: {integrity: sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==}+ engines: {node: '>=16.17.0'}+ dev: true++ resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==}+ engines: {node: '>=0.10.0'}+ dependencies:+ safer-buffer: 2.1.2+ dev: false++ resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}+ dev: false++ resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}+ engines: {node: '>= 0.10'}+ dev: false++ resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==}+ engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}+ dev: true++ resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}+ dev: true++ resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}+ dev: true++ resolution: {integrity: sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==}+ engines: {node: '>=14'}+ dependencies:+ mlly: 1.8.0+ pkg-types: 1.3.1+ dev: true++ resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==}+ dependencies:+ get-func-name: 2.0.2+ dev: true++ resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}+ dependencies:+ '@jridgewell/sourcemap-codec': 1.5.5+ dev: true++ resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}+ engines: {node: '>= 0.4'}+ dev: false++ resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==}+ dev: false++ resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}+ dev: true++ resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}+ engines: {node: '>= 0.6'}+ dependencies:+ mime-db: 1.52.0+ dev: false++ resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}+ engines: {node: '>=4'}+ hasBin: true+ dev: false++ resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==}+ engines: {node: '>=12'}+ dev: true++ resolution: {integrity: sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==}+ dependencies:+ acorn: 8.15.0+ pathe: 2.0.3+ pkg-types: 1.3.1+ ufo: 1.6.1+ dev: true++ resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==}+ dev: false++ resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}++ resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}+ engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}+ hasBin: true+ dev: true++ resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==}+ engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}+ dependencies:+ path-key: 4.0.0+ dev: true++ resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}+ engines: {node: '>=0.10.0'}+ dev: false++ resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}+ engines: {node: '>= 0.4'}+ dev: false++ resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}+ engines: {node: '>= 0.8'}+ dependencies:+ ee-first: 1.1.1+ dev: false++ resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==}+ engines: {node: '>=12'}+ dependencies:+ mimic-fn: 4.0.0+ dev: true++ resolution: {integrity: sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==}+ engines: {node: '>=18'}+ dependencies:+ yocto-queue: 1.2.2+ dev: true++ resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}+ engines: {node: '>= 0.8'}+ dev: false++ resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}+ engines: {node: '>=8'}+ dev: true++ resolution: {integrity: sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==}+ engines: {node: '>=12'}+ dev: true++ resolution: {integrity: sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==}+ dev: false++ resolution: {integrity: sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==}+ dev: true++ resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}+ dev: true++ resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==}+ dev: true++ resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}+ dev: true++ resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==}+ dependencies:+ confbox: 0.1.8+ mlly: 1.8.0+ pathe: 2.0.3+ dev: true++ resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}+ engines: {node: ^10 || ^12 || >=14}+ dependencies:+ nanoid: 3.3.11+ picocolors: 1.1.1+ source-map-js: 1.2.1+ dev: true++ resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==}+ engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}+ dependencies:+ '@jest/schemas': 29.6.3+ ansi-styles: 5.2.0+ react-is: 18.3.1+ dev: true++ resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}+ engines: {node: '>= 0.10'}+ dependencies:+ forwarded: 0.2.0+ ipaddr.js: 1.9.1+ dev: false++ resolution: {integrity: sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==}+ engines: {node: '>=0.6'}+ dependencies:+ side-channel: 1.1.0+ dev: false++ resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}+ engines: {node: '>= 0.6'}+ dev: false++ resolution: {integrity: sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==}+ engines: {node: '>= 0.8'}+ dependencies:+ bytes: 3.1.2+ http-errors: 2.0.1+ iconv-lite: 0.4.24+ unpipe: 1.0.0+ dev: false++ resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}+ dev: true++ resolution: {integrity: sha512-wDv/Ht1BNHB4upNbK74s9usvl7hObDnvVzknxqY/E/O3X6rW1U1rV1aENEfJ54eFZDTNo7zv1f5N4edCluH7+A==}+ engines: {node: '>=18.0.0', npm: '>=8.0.0'}+ hasBin: true+ dependencies:+ '@types/estree': 1.0.8+ optionalDependencies:+ '@rollup/rollup-android-arm-eabi': 4.55.1+ '@rollup/rollup-android-arm64': 4.55.1+ '@rollup/rollup-darwin-arm64': 4.55.1+ '@rollup/rollup-darwin-x64': 4.55.1+ '@rollup/rollup-freebsd-arm64': 4.55.1+ '@rollup/rollup-freebsd-x64': 4.55.1+ '@rollup/rollup-linux-arm-gnueabihf': 4.55.1+ '@rollup/rollup-linux-arm-musleabihf': 4.55.1+ '@rollup/rollup-linux-arm64-gnu': 4.55.1+ '@rollup/rollup-linux-arm64-musl': 4.55.1+ '@rollup/rollup-linux-loong64-gnu': 4.55.1+ '@rollup/rollup-linux-loong64-musl': 4.55.1+ '@rollup/rollup-linux-ppc64-gnu': 4.55.1+ '@rollup/rollup-linux-ppc64-musl': 4.55.1+ '@rollup/rollup-linux-riscv64-gnu': 4.55.1+ '@rollup/rollup-linux-riscv64-musl': 4.55.1+ '@rollup/rollup-linux-s390x-gnu': 4.55.1+ '@rollup/rollup-linux-x64-gnu': 4.55.1+ '@rollup/rollup-linux-x64-musl': 4.55.1+ '@rollup/rollup-openbsd-x64': 4.55.1+ '@rollup/rollup-openharmony-arm64': 4.55.1+ '@rollup/rollup-win32-arm64-msvc': 4.55.1+ '@rollup/rollup-win32-ia32-msvc': 4.55.1+ '@rollup/rollup-win32-x64-gnu': 4.55.1+ '@rollup/rollup-win32-x64-msvc': 4.55.1+ fsevents: 2.3.3+ dev: true++ resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}+ dev: false++ resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}+ dev: false++ resolution: {integrity: sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==}+ engines: {node: '>= 0.8.0'}+ dependencies:+ debug: 2.6.9+ depd: 2.0.0+ destroy: 1.2.0+ encodeurl: 2.0.0+ escape-html: 1.0.3+ etag: 1.8.1+ fresh: 0.5.2+ http-errors: 2.0.1+ mime: 1.6.0+ ms: 2.1.3+ on-finished: 2.4.1+ range-parser: 1.2.1+ statuses: 2.0.2+ transitivePeerDependencies:+ - supports-color+ dev: false++ resolution: {integrity: sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==}+ engines: {node: '>= 0.8.0'}+ dependencies:+ encodeurl: 2.0.0+ escape-html: 1.0.3+ parseurl: 1.3.3+ send: 0.19.2+ transitivePeerDependencies:+ - supports-color+ dev: false++ resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}+ dev: false++ resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}+ engines: {node: '>=8'}+ dependencies:+ shebang-regex: 3.0.0+ dev: true++ resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}+ engines: {node: '>=8'}+ dev: true++ resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}+ engines: {node: '>= 0.4'}+ dependencies:+ es-errors: 1.3.0+ object-inspect: 1.13.4+ dev: false++ resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==}+ engines: {node: '>= 0.4'}+ dependencies:+ call-bound: 1.0.4+ es-errors: 1.3.0+ get-intrinsic: 1.3.0+ object-inspect: 1.13.4+ dev: false++ resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==}+ engines: {node: '>= 0.4'}+ dependencies:+ call-bound: 1.0.4+ es-errors: 1.3.0+ get-intrinsic: 1.3.0+ object-inspect: 1.13.4+ side-channel-map: 1.0.1+ dev: false++ resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}+ engines: {node: '>= 0.4'}+ dependencies:+ es-errors: 1.3.0+ object-inspect: 1.13.4+ side-channel-list: 1.0.0+ side-channel-map: 1.0.1+ side-channel-weakmap: 1.0.2+ dev: false++ resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}+ dev: true++ resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}+ engines: {node: '>=14'}+ dev: true++ resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}+ engines: {node: '>=0.10.0'}+ dev: true++ resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}+ dev: true++ resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==}+ engines: {node: '>= 0.8'}+ dev: false++ resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==}+ dev: true++ resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==}+ engines: {node: '>=12'}+ dev: true++ resolution: {integrity: sha512-631UJ6O00eNGfMiWG78ck80dfBab8X6IVFB51jZK5Icd7XAs60Z5y7QdSd/wGIklnWvRbUNloVzhOKKmutxQ6Q==}+ dependencies:+ js-tokens: 9.0.1+ dev: true++ resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}+ dev: true++ resolution: {integrity: sha512-i11VH5gS6IFeLY3gMBQ00/MmLncVP7JLXOw1vlgkytLmJK7QnEr7NXf0LBdxfmNPAeyetukOk0bOYrJrFGjYJQ==}+ engines: {node: '>=14.0.0'}+ dev: true++ resolution: {integrity: sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==}+ engines: {node: '>=14.0.0'}+ dev: true++ resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}+ engines: {node: '>=0.6'}+ dev: false++ resolution: {integrity: sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==}+ engines: {node: '>=4'}+ dev: true++ resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}+ engines: {node: '>= 0.6'}+ dependencies:+ media-typer: 0.3.0+ mime-types: 2.1.35+ dev: false++ resolution: {integrity: sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==}+ dev: true++ resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}+ dev: true++ resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}+ engines: {node: '>= 0.8'}+ dev: false++ resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==}+ engines: {node: '>= 0.4.0'}+ dev: false++ resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}+ engines: {node: '>= 0.8'}+ dev: false++ resolution: {integrity: sha512-YAXkfvGtuTzwWbDSACdJSg4A4DZiAqckWe90Zapc/sEX3XvHcw1NdurM/6od8J207tSDqNbSsgdCacBgvJKFuA==}+ engines: {node: ^18.0.0 || >=20.0.0}+ hasBin: true+ dependencies:+ cac: 6.7.14+ debug: 4.4.3+ pathe: 1.1.2+ picocolors: 1.1.1+ vite: 5.4.21+ transitivePeerDependencies:+ - '@types/node'+ - less+ - lightningcss+ - sass+ - sass-embedded+ - stylus+ - sugarss+ - supports-color+ - terser+ dev: true++ resolution: {integrity: sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==}+ engines: {node: ^18.0.0 || >=20.0.0}+ hasBin: true+ peerDependencies:+ '@types/node': ^18.0.0 || >=20.0.0+ less: '*'+ lightningcss: ^1.21.0+ sass: '*'+ sass-embedded: '*'+ stylus: '*'+ sugarss: '*'+ terser: ^5.4.0+ peerDependenciesMeta:+ '@types/node':+ optional: true+ less:+ optional: true+ lightningcss:+ optional: true+ sass:+ optional: true+ sass-embedded:+ optional: true+ stylus:+ optional: true+ sugarss:+ optional: true+ terser:+ optional: true+ dependencies:+ esbuild: 0.21.5+ postcss: 8.5.6+ rollup: 4.55.1+ optionalDependencies:+ fsevents: 2.3.3+ dev: true++ resolution: {integrity: sha512-Ljb1cnSJSivGN0LqXd/zmDbWEM0RNNg2t1QW/XUhYl/qPqyu7CsqeWtqQXHVaJsecLPuDoak2oJcZN2QoRIOag==}+ engines: {node: ^18.0.0 || >=20.0.0}+ hasBin: true+ peerDependencies:+ '@edge-runtime/vm': '*'+ '@types/node': ^18.0.0 || >=20.0.0+ '@vitest/browser': 1.6.1+ '@vitest/ui': 1.6.1+ happy-dom: '*'+ jsdom: '*'+ peerDependenciesMeta:+ '@edge-runtime/vm':+ optional: true+ '@types/node':+ optional: true+ '@vitest/browser':+ optional: true+ '@vitest/ui':+ optional: true+ happy-dom:+ optional: true+ jsdom:+ optional: true+ dependencies:+ '@vitest/expect': 1.6.1+ '@vitest/runner': 1.6.1+ '@vitest/snapshot': 1.6.1+ '@vitest/spy': 1.6.1+ '@vitest/utils': 1.6.1+ acorn-walk: 8.3.4+ chai: 4.5.0+ debug: 4.4.3+ execa: 8.0.1+ local-pkg: 0.5.1+ magic-string: 0.30.21+ pathe: 1.1.2+ picocolors: 1.1.1+ std-env: 3.10.0+ strip-literal: 2.1.1+ tinybench: 2.9.0+ tinypool: 0.8.4+ vite: 5.4.21+ vite-node: 1.6.1+ why-is-node-running: 2.3.0+ transitivePeerDependencies:+ - less+ - lightningcss+ - sass+ - sass-embedded+ - stylus+ - sugarss+ - supports-color+ - terser+ dev: true++ resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}+ engines: {node: '>= 8'}+ hasBin: true+ dependencies:+ isexe: 2.0.0+ dev: true++ resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}+ engines: {node: '>=8'}+ hasBin: true+ dependencies:+ siginfo: 2.0.0+ stackback: 0.0.2+ dev: true++ resolution: {integrity: sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==}+ engines: {node: '>=10.0.0'}+ peerDependencies:+ bufferutil: ^4.0.1+ utf-8-validate: '>=5.0.2'+ peerDependenciesMeta:+ bufferutil:+ optional: true+ utf-8-validate:+ optional: true+ dev: false++ resolution: {integrity: sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==}+ engines: {node: '>=12.20'}+ dev: truediff --git a/v3/@claude-flow/mcp/src/connection-pool.ts b/v3/@claude-flow/mcp/src/connection-pool.tsnew file mode 100644index 0000000000..e3216d1ba8--- /dev/null+++ b/v3/@claude-flow/mcp/src/connection-pool.ts@@ -0,0 +1,344 @@+/**+ * @claude-flow/mcp - Connection Pool+ *+ * High-performance connection pooling+ */++import { EventEmitter } from 'events';+import type {+ PooledConnection,+ ConnectionPoolStats,+ ConnectionPoolConfig,+ ConnectionState,+ IConnectionPool,+ ILogger,+ TransportType,+} from './types.js';++const DEFAULT_POOL_CONFIG: ConnectionPoolConfig = {+ maxConnections: 10,+ minConnections: 2,+ idleTimeout: 30000,+ acquireTimeout: 5000,+ maxWaitingClients: 50,+ evictionRunInterval: 10000,+};++class ManagedConnection implements PooledConnection {+ public state: ConnectionState = 'idle';+ public lastUsedAt: Date;+ public useCount: number = 0;++ constructor(+ public readonly id: string,+ public readonly transport: TransportType,+ public readonly createdAt: Date = new Date(),+ public metadata?: Record<string, unknown>+ ) {+ this.lastUsedAt = this.createdAt;+ }++ acquire(): void {+ this.state = 'busy';+ this.lastUsedAt = new Date();+ this.useCount++;+ }++ release(): void {+ this.state = 'idle';+ this.lastUsedAt = new Date();+ }++ isExpired(idleTimeout: number): boolean {+ if (this.state !== 'idle') return false;+ return Date.now() - this.lastUsedAt.getTime() > idleTimeout;+ }++ isHealthy(): boolean {+ return this.state !== 'error' && this.state !== 'closed';+ }+}++interface WaitingClient {+ resolve: (connection: PooledConnection) => void;+ reject: (error: Error) => void;+ timestamp: number;+}++export class ConnectionPool extends EventEmitter implements IConnectionPool {+ private readonly config: ConnectionPoolConfig;+ private readonly connections: Map<string, ManagedConnection> = new Map();+ private readonly waitingClients: WaitingClient[] = [];+ private evictionTimer?: NodeJS.Timeout;+ private connectionCounter: number = 0;+ private isShuttingDown: boolean = false;++ private stats = {+ totalAcquired: 0,+ totalReleased: 0,+ totalCreated: 0,+ totalDestroyed: 0,+ acquireTimeTotal: 0,+ acquireCount: 0,+ };++ constructor(+ config: Partial<ConnectionPoolConfig> = {},+ private readonly logger: ILogger,+ private readonly transportType: TransportType = 'in-process'+ ) {+ super();+ this.config = { ...DEFAULT_POOL_CONFIG, ...config };+ this.startEvictionTimer();+ this.initializeMinConnections();+ }++ private async initializeMinConnections(): Promise<void> {+ const promises: Promise<ManagedConnection>[] = [];+ for (let i = 0; i < this.config.minConnections; i++) {+ promises.push(this.createConnection());+ }+ await Promise.all(promises);+ this.logger.debug('Connection pool initialized', {+ minConnections: this.config.minConnections,+ });+ }++ private async createConnection(): Promise<ManagedConnection> {+ const id = `conn-${++this.connectionCounter}-${Date.now()}`;+ const connection = new ManagedConnection(id, this.transportType);++ this.connections.set(id, connection);+ this.stats.totalCreated++;++ this.emit('pool:connection:created', { connectionId: id });+ this.logger.debug('Connection created', { id, total: this.connections.size });++ return connection;+ }++ async acquire(): Promise<PooledConnection> {+ const startTime = performance.now();++ if (this.isShuttingDown) {+ throw new Error('Connection pool is shutting down');+ }++ for (const connection of this.connections.values()) {+ if (connection.state === 'idle' && connection.isHealthy()) {+ connection.acquire();+ this.stats.totalAcquired++;+ this.recordAcquireTime(startTime);++ this.emit('pool:connection:acquired', { connectionId: connection.id });+ this.logger.debug('Connection acquired from pool', { id: connection.id });++ return connection;+ }+ }++ if (this.connections.size < this.config.maxConnections) {+ const connection = await this.createConnection();+ connection.acquire();+ this.stats.totalAcquired++;+ this.recordAcquireTime(startTime);++ this.emit('pool:connection:acquired', { connectionId: connection.id });+ return connection;+ }++ return this.waitForConnection(startTime);+ }++ private waitForConnection(startTime: number): Promise<PooledConnection> {+ return new Promise((resolve, reject) => {+ if (this.waitingClients.length >= this.config.maxWaitingClients) {+ reject(new Error('Connection pool exhausted - max waiting clients reached'));+ return;+ }++ const client: WaitingClient = {+ resolve: (connection) => {+ this.recordAcquireTime(startTime);+ resolve(connection);+ },+ reject,+ timestamp: Date.now(),+ };++ this.waitingClients.push(client);++ setTimeout(() => {+ const index = this.waitingClients.indexOf(client);+ if (index !== -1) {+ this.waitingClients.splice(index, 1);+ reject(new Error(`Connection acquire timeout after ${this.config.acquireTimeout}ms`));+ }+ }, this.config.acquireTimeout);+ });+ }++ release(connection: PooledConnection): void {+ const managed = this.connections.get(connection.id);+ if (!managed) {+ this.logger.warn('Attempted to release unknown connection', { id: connection.id });+ return;+ }++ const waitingClient = this.waitingClients.shift();+ if (waitingClient) {+ managed.acquire();+ this.stats.totalAcquired++;+ this.emit('pool:connection:acquired', { connectionId: connection.id });+ waitingClient.resolve(managed);+ return;+ }++ managed.release();+ this.stats.totalReleased++;++ this.emit('pool:connection:released', { connectionId: connection.id });+ this.logger.debug('Connection released to pool', { id: connection.id });+ }++ destroy(connection: PooledConnection): void {+ const managed = this.connections.get(connection.id);+ if (!managed) {+ return;+ }++ managed.state = 'closed';+ this.connections.delete(connection.id);+ this.stats.totalDestroyed++;++ this.emit('pool:connection:destroyed', { connectionId: connection.id });+ this.logger.debug('Connection destroyed', { id: connection.id });++ if (this.connections.size < this.config.minConnections && !this.isShuttingDown) {+ this.createConnection().catch((err) => {+ this.logger.error('Failed to create replacement connection', err);+ });+ }+ }++ getStats(): ConnectionPoolStats {+ let idleCount = 0;+ let busyCount = 0;++ for (const connection of this.connections.values()) {+ if (connection.state === 'idle') idleCount++;+ else if (connection.state === 'busy') busyCount++;+ }++ return {+ totalConnections: this.connections.size,+ idleConnections: idleCount,+ busyConnections: busyCount,+ pendingRequests: this.waitingClients.length,+ totalAcquired: this.stats.totalAcquired,+ totalReleased: this.stats.totalReleased,+ totalCreated: this.stats.totalCreated,+ totalDestroyed: this.stats.totalDestroyed,+ avgAcquireTime: this.stats.acquireCount > 0+ ? this.stats.acquireTimeTotal / this.stats.acquireCount+ : 0,+ };+ }++ async drain(): Promise<void> {+ this.isShuttingDown = true;+ this.logger.info('Draining connection pool');++ while (this.waitingClients.length > 0) {+ const client = this.waitingClients.shift();+ client?.reject(new Error('Connection pool is draining'));+ }++ const maxWait = 10000;+ const startTime = Date.now();++ while (Date.now() - startTime < maxWait) {+ let busyCount = 0;+ for (const connection of this.connections.values()) {+ if (connection.state === 'busy') busyCount++;+ }++ if (busyCount === 0) break;++ await new Promise((resolve) => setTimeout(resolve, 100));+ }++ this.logger.info('Connection pool drained');+ }++ async clear(): Promise<void> {+ this.stopEvictionTimer();+ await this.drain();++ for (const connection of this.connections.values()) {+ connection.state = 'closed';+ }++ this.connections.clear();+ this.logger.info('Connection pool cleared');+ }++ private startEvictionTimer(): void {+ this.evictionTimer = setInterval(() => {+ this.evictIdleConnections();+ }, this.config.evictionRunInterval);+ }++ private stopEvictionTimer(): void {+ if (this.evictionTimer) {+ clearInterval(this.evictionTimer);+ this.evictionTimer = undefined;+ }+ }++ private evictIdleConnections(): void {+ if (this.isShuttingDown) return;++ const toEvict: ManagedConnection[] = [];++ for (const connection of this.connections.values()) {+ if (+ connection.isExpired(this.config.idleTimeout) &&+ this.connections.size > this.config.minConnections+ ) {+ toEvict.push(connection);+ }+ }++ for (const connection of toEvict) {+ this.destroy(connection);+ this.logger.debug('Evicted idle connection', { id: connection.id });+ }++ if (toEvict.length > 0) {+ this.logger.info('Evicted idle connections', { count: toEvict.length });+ }+ }++ private recordAcquireTime(startTime: number): void {+ const duration = performance.now() - startTime;+ this.stats.acquireTimeTotal += duration;+ this.stats.acquireCount++;+ }++ getConnections(): PooledConnection[] {+ return Array.from(this.connections.values());+ }++ isHealthy(): boolean {+ return !this.isShuttingDown && this.connections.size >= this.config.minConnections;+ }+}++export function createConnectionPool(+ config: Partial<ConnectionPoolConfig> = {},+ logger: ILogger,+ transportType: TransportType = 'in-process'+): ConnectionPool {+ return new ConnectionPool(config, logger, transportType);+}diff --git a/v3/@claude-flow/mcp/src/index.ts b/v3/@claude-flow/mcp/src/index.tsnew file mode 100644index 0000000000..6246db85ba--- /dev/null+++ b/v3/@claude-flow/mcp/src/index.ts@@ -0,0 +1,212 @@+/**+ * @claude-flow/mcp - Standalone MCP Server+ *+ * Zero-dependency MCP (Model Context Protocol) implementation+ *+ * Features:+ * - High-performance server with <400ms startup+ * - Connection pooling with max 10 connections+ * - Multiple transport support (stdio, http, websocket, in-process)+ * - Fast tool registry with <10ms registration+ * - Session management with timeout handling+ * - Comprehensive metrics and monitoring+ *+ * @module @claude-flow/mcp+ * @version 3.0.0+ */++// Core types+export type {+ JsonRpcVersion,+ RequestId,+ MCPMessage,+ MCPRequest,+ MCPResponse,+ MCPNotification,+ MCPError,+ TransportType,+ AuthMethod,+ AuthConfig,+ LoadBalancerConfig,+ ConnectionPoolConfig,+ MCPServerConfig,+ SessionState,+ MCPSession,+ MCPClientInfo,+ MCPCapabilities,+ MCPProtocolVersion,+ MCPInitializeParams,+ MCPInitializeResult,+ JSONSchema,+ ToolContext,+ ToolHandler,+ MCPTool,+ ToolCallResult,+ ToolRegistrationOptions,+ RequestHandler,+ NotificationHandler,+ TransportHealthStatus,+ ITransport,+ ConnectionState,+ PooledConnection,+ ConnectionPoolStats,+ IConnectionPool,+ ToolCallMetrics,+ MCPServerMetrics,+ SessionMetrics,+ MCPEventType,+ MCPEvent,+ EventHandler,+ LogLevel,+ ILogger,+ // MCP 2025-11-25 types+ MCPResource,+ ResourceContent,+ ResourceTemplate,+ ResourceListResult,+ ResourceReadResult,+ PromptArgument,+ MCPPrompt,+ PromptRole,+ ContentAnnotations,+ TextContent,+ ImageContent,+ AudioContent,+ EmbeddedResource,+ PromptContent,+ PromptMessage,+ PromptListResult,+ PromptGetResult,+ TaskState,+ MCPTask,+ TaskProgress,+ TaskResult,+ PaginatedRequest,+ PaginatedResult,+ ProgressNotification,+ CancellationParams,+ SamplingMessage,+ ModelPreferences,+ CreateMessageRequest,+ CreateMessageResult,+ Root,+ RootsListResult,+ MCPLogLevel,+ LoggingMessage,+ CompletionReference,+ CompletionArgument,+ CompletionResult,+} from './types.js';++// Error handling+export { ErrorCodes, MCPServerError } from './types.js';++// Server+import { MCPServer, createMCPServer } from './server.js';+export { MCPServer, createMCPServer };+export type { IMCPServer } from './server.js';++// Tool Registry+export { ToolRegistry, createToolRegistry, defineTool } from './tool-registry.js';++// Session Manager+import { SessionManager, createSessionManager } from './session-manager.js';+export { SessionManager, createSessionManager };+export type { SessionConfig } from './session-manager.js';++// Connection Pool+export { ConnectionPool, createConnectionPool } from './connection-pool.js';++// Resource Registry (MCP 2025-11-25)+export {+ ResourceRegistry,+ createResourceRegistry,+ createTextResource,+ createFileResource,+} from './resource-registry.js';+export type { ResourceHandler, SubscriptionCallback, ResourceRegistryOptions } from './resource-registry.js';++// Prompt Registry (MCP 2025-11-25)+export {+ PromptRegistry,+ createPromptRegistry,+ definePrompt,+ textMessage,+ resourceMessage,+ interpolate,+} from './prompt-registry.js';+export type { PromptHandler, PromptDefinition, PromptRegistryOptions } from './prompt-registry.js';++// Task Manager (MCP 2025-11-25)+export { TaskManager, createTaskManager } from './task-manager.js';+export type { TaskExecutor, TaskManagerOptions } from './task-manager.js';++// Transport layer+export {+ createTransport,+ createInProcessTransport,+ TransportManager,+ createTransportManager,+ DEFAULT_TRANSPORT_CONFIGS,+ StdioTransport,+ HttpTransport,+ WebSocketTransport,+} from './transport/index.js';++export type {+ TransportConfig,+ StdioTransportConfig,+ HttpTransportConfig,+ WebSocketTransportConfig,+} from './transport/index.js';++// Import types for quickStart+import type { MCPServerConfig, ILogger } from './types.js';++/**+ * Quick start function to create and configure an MCP server+ *+ * @example+ * ```typescript+ * import { quickStart } from '@claude-flow/mcp';+ *+ * const server = await quickStart({+ * transport: 'stdio',+ * name: 'My MCP Server',+ * });+ *+ * server.registerTool({+ * name: 'my-tool',+ * description: 'My custom tool',+ * inputSchema: { type: 'object', properties: {} },+ * handler: async () => ({ result: 'success' }),+ * });+ *+ * await server.start();+ * ```+ */+export async function quickStart(+ config: Partial<MCPServerConfig>,+ logger?: ILogger+): Promise<MCPServer> {+ const defaultLogger: ILogger = logger || {+ debug: (msg, data) => console.debug(`[DEBUG] ${msg}`, data || ''),+ info: (msg, data) => console.info(`[INFO] ${msg}`, data || ''),+ warn: (msg, data) => console.warn(`[WARN] ${msg}`, data || ''),+ error: (msg, data) => console.error(`[ERROR] ${msg}`, data || ''),+ };++ const server = createMCPServer(config, defaultLogger);++ return server;+}++/**+ * Module version+ */+export const VERSION = '3.0.0';++/**+ * Module name+ */+export const MODULE_NAME = '@claude-flow/mcp';diff --git a/v3/@claude-flow/mcp/src/prompt-registry.ts b/v3/@claude-flow/mcp/src/prompt-registry.tsnew file mode 100644index 0000000000..19fc2cf0d3--- /dev/null+++ b/v3/@claude-flow/mcp/src/prompt-registry.ts@@ -0,0 +1,296 @@+/**+ * @claude-flow/mcp - Prompt Registry+ *+ * MCP 2025-11-25 compliant prompt management+ * Supports: list, get, arguments, templates, embedded resources+ */++import { EventEmitter } from 'events';+import type {+ MCPPrompt,+ PromptArgument,+ PromptMessage,+ PromptListResult,+ PromptGetResult,+ PromptContent,+ TextContent,+ EmbeddedResource,+ ResourceContent,+ ILogger,+} from './types.js';++export type PromptHandler = (+ args: Record<string, string>+) => Promise<PromptMessage[]>;++export interface PromptDefinition extends MCPPrompt {+ handler: PromptHandler;+}++export interface PromptRegistryOptions {+ maxPrompts?: number;+ validateArguments?: boolean;+}++export class PromptRegistry extends EventEmitter {+ private prompts: Map<string, PromptDefinition> = new Map();++ private readonly options: Required<PromptRegistryOptions>;++ constructor(+ private readonly logger: ILogger,+ options: PromptRegistryOptions = {}+ ) {+ super();+ this.options = {+ maxPrompts: options.maxPrompts ?? 1000,+ validateArguments: options.validateArguments ?? true,+ };+ }++ /**+ * Register a prompt+ */+ register(prompt: PromptDefinition): boolean {+ if (this.prompts.size >= this.options.maxPrompts) {+ this.logger.error('Maximum prompts reached', { max: this.options.maxPrompts });+ return false;+ }++ if (this.prompts.has(prompt.name)) {+ this.logger.warn('Prompt already registered', { name: prompt.name });+ return false;+ }++ this.prompts.set(prompt.name, prompt);++ this.logger.debug('Prompt registered', { name: prompt.name });+ this.emit('prompt:registered', { name: prompt.name });+ this.emitListChanged();++ return true;+ }++ /**+ * Unregister a prompt+ */+ unregister(name: string): boolean {+ if (!this.prompts.has(name)) {+ return false;+ }++ this.prompts.delete(name);++ this.logger.debug('Prompt unregistered', { name });+ this.emit('prompt:unregistered', { name });+ this.emitListChanged();++ return true;+ }++ /**+ * List prompts with pagination+ */+ list(cursor?: string, pageSize: number = 50): PromptListResult {+ const allPrompts = Array.from(this.prompts.values()).map((p) => ({+ name: p.name,+ title: p.title,+ description: p.description,+ arguments: p.arguments,+ }));++ let startIndex = 0;+ if (cursor) {+ const decoded = this.decodeCursor(cursor);+ startIndex = decoded.offset;+ }++ const endIndex = Math.min(startIndex + pageSize, allPrompts.length);+ const prompts = allPrompts.slice(startIndex, endIndex);++ const result: PromptListResult = { prompts };++ if (endIndex < allPrompts.length) {+ result.nextCursor = this.encodeCursor({ offset: endIndex });+ }++ return result;+ }++ /**+ * Get a prompt with arguments+ */+ async get(+ name: string,+ args: Record<string, string> = {}+ ): Promise<PromptGetResult> {+ const prompt = this.prompts.get(name);+ if (!prompt) {+ throw new Error(`Prompt not found: ${name}`);+ }++ // Validate required arguments+ if (this.options.validateArguments && prompt.arguments) {+ for (const arg of prompt.arguments) {+ if (arg.required && !(arg.name in args)) {+ throw new Error(`Missing required argument: ${arg.name}`);+ }+ }+ }++ const messages = await prompt.handler(args);++ this.emit('prompt:get', { name, argCount: Object.keys(args).length });++ return {+ description: prompt.description,+ messages,+ };+ }++ /**+ * Get prompt by name+ */+ getPrompt(name: string): MCPPrompt | undefined {+ const prompt = this.prompts.get(name);+ if (!prompt) return undefined;++ return {+ name: prompt.name,+ title: prompt.title,+ description: prompt.description,+ arguments: prompt.arguments,+ };+ }++ /**+ * Check if prompt exists+ */+ hasPrompt(name: string): boolean {+ return this.prompts.has(name);+ }++ /**+ * Get prompt count+ */+ getPromptCount(): number {+ return this.prompts.size;+ }++ /**+ * Get stats+ */+ getStats(): {+ totalPrompts: number;+ promptsWithArgs: number;+ } {+ let promptsWithArgs = 0;+ for (const prompt of this.prompts.values()) {+ if (prompt.arguments && prompt.arguments.length > 0) {+ promptsWithArgs++;+ }+ }++ return {+ totalPrompts: this.prompts.size,+ promptsWithArgs,+ };+ }++ /**+ * Encode cursor for pagination+ */+ private encodeCursor(data: { offset: number }): string {+ return Buffer.from(JSON.stringify(data)).toString('base64');+ }++ /**+ * Decode cursor for pagination+ */+ private decodeCursor(cursor: string): { offset: number } {+ try {+ return JSON.parse(Buffer.from(cursor, 'base64').toString('utf-8'));+ } catch {+ return { offset: 0 };+ }+ }++ /**+ * Emit listChanged notification+ */+ private emitListChanged(): void {+ this.emit('prompts:listChanged');+ }+}++export function createPromptRegistry(+ logger: ILogger,+ options?: PromptRegistryOptions+): PromptRegistry {+ return new PromptRegistry(logger, options);+}++/**+ * Helper to define a prompt+ */+export function definePrompt(+ name: string,+ description: string,+ handler: PromptHandler,+ options?: {+ title?: string;+ arguments?: PromptArgument[];+ }+): PromptDefinition {+ return {+ name,+ description,+ title: options?.title,+ arguments: options?.arguments,+ handler,+ };+}++/**+ * Helper to create a text message+ */+export function textMessage(+ role: 'user' | 'assistant',+ text: string+): PromptMessage {+ return {+ role,+ content: {+ type: 'text',+ text,+ } as TextContent,+ };+}++/**+ * Helper to create a message with embedded resource+ */+export function resourceMessage(+ role: 'user' | 'assistant',+ resource: ResourceContent+): PromptMessage {+ return {+ role,+ content: {+ type: 'resource',+ resource,+ } as EmbeddedResource,+ };+}++/**+ * Template string interpolation for prompts+ */+export function interpolate(+ template: string,+ args: Record<string, string>+): string {+ return template.replace(/\{(\w+)\}/g, (match, key) => {+ return args[key] ?? match;+ });+}diff --git a/v3/@claude-flow/mcp/src/resource-registry.ts b/v3/@claude-flow/mcp/src/resource-registry.tsnew file mode 100644index 0000000000..59a7462a15--- /dev/null+++ b/v3/@claude-flow/mcp/src/resource-registry.ts@@ -0,0 +1,459 @@+/**+ * @claude-flow/mcp - Resource Registry+ *+ * MCP 2025-11-25 compliant resource management+ * Supports: list, read, subscribe, templates, pagination+ */++import { EventEmitter } from 'events';+import type {+ MCPResource,+ ResourceContent,+ ResourceTemplate,+ ResourceListResult,+ ResourceReadResult,+ ILogger,+ ContentAnnotations,+} from './types.js';++export type ResourceHandler = (uri: string) => Promise<ResourceContent[]>;+export type SubscriptionCallback = (uri: string, content: ResourceContent[]) => void;++export interface ResourceRegistryOptions {+ enableSubscriptions?: boolean;+ maxSubscriptionsPerResource?: number;+ cacheEnabled?: boolean;+ cacheTTL?: number;+}++interface CachedResource {+ content: ResourceContent[];+ cachedAt: number;+ ttl: number;+}++interface Subscription {+ id: string;+ uri: string;+ callback: SubscriptionCallback;+ createdAt: Date;+}++export class ResourceRegistry extends EventEmitter {+ private resources: Map<string, MCPResource> = new Map();+ private templates: Map<string, ResourceTemplate> = new Map();+ private handlers: Map<string, ResourceHandler> = new Map();+ private subscriptions: Map<string, Subscription[]> = new Map();+ private cache: Map<string, CachedResource> = new Map();+ private subscriptionCounter = 0;++ private readonly options: Required<ResourceRegistryOptions>;++ constructor(+ private readonly logger: ILogger,+ options: ResourceRegistryOptions = {}+ ) {+ super();+ this.options = {+ enableSubscriptions: options.enableSubscriptions ?? true,+ maxSubscriptionsPerResource: options.maxSubscriptionsPerResource ?? 100,+ cacheEnabled: options.cacheEnabled ?? true,+ cacheTTL: options.cacheTTL ?? 60000, // 1 minute default+ };+ }++ /**+ * Register a static resource+ */+ registerResource(resource: MCPResource, handler: ResourceHandler): boolean {+ if (this.resources.has(resource.uri)) {+ this.logger.warn('Resource already registered', { uri: resource.uri });+ return false;+ }++ this.resources.set(resource.uri, resource);+ this.handlers.set(resource.uri, handler);++ this.logger.debug('Resource registered', { uri: resource.uri, name: resource.name });+ this.emit('resource:registered', { uri: resource.uri });+ this.emitListChanged();++ return true;+ }++ /**+ * Register a resource template (dynamic URIs)+ */+ registerTemplate(template: ResourceTemplate, handler: ResourceHandler): boolean {+ if (this.templates.has(template.uriTemplate)) {+ this.logger.warn('Template already registered', { template: template.uriTemplate });+ return false;+ }++ this.templates.set(template.uriTemplate, template);+ this.handlers.set(template.uriTemplate, handler);++ this.logger.debug('Resource template registered', { template: template.uriTemplate });+ this.emit('template:registered', { template: template.uriTemplate });++ return true;+ }++ /**+ * Unregister a resource+ */+ unregisterResource(uri: string): boolean {+ if (!this.resources.has(uri)) {+ return false;+ }++ this.resources.delete(uri);+ this.handlers.delete(uri);+ this.cache.delete(uri);++ // Cancel subscriptions for this resource+ const subs = this.subscriptions.get(uri) || [];+ for (const sub of subs) {+ this.emit('subscription:cancelled', { subscriptionId: sub.id, uri });+ }+ this.subscriptions.delete(uri);++ this.logger.debug('Resource unregistered', { uri });+ this.emit('resource:unregistered', { uri });+ this.emitListChanged();++ return true;+ }++ /**+ * List resources with pagination+ */+ list(cursor?: string, pageSize: number = 50): ResourceListResult {+ const allResources = Array.from(this.resources.values());++ let startIndex = 0;+ if (cursor) {+ const decoded = this.decodeCursor(cursor);+ startIndex = decoded.offset;+ }++ const endIndex = Math.min(startIndex + pageSize, allResources.length);+ const resources = allResources.slice(startIndex, endIndex);++ const result: ResourceListResult = { resources };++ if (endIndex < allResources.length) {+ result.nextCursor = this.encodeCursor({ offset: endIndex });+ }++ return result;+ }++ /**+ * Read resource content+ */+ async read(uri: string): Promise<ResourceReadResult> {+ // Check cache first+ if (this.options.cacheEnabled) {+ const cached = this.cache.get(uri);+ if (cached && Date.now() - cached.cachedAt < cached.ttl) {+ this.logger.debug('Resource cache hit', { uri });+ return { contents: cached.content };+ }+ }++ // Find handler (exact match or template match)+ let handler = this.handlers.get(uri);+ if (!handler) {+ handler = this.findTemplateHandler(uri);+ }++ if (!handler) {+ throw new Error(`Resource not found: ${uri}`);+ }++ const contents = await handler(uri);++ // Cache the result+ if (this.options.cacheEnabled) {+ this.cache.set(uri, {+ content: contents,+ cachedAt: Date.now(),+ ttl: this.options.cacheTTL,+ });+ }++ this.emit('resource:read', { uri, contentCount: contents.length });+ return { contents };+ }++ /**+ * Subscribe to resource updates+ */+ subscribe(uri: string, callback: SubscriptionCallback): string {+ if (!this.options.enableSubscriptions) {+ throw new Error('Subscriptions are disabled');+ }++ const existingSubs = this.subscriptions.get(uri) || [];+ if (existingSubs.length >= this.options.maxSubscriptionsPerResource) {+ throw new Error(`Maximum subscriptions reached for resource: ${uri}`);+ }++ const subscriptionId = `sub-${++this.subscriptionCounter}-${Date.now()}`;+ const subscription: Subscription = {+ id: subscriptionId,+ uri,+ callback,+ createdAt: new Date(),+ };++ existingSubs.push(subscription);+ this.subscriptions.set(uri, existingSubs);++ this.logger.debug('Subscription created', { subscriptionId, uri });+ this.emit('subscription:created', { subscriptionId, uri });++ return subscriptionId;+ }++ /**+ * Unsubscribe from resource updates+ */+ unsubscribe(subscriptionId: string): boolean {+ for (const [uri, subs] of this.subscriptions) {+ const index = subs.findIndex((s) => s.id === subscriptionId);+ if (index !== -1) {+ subs.splice(index, 1);+ if (subs.length === 0) {+ this.subscriptions.delete(uri);+ }+ this.logger.debug('Subscription removed', { subscriptionId, uri });+ this.emit('subscription:removed', { subscriptionId, uri });+ return true;+ }+ }+ return false;+ }++ /**+ * Notify subscribers of resource update+ */+ async notifyUpdate(uri: string): Promise<void> {+ const subs = this.subscriptions.get(uri);+ if (!subs || subs.length === 0) {+ return;+ }++ // Invalidate cache+ this.cache.delete(uri);++ // Read fresh content+ const { contents } = await this.read(uri);++ // Notify all subscribers+ for (const sub of subs) {+ try {+ sub.callback(uri, contents);+ } catch (error) {+ this.logger.error('Subscription callback error', { subscriptionId: sub.id, error });+ }+ }++ this.emit('resource:updated', { uri, subscriberCount: subs.length });+ }++ /**+ * Get resource by URI+ */+ getResource(uri: string): MCPResource | undefined {+ return this.resources.get(uri);+ }++ /**+ * Check if resource exists+ */+ hasResource(uri: string): boolean {+ return this.resources.has(uri) || this.matchesTemplate(uri);+ }++ /**+ * Get resource count+ */+ getResourceCount(): number {+ return this.resources.size;+ }++ /**+ * Get all templates+ */+ getTemplates(): ResourceTemplate[] {+ return Array.from(this.templates.values());+ }++ /**+ * Get subscription count for a resource+ */+ getSubscriptionCount(uri: string): number {+ return this.subscriptions.get(uri)?.length || 0;+ }++ /**+ * Get stats+ */+ getStats(): {+ totalResources: number;+ totalTemplates: number;+ totalSubscriptions: number;+ cacheSize: number;+ } {+ let totalSubscriptions = 0;+ for (const subs of this.subscriptions.values()) {+ totalSubscriptions += subs.length;+ }++ return {+ totalResources: this.resources.size,+ totalTemplates: this.templates.size,+ totalSubscriptions,+ cacheSize: this.cache.size,+ };+ }++ /**+ * Clear cache+ */+ clearCache(): void {+ this.cache.clear();+ this.logger.debug('Resource cache cleared');+ }++ /**+ * Find handler for template URI+ */+ private findTemplateHandler(uri: string): ResourceHandler | undefined {+ for (const [template, handler] of this.handlers) {+ if (this.matchesTemplate(uri, template)) {+ return handler;+ }+ }+ return undefined;+ }++ /**+ * Check if URI matches any template+ */+ private matchesTemplate(uri: string, template?: string): boolean {+ if (template) {+ // Simple template matching (supports {param} style)+ const regex = new RegExp('^' + template.replace(/\{[^}]+\}/g, '[^/]+') + '$');+ return regex.test(uri);+ }++ for (const t of this.templates.keys()) {+ const regex = new RegExp('^' + t.replace(/\{[^}]+\}/g, '[^/]+') + '$');+ if (regex.test(uri)) {+ return true;+ }+ }+ return false;+ }++ /**+ * Encode cursor for pagination+ */+ private encodeCursor(data: { offset: number }): string {+ return Buffer.from(JSON.stringify(data)).toString('base64');+ }++ /**+ * Decode cursor for pagination+ */+ private decodeCursor(cursor: string): { offset: number } {+ try {+ return JSON.parse(Buffer.from(cursor, 'base64').toString('utf-8'));+ } catch {+ return { offset: 0 };+ }+ }++ /**+ * Emit listChanged notification+ */+ private emitListChanged(): void {+ this.emit('resources:listChanged');+ }+}++export function createResourceRegistry(+ logger: ILogger,+ options?: ResourceRegistryOptions+): ResourceRegistry {+ return new ResourceRegistry(logger, options);+}++/**+ * Helper to create a static text resource+ */+export function createTextResource(+ uri: string,+ name: string,+ text: string,+ options?: {+ description?: string;+ mimeType?: string;+ annotations?: ContentAnnotations;+ }+): { resource: MCPResource; handler: ResourceHandler } {+ const resource: MCPResource = {+ uri,+ name,+ description: options?.description,+ mimeType: options?.mimeType || 'text/plain',+ annotations: options?.annotations,+ };++ const handler: ResourceHandler = async () => [+ {+ uri,+ mimeType: options?.mimeType || 'text/plain',+ text,+ },+ ];++ return { resource, handler };+}++/**+ * Helper to create a file resource+ */+export function createFileResource(+ uri: string,+ name: string,+ filePath: string,+ options?: {+ description?: string;+ mimeType?: string;+ }+): { resource: MCPResource; handler: ResourceHandler } {+ const resource: MCPResource = {+ uri,+ name,+ description: options?.description,+ mimeType: options?.mimeType || 'application/octet-stream',+ };++ const handler: ResourceHandler = async () => {+ const fs = await import('fs/promises');+ const content = await fs.readFile(filePath);+ return [+ {+ uri,+ mimeType: options?.mimeType || 'application/octet-stream',+ blob: content.toString('base64'),+ },+ ];+ };++ return { resource, handler };+}diff --git a/v3/@claude-flow/mcp/src/server.ts b/v3/@claude-flow/mcp/src/server.tsnew file mode 100644index 0000000000..5f04520ab0--- /dev/null+++ b/v3/@claude-flow/mcp/src/server.ts@@ -0,0 +1,1009 @@+/**+ * @claude-flow/mcp - MCP Server+ *+ * High-performance MCP server implementation+ */++import { EventEmitter } from 'events';+import { platform, arch } from 'os';+import type {+ MCPServerConfig,+ MCPRequest,+ MCPResponse,+ MCPNotification,+ MCPSession,+ MCPTool,+ MCPInitializeParams,+ MCPInitializeResult,+ MCPCapabilities,+ MCPProtocolVersion,+ MCPServerMetrics,+ ITransport,+ TransportType,+ ILogger,+ ToolContext,+} from './types.js';+import { MCPServerError, ErrorCodes } from './types.js';+import { ToolRegistry, createToolRegistry } from './tool-registry.js';+import { SessionManager, createSessionManager } from './session-manager.js';+import { ConnectionPool, createConnectionPool } from './connection-pool.js';+import { ResourceRegistry, createResourceRegistry } from './resource-registry.js';+import { PromptRegistry, createPromptRegistry } from './prompt-registry.js';+import { TaskManager, createTaskManager } from './task-manager.js';+import { createTransport, TransportManager, createTransportManager } from './transport/index.js';++const DEFAULT_CONFIG: Partial<MCPServerConfig> = {+ name: 'Claude-Flow MCP Server V3',+ version: '3.0.0',+ transport: 'stdio',+ host: 'localhost',+ port: 3000,+ enableMetrics: true,+ enableCaching: true,+ cacheTTL: 10000,+ logLevel: 'info',+ requestTimeout: 30000,+ maxRequestSize: 10 * 1024 * 1024,+};++export interface IMCPServer {+ start(): Promise<void>;+ stop(): Promise<void>;+ registerTool(tool: MCPTool): boolean;+ registerTools(tools: MCPTool[]): { registered: number; failed: string[] };+ getHealthStatus(): Promise<{+ healthy: boolean;+ error?: string;+ metrics?: Record<string, number>;+ }>;+ getMetrics(): MCPServerMetrics;+ getSessions(): MCPSession[];+ getSession(sessionId: string): MCPSession | undefined;+ terminateSession(sessionId: string): boolean;+}++export class MCPServer extends EventEmitter implements IMCPServer {+ private readonly config: MCPServerConfig;+ private readonly toolRegistry: ToolRegistry;+ private readonly sessionManager: SessionManager;+ private readonly resourceRegistry: ResourceRegistry;+ private readonly promptRegistry: PromptRegistry;+ private readonly taskManager: TaskManager;+ private readonly connectionPool?: ConnectionPool;+ private readonly transportManager: TransportManager;+ private transport?: ITransport;+ private running = false;+ private startTime?: Date;+ private startupDuration?: number;+ private currentSession?: MCPSession;+ private resourceSubscriptions: Map<string, Set<string>> = new Map(); // sessionId -> subscribed URIs++ private readonly serverInfo = {+ name: 'Claude-Flow MCP Server V3',+ version: '3.0.0',+ };++ // MCP 2025-11-25 protocol version+ private readonly protocolVersion: MCPProtocolVersion = {+ major: 2025,+ minor: 11,+ patch: 25,+ };++ // Full MCP 2025-11-25 capabilities+ private readonly capabilities: MCPCapabilities = {+ logging: { level: 'info' },+ tools: { listChanged: true },+ resources: { listChanged: true, subscribe: true },+ prompts: { listChanged: true },+ };++ private requestStats = {+ total: 0,+ successful: 0,+ failed: 0,+ totalResponseTime: 0,+ };++ constructor(+ config: Partial<MCPServerConfig>,+ private readonly logger: ILogger,+ private readonly orchestrator?: unknown,+ private readonly swarmCoordinator?: unknown+ ) {+ super();+ this.config = { ...DEFAULT_CONFIG, ...config } as MCPServerConfig;++ this.toolRegistry = createToolRegistry(logger);+ this.sessionManager = createSessionManager(logger, {+ maxSessions: 100,+ sessionTimeout: 30 * 60 * 1000,+ });+ this.resourceRegistry = createResourceRegistry(logger, {+ enableSubscriptions: true,+ cacheEnabled: true,+ cacheTTL: 60000,+ });+ this.promptRegistry = createPromptRegistry(logger);+ this.taskManager = createTaskManager(logger, {+ maxConcurrentTasks: 10,+ taskTimeout: 300000,+ });+ this.transportManager = createTransportManager(logger);++ if (this.config.connectionPool) {+ this.connectionPool = createConnectionPool(+ this.config.connectionPool,+ logger,+ this.config.transport+ );+ }++ this.setupEventHandlers();+ }++ /**+ * Get resource registry for external registration+ */+ getResourceRegistry(): ResourceRegistry {+ return this.resourceRegistry;+ }++ /**+ * Get prompt registry for external registration+ */+ getPromptRegistry(): PromptRegistry {+ return this.promptRegistry;+ }++ /**+ * Get task manager for async operations+ */+ getTaskManager(): TaskManager {+ return this.taskManager;+ }++ async start(): Promise<void> {+ if (this.running) {+ throw new MCPServerError('Server already running');+ }++ const startTime = performance.now();+ this.startTime = new Date();++ this.logger.info('Starting MCP server', {+ name: this.config.name,+ version: this.config.version,+ transport: this.config.transport,+ });++ try {+ this.transport = createTransport(this.config.transport, this.logger, {+ type: this.config.transport,+ host: this.config.host,+ port: this.config.port,+ corsEnabled: this.config.corsEnabled,+ corsOrigins: this.config.corsOrigins,+ auth: this.config.auth,+ maxRequestSize: String(this.config.maxRequestSize),+ requestTimeout: this.config.requestTimeout,+ } as any);++ this.transport.onRequest(async (request) => {+ return await this.handleRequest(request);+ });++ this.transport.onNotification(async (notification) => {+ await this.handleNotification(notification);+ });++ await this.transport.start();+ await this.registerBuiltInTools();++ this.running = true;+ this.startupDuration = performance.now() - startTime;++ this.logger.info('MCP server started', {+ startupTime: `${this.startupDuration.toFixed(2)}ms`,+ tools: this.toolRegistry.getToolCount(),+ });++ this.emit('server:started', {+ startupTime: this.startupDuration,+ tools: this.toolRegistry.getToolCount(),+ });++ } catch (error) {+ this.logger.error('Failed to start MCP server', { error });+ throw new MCPServerError('Failed to start server', ErrorCodes.INTERNAL_ERROR, { error });+ }+ }++ async stop(): Promise<void> {+ if (!this.running) {+ return;+ }++ this.logger.info('Stopping MCP server');++ try {+ if (this.transport) {+ await this.transport.stop();+ this.transport = undefined;+ }++ this.sessionManager.clearAll();+ this.taskManager.destroy();+ this.resourceSubscriptions.clear();++ if (this.connectionPool) {+ await this.connectionPool.clear();+ }++ this.running = false;+ this.currentSession = undefined;++ this.logger.info('MCP server stopped');+ this.emit('server:stopped');++ } catch (error) {+ this.logger.error('Error stopping MCP server', { error });+ throw error;+ }+ }++ registerTool(tool: MCPTool): boolean {+ return this.toolRegistry.register(tool);+ }++ registerTools(tools: MCPTool[]): { registered: number; failed: string[] } {+ return this.toolRegistry.registerBatch(tools);+ }++ unregisterTool(name: string): boolean {+ return this.toolRegistry.unregister(name);+ }++ async getHealthStatus(): Promise<{+ healthy: boolean;+ error?: string;+ metrics?: Record<string, number>;+ }> {+ try {+ const transportHealth = this.transport+ ? await this.transport.getHealthStatus()+ : { healthy: false, error: 'Transport not initialized' };++ const sessionMetrics = this.sessionManager.getSessionMetrics();+ const poolStats = this.connectionPool?.getStats();++ const metrics: Record<string, number> = {+ registeredTools: this.toolRegistry.getToolCount(),+ totalRequests: this.requestStats.total,+ successfulRequests: this.requestStats.successful,+ failedRequests: this.requestStats.failed,+ totalSessions: sessionMetrics.total,+ activeSessions: sessionMetrics.active,+ ...(transportHealth.metrics || {}),+ };++ if (poolStats) {+ metrics.poolConnections = poolStats.totalConnections;+ metrics.poolIdleConnections = poolStats.idleConnections;+ metrics.poolBusyConnections = poolStats.busyConnections;+ }++ return {+ healthy: this.running && transportHealth.healthy,+ error: transportHealth.error,+ metrics,+ };++ } catch (error) {+ return {+ healthy: false,+ error: error instanceof Error ? error.message : 'Unknown error',+ };+ }+ }++ getMetrics(): MCPServerMetrics {+ const sessionMetrics = this.sessionManager.getSessionMetrics();+ const registryStats = this.toolRegistry.getStats();++ return {+ totalRequests: this.requestStats.total,+ successfulRequests: this.requestStats.successful,+ failedRequests: this.requestStats.failed,+ averageResponseTime: this.requestStats.total > 0+ ? this.requestStats.totalResponseTime / this.requestStats.total+ : 0,+ activeSessions: sessionMetrics.active,+ toolInvocations: Object.fromEntries(+ registryStats.topTools.map((t) => [t.name, t.calls])+ ),+ errors: {},+ lastReset: this.startTime || new Date(),+ startupTime: this.startupDuration,+ uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,+ };+ }++ getSessions(): MCPSession[] {+ return this.sessionManager.getActiveSessions();+ }++ getSession(sessionId: string): MCPSession | undefined {+ return this.sessionManager.getSession(sessionId);+ }++ terminateSession(sessionId: string): boolean {+ const result = this.sessionManager.closeSession(sessionId, 'Terminated by server');+ if (this.currentSession?.id === sessionId) {+ this.currentSession = undefined;+ }+ return result;+ }++ private async handleRequest(request: MCPRequest): Promise<MCPResponse> {+ const startTime = performance.now();+ this.requestStats.total++;++ this.logger.debug('Handling request', {+ id: request.id,+ method: request.method,+ });++ try {+ if (request.method === 'initialize') {+ return await this.handleInitialize(request);+ }++ const session = this.getOrCreateSession();++ if (!session.isInitialized && request.method !== 'initialized') {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.SERVER_NOT_INITIALIZED,+ 'Server not initialized'+ );+ }++ this.sessionManager.updateActivity(session.id);++ const response = await this.routeRequest(request);++ const duration = performance.now() - startTime;+ this.requestStats.successful++;+ this.requestStats.totalResponseTime += duration;++ this.logger.debug('Request completed', {+ id: request.id,+ method: request.method,+ duration: `${duration.toFixed(2)}ms`,+ });++ return response;++ } catch (error) {+ const duration = performance.now() - startTime;+ this.requestStats.failed++;+ this.requestStats.totalResponseTime += duration;++ this.logger.error('Request failed', {+ id: request.id,+ method: request.method,+ error,+ });++ return this.createErrorResponse(+ request.id,+ ErrorCodes.INTERNAL_ERROR,+ error instanceof Error ? error.message : 'Internal error'+ );+ }+ }++ private async handleNotification(notification: MCPNotification): Promise<void> {+ this.logger.debug('Handling notification', { method: notification.method });++ switch (notification.method) {+ case 'initialized':+ this.logger.info('Client initialized notification received');+ break;++ case 'notifications/cancelled':+ this.logger.debug('Request cancelled', notification.params);+ break;++ default:+ this.logger.debug('Unknown notification', { method: notification.method });+ }+ }++ private async handleInitialize(request: MCPRequest): Promise<MCPResponse> {+ const params = request.params as unknown as MCPInitializeParams | undefined;++ if (!params) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ 'Invalid params'+ );+ }++ const session = this.sessionManager.createSession(this.config.transport);+ this.sessionManager.initializeSession(session.id, params);+ this.currentSession = session;++ const result: MCPInitializeResult = {+ protocolVersion: this.protocolVersion,+ capabilities: this.capabilities,+ serverInfo: this.serverInfo,+ instructions: 'Claude-Flow MCP Server V3 ready for tool execution',+ };++ this.logger.info('Session initialized', {+ sessionId: session.id,+ clientInfo: params.clientInfo,+ });++ return {+ jsonrpc: '2.0',+ id: request.id,+ result,+ };+ }++ private async routeRequest(request: MCPRequest): Promise<MCPResponse> {+ switch (request.method) {+ // Tool methods+ case 'tools/list':+ return this.handleToolsList(request);+ case 'tools/call':+ return this.handleToolsCall(request);++ // Resource methods (MCP 2025-11-25)+ case 'resources/list':+ return this.handleResourcesList(request);+ case 'resources/read':+ return this.handleResourcesRead(request);+ case 'resources/subscribe':+ return this.handleResourcesSubscribe(request);+ case 'resources/unsubscribe':+ return this.handleResourcesUnsubscribe(request);++ // Prompt methods (MCP 2025-11-25)+ case 'prompts/list':+ return this.handlePromptsList(request);+ case 'prompts/get':+ return this.handlePromptsGet(request);++ // Task methods (MCP 2025-11-25)+ case 'tasks/status':+ return this.handleTasksStatus(request);+ case 'tasks/cancel':+ return this.handleTasksCancel(request);++ // Completion (MCP 2025-11-25)+ case 'completion/complete':+ return this.handleCompletion(request);++ // Logging (MCP 2025-11-25)+ case 'logging/setLevel':+ return this.handleLoggingSetLevel(request);++ // Utility+ case 'ping':+ return {+ jsonrpc: '2.0',+ id: request.id,+ result: { pong: true, timestamp: Date.now() },+ };++ default:+ // Check if it's a direct tool call+ if (this.toolRegistry.hasTool(request.method)) {+ return this.handleToolExecution(request);+ }++ return this.createErrorResponse(+ request.id,+ ErrorCodes.METHOD_NOT_FOUND,+ `Method not found: ${request.method}`+ );+ }+ }++ private handleToolsList(request: MCPRequest): MCPResponse {+ const tools = this.toolRegistry.listTools().map((t) => ({+ name: t.name,+ description: t.description,+ inputSchema: this.toolRegistry.getTool(t.name)?.inputSchema,+ }));++ return {+ jsonrpc: '2.0',+ id: request.id,+ result: { tools },+ };+ }++ private async handleToolsCall(request: MCPRequest): Promise<MCPResponse> {+ const params = request.params as { name: string; arguments?: Record<string, unknown> };++ if (!params?.name) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ 'Tool name is required'+ );+ }++ const context: ToolContext = {+ sessionId: this.currentSession?.id || 'unknown',+ requestId: request.id,+ orchestrator: this.orchestrator,+ swarmCoordinator: this.swarmCoordinator,+ };++ const result = await this.toolRegistry.execute(+ params.name,+ params.arguments || {},+ context+ );++ return {+ jsonrpc: '2.0',+ id: request.id,+ result,+ };+ }++ private async handleToolExecution(request: MCPRequest): Promise<MCPResponse> {+ const context: ToolContext = {+ sessionId: this.currentSession?.id || 'unknown',+ requestId: request.id,+ orchestrator: this.orchestrator,+ swarmCoordinator: this.swarmCoordinator,+ };++ const result = await this.toolRegistry.execute(+ request.method,+ (request.params as Record<string, unknown>) || {},+ context+ );++ return {+ jsonrpc: '2.0',+ id: request.id,+ result,+ };+ }++ // ============================================================================+ // Resource Handlers (MCP 2025-11-25)+ // ============================================================================++ private handleResourcesList(request: MCPRequest): MCPResponse {+ const params = request.params as { cursor?: string } | undefined;+ const result = this.resourceRegistry.list(params?.cursor);++ return {+ jsonrpc: '2.0',+ id: request.id,+ result,+ };+ }++ private async handleResourcesRead(request: MCPRequest): Promise<MCPResponse> {+ const params = request.params as { uri: string } | undefined;++ if (!params?.uri) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ 'Resource URI is required'+ );+ }++ try {+ const result = await this.resourceRegistry.read(params.uri);+ return {+ jsonrpc: '2.0',+ id: request.id,+ result,+ };+ } catch (error) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ error instanceof Error ? error.message : 'Resource read failed'+ );+ }+ }++ private handleResourcesSubscribe(request: MCPRequest): MCPResponse {+ const params = request.params as { uri: string } | undefined;+ const sessionId = this.currentSession?.id;++ if (!params?.uri) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ 'Resource URI is required'+ );+ }++ if (!sessionId) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.SERVER_NOT_INITIALIZED,+ 'No active session'+ );+ }++ try {+ // Track subscription for this session+ let sessionSubs = this.resourceSubscriptions.get(sessionId);+ if (!sessionSubs) {+ sessionSubs = new Set();+ this.resourceSubscriptions.set(sessionId, sessionSubs);+ }++ const subscriptionId = this.resourceRegistry.subscribe(params.uri, (uri, content) => {+ // Send notification when resource updates+ this.sendNotification('notifications/resources/updated', { uri });+ });++ sessionSubs.add(params.uri);++ return {+ jsonrpc: '2.0',+ id: request.id,+ result: { subscriptionId },+ };+ } catch (error) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INTERNAL_ERROR,+ error instanceof Error ? error.message : 'Subscription failed'+ );+ }+ }++ private handleResourcesUnsubscribe(request: MCPRequest): MCPResponse {+ const params = request.params as { uri: string } | undefined;+ const sessionId = this.currentSession?.id;++ if (!params?.uri) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ 'Resource URI is required'+ );+ }++ if (sessionId) {+ const sessionSubs = this.resourceSubscriptions.get(sessionId);+ if (sessionSubs) {+ sessionSubs.delete(params.uri);+ }+ }++ return {+ jsonrpc: '2.0',+ id: request.id,+ result: { success: true },+ };+ }++ // ============================================================================+ // Prompt Handlers (MCP 2025-11-25)+ // ============================================================================++ private handlePromptsList(request: MCPRequest): MCPResponse {+ const params = request.params as { cursor?: string } | undefined;+ const result = this.promptRegistry.list(params?.cursor);++ return {+ jsonrpc: '2.0',+ id: request.id,+ result,+ };+ }++ private async handlePromptsGet(request: MCPRequest): Promise<MCPResponse> {+ const params = request.params as { name: string; arguments?: Record<string, string> } | undefined;++ if (!params?.name) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ 'Prompt name is required'+ );+ }++ try {+ const result = await this.promptRegistry.get(params.name, params.arguments);+ return {+ jsonrpc: '2.0',+ id: request.id,+ result,+ };+ } catch (error) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ error instanceof Error ? error.message : 'Prompt get failed'+ );+ }+ }++ // ============================================================================+ // Task Handlers (MCP 2025-11-25)+ // ============================================================================++ private handleTasksStatus(request: MCPRequest): MCPResponse {+ const params = request.params as { taskId?: string } | undefined;++ if (params?.taskId) {+ const task = this.taskManager.getTask(params.taskId);+ if (!task) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ `Task not found: ${params.taskId}`+ );+ }+ return {+ jsonrpc: '2.0',+ id: request.id,+ result: task,+ };+ }++ // Return all tasks+ return {+ jsonrpc: '2.0',+ id: request.id,+ result: { tasks: this.taskManager.getAllTasks() },+ };+ }++ private handleTasksCancel(request: MCPRequest): MCPResponse {+ const params = request.params as { taskId: string; reason?: string } | undefined;++ if (!params?.taskId) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ 'Task ID is required'+ );+ }++ const success = this.taskManager.cancelTask(params.taskId, params.reason);++ return {+ jsonrpc: '2.0',+ id: request.id,+ result: { success },+ };+ }++ // ============================================================================+ // Completion Handler (MCP 2025-11-25)+ // ============================================================================++ private handleCompletion(request: MCPRequest): MCPResponse {+ const params = request.params as {+ ref: { type: string; name?: string; uri?: string };+ argument: { name: string; value: string };+ } | undefined;++ if (!params?.ref || !params?.argument) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ 'Completion reference and argument are required'+ );+ }++ // Basic completion implementation - can be extended+ const completions: string[] = [];++ if (params.ref.type === 'ref/prompt') {+ // Get prompt argument completions+ const prompt = this.promptRegistry.getPrompt(params.ref.name || '');+ if (prompt?.arguments) {+ for (const arg of prompt.arguments) {+ if (arg.name === params.argument.name) {+ // Could add domain-specific completions here+ }+ }+ }+ } else if (params.ref.type === 'ref/resource') {+ // Get resource URI completions+ const { resources } = this.resourceRegistry.list();+ for (const resource of resources) {+ if (resource.uri.startsWith(params.argument.value)) {+ completions.push(resource.uri);+ }+ }+ }++ return {+ jsonrpc: '2.0',+ id: request.id,+ result: {+ completion: {+ values: completions.slice(0, 10),+ total: completions.length,+ hasMore: completions.length > 10,+ },+ },+ };+ }++ // ============================================================================+ // Logging Handler (MCP 2025-11-25)+ // ============================================================================++ private handleLoggingSetLevel(request: MCPRequest): MCPResponse {+ const params = request.params as { level: string } | undefined;++ if (!params?.level) {+ return this.createErrorResponse(+ request.id,+ ErrorCodes.INVALID_PARAMS,+ 'Log level is required'+ );+ }++ // Update capabilities+ this.capabilities.logging = { level: params.level as 'debug' | 'info' | 'warn' | 'error' };++ this.logger.info('Log level updated', { level: params.level });++ return {+ jsonrpc: '2.0',+ id: request.id,+ result: { success: true },+ };+ }++ // ============================================================================+ // Notification Sender+ // ============================================================================++ private async sendNotification(method: string, params?: Record<string, unknown>): Promise<void> {+ if (this.transport?.sendNotification) {+ await this.transport.sendNotification({+ jsonrpc: '2.0',+ method,+ params,+ });+ }+ }++ private getOrCreateSession(): MCPSession {+ if (this.currentSession) {+ return this.currentSession;+ }++ const session = this.sessionManager.createSession(this.config.transport);+ this.currentSession = session;+ return session;+ }++ private createErrorResponse(+ id: string | number | null,+ code: number,+ message: string+ ): MCPResponse {+ return {+ jsonrpc: '2.0',+ id,+ error: { code, message },+ };+ }++ private async registerBuiltInTools(): Promise<void> {+ this.registerTool({+ name: 'system/info',+ description: 'Get system information',+ inputSchema: { type: 'object', properties: {} },+ handler: async () => ({+ name: this.serverInfo.name,+ version: this.serverInfo.version,+ platform: platform(),+ arch: arch(),+ runtime: 'Node.js',+ uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,+ }),+ category: 'system',+ });++ this.registerTool({+ name: 'system/health',+ description: 'Get system health status',+ inputSchema: { type: 'object', properties: {} },+ handler: async () => await this.getHealthStatus(),+ category: 'system',+ cacheable: true,+ cacheTTL: 2000,+ });++ this.registerTool({+ name: 'system/metrics',+ description: 'Get server metrics',+ inputSchema: { type: 'object', properties: {} },+ handler: async () => this.getMetrics(),+ category: 'system',+ cacheable: true,+ cacheTTL: 1000,+ });++ this.registerTool({+ name: 'tools/list-detailed',+ description: 'List all registered tools with details',+ inputSchema: {+ type: 'object',+ properties: {+ category: { type: 'string', description: 'Filter by category' },+ },+ },+ handler: async (input: unknown) => {+ const params = input as { category?: string };+ if (params.category) {+ return this.toolRegistry.getByCategory(params.category);+ }+ return this.toolRegistry.listTools();+ },+ category: 'system',+ });++ this.logger.info('Built-in tools registered', {+ count: 4,+ });+ }++ private setupEventHandlers(): void {+ this.toolRegistry.on('tool:registered', (name) => {+ this.emit('tool:registered', name);+ });++ this.toolRegistry.on('tool:called', (data) => {+ this.emit('tool:called', data);+ });++ this.toolRegistry.on('tool:completed', (data) => {+ this.emit('tool:completed', data);+ });++ this.toolRegistry.on('tool:error', (data) => {+ this.emit('tool:error', data);+ });++ this.sessionManager.on('session:created', (session) => {+ this.emit('session:created', session);+ });++ this.sessionManager.on('session:closed', (data) => {+ this.emit('session:closed', data);+ });++ this.sessionManager.on('session:expired', (session) => {+ this.emit('session:expired', session);+ });+ }+}++export function createMCPServer(+ config: Partial<MCPServerConfig>,+ logger: ILogger,+ orchestrator?: unknown,+ swarmCoordinator?: unknown+): MCPServer {+ return new MCPServer(config, logger, orchestrator, swarmCoordinator);+}diff --git a/v3/@claude-flow/mcp/src/session-manager.ts b/v3/@claude-flow/mcp/src/session-manager.tsnew file mode 100644index 0000000000..f913a62a0b--- /dev/null+++ b/v3/@claude-flow/mcp/src/session-manager.ts@@ -0,0 +1,339 @@+/**+ * @claude-flow/mcp - Session Manager+ *+ * MCP session lifecycle management+ */++import { EventEmitter } from 'events';+import type {+ MCPSession,+ SessionState,+ SessionMetrics,+ MCPInitializeParams,+ TransportType,+ ILogger,+} from './types.js';++export interface SessionConfig {+ maxSessions?: number;+ sessionTimeout?: number;+ cleanupInterval?: number;+ enableMetrics?: boolean;+}++const DEFAULT_SESSION_CONFIG: Required<SessionConfig> = {+ maxSessions: 100,+ sessionTimeout: 30 * 60 * 1000,+ cleanupInterval: 60 * 1000,+ enableMetrics: true,+};++export class SessionManager extends EventEmitter {+ private readonly sessions: Map<string, MCPSession> = new Map();+ private readonly config: Required<SessionConfig>;+ private cleanupTimer?: NodeJS.Timeout;+ private sessionCounter = 0;++ private totalCreated = 0;+ private totalClosed = 0;+ private totalExpired = 0;++ constructor(+ private readonly logger: ILogger,+ config: SessionConfig = {}+ ) {+ super();+ this.config = { ...DEFAULT_SESSION_CONFIG, ...config };+ this.startCleanupTimer();+ }++ createSession(transport: TransportType): MCPSession {+ if (this.sessions.size >= this.config.maxSessions) {+ throw new Error(`Maximum sessions (${this.config.maxSessions}) reached`);+ }++ const id = this.generateSessionId();+ const now = new Date();++ const session: MCPSession = {+ id,+ state: 'created',+ transport,+ createdAt: now,+ lastActivityAt: now,+ isInitialized: false,+ isAuthenticated: false,+ };++ this.sessions.set(id, session);+ this.totalCreated++;++ this.logger.debug('Session created', { id, transport });+ this.emit('session:created', session);++ return session;+ }++ initializeSession(+ sessionId: string,+ params: MCPInitializeParams+ ): MCPSession | undefined {+ const session = this.sessions.get(sessionId);+ if (!session) {+ this.logger.warn('Session not found for initialization', { sessionId });+ return undefined;+ }++ session.state = 'ready';+ session.isInitialized = true;+ session.clientInfo = params.clientInfo;+ session.protocolVersion = params.protocolVersion;+ session.capabilities = params.capabilities;+ session.lastActivityAt = new Date();++ this.logger.info('Session initialized', {+ sessionId,+ clientInfo: params.clientInfo,+ protocolVersion: params.protocolVersion,+ });++ this.emit('session:initialized', session);+ return session;+ }++ authenticateSession(sessionId: string): boolean {+ const session = this.sessions.get(sessionId);+ if (!session) {+ return false;+ }++ session.isAuthenticated = true;+ session.lastActivityAt = new Date();++ this.logger.debug('Session authenticated', { sessionId });+ this.emit('session:authenticated', session);++ return true;+ }++ getSession(sessionId: string): MCPSession | undefined {+ return this.sessions.get(sessionId);+ }++ hasSession(sessionId: string): boolean {+ return this.sessions.has(sessionId);+ }++ getActiveSessions(): MCPSession[] {+ return Array.from(this.sessions.values()).filter(+ (s) => s.state === 'ready' || s.state === 'created' || s.state === 'initializing'+ );+ }++ updateActivity(sessionId: string): boolean {+ const session = this.sessions.get(sessionId);+ if (!session) {+ return false;+ }++ session.lastActivityAt = new Date();+ return true;+ }++ setState(sessionId: string, state: SessionState): boolean {+ const session = this.sessions.get(sessionId);+ if (!session) {+ return false;+ }++ const oldState = session.state;+ session.state = state;+ session.lastActivityAt = new Date();++ this.logger.debug('Session state changed', {+ sessionId,+ oldState,+ newState: state,+ });++ this.emit('session:stateChanged', { session, oldState, newState: state });+ return true;+ }++ setMetadata(sessionId: string, key: string, value: unknown): boolean {+ const session = this.sessions.get(sessionId);+ if (!session) {+ return false;+ }++ if (!session.metadata) {+ session.metadata = {};+ }+ session.metadata[key] = value;+ session.lastActivityAt = new Date();++ return true;+ }++ getMetadata(sessionId: string, key: string): unknown {+ const session = this.sessions.get(sessionId);+ return session?.metadata?.[key];+ }++ closeSession(sessionId: string, reason?: string): boolean {+ const session = this.sessions.get(sessionId);+ if (!session) {+ return false;+ }++ session.state = 'closed';+ this.sessions.delete(sessionId);+ this.totalClosed++;++ this.logger.info('Session closed', { sessionId, reason });+ this.emit('session:closed', { session, reason });++ return true;+ }++ removeSession(sessionId: string): boolean {+ return this.closeSession(sessionId);+ }++ getSessionMetrics(): SessionMetrics {+ let authenticated = 0;+ let active = 0;++ for (const session of this.sessions.values()) {+ if (session.isAuthenticated) authenticated++;+ if (session.state === 'ready') active++;+ }++ return {+ total: this.sessions.size,+ active,+ authenticated,+ expired: this.totalExpired,+ };+ }++ getStats(): {+ total: number;+ byState: Record<SessionState, number>;+ byTransport: Record<TransportType, number>;+ totalCreated: number;+ totalClosed: number;+ totalExpired: number;+ oldestSession?: Date;+ newestSession?: Date;+ } {+ const byState: Record<string, number> = {+ created: 0,+ initializing: 0,+ ready: 0,+ closing: 0,+ closed: 0,+ error: 0,+ };++ const byTransport: Record<string, number> = {+ stdio: 0,+ http: 0,+ websocket: 0,+ 'in-process': 0,+ };++ let oldest: Date | undefined;+ let newest: Date | undefined;++ for (const session of this.sessions.values()) {+ byState[session.state] = (byState[session.state] || 0) + 1;+ byTransport[session.transport] = (byTransport[session.transport] || 0) + 1;++ if (!oldest || session.createdAt < oldest) {+ oldest = session.createdAt;+ }+ if (!newest || session.createdAt > newest) {+ newest = session.createdAt;+ }+ }++ return {+ total: this.sessions.size,+ byState: byState as Record<SessionState, number>,+ byTransport: byTransport as Record<TransportType, number>,+ totalCreated: this.totalCreated,+ totalClosed: this.totalClosed,+ totalExpired: this.totalExpired,+ oldestSession: oldest,+ newestSession: newest,+ };+ }++ cleanupExpiredSessions(): number {+ const now = Date.now();+ const expired: string[] = [];++ for (const [id, session] of this.sessions) {+ const inactiveTime = now - session.lastActivityAt.getTime();+ if (inactiveTime > this.config.sessionTimeout) {+ expired.push(id);+ }+ }++ for (const id of expired) {+ const session = this.sessions.get(id);+ if (session) {+ session.state = 'closed';+ this.sessions.delete(id);+ this.totalExpired++;+ this.logger.info('Session expired', { sessionId: id });+ this.emit('session:expired', session);+ }+ }++ if (expired.length > 0) {+ this.logger.info('Cleaned up expired sessions', { count: expired.length });+ }++ return expired.length;+ }++ private startCleanupTimer(): void {+ this.cleanupTimer = setInterval(() => {+ this.cleanupExpiredSessions();+ }, this.config.cleanupInterval);+ }++ private stopCleanupTimer(): void {+ if (this.cleanupTimer) {+ clearInterval(this.cleanupTimer);+ this.cleanupTimer = undefined;+ }+ }++ private generateSessionId(): string {+ return `session-${++this.sessionCounter}-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;+ }++ clearAll(): void {+ for (const id of this.sessions.keys()) {+ this.closeSession(id, 'Session manager cleared');+ }+ this.logger.info('All sessions cleared');+ }++ destroy(): void {+ this.stopCleanupTimer();+ this.clearAll();+ this.removeAllListeners();+ this.logger.info('Session manager destroyed');+ }+}++export function createSessionManager(+ logger: ILogger,+ config?: SessionConfig+): SessionManager {+ return new SessionManager(logger, config);+}diff --git a/v3/@claude-flow/mcp/src/task-manager.ts b/v3/@claude-flow/mcp/src/task-manager.tsnew file mode 100644index 0000000000..4429e660cd--- /dev/null+++ b/v3/@claude-flow/mcp/src/task-manager.ts@@ -0,0 +1,427 @@+/**+ * @claude-flow/mcp - Task Manager+ *+ * MCP 2025-11-25 compliant async task management+ * Supports: task tracking, progress reporting, cancellation+ */++import { EventEmitter } from 'events';+import type {+ MCPTask,+ TaskState,+ TaskProgress,+ TaskResult,+ MCPError,+ ILogger,+} from './types.js';++export type TaskExecutor<T = unknown> = (+ reportProgress: (progress: TaskProgress) => void,+ signal: AbortSignal+) => Promise<T>;++export interface TaskManagerOptions {+ maxConcurrentTasks?: number;+ taskTimeout?: number;+ cleanupInterval?: number;+ taskRetentionTime?: number;+}++interface ManagedTask extends MCPTask {+ executor?: TaskExecutor;+ abortController?: AbortController;+ promise?: Promise<unknown>;+}++export class TaskManager extends EventEmitter {+ private tasks: Map<string, ManagedTask> = new Map();+ private runningCount = 0;+ private taskCounter = 0;+ private cleanupTimer?: NodeJS.Timeout;++ private readonly options: Required<TaskManagerOptions>;++ constructor(+ private readonly logger: ILogger,+ options: TaskManagerOptions = {}+ ) {+ super();+ this.options = {+ maxConcurrentTasks: options.maxConcurrentTasks ?? 10,+ taskTimeout: options.taskTimeout ?? 300000, // 5 minutes+ cleanupInterval: options.cleanupInterval ?? 60000, // 1 minute+ taskRetentionTime: options.taskRetentionTime ?? 3600000, // 1 hour+ };++ this.startCleanupTimer();+ }++ /**+ * Create a new task+ */+ createTask<T>(executor: TaskExecutor<T>, metadata?: Record<string, unknown>): string {+ const taskId = `task-${++this.taskCounter}-${Date.now()}`;+ const now = new Date();++ const task: ManagedTask = {+ id: taskId,+ state: 'pending',+ createdAt: now,+ updatedAt: now,+ metadata,+ executor: executor as TaskExecutor,+ };++ this.tasks.set(taskId, task);++ this.logger.debug('Task created', { taskId });+ this.emit('task:created', { taskId });++ // Auto-start if we have capacity+ if (this.runningCount < this.options.maxConcurrentTasks) {+ this.startTask(taskId);+ }++ return taskId;+ }++ /**+ * Start a pending task+ */+ private async startTask(taskId: string): Promise<void> {+ const task = this.tasks.get(taskId);+ if (!task || task.state !== 'pending') {+ return;+ }++ if (this.runningCount >= this.options.maxConcurrentTasks) {+ return;+ }++ task.state = 'running';+ task.updatedAt = new Date();+ task.abortController = new AbortController();+ this.runningCount++;++ this.logger.debug('Task started', { taskId });+ this.emit('task:started', { taskId });++ // Set up timeout+ const timeoutId = setTimeout(() => {+ this.cancelTask(taskId, 'Task timeout');+ }, this.options.taskTimeout);++ // Progress reporter+ const reportProgress = (progress: TaskProgress) => {+ task.progress = progress;+ task.updatedAt = new Date();+ this.emit('task:progress', { taskId, progress });+ };++ try {+ const result = await task.executor!(reportProgress, task.abortController.signal);++ clearTimeout(timeoutId);++ if (task.state === 'running') {+ task.state = 'completed';+ task.result = result;+ task.updatedAt = new Date();+ task.progress = { progress: 100, total: 100 };++ this.logger.debug('Task completed', { taskId });+ this.emit('task:completed', { taskId, result });+ }+ } catch (error) {+ clearTimeout(timeoutId);++ if (task.state === 'running') {+ if (task.abortController.signal.aborted) {+ task.state = 'cancelled';+ this.logger.debug('Task cancelled', { taskId });+ this.emit('task:cancelled', { taskId });+ } else {+ task.state = 'failed';+ task.error = {+ code: -32603,+ message: error instanceof Error ? error.message : 'Task failed',+ };+ this.logger.error('Task failed', { taskId, error });+ this.emit('task:failed', { taskId, error: task.error });+ }+ task.updatedAt = new Date();+ }+ } finally {+ this.runningCount--;+ task.abortController = undefined;++ // Start next pending task+ this.startNextPendingTask();+ }+ }++ /**+ * Start next pending task if available+ */+ private startNextPendingTask(): void {+ for (const [taskId, task] of this.tasks) {+ if (task.state === 'pending') {+ this.startTask(taskId);+ break;+ }+ }+ }++ /**+ * Cancel a task+ */+ cancelTask(taskId: string, reason?: string): boolean {+ const task = this.tasks.get(taskId);+ if (!task) {+ return false;+ }++ if (task.state !== 'pending' && task.state !== 'running') {+ return false;+ }++ if (task.abortController) {+ task.abortController.abort(reason);+ }++ if (task.state === 'pending') {+ task.state = 'cancelled';+ task.updatedAt = new Date();+ task.error = { code: -32800, message: reason || 'Cancelled' };+ this.emit('task:cancelled', { taskId, reason });+ }++ this.logger.debug('Task cancel requested', { taskId, reason });+ return true;+ }++ /**+ * Get task status+ */+ getTask(taskId: string): TaskResult | undefined {+ const task = this.tasks.get(taskId);+ if (!task) {+ return undefined;+ }++ return {+ taskId: task.id,+ state: task.state,+ progress: task.progress,+ result: task.result,+ error: task.error,+ };+ }++ /**+ * Get all tasks+ */+ getAllTasks(): TaskResult[] {+ return Array.from(this.tasks.values()).map((task) => ({+ taskId: task.id,+ state: task.state,+ progress: task.progress,+ result: task.result,+ error: task.error,+ }));+ }++ /**+ * Get tasks by state+ */+ getTasksByState(state: TaskState): TaskResult[] {+ return Array.from(this.tasks.values())+ .filter((task) => task.state === state)+ .map((task) => ({+ taskId: task.id,+ state: task.state,+ progress: task.progress,+ result: task.result,+ error: task.error,+ }));+ }++ /**+ * Wait for task completion+ */+ async waitForTask(taskId: string, timeout?: number): Promise<TaskResult> {+ const task = this.tasks.get(taskId);+ if (!task) {+ throw new Error(`Task not found: ${taskId}`);+ }++ const effectiveTimeout = timeout ?? this.options.taskTimeout;++ return new Promise((resolve, reject) => {+ const checkState = () => {+ const result = this.getTask(taskId);+ if (!result) {+ reject(new Error(`Task not found: ${taskId}`));+ return true;+ }+ if (result.state === 'completed' || result.state === 'failed' || result.state === 'cancelled') {+ resolve(result);+ return true;+ }+ return false;+ };++ if (checkState()) return;++ const timeoutId = setTimeout(() => {+ this.off('task:completed', onComplete);+ this.off('task:failed', onFail);+ this.off('task:cancelled', onCancel);+ reject(new Error(`Wait timeout for task: ${taskId}`));+ }, effectiveTimeout);++ const cleanup = () => {+ clearTimeout(timeoutId);+ this.off('task:completed', onComplete);+ this.off('task:failed', onFail);+ this.off('task:cancelled', onCancel);+ };++ const onComplete = (event: { taskId: string }) => {+ if (event.taskId === taskId) {+ cleanup();+ resolve(this.getTask(taskId)!);+ }+ };++ const onFail = (event: { taskId: string }) => {+ if (event.taskId === taskId) {+ cleanup();+ resolve(this.getTask(taskId)!);+ }+ };++ const onCancel = (event: { taskId: string }) => {+ if (event.taskId === taskId) {+ cleanup();+ resolve(this.getTask(taskId)!);+ }+ };++ this.on('task:completed', onComplete);+ this.on('task:failed', onFail);+ this.on('task:cancelled', onCancel);+ });+ }++ /**+ * Get stats+ */+ getStats(): {+ totalTasks: number;+ pendingTasks: number;+ runningTasks: number;+ completedTasks: number;+ failedTasks: number;+ cancelledTasks: number;+ } {+ let pending = 0;+ let running = 0;+ let completed = 0;+ let failed = 0;+ let cancelled = 0;++ for (const task of this.tasks.values()) {+ switch (task.state) {+ case 'pending':+ pending++;+ break;+ case 'running':+ running++;+ break;+ case 'completed':+ completed++;+ break;+ case 'failed':+ failed++;+ break;+ case 'cancelled':+ cancelled++;+ break;+ }+ }++ return {+ totalTasks: this.tasks.size,+ pendingTasks: pending,+ runningTasks: running,+ completedTasks: completed,+ failedTasks: failed,+ cancelledTasks: cancelled,+ };+ }++ /**+ * Start cleanup timer+ */+ private startCleanupTimer(): void {+ this.cleanupTimer = setInterval(() => {+ this.cleanupOldTasks();+ }, this.options.cleanupInterval);+ }++ /**+ * Cleanup old completed/failed/cancelled tasks+ */+ private cleanupOldTasks(): void {+ const now = Date.now();+ const toDelete: string[] = [];++ for (const [taskId, task] of this.tasks) {+ if (+ (task.state === 'completed' || task.state === 'failed' || task.state === 'cancelled') &&+ now - task.updatedAt.getTime() > this.options.taskRetentionTime+ ) {+ toDelete.push(taskId);+ }+ }++ for (const taskId of toDelete) {+ this.tasks.delete(taskId);+ this.logger.debug('Task cleaned up', { taskId });+ }++ if (toDelete.length > 0) {+ this.emit('tasks:cleaned', { count: toDelete.length });+ }+ }++ /**+ * Destroy the task manager+ */+ destroy(): void {+ if (this.cleanupTimer) {+ clearInterval(this.cleanupTimer);+ this.cleanupTimer = undefined;+ }++ // Cancel all running tasks+ for (const task of this.tasks.values()) {+ if (task.abortController) {+ task.abortController.abort('Task manager destroyed');+ }+ }++ this.tasks.clear();+ this.removeAllListeners();++ this.logger.debug('Task manager destroyed');+ }+}++export function createTaskManager(+ logger: ILogger,+ options?: TaskManagerOptions+): TaskManager {+ return new TaskManager(logger, options);+}diff --git a/v3/@claude-flow/mcp/src/tool-registry.ts b/v3/@claude-flow/mcp/src/tool-registry.tsnew file mode 100644index 0000000000..0fb82399b9--- /dev/null+++ b/v3/@claude-flow/mcp/src/tool-registry.ts@@ -0,0 +1,458 @@+/**+ * @claude-flow/mcp - Tool Registry+ *+ * High-performance tool management with O(1) lookup+ */++import { EventEmitter } from 'events';+import type {+ MCPTool,+ JSONSchema,+ ToolHandler,+ ToolContext,+ ToolCallResult,+ ToolRegistrationOptions,+ ILogger,+} from './types.js';++interface ToolMetadata {+ tool: MCPTool;+ registeredAt: Date;+ callCount: number;+ lastCalled?: Date;+ avgExecutionTime: number;+ errorCount: number;+}++interface ToolSearchOptions {+ category?: string;+ tags?: string[];+ deprecated?: boolean;+ cacheable?: boolean;+}++export class ToolRegistry extends EventEmitter {+ private readonly tools: Map<string, ToolMetadata> = new Map();+ private readonly categoryIndex: Map<string, Set<string>> = new Map();+ private readonly tagIndex: Map<string, Set<string>> = new Map();+ private defaultContext?: ToolContext;++ private totalRegistrations = 0;+ private totalLookups = 0;+ private totalExecutions = 0;++ constructor(private readonly logger: ILogger) {+ super();+ }++ register(tool: MCPTool, options: ToolRegistrationOptions = {}): boolean {+ const startTime = performance.now();++ if (this.tools.has(tool.name) && !options.override) {+ this.logger.warn('Tool already registered', { name: tool.name });+ return false;+ }++ if (options.validate !== false) {+ const validation = this.validateTool(tool);+ if (!validation.valid) {+ this.logger.error('Tool validation failed', {+ name: tool.name,+ errors: validation.errors,+ });+ return false;+ }+ }++ const metadata: ToolMetadata = {+ tool,+ registeredAt: new Date(),+ callCount: 0,+ avgExecutionTime: 0,+ errorCount: 0,+ };++ this.tools.set(tool.name, metadata);+ this.totalRegistrations++;++ if (tool.category) {+ if (!this.categoryIndex.has(tool.category)) {+ this.categoryIndex.set(tool.category, new Set());+ }+ this.categoryIndex.get(tool.category)!.add(tool.name);+ }++ if (tool.tags) {+ for (const tag of tool.tags) {+ if (!this.tagIndex.has(tag)) {+ this.tagIndex.set(tag, new Set());+ }+ this.tagIndex.get(tag)!.add(tool.name);+ }+ }++ const duration = performance.now() - startTime;+ this.logger.debug('Tool registered', {+ name: tool.name,+ category: tool.category,+ duration: `${duration.toFixed(2)}ms`,+ });++ this.emit('tool:registered', tool.name);+ return true;+ }++ registerBatch(tools: MCPTool[], options: ToolRegistrationOptions = {}): {+ registered: number;+ failed: string[];+ } {+ const startTime = performance.now();+ const failed: string[] = [];+ let registered = 0;++ for (const tool of tools) {+ if (this.register(tool, options)) {+ registered++;+ } else {+ failed.push(tool.name);+ }+ }++ const duration = performance.now() - startTime;+ this.logger.info('Batch registration complete', {+ total: tools.length,+ registered,+ failed: failed.length,+ duration: `${duration.toFixed(2)}ms`,+ });++ return { registered, failed };+ }++ unregister(name: string): boolean {+ const metadata = this.tools.get(name);+ if (!metadata) {+ return false;+ }++ if (metadata.tool.category) {+ const categoryTools = this.categoryIndex.get(metadata.tool.category);+ categoryTools?.delete(name);+ if (categoryTools?.size === 0) {+ this.categoryIndex.delete(metadata.tool.category);+ }+ }++ if (metadata.tool.tags) {+ for (const tag of metadata.tool.tags) {+ const tagTools = this.tagIndex.get(tag);+ tagTools?.delete(name);+ if (tagTools?.size === 0) {+ this.tagIndex.delete(tag);+ }+ }+ }++ this.tools.delete(name);+ this.logger.debug('Tool unregistered', { name });+ this.emit('tool:unregistered', name);++ return true;+ }++ getTool(name: string): MCPTool | undefined {+ this.totalLookups++;+ return this.tools.get(name)?.tool;+ }++ hasTool(name: string): boolean {+ return this.tools.has(name);+ }++ getToolCount(): number {+ return this.tools.size;+ }++ getToolNames(): string[] {+ return Array.from(this.tools.keys());+ }++ listTools(): Array<{+ name: string;+ description: string;+ category?: string;+ tags?: string[];+ deprecated?: boolean;+ }> {+ return Array.from(this.tools.values()).map(({ tool }) => ({+ name: tool.name,+ description: tool.description,+ category: tool.category,+ tags: tool.tags,+ deprecated: tool.deprecated,+ }));+ }++ search(options: ToolSearchOptions): MCPTool[] {+ let results: Set<string> | undefined;++ if (options.category) {+ const categoryTools = this.categoryIndex.get(options.category);+ if (!categoryTools) return [];+ results = new Set(categoryTools);+ }++ if (options.tags && options.tags.length > 0) {+ for (const tag of options.tags) {+ const tagTools = this.tagIndex.get(tag);+ if (!tagTools) return [];++ if (results) {+ results = new Set([...results].filter((name) => tagTools.has(name)));+ } else {+ results = new Set(tagTools);+ }+ }+ }++ if (!results) {+ results = new Set(this.tools.keys());+ }++ const tools: MCPTool[] = [];+ for (const name of results) {+ const metadata = this.tools.get(name);+ if (!metadata) continue;++ const tool = metadata.tool;++ if (options.deprecated !== undefined && tool.deprecated !== options.deprecated) {+ continue;+ }++ if (options.cacheable !== undefined && tool.cacheable !== options.cacheable) {+ continue;+ }++ tools.push(tool);+ }++ return tools;+ }++ getByCategory(category: string): MCPTool[] {+ const toolNames = this.categoryIndex.get(category);+ if (!toolNames) return [];++ return Array.from(toolNames)+ .map((name) => this.tools.get(name)?.tool)+ .filter((tool): tool is MCPTool => tool !== undefined);+ }++ getByTag(tag: string): MCPTool[] {+ const toolNames = this.tagIndex.get(tag);+ if (!toolNames) return [];++ return Array.from(toolNames)+ .map((name) => this.tools.get(name)?.tool)+ .filter((tool): tool is MCPTool => tool !== undefined);+ }++ getCategories(): string[] {+ return Array.from(this.categoryIndex.keys());+ }++ getTags(): string[] {+ return Array.from(this.tagIndex.keys());+ }++ async execute(+ name: string,+ input: Record<string, unknown>,+ context?: ToolContext+ ): Promise<ToolCallResult> {+ const startTime = performance.now();+ const metadata = this.tools.get(name);++ if (!metadata) {+ return {+ content: [{ type: 'text', text: `Tool not found: ${name}` }],+ isError: true,+ };+ }++ const execContext: ToolContext = {+ sessionId: context?.sessionId || this.defaultContext?.sessionId || 'default-session',+ ...this.defaultContext,+ ...context,+ };+ this.totalExecutions++;+ metadata.callCount++;+ metadata.lastCalled = new Date();++ try {+ this.emit('tool:called', { name, input });++ const result = await metadata.tool.handler(input, execContext);++ const duration = performance.now() - startTime;+ this.updateAverageExecutionTime(metadata, duration);++ this.logger.debug('Tool executed', {+ name,+ duration: `${duration.toFixed(2)}ms`,+ success: true,+ });++ this.emit('tool:completed', { name, duration, success: true });++ return {+ content: [{+ type: 'text',+ text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),+ }],+ isError: false,+ };+ } catch (error) {+ const duration = performance.now() - startTime;+ metadata.errorCount++;++ this.logger.error('Tool execution failed', { name, error });+ this.emit('tool:error', { name, error, duration });++ return {+ content: [{+ type: 'text',+ text: `Error: ${error instanceof Error ? error.message : String(error)}`,+ }],+ isError: true,+ };+ }+ }++ setDefaultContext(context: ToolContext): void {+ this.defaultContext = context;+ }++ getMetadata(name: string): ToolMetadata | undefined {+ return this.tools.get(name);+ }++ getStats(): {+ totalTools: number;+ totalCategories: number;+ totalTags: number;+ totalRegistrations: number;+ totalLookups: number;+ totalExecutions: number;+ topTools: Array<{ name: string; calls: number }>;+ } {+ const topTools = Array.from(this.tools.entries())+ .map(([name, metadata]) => ({ name, calls: metadata.callCount }))+ .sort((a, b) => b.calls - a.calls)+ .slice(0, 10);++ return {+ totalTools: this.tools.size,+ totalCategories: this.categoryIndex.size,+ totalTags: this.tagIndex.size,+ totalRegistrations: this.totalRegistrations,+ totalLookups: this.totalLookups,+ totalExecutions: this.totalExecutions,+ topTools,+ };+ }++ validateTool(tool: MCPTool): { valid: boolean; errors: string[] } {+ const errors: string[] = [];++ if (!tool.name || typeof tool.name !== 'string') {+ errors.push('Tool name is required and must be a string');+ } else if (!/^[a-zA-Z][a-zA-Z0-9_/:-]*$/.test(tool.name)) {+ errors.push('Tool name must start with a letter and contain only alphanumeric characters, underscores, slashes, colons, and hyphens');+ }++ if (!tool.description || typeof tool.description !== 'string') {+ errors.push('Tool description is required and must be a string');+ }++ if (!tool.inputSchema || typeof tool.inputSchema !== 'object') {+ errors.push('Tool inputSchema is required and must be an object');+ } else {+ const schemaErrors = this.validateSchema(tool.inputSchema);+ errors.push(...schemaErrors);+ }++ if (typeof tool.handler !== 'function') {+ errors.push('Tool handler is required and must be a function');+ }++ return {+ valid: errors.length === 0,+ errors,+ };+ }++ private validateSchema(schema: JSONSchema, path = ''): string[] {+ const errors: string[] = [];++ if (!schema.type) {+ errors.push(`${path || 'schema'}: type is required`);+ }++ if (schema.type === 'object' && schema.properties) {+ for (const [key, propSchema] of Object.entries(schema.properties)) {+ const propPath = path ? `${path}.${key}` : key;+ errors.push(...this.validateSchema(propSchema, propPath));+ }+ }++ if (schema.type === 'array' && schema.items) {+ errors.push(...this.validateSchema(schema.items, `${path}[]`));+ }++ return errors;+ }++ private updateAverageExecutionTime(metadata: ToolMetadata, duration: number): void {+ const n = metadata.callCount;+ metadata.avgExecutionTime =+ ((metadata.avgExecutionTime * (n - 1)) + duration) / n;+ }++ clear(): void {+ this.tools.clear();+ this.categoryIndex.clear();+ this.tagIndex.clear();+ this.logger.info('Tool registry cleared');+ this.emit('registry:cleared');+ }+}++export function createToolRegistry(logger: ILogger): ToolRegistry {+ return new ToolRegistry(logger);+}++export function defineTool<TInput = Record<string, unknown>, TOutput = unknown>(+ name: string,+ description: string,+ inputSchema: JSONSchema,+ handler: ToolHandler<TInput, TOutput>,+ options?: {+ category?: string;+ tags?: string[];+ version?: string;+ deprecated?: boolean;+ cacheable?: boolean;+ cacheTTL?: number;+ timeout?: number;+ }+): MCPTool<TInput, TOutput> {+ return {+ name,+ description,+ inputSchema,+ handler,+ ...options,+ };+}diff --git a/v3/@claude-flow/mcp/src/transport/http.ts b/v3/@claude-flow/mcp/src/transport/http.tsnew file mode 100644index 0000000000..6879efc4f1--- /dev/null+++ b/v3/@claude-flow/mcp/src/transport/http.ts@@ -0,0 +1,473 @@+/**+ * @claude-flow/mcp - HTTP Transport+ *+ * HTTP/REST transport with WebSocket support+ */++import { EventEmitter } from 'events';+import express, { Express, Request, Response, NextFunction } from 'express';+import { createServer, Server } from 'http';+import { WebSocketServer, WebSocket } from 'ws';+import cors from 'cors';+import helmet from 'helmet';+import type {+ ITransport,+ TransportType,+ MCPRequest,+ MCPResponse,+ MCPNotification,+ RequestHandler,+ NotificationHandler,+ TransportHealthStatus,+ ILogger,+ AuthConfig,+} from '../types.js';++export interface HttpTransportConfig {+ host: string;+ port: number;+ tlsEnabled?: boolean;+ tlsCert?: string;+ tlsKey?: string;+ corsEnabled?: boolean;+ corsOrigins?: string[];+ auth?: AuthConfig;+ maxRequestSize?: string;+ requestTimeout?: number;+}++export class HttpTransport extends EventEmitter implements ITransport {+ public readonly type: TransportType = 'http';++ private requestHandler?: RequestHandler;+ private notificationHandler?: NotificationHandler;+ private app: Express;+ private server?: Server;+ private wss?: WebSocketServer;+ private running = false;+ private activeConnections = new Set<WebSocket>();++ private messagesReceived = 0;+ private messagesSent = 0;+ private errors = 0;+ private httpRequests = 0;+ private wsMessages = 0;++ constructor(+ private readonly logger: ILogger,+ private readonly config: HttpTransportConfig+ ) {+ super();+ this.app = express();+ this.setupMiddleware();+ this.setupRoutes();+ }++ async start(): Promise<void> {+ if (this.running) {+ throw new Error('HTTP transport already running');+ }++ this.logger.info('Starting HTTP transport', {+ host: this.config.host,+ port: this.config.port,+ });++ this.server = createServer(this.app);++ this.wss = new WebSocketServer({+ server: this.server,+ path: '/ws',+ });++ this.setupWebSocketHandlers();++ await new Promise<void>((resolve, reject) => {+ this.server!.listen(this.config.port, this.config.host, () => {+ resolve();+ });+ this.server!.on('error', reject);+ });++ this.running = true;+ this.logger.info('HTTP transport started', {+ url: `http://${this.config.host}:${this.config.port}`,+ });+ }++ async stop(): Promise<void> {+ if (!this.running) {+ return;+ }++ this.logger.info('Stopping HTTP transport');+ this.running = false;++ for (const ws of this.activeConnections) {+ try {+ ws.close(1000, 'Server shutting down');+ } catch {+ // Ignore errors+ }+ }+ this.activeConnections.clear();++ if (this.wss) {+ this.wss.close();+ this.wss = undefined;+ }++ if (this.server) {+ await new Promise<void>((resolve) => {+ this.server!.close(() => resolve());+ });+ this.server = undefined;+ }++ this.logger.info('HTTP transport stopped');+ }++ onRequest(handler: RequestHandler): void {+ this.requestHandler = handler;+ }++ onNotification(handler: NotificationHandler): void {+ this.notificationHandler = handler;+ }++ async getHealthStatus(): Promise<TransportHealthStatus> {+ return {+ healthy: this.running,+ metrics: {+ messagesReceived: this.messagesReceived,+ messagesSent: this.messagesSent,+ errors: this.errors,+ httpRequests: this.httpRequests,+ wsMessages: this.wsMessages,+ activeConnections: this.activeConnections.size,+ },+ };+ }++ async sendNotification(notification: MCPNotification): Promise<void> {+ const message = JSON.stringify(notification);++ for (const ws of this.activeConnections) {+ try {+ if (ws.readyState === WebSocket.OPEN) {+ ws.send(message);+ this.messagesSent++;+ }+ } catch (error) {+ this.logger.error('Failed to send notification', { error });+ this.errors++;+ }+ }+ }++ private setupMiddleware(): void {+ this.app.use(helmet({+ contentSecurityPolicy: false,+ }));++ if (this.config.corsEnabled !== false) {+ const allowedOrigins = this.config.corsOrigins;++ if (!allowedOrigins || allowedOrigins.length === 0) {+ this.logger.warn('CORS: No origins configured, restricting to same-origin only');+ }++ this.app.use(cors({+ origin: (origin, callback) => {+ if (!origin) {+ callback(null, true);+ return;+ }++ if (allowedOrigins && allowedOrigins.length > 0) {+ if (allowedOrigins.includes(origin) || allowedOrigins.includes('*')) {+ callback(null, true);+ } else {+ callback(new Error(`CORS: Origin '${origin}' not allowed`));+ }+ } else {+ callback(new Error('CORS: Cross-origin requests not allowed'));+ }+ },+ credentials: true,+ maxAge: 86400,+ methods: ['GET', 'POST', 'OPTIONS'],+ allowedHeaders: ['Content-Type', 'Authorization', 'X-Request-ID'],+ }));+ }++ this.app.use(express.json({+ limit: this.config.maxRequestSize || '10mb',+ }));++ if (this.config.requestTimeout) {+ this.app.use((req, res, next) => {+ res.setTimeout(this.config.requestTimeout!, () => {+ res.status(408).json({+ jsonrpc: '2.0',+ id: null,+ error: { code: -32000, message: 'Request timeout' },+ });+ });+ next();+ });+ }++ this.app.use((req, res, next) => {+ const startTime = performance.now();+ res.on('finish', () => {+ const duration = performance.now() - startTime;+ this.logger.debug('HTTP request', {+ method: req.method,+ path: req.path,+ status: res.statusCode,+ duration: `${duration.toFixed(2)}ms`,+ });+ });+ next();+ });+ }++ private setupRoutes(): void {+ this.app.get('/health', (req, res) => {+ res.json({+ status: 'ok',+ timestamp: new Date().toISOString(),+ connections: this.activeConnections.size,+ });+ });++ this.app.post('/rpc', async (req, res) => {+ await this.handleHttpRequest(req, res);+ });++ this.app.post('/mcp', async (req, res) => {+ await this.handleHttpRequest(req, res);+ });++ this.app.get('/info', (req, res) => {+ res.json({+ name: 'Claude-Flow MCP Server V3',+ version: '3.0.0',+ transport: 'http',+ capabilities: {+ jsonrpc: true,+ websocket: true,+ },+ });+ });++ this.app.use((req, res) => {+ res.status(404).json({+ error: 'Not found',+ path: req.path,+ });+ });++ this.app.use((err: Error, req: Request, res: Response, next: NextFunction) => {+ this.logger.error('Express error', { error: err });+ this.errors++;+ res.status(500).json({+ jsonrpc: '2.0',+ id: null,+ error: { code: -32603, message: 'Internal error' },+ });+ });+ }++ private setupWebSocketHandlers(): void {+ if (!this.wss) return;++ this.wss.on('connection', (ws) => {+ this.activeConnections.add(ws);+ this.logger.info('WebSocket client connected', {+ total: this.activeConnections.size,+ });++ ws.on('message', async (data) => {+ await this.handleWebSocketMessage(ws, data.toString());+ });++ ws.on('close', () => {+ this.activeConnections.delete(ws);+ this.logger.info('WebSocket client disconnected', {+ total: this.activeConnections.size,+ });+ });++ ws.on('error', (error) => {+ this.logger.error('WebSocket error', { error });+ this.errors++;+ this.activeConnections.delete(ws);+ });+ });+ }++ private async handleHttpRequest(req: Request, res: Response): Promise<void> {+ this.httpRequests++;+ this.messagesReceived++;++ const requiresAuth = this.config.auth?.enabled !== false;++ if (requiresAuth && this.config.auth) {+ const authResult = this.validateAuth(req);+ if (!authResult.valid) {+ this.logger.warn('Authentication failed', {+ ip: req.ip,+ path: req.path,+ error: authResult.error,+ });+ res.status(401).json({+ jsonrpc: '2.0',+ id: null,+ error: { code: -32001, message: 'Unauthorized' },+ });+ return;+ }+ } else if (requiresAuth && !this.config.auth) {+ this.logger.warn('No authentication configured - running in development mode');+ }++ const message = req.body;++ if (message.jsonrpc !== '2.0') {+ res.status(400).json({+ jsonrpc: '2.0',+ id: message.id || null,+ error: { code: -32600, message: 'Invalid JSON-RPC version' },+ });+ return;+ }++ if (!message.method) {+ res.status(400).json({+ jsonrpc: '2.0',+ id: message.id || null,+ error: { code: -32600, message: 'Missing method' },+ });+ return;+ }++ if (message.id === undefined) {+ if (this.notificationHandler) {+ await this.notificationHandler(message as MCPNotification);+ }+ res.status(204).end();+ } else {+ if (!this.requestHandler) {+ res.status(500).json({+ jsonrpc: '2.0',+ id: message.id,+ error: { code: -32603, message: 'No request handler' },+ });+ return;+ }++ try {+ const response = await this.requestHandler(message as MCPRequest);+ res.json(response);+ this.messagesSent++;+ } catch (error) {+ this.errors++;+ res.status(500).json({+ jsonrpc: '2.0',+ id: message.id,+ error: {+ code: -32603,+ message: error instanceof Error ? error.message : 'Internal error',+ },+ });+ }+ }+ }++ private async handleWebSocketMessage(ws: WebSocket, data: string): Promise<void> {+ this.wsMessages++;+ this.messagesReceived++;++ try {+ const message = JSON.parse(data);++ if (message.jsonrpc !== '2.0') {+ ws.send(JSON.stringify({+ jsonrpc: '2.0',+ id: message.id || null,+ error: { code: -32600, message: 'Invalid JSON-RPC version' },+ }));+ return;+ }++ if (message.id === undefined) {+ if (this.notificationHandler) {+ await this.notificationHandler(message as MCPNotification);+ }+ } else {+ if (!this.requestHandler) {+ ws.send(JSON.stringify({+ jsonrpc: '2.0',+ id: message.id,+ error: { code: -32603, message: 'No request handler' },+ }));+ return;+ }++ const response = await this.requestHandler(message as MCPRequest);+ ws.send(JSON.stringify(response));+ this.messagesSent++;+ }+ } catch (error) {+ this.errors++;+ this.logger.error('WebSocket message error', { error });++ try {+ const parsed = JSON.parse(data);+ ws.send(JSON.stringify({+ jsonrpc: '2.0',+ id: parsed.id || null,+ error: { code: -32700, message: 'Parse error' },+ }));+ } catch {+ ws.send(JSON.stringify({+ jsonrpc: '2.0',+ id: null,+ error: { code: -32700, message: 'Parse error' },+ }));+ }+ }+ }++ private validateAuth(req: Request): { valid: boolean; error?: string } {+ const auth = req.headers.authorization;++ if (!auth) {+ return { valid: false, error: 'Authorization header required' };+ }++ const tokenMatch = auth.match(/^Bearer\s+(.+)$/i);+ if (!tokenMatch) {+ return { valid: false, error: 'Invalid authorization format' };+ }++ const token = tokenMatch[1];++ if (this.config.auth?.tokens?.length) {+ if (!this.config.auth.tokens.includes(token)) {+ return { valid: false, error: 'Invalid token' };+ }+ }++ return { valid: true };+ }+}++export function createHttpTransport(+ logger: ILogger,+ config: HttpTransportConfig+): HttpTransport {+ return new HttpTransport(logger, config);+}diff --git a/v3/@claude-flow/mcp/src/transport/index.ts b/v3/@claude-flow/mcp/src/transport/index.tsnew file mode 100644index 0000000000..1131dfce51--- /dev/null+++ b/v3/@claude-flow/mcp/src/transport/index.ts@@ -0,0 +1,233 @@+/**+ * @claude-flow/mcp - Transport Factory+ *+ * Central factory for creating transport instances+ */++import type {+ ITransport,+ TransportType,+ TransportHealthStatus,+ ILogger,+} from '../types.js';+import { StdioTransport, StdioTransportConfig, createStdioTransport } from './stdio.js';+import { HttpTransport, HttpTransportConfig, createHttpTransport } from './http.js';+import { WebSocketTransport, WebSocketTransportConfig, createWebSocketTransport } from './websocket.js';++export { StdioTransport } from './stdio.js';+export { HttpTransport } from './http.js';+export { WebSocketTransport } from './websocket.js';++export type { StdioTransportConfig } from './stdio.js';+export type { HttpTransportConfig } from './http.js';+export type { WebSocketTransportConfig } from './websocket.js';++export type TransportConfig =+ | { type: 'stdio' } & StdioTransportConfig+ | { type: 'http' } & HttpTransportConfig+ | { type: 'websocket' } & WebSocketTransportConfig+ | { type: 'in-process' };++export function createTransport(+ type: TransportType,+ logger: ILogger,+ config?: Partial<TransportConfig>+): ITransport {+ switch (type) {+ case 'stdio':+ return createStdioTransport(logger, config as StdioTransportConfig);++ case 'http':+ if (!config || !('host' in config) || !('port' in config)) {+ throw new Error('HTTP transport requires host and port configuration');+ }+ return createHttpTransport(logger, {+ host: config.host as string,+ port: config.port as number,+ ...config,+ } as HttpTransportConfig);++ case 'websocket':+ if (!config || !('host' in config) || !('port' in config)) {+ throw new Error('WebSocket transport requires host and port configuration');+ }+ return createWebSocketTransport(logger, {+ host: config.host as string,+ port: config.port as number,+ ...config,+ } as WebSocketTransportConfig);++ case 'in-process':+ return createInProcessTransport(logger);++ default:+ throw new Error(`Unknown transport type: ${type}`);+ }+}++class InProcessTransport implements ITransport {+ public readonly type: TransportType = 'in-process';++ constructor(private readonly logger: ILogger) {}++ async start(): Promise<void> {+ this.logger.debug('In-process transport started');+ }++ async stop(): Promise<void> {+ this.logger.debug('In-process transport stopped');+ }++ onRequest(): void {+ // No-op - requests are handled directly+ }++ onNotification(): void {+ // No-op - notifications are handled directly+ }++ async getHealthStatus(): Promise<TransportHealthStatus> {+ return {+ healthy: true,+ metrics: {+ latency: 0,+ connections: 1,+ },+ };+ }+}++export function createInProcessTransport(logger: ILogger): ITransport {+ return new InProcessTransport(logger);+}++export class TransportManager {+ private transports: Map<string, ITransport> = new Map();+ private running = false;++ constructor(private readonly logger: ILogger) {}++ addTransport(name: string, transport: ITransport): void {+ if (this.transports.has(name)) {+ throw new Error(`Transport "${name}" already exists`);+ }+ this.transports.set(name, transport);+ this.logger.debug('Transport added', { name, type: transport.type });+ }++ async removeTransport(name: string): Promise<boolean> {+ const transport = this.transports.get(name);+ if (!transport) {+ return false;+ }++ await transport.stop();+ this.transports.delete(name);+ this.logger.debug('Transport removed', { name });+ return true;+ }++ getTransport(name: string): ITransport | undefined {+ return this.transports.get(name);+ }++ getTransportNames(): string[] {+ return Array.from(this.transports.keys());+ }++ async startAll(): Promise<void> {+ if (this.running) {+ throw new Error('TransportManager already running');+ }++ this.logger.info('Starting all transports', { count: this.transports.size });++ const startPromises = Array.from(this.transports.entries()).map(+ async ([name, transport]) => {+ try {+ await transport.start();+ this.logger.info('Transport started', { name, type: transport.type });+ } catch (error) {+ this.logger.error('Failed to start transport', { name, error });+ throw error;+ }+ }+ );++ await Promise.all(startPromises);+ this.running = true;+ this.logger.info('All transports started');+ }++ async stopAll(): Promise<void> {+ if (!this.running) {+ return;+ }++ this.logger.info('Stopping all transports');++ const stopPromises = Array.from(this.transports.entries()).map(+ async ([name, transport]) => {+ try {+ await transport.stop();+ this.logger.info('Transport stopped', { name });+ } catch (error) {+ this.logger.error('Error stopping transport', { name, error });+ }+ }+ );++ await Promise.all(stopPromises);+ this.running = false;+ this.logger.info('All transports stopped');+ }++ async getHealthStatus(): Promise<Record<string, { healthy: boolean; error?: string }>> {+ const results: Record<string, { healthy: boolean; error?: string }> = {};++ for (const [name, transport] of this.transports) {+ try {+ const status = await transport.getHealthStatus();+ results[name] = { healthy: status.healthy, error: status.error };+ } catch (error) {+ results[name] = {+ healthy: false,+ error: error instanceof Error ? error.message : 'Unknown error',+ };+ }+ }++ return results;+ }++ isRunning(): boolean {+ return this.running;+ }+}++export function createTransportManager(logger: ILogger): TransportManager {+ return new TransportManager(logger);+}++export const DEFAULT_TRANSPORT_CONFIGS = {+ stdio: {} as StdioTransportConfig,++ http: {+ host: 'localhost',+ port: 3000,+ corsEnabled: true,+ corsOrigins: ['*'],+ maxRequestSize: '10mb',+ requestTimeout: 30000,+ } as HttpTransportConfig,++ websocket: {+ host: 'localhost',+ port: 3001,+ path: '/ws',+ maxConnections: 100,+ heartbeatInterval: 30000,+ heartbeatTimeout: 10000,+ maxMessageSize: 10 * 1024 * 1024,+ } as WebSocketTransportConfig,+} as const;diff --git a/v3/@claude-flow/mcp/src/transport/stdio.ts b/v3/@claude-flow/mcp/src/transport/stdio.tsnew file mode 100644index 0000000000..b1e4883fa0--- /dev/null+++ b/v3/@claude-flow/mcp/src/transport/stdio.ts@@ -0,0 +1,252 @@+/**+ * @claude-flow/mcp - Stdio Transport+ *+ * Standard I/O transport for MCP communication+ */++import { EventEmitter } from 'events';+import * as readline from 'readline';+import type {+ ITransport,+ TransportType,+ MCPRequest,+ MCPResponse,+ MCPNotification,+ RequestHandler,+ NotificationHandler,+ TransportHealthStatus,+ ILogger,+} from '../types.js';++export interface StdioTransportConfig {+ inputStream?: NodeJS.ReadableStream;+ outputStream?: NodeJS.WritableStream;+ maxMessageSize?: number;+}++export class StdioTransport extends EventEmitter implements ITransport {+ public readonly type: TransportType = 'stdio';++ private requestHandler?: RequestHandler;+ private notificationHandler?: NotificationHandler;+ private rl?: readline.Interface;+ private running = false;++ private messagesReceived = 0;+ private messagesSent = 0;+ private errors = 0;++ private readonly inputStream: NodeJS.ReadableStream;+ private readonly outputStream: NodeJS.WritableStream;+ private readonly maxMessageSize: number;++ constructor(+ private readonly logger: ILogger,+ config: StdioTransportConfig = {}+ ) {+ super();+ this.inputStream = config.inputStream || process.stdin;+ this.outputStream = config.outputStream || process.stdout;+ this.maxMessageSize = config.maxMessageSize || 10 * 1024 * 1024;+ }++ async start(): Promise<void> {+ if (this.running) {+ throw new Error('Stdio transport already running');+ }++ this.logger.info('Starting stdio transport');++ this.rl = readline.createInterface({+ input: this.inputStream,+ crlfDelay: Infinity,+ });++ this.rl.on('line', (line) => {+ this.handleLine(line);+ });++ this.rl.on('close', () => {+ this.handleClose();+ });++ this.inputStream.on('error', (error) => {+ this.handleError(error);+ });++ this.running = true;+ this.logger.info('Stdio transport started');+ }++ async stop(): Promise<void> {+ if (!this.running) {+ return;+ }++ this.logger.info('Stopping stdio transport');+ this.running = false;++ if (this.rl) {+ this.rl.close();+ this.rl = undefined;+ }++ this.logger.info('Stdio transport stopped');+ }++ onRequest(handler: RequestHandler): void {+ this.requestHandler = handler;+ }++ onNotification(handler: NotificationHandler): void {+ this.notificationHandler = handler;+ }++ async getHealthStatus(): Promise<TransportHealthStatus> {+ return {+ healthy: this.running,+ metrics: {+ messagesReceived: this.messagesReceived,+ messagesSent: this.messagesSent,+ errors: this.errors,+ },+ };+ }++ private async handleLine(line: string): Promise<void> {+ if (!line.trim()) {+ return;+ }++ if (line.length > this.maxMessageSize) {+ this.logger.error('Message exceeds maximum size', {+ size: line.length,+ max: this.maxMessageSize,+ });+ this.errors++;+ return;+ }++ try {+ const message = JSON.parse(line);+ this.messagesReceived++;++ if (message.jsonrpc !== '2.0') {+ this.logger.warn('Invalid JSON-RPC version', { received: message.jsonrpc });+ await this.sendError(message.id, -32600, 'Invalid JSON-RPC version');+ return;+ }++ if (!message.method) {+ this.logger.warn('Missing method in request');+ await this.sendError(message.id, -32600, 'Missing method');+ return;+ }++ if (message.id !== undefined) {+ await this.handleRequest(message as MCPRequest);+ } else {+ await this.handleNotification(message as MCPNotification);+ }+ } catch (error) {+ this.errors++;+ this.logger.error('Failed to parse message', { error, line: line.substring(0, 100) });+ await this.sendError(null, -32700, 'Parse error');+ }+ }++ private async handleRequest(request: MCPRequest): Promise<void> {+ if (!this.requestHandler) {+ this.logger.warn('No request handler registered');+ await this.sendError(request.id, -32603, 'No request handler');+ return;+ }++ try {+ const startTime = performance.now();+ const response = await this.requestHandler(request);+ const duration = performance.now() - startTime;++ this.logger.debug('Request processed', {+ method: request.method,+ duration: `${duration.toFixed(2)}ms`,+ });++ await this.sendResponse(response);+ } catch (error) {+ this.logger.error('Request handler error', { method: request.method, error });+ await this.sendError(+ request.id,+ -32603,+ error instanceof Error ? error.message : 'Internal error'+ );+ }+ }++ private async handleNotification(notification: MCPNotification): Promise<void> {+ if (!this.notificationHandler) {+ this.logger.debug('Notification received but no handler', { method: notification.method });+ return;+ }++ try {+ await this.notificationHandler(notification);+ } catch (error) {+ this.logger.error('Notification handler error', { method: notification.method, error });+ }+ }++ private async sendResponse(response: MCPResponse): Promise<void> {+ const json = JSON.stringify(response);+ await this.write(json);+ this.messagesSent++;+ }++ private async sendError(id: string | number | null, code: number, message: string): Promise<void> {+ const response: MCPResponse = {+ jsonrpc: '2.0',+ id,+ error: { code, message },+ };+ await this.sendResponse(response);+ this.errors++;+ }++ async sendNotification(notification: MCPNotification): Promise<void> {+ const json = JSON.stringify(notification);+ await this.write(json);+ this.messagesSent++;+ }++ private write(data: string): Promise<void> {+ return new Promise((resolve, reject) => {+ this.outputStream.write(data + '\n', (error) => {+ if (error) {+ this.errors++;+ reject(error);+ } else {+ resolve();+ }+ });+ });+ }++ private handleClose(): void {+ this.logger.info('Stdio stream closed');+ this.running = false;+ this.emit('close');+ }++ private handleError(error: Error): void {+ this.logger.error('Stdio stream error', error);+ this.errors++;+ this.emit('error', error);+ }+}++export function createStdioTransport(+ logger: ILogger,+ config: StdioTransportConfig = {}+): StdioTransport {+ return new StdioTransport(logger, config);+}diff --git a/v3/@claude-flow/mcp/src/transport/websocket.ts b/v3/@claude-flow/mcp/src/transport/websocket.tsnew file mode 100644index 0000000000..a329f3256e--- /dev/null+++ b/v3/@claude-flow/mcp/src/transport/websocket.ts@@ -0,0 +1,396 @@+/**+ * @claude-flow/mcp - WebSocket Transport+ *+ * Standalone WebSocket transport with heartbeat+ */++import { EventEmitter } from 'events';+import { WebSocketServer, WebSocket, RawData } from 'ws';+import { createServer, Server } from 'http';+import type {+ ITransport,+ TransportType,+ MCPRequest,+ MCPResponse,+ MCPNotification,+ RequestHandler,+ NotificationHandler,+ TransportHealthStatus,+ ILogger,+ AuthConfig,+} from '../types.js';++export interface WebSocketTransportConfig {+ host: string;+ port: number;+ path?: string;+ maxConnections?: number;+ heartbeatInterval?: number;+ heartbeatTimeout?: number;+ maxMessageSize?: number;+ auth?: AuthConfig;+ enableBinaryMode?: boolean;+}++interface ClientConnection {+ id: string;+ ws: WebSocket;+ createdAt: Date;+ lastActivity: Date;+ messageCount: number;+ isAlive: boolean;+ isAuthenticated: boolean;+}++export class WebSocketTransport extends EventEmitter implements ITransport {+ public readonly type: TransportType = 'websocket';++ private requestHandler?: RequestHandler;+ private notificationHandler?: NotificationHandler;+ private server?: Server;+ private wss?: WebSocketServer;+ private clients: Map<string, ClientConnection> = new Map();+ private heartbeatTimer?: NodeJS.Timeout;+ private running = false;+ private connectionCounter = 0;++ private messagesReceived = 0;+ private messagesSent = 0;+ private errors = 0;+ private totalConnections = 0;++ constructor(+ private readonly logger: ILogger,+ private readonly config: WebSocketTransportConfig+ ) {+ super();+ }++ async start(): Promise<void> {+ if (this.running) {+ throw new Error('WebSocket transport already running');+ }++ this.logger.info('Starting WebSocket transport', {+ host: this.config.host,+ port: this.config.port,+ path: this.config.path || '/ws',+ });++ this.server = createServer((req, res) => {+ res.writeHead(426, { 'Content-Type': 'text/plain' });+ res.end('Upgrade Required - WebSocket connection expected');+ });++ this.wss = new WebSocketServer({+ server: this.server,+ path: this.config.path || '/ws',+ maxPayload: this.config.maxMessageSize || 10 * 1024 * 1024,+ perMessageDeflate: true,+ });++ this.setupWebSocketHandlers();+ this.startHeartbeat();++ await new Promise<void>((resolve, reject) => {+ this.server!.listen(this.config.port, this.config.host, () => {+ resolve();+ });+ this.server!.on('error', reject);+ });++ this.running = true;+ this.logger.info('WebSocket transport started', {+ url: `ws://${this.config.host}:${this.config.port}${this.config.path || '/ws'}`,+ });+ }++ async stop(): Promise<void> {+ if (!this.running) {+ return;+ }++ this.logger.info('Stopping WebSocket transport');+ this.running = false;++ this.stopHeartbeat();++ for (const client of this.clients.values()) {+ try {+ client.ws.close(1000, 'Server shutting down');+ } catch {+ // Ignore errors+ }+ }+ this.clients.clear();++ if (this.wss) {+ this.wss.close();+ this.wss = undefined;+ }++ if (this.server) {+ await new Promise<void>((resolve) => {+ this.server!.close(() => resolve());+ });+ this.server = undefined;+ }++ this.logger.info('WebSocket transport stopped');+ }++ onRequest(handler: RequestHandler): void {+ this.requestHandler = handler;+ }++ onNotification(handler: NotificationHandler): void {+ this.notificationHandler = handler;+ }++ async getHealthStatus(): Promise<TransportHealthStatus> {+ return {+ healthy: this.running,+ metrics: {+ messagesReceived: this.messagesReceived,+ messagesSent: this.messagesSent,+ errors: this.errors,+ activeConnections: this.clients.size,+ totalConnections: this.totalConnections,+ },+ };+ }++ async sendNotification(notification: MCPNotification): Promise<void> {+ const message = this.serializeMessage(notification);++ for (const client of this.clients.values()) {+ try {+ if (client.ws.readyState === WebSocket.OPEN) {+ client.ws.send(message);+ this.messagesSent++;+ }+ } catch (error) {+ this.logger.error('Failed to send notification', { clientId: client.id, error });+ this.errors++;+ }+ }+ }++ async sendToClient(clientId: string, notification: MCPNotification): Promise<boolean> {+ const client = this.clients.get(clientId);+ if (!client || client.ws.readyState !== WebSocket.OPEN) {+ return false;+ }++ try {+ client.ws.send(this.serializeMessage(notification));+ this.messagesSent++;+ return true;+ } catch (error) {+ this.logger.error('Failed to send to client', { clientId, error });+ this.errors++;+ return false;+ }+ }++ getClients(): string[] {+ return Array.from(this.clients.keys());+ }++ getClientInfo(clientId: string): ClientConnection | undefined {+ return this.clients.get(clientId);+ }++ disconnectClient(clientId: string, reason = 'Disconnected by server'): boolean {+ const client = this.clients.get(clientId);+ if (!client) {+ return false;+ }++ try {+ client.ws.close(1000, reason);+ return true;+ } catch {+ return false;+ }+ }++ private setupWebSocketHandlers(): void {+ if (!this.wss) return;++ this.wss.on('connection', (ws) => {+ if (this.config.maxConnections && this.clients.size >= this.config.maxConnections) {+ this.logger.warn('Max connections reached, rejecting client');+ ws.close(1013, 'Server at capacity');+ return;+ }++ const clientId = `client-${++this.connectionCounter}`;+ const client: ClientConnection = {+ id: clientId,+ ws,+ createdAt: new Date(),+ lastActivity: new Date(),+ messageCount: 0,+ isAlive: true,+ isAuthenticated: !this.config.auth?.enabled,+ };++ this.clients.set(clientId, client);+ this.totalConnections++;++ this.logger.info('Client connected', {+ id: clientId,+ total: this.clients.size,+ });++ ws.on('message', async (data) => {+ await this.handleMessage(client, data);+ });++ ws.on('pong', () => {+ client.isAlive = true;+ });++ ws.on('close', (code, reason) => {+ this.clients.delete(clientId);+ this.logger.info('Client disconnected', {+ id: clientId,+ code,+ reason: reason.toString(),+ total: this.clients.size,+ });+ this.emit('client:disconnected', clientId);+ });++ ws.on('error', (error) => {+ this.logger.error('Client error', { id: clientId, error });+ this.errors++;+ this.clients.delete(clientId);+ });++ this.emit('client:connected', clientId);+ });+ }++ private async handleMessage(client: ClientConnection, data: RawData): Promise<void> {+ client.lastActivity = new Date();+ client.messageCount++;+ this.messagesReceived++;++ try {+ const message = this.parseMessage(data);++ if (!client.isAuthenticated && this.config.auth?.enabled) {+ if (message.method !== 'authenticate') {+ client.ws.send(this.serializeMessage({+ jsonrpc: '2.0',+ id: message.id || null,+ error: { code: -32001, message: 'Authentication required' },+ } as MCPResponse));+ return;+ }+ }++ if (message.jsonrpc !== '2.0') {+ client.ws.send(this.serializeMessage({+ jsonrpc: '2.0',+ id: message.id || null,+ error: { code: -32600, message: 'Invalid JSON-RPC version' },+ } as MCPResponse));+ return;+ }++ if (message.id === undefined) {+ if (this.notificationHandler) {+ await this.notificationHandler(message as MCPNotification);+ }+ } else {+ if (!this.requestHandler) {+ client.ws.send(this.serializeMessage({+ jsonrpc: '2.0',+ id: message.id,+ error: { code: -32603, message: 'No request handler' },+ } as MCPResponse));+ return;+ }++ const startTime = performance.now();+ const response = await this.requestHandler(message as MCPRequest);+ const duration = performance.now() - startTime;++ this.logger.debug('Request processed', {+ clientId: client.id,+ method: message.method,+ duration: `${duration.toFixed(2)}ms`,+ });++ client.ws.send(this.serializeMessage(response));+ this.messagesSent++;+ }+ } catch (error) {+ this.errors++;+ this.logger.error('Message handling error', { clientId: client.id, error });++ try {+ client.ws.send(this.serializeMessage({+ jsonrpc: '2.0',+ id: null,+ error: { code: -32700, message: 'Parse error' },+ } as MCPResponse));+ } catch {+ // Ignore send errors+ }+ }+ }++ private parseMessage(data: RawData): any {+ if (this.config.enableBinaryMode && Buffer.isBuffer(data)) {+ return JSON.parse(data.toString());+ }+ return JSON.parse(data.toString());+ }++ private serializeMessage(message: MCPResponse | MCPNotification): string | Buffer {+ if (this.config.enableBinaryMode) {+ return JSON.stringify(message);+ }+ return JSON.stringify(message);+ }++ private startHeartbeat(): void {+ const interval = this.config.heartbeatInterval || 30000;++ this.heartbeatTimer = setInterval(() => {+ for (const client of this.clients.values()) {+ if (!client.isAlive) {+ this.logger.warn('Client heartbeat timeout', { id: client.id });+ client.ws.terminate();+ this.clients.delete(client.id);+ continue;+ }++ client.isAlive = false;+ try {+ client.ws.ping();+ } catch {+ // Ignore ping errors+ }+ }+ }, interval);+ }++ private stopHeartbeat(): void {+ if (this.heartbeatTimer) {+ clearInterval(this.heartbeatTimer);+ this.heartbeatTimer = undefined;+ }+ }+}++export function createWebSocketTransport(+ logger: ILogger,+ config: WebSocketTransportConfig+): WebSocketTransport {+ return new WebSocketTransport(logger, config);+}diff --git a/v3/@claude-flow/mcp/src/types.ts b/v3/@claude-flow/mcp/src/types.tsnew file mode 100644index 0000000000..e18e753dc0--- /dev/null+++ b/v3/@claude-flow/mcp/src/types.ts@@ -0,0 +1,663 @@+/**+ * @claude-flow/mcp - Standalone Types+ *+ * Complete type definitions for MCP server implementation+ * Zero external @claude-flow dependencies+ */++// ============================================================================+// Core Protocol Types+// ============================================================================++export type JsonRpcVersion = '2.0';++export interface MCPProtocolVersion {+ major: number;+ minor: number;+ patch: number;+}++export type RequestId = string | number | null;++export interface MCPMessage {+ jsonrpc: JsonRpcVersion;+}++export interface MCPRequest extends MCPMessage {+ id: RequestId;+ method: string;+ params?: Record<string, unknown>;+}++export interface MCPNotification extends MCPMessage {+ method: string;+ params?: Record<string, unknown>;+}++export interface MCPError {+ code: number;+ message: string;+ data?: unknown;+}++export interface MCPResponse extends MCPMessage {+ id: RequestId;+ result?: unknown;+ error?: MCPError;+}++// ============================================================================+// Server Configuration+// ============================================================================++export type TransportType = 'stdio' | 'http' | 'websocket' | 'in-process';++export type AuthMethod = 'token' | 'oauth' | 'api-key' | 'none';++export interface AuthConfig {+ enabled: boolean;+ method: AuthMethod;+ tokens?: string[];+ apiKeys?: string[];+ jwtSecret?: string;+ oauth?: {+ clientId: string;+ clientSecret: string;+ authorizationUrl: string;+ tokenUrl: string;+ };+}++export interface LoadBalancerConfig {+ enabled: boolean;+ maxConcurrentRequests: number;+ rateLimit?: {+ requestsPerSecond: number;+ burstSize: number;+ };+ circuitBreaker?: {+ failureThreshold: number;+ resetTimeout: number;+ };+}++export interface ConnectionPoolConfig {+ maxConnections: number;+ minConnections: number;+ idleTimeout: number;+ acquireTimeout: number;+ maxWaitingClients: number;+ evictionRunInterval: number;+}++export interface MCPServerConfig {+ name: string;+ version: string;+ transport: TransportType;+ host?: string;+ port?: number;+ tlsEnabled?: boolean;+ tlsCert?: string;+ tlsKey?: string;+ auth?: AuthConfig;+ loadBalancer?: LoadBalancerConfig;+ connectionPool?: ConnectionPoolConfig;+ corsEnabled?: boolean;+ corsOrigins?: string[];+ maxRequestSize?: number;+ requestTimeout?: number;+ enableMetrics?: boolean;+ enableCaching?: boolean;+ cacheTTL?: number;+ logLevel?: 'debug' | 'info' | 'warn' | 'error';+}++// ============================================================================+// Session Types+// ============================================================================++export type SessionState = 'created' | 'initializing' | 'ready' | 'closing' | 'closed' | 'error';++export interface MCPSession {+ id: string;+ state: SessionState;+ transport: TransportType;+ createdAt: Date;+ lastActivityAt: Date;+ isInitialized: boolean;+ isAuthenticated: boolean;+ clientInfo?: MCPClientInfo;+ protocolVersion?: MCPProtocolVersion;+ capabilities?: MCPCapabilities;+ metadata?: Record<string, unknown>;+}++export interface MCPClientInfo {+ name: string;+ version: string;+}++// ============================================================================+// Capability Types+// ============================================================================++export interface MCPCapabilities {+ logging?: {+ level: 'debug' | 'info' | 'warn' | 'error';+ };+ tools?: {+ listChanged: boolean;+ };+ resources?: {+ listChanged: boolean;+ subscribe: boolean;+ };+ prompts?: {+ listChanged: boolean;+ };+ experimental?: Record<string, unknown>;+}++export interface MCPInitializeParams {+ protocolVersion: MCPProtocolVersion;+ capabilities: MCPCapabilities;+ clientInfo: MCPClientInfo;+}++export interface MCPInitializeResult {+ protocolVersion: MCPProtocolVersion;+ capabilities: MCPCapabilities;+ serverInfo: {+ name: string;+ version: string;+ };+ instructions?: string;+}++// ============================================================================+// Tool Types+// ============================================================================++export interface JSONSchema {+ type: string;+ properties?: Record<string, JSONSchema>;+ required?: string[];+ items?: JSONSchema;+ enum?: string[];+ description?: string;+ default?: unknown;+ minimum?: number;+ maximum?: number;+ minLength?: number;+ maxLength?: number;+ pattern?: string;+ additionalProperties?: boolean | JSONSchema;+}++export interface ToolContext {+ sessionId: string;+ requestId?: RequestId;+ orchestrator?: unknown;+ swarmCoordinator?: unknown;+ agentManager?: unknown;+ resourceManager?: unknown;+ messageBus?: unknown;+ monitor?: unknown;+ metadata?: Record<string, unknown>;+}++export type ToolHandler<TInput = unknown, TOutput = unknown> = (+ input: TInput,+ context?: ToolContext+) => Promise<TOutput>;++export interface MCPTool<TInput = unknown, TOutput = unknown> {+ name: string;+ description: string;+ inputSchema: JSONSchema;+ handler: ToolHandler<TInput, TOutput>;+ category?: string;+ tags?: string[];+ version?: string;+ deprecated?: boolean;+ cacheable?: boolean;+ cacheTTL?: number;+ timeout?: number;+}++export interface ToolCallResult {+ content: Array<{+ type: 'text' | 'image' | 'resource';+ text?: string;+ data?: string;+ mimeType?: string;+ }>;+ isError: boolean;+}++export interface ToolRegistrationOptions {+ override?: boolean;+ validate?: boolean;+ preload?: boolean;+}++// ============================================================================+// Resource Types (MCP 2025-11-25)+// ============================================================================++export interface MCPResource {+ uri: string;+ name: string;+ description?: string;+ mimeType?: string;+ annotations?: ContentAnnotations;+}++export interface ResourceContent {+ uri: string;+ mimeType?: string;+ text?: string;+ blob?: string; // base64 encoded+}++export interface ResourceTemplate {+ uriTemplate: string;+ name: string;+ description?: string;+ mimeType?: string;+}++export interface ResourceListResult {+ resources: MCPResource[];+ nextCursor?: string;+}++export interface ResourceReadResult {+ contents: ResourceContent[];+}++// ============================================================================+// Prompt Types (MCP 2025-11-25)+// ============================================================================++export interface PromptArgument {+ name: string;+ description?: string;+ required?: boolean;+}++export interface MCPPrompt {+ name: string;+ title?: string;+ description?: string;+ arguments?: PromptArgument[];+}++export type PromptRole = 'user' | 'assistant';++export interface ContentAnnotations {+ audience?: Array<'user' | 'assistant'>;+ priority?: number;+ createdAt?: string;+ modifiedAt?: string;+}++export interface TextContent {+ type: 'text';+ text: string;+ annotations?: ContentAnnotations;+}++export interface ImageContent {+ type: 'image';+ data: string; // base64+ mimeType: string;+ annotations?: ContentAnnotations;+}++export interface AudioContent {+ type: 'audio';+ data: string; // base64+ mimeType: string;+ annotations?: ContentAnnotations;+}++export interface EmbeddedResource {+ type: 'resource';+ resource: ResourceContent;+ annotations?: ContentAnnotations;+}++export type PromptContent = TextContent | ImageContent | AudioContent | EmbeddedResource;++export interface PromptMessage {+ role: PromptRole;+ content: PromptContent;+}++export interface PromptListResult {+ prompts: MCPPrompt[];+ nextCursor?: string;+}++export interface PromptGetResult {+ description?: string;+ messages: PromptMessage[];+}++// ============================================================================+// Task Types (MCP 2025-11-25 - Async Operations)+// ============================================================================++export type TaskState = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';++export interface MCPTask {+ id: string;+ state: TaskState;+ progress?: TaskProgress;+ result?: unknown;+ error?: MCPError;+ createdAt: Date;+ updatedAt: Date;+ metadata?: Record<string, unknown>;+}++export interface TaskProgress {+ progress: number;+ total?: number;+ message?: string;+}++export interface TaskResult {+ taskId: string;+ state: TaskState;+ progress?: TaskProgress;+ result?: unknown;+ error?: MCPError;+}++// ============================================================================+// Pagination Types (MCP 2025-11-25)+// ============================================================================++export interface PaginatedRequest {+ cursor?: string;+}++export interface PaginatedResult<T> {+ items: T[];+ nextCursor?: string;+}++// ============================================================================+// Progress & Cancellation Types (MCP 2025-11-25)+// ============================================================================++export interface ProgressNotification {+ progressToken: string | number;+ progress: number;+ total?: number;+ message?: string;+}++export interface CancellationParams {+ requestId: RequestId;+ reason?: string;+}++// ============================================================================+// Sampling Types (MCP 2025-11-25 - Server-initiated LLM)+// ============================================================================++export interface SamplingMessage {+ role: PromptRole;+ content: PromptContent;+}++export interface ModelPreferences {+ hints?: Array<{ name?: string }>;+ costPriority?: number;+ speedPriority?: number;+ intelligencePriority?: number;+}++export interface CreateMessageRequest {+ messages: SamplingMessage[];+ modelPreferences?: ModelPreferences;+ systemPrompt?: string;+ includeContext?: 'none' | 'thisServer' | 'allServers';+ temperature?: number;+ maxTokens: number;+ stopSequences?: string[];+ metadata?: Record<string, unknown>;+}++export interface CreateMessageResult {+ role: 'assistant';+ content: PromptContent;+ model: string;+ stopReason?: 'endTurn' | 'stopSequence' | 'maxTokens';+}++// ============================================================================+// Roots Types (MCP 2025-11-25)+// ============================================================================++export interface Root {+ uri: string;+ name?: string;+}++export interface RootsListResult {+ roots: Root[];+}++// ============================================================================+// Logging Types (MCP 2025-11-25)+// ============================================================================++export type MCPLogLevel = 'debug' | 'info' | 'notice' | 'warning' | 'error' | 'critical' | 'alert' | 'emergency';++export interface LoggingMessage {+ level: MCPLogLevel;+ logger?: string;+ data?: unknown;+}++// ============================================================================+// Completion Types (MCP 2025-11-25)+// ============================================================================++export interface CompletionReference {+ type: 'ref/prompt' | 'ref/resource';+ name?: string;+ uri?: string;+}++export interface CompletionArgument {+ name: string;+ value: string;+}++export interface CompletionResult {+ values: string[];+ total?: number;+ hasMore?: boolean;+}++// ============================================================================+// Transport Types+// ============================================================================++export type RequestHandler = (request: MCPRequest) => Promise<MCPResponse>;++export type NotificationHandler = (notification: MCPNotification) => Promise<void>;++export interface TransportHealthStatus {+ healthy: boolean;+ error?: string;+ metrics?: Record<string, number>;+}++export interface ITransport {+ readonly type: TransportType;+ start(): Promise<void>;+ stop(): Promise<void>;+ onRequest(handler: RequestHandler): void;+ onNotification(handler: NotificationHandler): void;+ sendNotification?(notification: MCPNotification): Promise<void>;+ getHealthStatus(): Promise<TransportHealthStatus>;+}++// ============================================================================+// Connection Pool Types+// ============================================================================++export type ConnectionState = 'idle' | 'busy' | 'closing' | 'closed' | 'error';++export interface PooledConnection {+ id: string;+ state: ConnectionState;+ createdAt: Date;+ lastUsedAt: Date;+ useCount: number;+ transport: TransportType;+ metadata?: Record<string, unknown>;+}++export interface ConnectionPoolStats {+ totalConnections: number;+ idleConnections: number;+ busyConnections: number;+ pendingRequests: number;+ totalAcquired: number;+ totalReleased: number;+ totalCreated: number;+ totalDestroyed: number;+ avgAcquireTime: number;+}++export interface IConnectionPool {+ acquire(): Promise<PooledConnection>;+ release(connection: PooledConnection): void;+ destroy(connection: PooledConnection): void;+ getStats(): ConnectionPoolStats;+ drain(): Promise<void>;+ clear(): Promise<void>;+}++// ============================================================================+// Metrics Types+// ============================================================================++export interface ToolCallMetrics {+ toolName: string;+ duration: number;+ success: boolean;+ timestamp: number;+ transport: TransportType;+ cached?: boolean;+}++export interface MCPServerMetrics {+ totalRequests: number;+ successfulRequests: number;+ failedRequests: number;+ averageResponseTime: number;+ activeSessions: number;+ toolInvocations: Record<string, number>;+ errors: Record<string, number>;+ lastReset: Date;+ startupTime?: number;+ uptime?: number;+}++export interface SessionMetrics {+ total: number;+ active: number;+ authenticated: number;+ expired: number;+}++// ============================================================================+// Event Types+// ============================================================================++export type MCPEventType =+ | 'server:started'+ | 'server:stopped'+ | 'server:error'+ | 'session:created'+ | 'session:initialized'+ | 'session:closed'+ | 'session:error'+ | 'tool:registered'+ | 'tool:unregistered'+ | 'tool:called'+ | 'tool:completed'+ | 'tool:error'+ | 'transport:connected'+ | 'transport:disconnected'+ | 'transport:error'+ | 'pool:connection:acquired'+ | 'pool:connection:released'+ | 'pool:connection:created'+ | 'pool:connection:destroyed';++export interface MCPEvent {+ type: MCPEventType;+ timestamp: Date;+ data?: unknown;+}++export type EventHandler = (event: MCPEvent) => void;++// ============================================================================+// Logger Interface+// ============================================================================++export type LogLevel = 'debug' | 'info' | 'warn' | 'error';++export interface ILogger {+ debug(message: string, data?: unknown): void;+ info(message: string, data?: unknown): void;+ warn(message: string, data?: unknown): void;+ error(message: string, data?: unknown): void;+}++// ============================================================================+// Error Codes+// ============================================================================++export const ErrorCodes = {+ PARSE_ERROR: -32700,+ INVALID_REQUEST: -32600,+ METHOD_NOT_FOUND: -32601,+ INVALID_PARAMS: -32602,+ INTERNAL_ERROR: -32603,+ SERVER_NOT_INITIALIZED: -32002,+ UNKNOWN_ERROR: -32001,+ REQUEST_CANCELLED: -32800,+ RATE_LIMITED: -32000,+ AUTHENTICATION_REQUIRED: -32001,+ AUTHORIZATION_FAILED: -32002,+} as const;++export class MCPServerError extends Error {+ constructor(+ message: string,+ public code: number = ErrorCodes.INTERNAL_ERROR,+ public data?: unknown+ ) {+ super(message);+ this.name = 'MCPServerError';+ }++ toMCPError(): MCPError {+ return {+ code: this.code,+ message: this.message,+ data: this.data,+ };+ }+}diff --git a/v3/@claude-flow/mcp/tsconfig.json b/v3/@claude-flow/mcp/tsconfig.jsonnew file mode 100644index 0000000000..4b3f25a922--- /dev/null+++ b/v3/@claude-flow/mcp/tsconfig.json@@ -0,0 +1,20 @@+{+ "compilerOptions": {+ "target": "ES2022",+ "module": "NodeNext",+ "moduleResolution": "NodeNext",+ "declaration": true,+ "declarationMap": true,+ "sourceMap": true,+ "outDir": "./dist",+ "rootDir": "./src",+ "strict": true,+ "esModuleInterop": true,+ "skipLibCheck": true,+ "forceConsistentCasingInFileNames": true,+ "resolveJsonModule": true,+ "isolatedModules": true+ },+ "include": ["src/**/*"],+ "exclude": ["node_modules", "dist", "__tests__"]+}diff --git a/v3/@claude-flow/mcp/vitest.config.ts b/v3/@claude-flow/mcp/vitest.config.tsnew file mode 100644index 0000000000..2449a989eb--- /dev/null+++ b/v3/@claude-flow/mcp/vitest.config.ts@@ -0,0 +1,13 @@+import { defineConfig } from 'vitest/config';++export default defineConfig({+ test: {+ globals: true,+ environment: 'node',+ include: ['__tests__/**/*.test.ts'],+ coverage: {+ provider: 'v8',+ reporter: ['text', 'json', 'html'],+ },+ },+});diff --git a/v3/@claude-flow/providers/package.json b/v3/@claude-flow/providers/package.jsonnew file mode 100644index 0000000000..816a316f55--- /dev/null+++ b/v3/@claude-flow/providers/package.json@@ -0,0 +1,66 @@+{+ "name": "@claude-flow/providers",+ "version": "3.0.0",+ "description": "Multi-LLM Provider System for Claude Flow V3",+ "main": "dist/index.js",+ "module": "dist/index.js",+ "types": "dist/index.d.ts",+ "type": "module",+ "exports": {+ ".": {+ "types": "./dist/index.d.ts",+ "import": "./dist/index.js"+ }+ },+ "files": [+ "dist",+ "src"+ ],+ "scripts": {+ "build": "tsc",+ "dev": "tsc --watch",+ "test": "vitest run",+ "test:watch": "vitest",+ "test:integration": "vitest run src/__tests__/provider-integration.test.ts",+ "test:coverage": "vitest run --coverage",+ "test:quick": "npx tsx src/__tests__/quick-test.ts",+ "clean": "rm -rf dist",+ "typecheck": "tsc --noEmit"+ },+ "keywords": [+ "claude-flow",+ "llm",+ "provider",+ "anthropic",+ "openai",+ "google",+ "cohere",+ "ollama",+ "multi-provider",+ "load-balancing",+ "failover"+ ],+ "author": "Claude Flow Team",+ "license": "MIT",+ "dependencies": {+ "events": "^3.3.0"+ },+ "devDependencies": {+ "@types/node": "^20.0.0",+ "dotenv": "^16.4.5",+ "tsx": "^4.19.0",+ "typescript": "^5.5.0",+ "vitest": "^1.6.0"+ },+ "peerDependencies": {+ "@ruvector/ruvllm": "^0.2.3"+ },+ "peerDependenciesMeta": {+ "@ruvector/ruvllm": {+ "optional": true+ }+ },+ "engines": {+ "node": ">=20.0.0"+ }+}diff --git a/v3/@claude-flow/providers/src/__tests__/provider-integration.test.ts b/v3/@claude-flow/providers/src/__tests__/provider-integration.test.tsnew file mode 100644index 0000000000..b2b3c6c38f--- /dev/null+++ b/v3/@claude-flow/providers/src/__tests__/provider-integration.test.ts@@ -0,0 +1,446 @@+/**+ * Provider Integration Tests+ *+ * Tests all LLM providers with actual API calls using .env credentials+ *+ * Run with: npx vitest run src/__tests__/provider-integration.test.ts+ */++import { describe, it, expect, beforeAll, afterAll } from 'vitest';+import { config } from 'dotenv';+import { resolve } from 'path';++// Load .env from project root+config({ path: resolve(__dirname, '../../../../../.env') });++import {+ AnthropicProvider,+ OpenAIProvider,+ GoogleProvider,+ OllamaProvider,+ RuVectorProvider,+ ProviderManager,+ createProviderManager,+ LLMRequest,+ LLMProviderConfig,+ ProviderManagerConfig,+} from '../index.js';+import { BaseProviderOptions, consoleLogger } from '../base-provider.js';++// Test configuration+const TEST_PROMPT = 'Say "Hello from Claude Flow V3!" in exactly 5 words.';+const TEST_MESSAGES: LLMRequest['messages'] = [+ { role: 'user', content: TEST_PROMPT }+];++// Simple test request+const createTestRequest = (model?: string): LLMRequest => ({+ messages: TEST_MESSAGES,+ model,+ maxTokens: 50,+ temperature: 0.1,+ requestId: `test-${Date.now()}`,+});++describe('Provider Integration Tests', () => {++ describe('Anthropic Provider', () => {+ const apiKey = process.env.ANTHROPIC_API_KEY;++ it.skipIf(!apiKey)('should complete request with Claude 3.5 Sonnet', async () => {+ const provider = new AnthropicProvider({+ config: {+ provider: 'anthropic',+ apiKey,+ model: 'claude-3-5-sonnet-latest',+ maxTokens: 100,+ },+ logger: consoleLogger,+ });++ await provider.initialize();++ const response = await provider.complete(createTestRequest());++ console.log('Anthropic Response:', response.content);+ console.log('Usage:', response.usage);+ console.log('Cost:', response.cost);++ expect(response.content).toBeTruthy();+ expect(response.provider).toBe('anthropic');+ expect(response.usage.totalTokens).toBeGreaterThan(0);++ provider.destroy();+ }, 30000);++ it.skipIf(!apiKey)('should stream response', async () => {+ const provider = new AnthropicProvider({+ config: {+ provider: 'anthropic',+ apiKey,+ model: 'claude-3-5-sonnet-latest',+ maxTokens: 100,+ },+ logger: consoleLogger,+ });++ await provider.initialize();++ const chunks: string[] = [];+ for await (const event of provider.streamComplete(createTestRequest())) {+ if (event.type === 'content' && event.delta?.content) {+ chunks.push(event.delta.content);+ process.stdout.write(event.delta.content);+ }+ }+ console.log('\n');++ expect(chunks.length).toBeGreaterThan(0);++ provider.destroy();+ }, 30000);+ });++ describe('Google Gemini Provider', () => {+ const apiKey = process.env.GOOGLE_GEMINI_API_KEY;++ it.skipIf(!apiKey)('should complete request with Gemini 2.0 Flash', async () => {+ const provider = new GoogleProvider({+ config: {+ provider: 'google',+ apiKey,+ model: 'gemini-2.0-flash',+ maxTokens: 100,+ },+ logger: consoleLogger,+ });++ await provider.initialize();++ const response = await provider.complete(createTestRequest());++ console.log('Google Response:', response.content);+ console.log('Usage:', response.usage);+ console.log('Cost:', response.cost);++ expect(response.content).toBeTruthy();+ expect(response.provider).toBe('google');++ provider.destroy();+ }, 30000);+ });++ describe('OpenRouter Provider (OpenAI Compatible)', () => {+ const apiKey = process.env.OPENROUTER_API_KEY;++ it.skipIf(!apiKey)('should complete request via OpenRouter', async () => {+ const provider = new OpenAIProvider({+ config: {+ provider: 'openai',+ apiKey,+ apiUrl: 'https://openrouter.ai/api/v1',+ model: 'openai/gpt-4o-mini',+ maxTokens: 100,+ providerOptions: {+ headers: {+ 'HTTP-Referer': 'https://claude-flow.dev',+ 'X-Title': 'Claude Flow V3 Test',+ },+ },+ },+ logger: consoleLogger,+ });++ await provider.initialize();++ const response = await provider.complete(createTestRequest('openai/gpt-4o-mini'));++ console.log('OpenRouter Response:', response.content);+ console.log('Usage:', response.usage);++ expect(response.content).toBeTruthy();++ provider.destroy();+ }, 30000);+ });++ describe('Ollama Provider (Local)', () => {+ const ollamaUrl = process.env.OLLAMA_URL || 'http://localhost:11434';++ it.skip('should complete request with local model', async () => {+ const provider = new OllamaProvider({+ config: {+ provider: 'ollama',+ apiUrl: ollamaUrl,+ model: 'llama3.2',+ maxTokens: 100,+ },+ logger: consoleLogger,+ });++ try {+ await provider.initialize();++ const response = await provider.complete(createTestRequest());++ console.log('Ollama Response:', response.content);+ console.log('Usage:', response.usage);++ expect(response.content).toBeTruthy();+ expect(response.provider).toBe('ollama');++ provider.destroy();+ } catch (error) {+ console.log('Ollama not available locally, skipping test');+ }+ }, 60000);+ });++ describe('RuVector Provider (ruvllm)', () => {++ it('should complete request with CPU-friendly Qwen model', async () => {+ const provider = new RuVectorProvider({+ config: {+ provider: 'ruvector',+ model: 'qwen2.5:0.5b', // CPU-friendly small Qwen model+ maxTokens: 100,+ providerOptions: {+ // RuVector-specific options+ sonaEnabled: true,+ hnswEnabled: true,+ fastgrnnEnabled: true,+ // Local model settings+ localModel: 'qwen2.5:0.5b',+ ollamaUrl: 'http://localhost:11434',+ },+ },+ logger: consoleLogger,+ });++ try {+ await provider.initialize();++ const response = await provider.complete(createTestRequest('qwen2.5:0.5b'));++ console.log('RuVector Response:', response.content);+ console.log('Usage:', response.usage);+ console.log('Cost:', response.cost);++ // Check SONA metrics+ const sonaMetrics = await provider.getSonaMetrics();+ console.log('SONA Metrics:', sonaMetrics);++ expect(response.content).toBeTruthy();++ provider.destroy();+ } catch (error) {+ console.log('RuVector/Ollama not available, test details:', error);+ // Don't fail - local models may not be running+ }+ }, 120000);++ it('should search memory with HNSW', async () => {+ const provider = new RuVectorProvider({+ config: {+ provider: 'ruvector',+ model: 'qwen2.5:0.5b',+ maxTokens: 100,+ providerOptions: {+ hnswEnabled: true,+ },+ },+ logger: consoleLogger,+ });++ try {+ await provider.initialize();++ // Search memory+ const results = await provider.searchMemory('test query', 5);+ console.log('Memory search results:', results);++ expect(Array.isArray(results)).toBe(true);++ provider.destroy();+ } catch (error) {+ console.log('Memory search not available:', error);+ }+ }, 30000);+ });++ describe('Provider Manager', () => {+ const anthropicKey = process.env.ANTHROPIC_API_KEY;+ const googleKey = process.env.GOOGLE_GEMINI_API_KEY;++ it.skipIf(!anthropicKey && !googleKey)('should manage multiple providers with failover', async () => {+ const providers: LLMProviderConfig[] = [];++ if (anthropicKey) {+ providers.push({+ provider: 'anthropic',+ apiKey: anthropicKey,+ model: 'claude-3-5-sonnet-latest',+ maxTokens: 100,+ });+ }++ if (googleKey) {+ providers.push({+ provider: 'google',+ apiKey: googleKey,+ model: 'gemini-2.0-flash',+ maxTokens: 100,+ });+ }++ const config: ProviderManagerConfig = {+ providers,+ loadBalancing: {+ enabled: true,+ strategy: 'round-robin',+ },+ fallback: {+ enabled: true,+ maxAttempts: 2,+ },+ cache: {+ enabled: true,+ ttl: 60000,+ maxSize: 100,+ },+ };++ const manager = await createProviderManager(config, consoleLogger);++ // List providers+ const providerList = manager.listProviders();+ console.log('Active providers:', providerList);+ expect(providerList.length).toBeGreaterThan(0);++ // Complete request+ const response = await manager.complete(createTestRequest());+ console.log('Manager Response:', response.content);+ console.log('Provider used:', response.provider);++ expect(response.content).toBeTruthy();++ // Health check all+ const health = await manager.healthCheck();+ console.log('Health status:', Object.fromEntries(health));++ // Get metrics+ const metrics = manager.getMetrics();+ console.log('Metrics:', Object.fromEntries(metrics));++ manager.destroy();+ }, 60000);++ it.skipIf(!anthropicKey)('should use cache for repeated requests', async () => {+ const manager = await createProviderManager({+ providers: [{+ provider: 'anthropic',+ apiKey: anthropicKey,+ model: 'claude-3-5-sonnet-latest',+ maxTokens: 50,+ }],+ cache: {+ enabled: true,+ ttl: 60000,+ maxSize: 100,+ },+ }, consoleLogger);++ const request = createTestRequest();++ // First request - no cache+ const start1 = Date.now();+ const response1 = await manager.complete(request);+ const time1 = Date.now() - start1;+ console.log(`First request: ${time1}ms`);++ // Second request - should hit cache+ const start2 = Date.now();+ const response2 = await manager.complete(request);+ const time2 = Date.now() - start2;+ console.log(`Second request (cached): ${time2}ms`);++ expect(response1.content).toBe(response2.content);+ expect(time2).toBeLessThan(time1); // Cache should be faster++ manager.destroy();+ }, 60000);+ });++ describe('Cost Estimation', () => {+ const apiKey = process.env.ANTHROPIC_API_KEY;++ it.skipIf(!apiKey)('should estimate costs accurately', async () => {+ const manager = await createProviderManager({+ providers: [{+ provider: 'anthropic',+ apiKey,+ model: 'claude-3-5-sonnet-latest',+ maxTokens: 100,+ }],+ }, consoleLogger);++ const request = createTestRequest();++ // Get cost estimates+ const estimates = await manager.estimateCost(request);+ console.log('Cost estimates:', Object.fromEntries(estimates));++ // Make actual request+ const response = await manager.complete(request);+ console.log('Actual cost:', response.cost);++ // Compare estimate to actual+ const estimate = estimates.get('anthropic');+ if (estimate && response.cost) {+ const estimateTotal = estimate.estimatedCost.total;+ const actualTotal = response.cost.totalCost;+ const accuracy = 1 - Math.abs(estimateTotal - actualTotal) / actualTotal;+ console.log(`Estimation accuracy: ${(accuracy * 100).toFixed(1)}%`);+ }++ manager.destroy();+ }, 30000);+ });+});++// Quick standalone test runner+async function runQuickTest() {+ console.log('\n=== Quick Provider Test ===\n');++ const apiKey = process.env.ANTHROPIC_API_KEY;+ if (!apiKey) {+ console.log('No ANTHROPIC_API_KEY found in .env');+ return;+ }++ const provider = new AnthropicProvider({+ config: {+ provider: 'anthropic',+ apiKey,+ model: 'claude-3-5-sonnet-latest',+ maxTokens: 100,+ },+ logger: consoleLogger,+ });++ await provider.initialize();++ const response = await provider.complete({+ messages: [{ role: 'user', content: 'What is 2+2? Reply with just the number.' }],+ maxTokens: 10,+ });++ console.log('Response:', response.content);+ console.log('Tokens:', response.usage);+ console.log('Cost:', response.cost);++ provider.destroy();+}++// Export for direct execution+export { runQuickTest };diff --git a/v3/@claude-flow/providers/src/__tests__/quick-test.ts b/v3/@claude-flow/providers/src/__tests__/quick-test.tsnew file mode 100644index 0000000000..12aa826974--- /dev/null+++ b/v3/@claude-flow/providers/src/__tests__/quick-test.ts@@ -0,0 +1,356 @@+#!/usr/bin/env npx tsx+/**+ * Quick Provider Test Script+ *+ * Tests all available providers using .env credentials+ *+ * Usage:+ * cd v3/@claude-flow/providers+ * npm run test:quick+ *+ * Or directly:+ * npx tsx src/__tests__/quick-test.ts+ */++import { config } from 'dotenv';+import { resolve, dirname } from 'path';+import { fileURLToPath } from 'url';++const __dirname = dirname(fileURLToPath(import.meta.url));++// Load .env from project root+config({ path: resolve(__dirname, '../../../../../.env') });++import {+ AnthropicProvider,+ OpenAIProvider,+ GoogleProvider,+ OllamaProvider,+ RuVectorProvider,+ createProviderManager,+ LLMRequest,+} from '../index.js';+import { consoleLogger } from '../base-provider.js';++const TEST_PROMPT = 'Say "Hello from Claude Flow V3!" Be brief.';++const createTestRequest = (model?: string): LLMRequest => ({+ messages: [{ role: 'user', content: TEST_PROMPT }],+ model,+ maxTokens: 50,+ temperature: 0.1,+ requestId: `test-${Date.now()}`,+});++async function testAnthropic() {+ const apiKey = process.env.ANTHROPIC_API_KEY;+ if (!apiKey) {+ console.log('⏭️ Skipping Anthropic - no API key');+ return null;+ }++ console.log('\n🔷 Testing Anthropic Claude...');++ const provider = new AnthropicProvider({+ config: {+ provider: 'anthropic',+ apiKey,+ model: 'claude-3-haiku-20240307', // Use cheaper, widely-available model+ maxTokens: 100,+ },+ logger: consoleLogger,+ });++ try {+ await provider.initialize();+ const response = await provider.complete(createTestRequest());++ console.log('✅ Anthropic Response:', response.content);+ console.log(' Tokens:', response.usage);+ console.log(' Cost:', response.cost);++ provider.destroy();+ return response;+ } catch (error) {+ console.error('❌ Anthropic Error:', error);+ provider.destroy();+ return null;+ }+}++async function testGoogle() {+ const apiKey = process.env.GOOGLE_GEMINI_API_KEY;+ if (!apiKey) {+ console.log('⏭️ Skipping Google - no API key');+ return null;+ }++ console.log('\n🔷 Testing Google Gemini...');++ const provider = new GoogleProvider({+ config: {+ provider: 'google',+ apiKey,+ model: 'gemini-2.0-flash',+ maxTokens: 100,+ },+ logger: consoleLogger,+ });++ try {+ await provider.initialize();+ const response = await provider.complete(createTestRequest());++ console.log('✅ Google Response:', response.content);+ console.log(' Tokens:', response.usage);+ console.log(' Cost:', response.cost);++ provider.destroy();+ return response;+ } catch (error) {+ console.error('❌ Google Error:', error);+ provider.destroy();+ return null;+ }+}++async function testOpenRouter() {+ const apiKey = process.env.OPENROUTER_API_KEY;+ if (!apiKey) {+ console.log('⏭️ Skipping OpenRouter - no API key');+ return null;+ }++ console.log('\n🔷 Testing OpenRouter (GPT-4o-mini)...');++ const provider = new OpenAIProvider({+ config: {+ provider: 'openai',+ apiKey,+ apiUrl: 'https://openrouter.ai/api/v1',+ model: 'openai/gpt-4o-mini',+ maxTokens: 100,+ providerOptions: {+ headers: {+ 'HTTP-Referer': 'https://claude-flow.dev',+ 'X-Title': 'Claude Flow V3 Test',+ },+ },+ },+ logger: consoleLogger,+ });++ try {+ await provider.initialize();+ const response = await provider.complete(createTestRequest('openai/gpt-4o-mini'));++ console.log('✅ OpenRouter Response:', response.content);+ console.log(' Tokens:', response.usage);++ provider.destroy();+ return response;+ } catch (error) {+ console.error('❌ OpenRouter Error:', error);+ provider.destroy();+ return null;+ }+}++async function testOllama() {+ console.log('\n🔷 Testing Ollama (local)...');++ const provider = new OllamaProvider({+ config: {+ provider: 'ollama',+ apiUrl: 'http://localhost:11434',+ model: 'qwen2.5:0.5b',+ maxTokens: 100,+ },+ logger: consoleLogger,+ });++ try {+ await provider.initialize();+ const response = await provider.complete(createTestRequest('qwen2.5:0.5b'));++ console.log('✅ Ollama Response:', response.content);+ console.log(' Tokens:', response.usage);+ console.log(' Cost: $0.00 (local)');++ provider.destroy();+ return response;+ } catch (error: any) {+ if (error.message?.includes('ECONNREFUSED') || error.message?.includes('fetch failed')) {+ console.log('⏭️ Skipping Ollama - not running locally');+ console.log(' To test: ollama pull qwen2.5:0.5b && ollama serve');+ } else {+ console.error('❌ Ollama Error:', error.message);+ }+ provider.destroy();+ return null;+ }+}++async function testRuVector() {+ console.log('\n🔷 Testing RuVector (SONA + Local Qwen)...');++ const provider = new RuVectorProvider({+ config: {+ provider: 'ruvector',+ model: 'qwen2.5:0.5b',+ maxTokens: 100,+ providerOptions: {+ sonaEnabled: true,+ hnswEnabled: true,+ fastgrnnEnabled: true,+ localModel: 'qwen2.5:0.5b',+ ollamaUrl: 'http://localhost:11434',+ },+ },+ logger: consoleLogger,+ });++ try {+ await provider.initialize();+ const response = await provider.complete(createTestRequest('qwen2.5:0.5b'));++ console.log('✅ RuVector Response:', response.content);+ console.log(' Tokens:', response.usage);++ // Show SONA metrics+ try {+ const sonaMetrics = await provider.getSonaMetrics();+ console.log(' SONA Metrics:', sonaMetrics);+ } catch {+ console.log(' SONA: Not available (optional)');+ }++ provider.destroy();+ return response;+ } catch (error: any) {+ if (error.message?.includes('ECONNREFUSED') || error.message?.includes('fetch failed')) {+ console.log('⏭️ Skipping RuVector - Ollama not running locally');+ console.log(' To test: ollama pull qwen2.5:0.5b && ollama serve');+ } else {+ console.error('❌ RuVector Error:', error.message);+ }+ provider.destroy();+ return null;+ }+}++async function testProviderManager() {+ console.log('\n🔷 Testing Provider Manager (multi-provider)...');++ const providers = [];++ if (process.env.ANTHROPIC_API_KEY) {+ providers.push({+ provider: 'anthropic' as const,+ apiKey: process.env.ANTHROPIC_API_KEY,+ model: 'claude-3-haiku-20240307',+ maxTokens: 100,+ });+ }++ // Add OpenRouter as second provider for load balancing/failover+ if (process.env.OPENROUTER_API_KEY) {+ providers.push({+ provider: 'openai' as const, // OpenRouter uses OpenAI-compatible API+ apiKey: process.env.OPENROUTER_API_KEY,+ apiUrl: 'https://openrouter.ai/api/v1',+ model: 'openai/gpt-4o-mini',+ maxTokens: 100,+ } as any);+ }++ if (providers.length === 0) {+ console.log('⏭️ Skipping Provider Manager - no cloud API keys');+ return null;+ }++ try {+ const manager = await createProviderManager({+ providers,+ loadBalancing: {+ enabled: true,+ strategy: 'round-robin',+ },+ fallback: {+ enabled: true,+ maxAttempts: 2,+ },+ cache: {+ enabled: true,+ ttl: 60000,+ maxSize: 100,+ },+ }, consoleLogger);++ console.log(' Active providers:', manager.listProviders());++ // Make request+ const response = await manager.complete(createTestRequest());+ console.log('✅ Manager Response:', response.content);+ console.log(' Used provider:', response.provider);++ // Test cache+ console.log(' Testing cache...');+ const start = Date.now();+ const cached = await manager.complete(createTestRequest());+ const cacheTime = Date.now() - start;+ console.log(` Cache hit time: ${cacheTime}ms`);++ manager.destroy();+ return response;+ } catch (error) {+ console.error('❌ Manager Error:', error);+ return null;+ }+}++async function main() {+ console.log('╔════════════════════════════════════════════════╗');+ console.log('║ Claude Flow V3 - Provider Test Suite ║');+ console.log('╚════════════════════════════════════════════════╝');++ console.log('\n📋 Loaded .env from:', resolve(__dirname, '../../../../../.env'));+ console.log('\n🔑 Available API Keys:');+ console.log(' ANTHROPIC_API_KEY:', process.env.ANTHROPIC_API_KEY ? '✓' : '✗');+ console.log(' GOOGLE_GEMINI_API_KEY:', process.env.GOOGLE_GEMINI_API_KEY ? '✓' : '✗');+ console.log(' OPENROUTER_API_KEY:', process.env.OPENROUTER_API_KEY ? '✓' : '✗');++ const results = {+ anthropic: await testAnthropic(),+ google: await testGoogle(),+ openrouter: await testOpenRouter(),+ ollama: await testOllama(),+ ruvector: await testRuVector(),+ manager: await testProviderManager(),+ };++ // Summary+ console.log('\n╔════════════════════════════════════════════════╗');+ console.log('║ Test Summary ║');+ console.log('╚════════════════════════════════════════════════╝');++ const passed = Object.entries(results).filter(([_, r]) => r !== null).length;+ const total = Object.keys(results).length;++ Object.entries(results).forEach(([name, result]) => {+ const status = result !== null ? '✅' : '⏭️';+ console.log(` ${status} ${name}`);+ });++ console.log(`\n📊 Passed: ${passed}/${total}`);++ if (results.ollama === null && results.ruvector === null) {+ console.log('\n💡 To test local models:');+ console.log(' 1. Install Ollama: https://ollama.ai');+ console.log(' 2. Pull Qwen: ollama pull qwen2.5:0.5b');+ console.log(' 3. Start server: ollama serve');+ console.log(' 4. Re-run this test');+ }+}++main().catch(console.error);diff --git a/v3/@claude-flow/providers/src/anthropic-provider.ts b/v3/@claude-flow/providers/src/anthropic-provider.tsnew file mode 100644index 0000000000..e934d19d2b--- /dev/null+++ b/v3/@claude-flow/providers/src/anthropic-provider.ts@@ -0,0 +1,435 @@+/**+ * V3 Anthropic (Claude) Provider+ *+ * Supports Claude 3.5, 3 Opus, Sonnet, and Haiku models.+ *+ * @module @claude-flow/providers/anthropic-provider+ */++import { BaseProvider, BaseProviderOptions } from './base-provider.js';+import {+ LLMProvider,+ LLMModel,+ LLMRequest,+ LLMResponse,+ LLMStreamEvent,+ ModelInfo,+ ProviderCapabilities,+ HealthCheckResult,+ AuthenticationError,+ RateLimitError,+ LLMProviderError,+} from './types.js';++interface AnthropicRequest {+ model: string;+ messages: Array<{+ role: 'user' | 'assistant';+ content: string | Array<{ type: string; text?: string; source?: unknown }>;+ }>;+ system?: string;+ max_tokens: number;+ temperature?: number;+ top_p?: number;+ top_k?: number;+ stop_sequences?: string[];+ stream?: boolean;+ tools?: Array<{+ name: string;+ description: string;+ input_schema: unknown;+ }>;+}++interface AnthropicResponse {+ id: string;+ type: string;+ role: string;+ model: string;+ content: Array<{ type: string; text?: string; name?: string; input?: unknown }>;+ stop_reason: string;+ usage: {+ input_tokens: number;+ output_tokens: number;+ };+}++export class AnthropicProvider extends BaseProvider {+ readonly name: LLMProvider = 'anthropic';+ readonly capabilities: ProviderCapabilities = {+ supportedModels: [+ 'claude-3-5-sonnet-20241022',+ 'claude-3-5-sonnet-latest',+ 'claude-3-opus-20240229',+ 'claude-3-sonnet-20240229',+ 'claude-3-haiku-20240307',+ ],+ maxContextLength: {+ 'claude-3-5-sonnet-20241022': 200000,+ 'claude-3-5-sonnet-latest': 200000,+ 'claude-3-opus-20240229': 200000,+ 'claude-3-sonnet-20240229': 200000,+ 'claude-3-haiku-20240307': 200000,+ },+ maxOutputTokens: {+ 'claude-3-5-sonnet-20241022': 8192,+ 'claude-3-5-sonnet-latest': 8192,+ 'claude-3-opus-20240229': 4096,+ 'claude-3-sonnet-20240229': 4096,+ 'claude-3-haiku-20240307': 4096,+ },+ supportsStreaming: true,+ supportsToolCalling: true,+ supportsSystemMessages: true,+ supportsVision: true,+ supportsAudio: false,+ supportsFineTuning: false,+ supportsEmbeddings: false,+ supportsBatching: true,+ rateLimit: {+ requestsPerMinute: 1000,+ tokensPerMinute: 100000,+ concurrentRequests: 100,+ },+ pricing: {+ 'claude-3-5-sonnet-20241022': {+ promptCostPer1k: 0.003,+ completionCostPer1k: 0.015,+ currency: 'USD',+ },+ 'claude-3-5-sonnet-latest': {+ promptCostPer1k: 0.003,+ completionCostPer1k: 0.015,+ currency: 'USD',+ },+ 'claude-3-opus-20240229': {+ promptCostPer1k: 0.015,+ completionCostPer1k: 0.075,+ currency: 'USD',+ },+ 'claude-3-sonnet-20240229': {+ promptCostPer1k: 0.003,+ completionCostPer1k: 0.015,+ currency: 'USD',+ },+ 'claude-3-haiku-20240307': {+ promptCostPer1k: 0.00025,+ completionCostPer1k: 0.00125,+ currency: 'USD',+ },+ },+ };++ private baseUrl: string = 'https://api.anthropic.com/v1';+ private headers: Record<string, string> = {};++ constructor(options: BaseProviderOptions) {+ super(options);+ }++ protected async doInitialize(): Promise<void> {+ if (!this.config.apiKey) {+ throw new AuthenticationError('Anthropic API key is required', 'anthropic');+ }++ this.baseUrl = this.config.apiUrl || 'https://api.anthropic.com/v1';+ this.headers = {+ 'x-api-key': this.config.apiKey,+ 'anthropic-version': '2023-06-01',+ 'Content-Type': 'application/json',+ };+ }++ protected async doComplete(request: LLMRequest): Promise<LLMResponse> {+ const anthropicRequest = this.buildRequest(request);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), this.config.timeout || 60000);++ try {+ const response = await fetch(`${this.baseUrl}/messages`, {+ method: 'POST',+ headers: this.headers,+ body: JSON.stringify(anthropicRequest),+ signal: controller.signal,+ });++ clearTimeout(timeout);++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const data = await response.json() as AnthropicResponse;+ return this.transformResponse(data, request);+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ }+ }++ protected async *doStreamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent> {+ const anthropicRequest = this.buildRequest(request, true);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), (this.config.timeout || 60000) * 2);++ try {+ const response = await fetch(`${this.baseUrl}/messages`, {+ method: 'POST',+ headers: this.headers,+ body: JSON.stringify(anthropicRequest),+ signal: controller.signal,+ });++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const reader = response.body!.getReader();+ const decoder = new TextDecoder();+ let buffer = '';+ let totalOutputTokens = 0;+ let inputTokens = 0;++ while (true) {+ const { done, value } = await reader.read();+ if (done) break;++ buffer += decoder.decode(value, { stream: true });+ const lines = buffer.split('\n');+ buffer = lines.pop() || '';++ for (const line of lines) {+ if (line.startsWith('data: ')) {+ const data = line.slice(6);+ if (data === '[DONE]') continue;++ try {+ const event = JSON.parse(data);++ if (event.type === 'content_block_delta' && event.delta?.text) {+ yield {+ type: 'content',+ delta: { content: event.delta.text },+ };+ } else if (event.type === 'message_delta' && event.usage) {+ totalOutputTokens = event.usage.output_tokens;+ } else if (event.type === 'message_start' && event.message?.usage) {+ inputTokens = event.message.usage.input_tokens;+ } else if (event.type === 'message_stop') {+ const model = request.model || this.config.model;+ const pricing = this.capabilities.pricing[model];++ const promptCost = (inputTokens / 1000) * pricing.promptCostPer1k;+ const completionCost = (totalOutputTokens / 1000) * pricing.completionCostPer1k;++ yield {+ type: 'done',+ usage: {+ promptTokens: inputTokens,+ completionTokens: totalOutputTokens,+ totalTokens: inputTokens + totalOutputTokens,+ },+ cost: {+ promptCost,+ completionCost,+ totalCost: promptCost + completionCost,+ currency: 'USD',+ },+ };+ }+ } catch {+ // Ignore parse errors+ }+ }+ }+ }+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ } finally {+ clearTimeout(timeout);+ }+ }++ async listModels(): Promise<LLMModel[]> {+ return this.capabilities.supportedModels;+ }++ async getModelInfo(model: LLMModel): Promise<ModelInfo> {+ const descriptions: Record<string, string> = {+ 'claude-3-5-sonnet-20241022': 'Latest Claude 3.5 Sonnet - Best balance of intelligence and speed',+ 'claude-3-5-sonnet-latest': 'Claude 3.5 Sonnet latest version',+ 'claude-3-opus-20240229': 'Most capable Claude model for complex tasks',+ 'claude-3-sonnet-20240229': 'Balanced Claude 3 model',+ 'claude-3-haiku-20240307': 'Fastest Claude 3 model for simple tasks',+ };++ return {+ model,+ name: model,+ description: descriptions[model] || 'Anthropic Claude model',+ contextLength: this.capabilities.maxContextLength[model] || 200000,+ maxOutputTokens: this.capabilities.maxOutputTokens[model] || 4096,+ supportedFeatures: ['chat', 'completion', 'vision', 'tool_calling'],+ pricing: this.capabilities.pricing[model],+ };+ }++ protected async doHealthCheck(): Promise<HealthCheckResult> {+ try {+ // Use a minimal request to check API availability+ const response = await fetch(`${this.baseUrl}/messages`, {+ method: 'POST',+ headers: this.headers,+ body: JSON.stringify({+ model: this.config.model,+ max_tokens: 1,+ messages: [{ role: 'user', content: 'Hi' }],+ }),+ });++ return {+ healthy: response.ok,+ timestamp: new Date(),+ ...(response.ok ? {} : { error: `HTTP ${response.status}` }),+ };+ } catch (error) {+ return {+ healthy: false,+ error: error instanceof Error ? error.message : 'Unknown error',+ timestamp: new Date(),+ };+ }+ }++ private buildRequest(request: LLMRequest, stream = false): AnthropicRequest {+ // Extract system message+ const systemMessage = request.messages.find((m) => m.role === 'system');+ const otherMessages = request.messages.filter((m) => m.role !== 'system');++ // Transform messages+ const messages = otherMessages.map((msg) => ({+ role: msg.role as 'user' | 'assistant',+ content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),+ }));++ const anthropicRequest: AnthropicRequest = {+ model: request.model || this.config.model,+ messages,+ max_tokens: request.maxTokens || this.config.maxTokens || 4096,+ stream,+ };++ if (systemMessage) {+ anthropicRequest.system = typeof systemMessage.content === 'string'+ ? systemMessage.content+ : JSON.stringify(systemMessage.content);+ }++ if (request.temperature !== undefined) {+ anthropicRequest.temperature = request.temperature;+ } else if (this.config.temperature !== undefined) {+ anthropicRequest.temperature = this.config.temperature;+ }++ if (request.topP !== undefined || this.config.topP !== undefined) {+ anthropicRequest.top_p = request.topP ?? this.config.topP;+ }++ if (request.topK !== undefined || this.config.topK !== undefined) {+ anthropicRequest.top_k = request.topK ?? this.config.topK;+ }++ if (request.stopSequences || this.config.stopSequences) {+ anthropicRequest.stop_sequences = request.stopSequences || this.config.stopSequences;+ }++ // Add tools if present+ if (request.tools) {+ anthropicRequest.tools = request.tools.map((tool) => ({+ name: tool.function.name,+ description: tool.function.description,+ input_schema: tool.function.parameters,+ }));+ }++ return anthropicRequest;+ }++ private transformResponse(data: AnthropicResponse, request: LLMRequest): LLMResponse {+ const model = request.model || this.config.model;+ const pricing = this.capabilities.pricing[model];++ const promptCost = (data.usage.input_tokens / 1000) * pricing.promptCostPer1k;+ const completionCost = (data.usage.output_tokens / 1000) * pricing.completionCostPer1k;++ // Extract text content+ const textContent = data.content+ .filter((c) => c.type === 'text')+ .map((c) => c.text)+ .join('');++ // Extract tool calls+ const toolCalls = data.content+ .filter((c) => c.type === 'tool_use')+ .map((c) => ({+ id: `tool_${Date.now()}`,+ type: 'function' as const,+ function: {+ name: c.name || '',+ arguments: JSON.stringify(c.input || {}),+ },+ }));++ return {+ id: data.id,+ model: model as LLMModel,+ provider: 'anthropic',+ content: textContent,+ toolCalls: toolCalls.length > 0 ? toolCalls : undefined,+ usage: {+ promptTokens: data.usage.input_tokens,+ completionTokens: data.usage.output_tokens,+ totalTokens: data.usage.input_tokens + data.usage.output_tokens,+ },+ cost: {+ promptCost,+ completionCost,+ totalCost: promptCost + completionCost,+ currency: 'USD',+ },+ finishReason: data.stop_reason === 'end_turn' ? 'stop' : 'length',+ };+ }++ private async handleErrorResponse(response: Response): Promise<never> {+ const errorText = await response.text();+ let errorData: { error?: { message?: string } };++ try {+ errorData = JSON.parse(errorText);+ } catch {+ errorData = { error: { message: errorText } };+ }++ const message = errorData.error?.message || 'Unknown error';++ switch (response.status) {+ case 401:+ throw new AuthenticationError(message, 'anthropic', errorData);+ case 429:+ throw new RateLimitError(message, 'anthropic', undefined, errorData);+ default:+ throw new LLMProviderError(+ message,+ `ANTHROPIC_${response.status}`,+ 'anthropic',+ response.status,+ response.status >= 500,+ errorData+ );+ }+ }+}diff --git a/v3/@claude-flow/providers/src/base-provider.ts b/v3/@claude-flow/providers/src/base-provider.tsnew file mode 100644index 0000000000..68cf4c1c76--- /dev/null+++ b/v3/@claude-flow/providers/src/base-provider.ts@@ -0,0 +1,596 @@+/**+ * V3 Abstract Base Provider+ *+ * Provides common functionality for all LLM providers:+ * - Circuit breaker protection+ * - Health monitoring+ * - Cost tracking+ * - Request metrics+ *+ * @module @claude-flow/providers/base-provider+ */++import { EventEmitter } from 'events';+import {+ ILLMProvider,+ LLMProvider,+ LLMProviderConfig,+ LLMRequest,+ LLMResponse,+ LLMStreamEvent,+ LLMModel,+ ModelInfo,+ ProviderCapabilities,+ HealthCheckResult,+ ProviderStatus,+ CostEstimate,+ UsageStats,+ UsagePeriod,+ LLMProviderError,+ RateLimitError,+ ProviderUnavailableError,+} from './types.js';++/**+ * Simple circuit breaker implementation+ */+class CircuitBreaker {+ private failures = 0;+ private lastFailure = 0;+ private state: 'closed' | 'open' | 'half-open' = 'closed';++ constructor(+ private readonly name: string,+ private readonly threshold: number = 5,+ private readonly resetTimeout: number = 60000+ ) {}++ async execute<T>(fn: () => Promise<T>): Promise<T> {+ if (this.state === 'open') {+ if (Date.now() - this.lastFailure > this.resetTimeout) {+ this.state = 'half-open';+ } else {+ throw new Error(`Circuit breaker ${this.name} is open`);+ }+ }++ try {+ const result = await fn();+ this.onSuccess();+ return result;+ } catch (error) {+ this.onFailure();+ throw error;+ }+ }++ private onSuccess(): void {+ this.failures = 0;+ this.state = 'closed';+ }++ private onFailure(): void {+ this.failures++;+ this.lastFailure = Date.now();++ if (this.failures >= this.threshold) {+ this.state = 'open';+ }+ }++ getState(): string {+ return this.state;+ }+}++/**+ * Logger interface+ */+export interface ILogger {+ info(message: string, meta?: Record<string, unknown>): void;+ warn(message: string, meta?: Record<string, unknown>): void;+ error(message: string, error?: unknown): void;+ debug(message: string, meta?: Record<string, unknown>): void;+}++/**+ * Console logger implementation+ */+export const consoleLogger: ILogger = {+ info: (msg, meta) => console.log(`[INFO] ${msg}`, meta || ''),+ warn: (msg, meta) => console.warn(`[WARN] ${msg}`, meta || ''),+ error: (msg, err) => console.error(`[ERROR] ${msg}`, err || ''),+ debug: (msg, meta) => console.debug(`[DEBUG] ${msg}`, meta || ''),+};++/**+ * Base provider options+ */+export interface BaseProviderOptions {+ logger?: ILogger;+ config: LLMProviderConfig;+ cacheTTL?: number;+ circuitBreakerOptions?: {+ threshold?: number;+ resetTimeout?: number;+ };+}++/**+ * Abstract base class for LLM providers+ */+export abstract class BaseProvider extends EventEmitter implements ILLMProvider {+ abstract readonly name: LLMProvider;+ abstract readonly capabilities: ProviderCapabilities;++ protected logger: ILogger;+ protected circuitBreaker: CircuitBreaker;+ protected healthCheckInterval?: ReturnType<typeof setInterval>;+ protected lastHealthCheck?: HealthCheckResult;++ // Metrics+ protected requestCount = 0;+ protected errorCount = 0;+ protected totalTokens = 0;+ protected totalCost = 0;+ protected requestMetrics: Map<string, {+ timestamp: Date;+ model: string;+ tokens: number;+ cost?: number;+ latency: number;+ }> = new Map();++ public config: LLMProviderConfig;++ constructor(options: BaseProviderOptions) {+ super();+ this.logger = options.logger || consoleLogger;+ this.config = options.config;++ // Initialize circuit breaker+ this.circuitBreaker = new CircuitBreaker(+ `llm-${this.config.provider}`,+ options.circuitBreakerOptions?.threshold || 5,+ options.circuitBreakerOptions?.resetTimeout || 60000+ );+ }++ /**+ * Initialize the provider+ */+ async initialize(): Promise<void> {+ this.logger.info(`Initializing ${this.name} provider`, {+ model: this.config.model,+ temperature: this.config.temperature,+ maxTokens: this.config.maxTokens,+ });++ // Validate configuration+ this.validateConfig();++ // Provider-specific initialization+ await this.doInitialize();++ // Start health checks if caching enabled+ if (this.config.enableCaching) {+ this.startHealthChecks();+ }++ // Initial health check+ await this.healthCheck();+ }++ /**+ * Provider-specific initialization (override in subclass)+ */+ protected abstract doInitialize(): Promise<void>;++ /**+ * Validate provider configuration+ */+ protected validateConfig(): void {+ if (!this.config.model) {+ throw new Error(`Model is required for ${this.name} provider`);+ }++ if (!this.validateModel(this.config.model)) {+ this.logger.warn(`Model ${this.config.model} may not be supported by ${this.name}`);+ }++ if (this.config.temperature !== undefined) {+ if (this.config.temperature < 0 || this.config.temperature > 2) {+ throw new Error('Temperature must be between 0 and 2');+ }+ }+ }++ /**+ * Complete a request+ */+ async complete(request: LLMRequest): Promise<LLMResponse> {+ const startTime = Date.now();++ try {+ const response = await this.circuitBreaker.execute(async () => {+ return await this.doComplete(request);+ });++ const latency = Date.now() - startTime;+ this.trackRequest(request, response, latency);++ this.emit('response', {+ provider: this.name,+ model: response.model,+ latency,+ tokens: response.usage.totalTokens,+ cost: response.cost?.totalCost,+ });++ return response;+ } catch (error) {+ this.errorCount++;++ const providerError = this.transformError(error);++ this.emit('error', {+ provider: this.name,+ error: providerError,+ request,+ });++ throw providerError;+ }+ }++ /**+ * Provider-specific completion (override in subclass)+ */+ protected abstract doComplete(request: LLMRequest): Promise<LLMResponse>;++ /**+ * Stream complete a request+ */+ async *streamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent> {+ const startTime = Date.now();+ let totalTokens = 0;+ let totalCost = 0;++ try {+ if (!this.capabilities.supportsStreaming) {+ throw new LLMProviderError(+ 'Streaming not supported',+ 'STREAMING_NOT_SUPPORTED',+ this.name,+ undefined,+ false+ );+ }++ const stream = await this.circuitBreaker.execute(async () => {+ return this.doStreamComplete(request);+ });++ for await (const event of stream) {+ if (event.usage) {+ totalTokens = event.usage.totalTokens;+ }+ if (event.cost) {+ totalCost = event.cost.totalCost;+ }+ yield event;+ }++ const latency = Date.now() - startTime;+ this.trackStreamRequest(request, totalTokens, totalCost, latency);+ } catch (error) {+ this.errorCount++;+ const providerError = this.transformError(error);++ yield { type: 'error', error: providerError };+ throw providerError;+ }+ }++ /**+ * Provider-specific stream completion (override in subclass)+ */+ protected abstract doStreamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent>;++ /**+ * List available models+ */+ abstract listModels(): Promise<LLMModel[]>;++ /**+ * Get model information+ */+ abstract getModelInfo(model: LLMModel): Promise<ModelInfo>;++ /**+ * Validate if a model is supported+ */+ validateModel(model: LLMModel): boolean {+ return this.capabilities.supportedModels.includes(model);+ }++ /**+ * Perform health check+ */+ async healthCheck(): Promise<HealthCheckResult> {+ const startTime = Date.now();++ try {+ const result = await this.doHealthCheck();++ this.lastHealthCheck = {+ ...result,+ latency: Date.now() - startTime,+ timestamp: new Date(),+ };++ this.emit('health_check', this.lastHealthCheck);+ return this.lastHealthCheck;+ } catch (error) {+ this.lastHealthCheck = {+ healthy: false,+ error: error instanceof Error ? error.message : 'Unknown error',+ latency: Date.now() - startTime,+ timestamp: new Date(),+ };++ this.emit('health_check', this.lastHealthCheck);+ return this.lastHealthCheck;+ }+ }++ /**+ * Provider-specific health check (override in subclass)+ */+ protected abstract doHealthCheck(): Promise<HealthCheckResult>;++ /**+ * Get provider status+ */+ getStatus(): ProviderStatus {+ const queueLength = this.requestMetrics.size;++ return {+ available: this.lastHealthCheck?.healthy ?? false,+ currentLoad: Math.min(queueLength / 100, 1),+ queueLength,+ activeRequests: queueLength,+ rateLimitRemaining: this.getRateLimitRemaining(),+ rateLimitReset: this.getRateLimitReset(),+ };+ }++ /**+ * Get remaining rate limit (override in provider)+ */+ protected getRateLimitRemaining(): number | undefined {+ return undefined;+ }++ /**+ * Get rate limit reset time (override in provider)+ */+ protected getRateLimitReset(): Date | undefined {+ return undefined;+ }++ /**+ * Estimate cost for a request+ */+ async estimateCost(request: LLMRequest): Promise<CostEstimate> {+ const model = request.model || this.config.model;+ const pricing = this.capabilities.pricing?.[model];++ if (!pricing) {+ return {+ estimatedPromptTokens: 0,+ estimatedCompletionTokens: 0,+ estimatedTotalTokens: 0,+ estimatedCost: { prompt: 0, completion: 0, total: 0, currency: 'USD' },+ confidence: 0,+ };+ }++ const promptTokens = this.estimateTokens(JSON.stringify(request.messages));+ const completionTokens = request.maxTokens || this.config.maxTokens || 1000;++ const promptCost = (promptTokens / 1000) * pricing.promptCostPer1k;+ const completionCost = (completionTokens / 1000) * pricing.completionCostPer1k;++ return {+ estimatedPromptTokens: promptTokens,+ estimatedCompletionTokens: completionTokens,+ estimatedTotalTokens: promptTokens + completionTokens,+ estimatedCost: {+ prompt: promptCost,+ completion: completionCost,+ total: promptCost + completionCost,+ currency: pricing.currency,+ },+ confidence: 0.7,+ };+ }++ /**+ * Simple token estimation (4 chars ≈ 1 token)+ */+ protected estimateTokens(text: string): number {+ return Math.ceil(text.length / 4);+ }++ /**+ * Get usage statistics+ */+ async getUsage(period: UsagePeriod = 'day'): Promise<UsageStats> {+ const now = new Date();+ const start = this.getStartDate(now, period);++ return {+ period: { start, end: now },+ requests: this.requestCount,+ tokens: {+ prompt: Math.floor(this.totalTokens * 0.7),+ completion: Math.floor(this.totalTokens * 0.3),+ total: this.totalTokens,+ },+ cost: {+ prompt: this.totalCost * 0.7,+ completion: this.totalCost * 0.3,+ total: this.totalCost,+ currency: 'USD',+ },+ errors: this.errorCount,+ averageLatency: this.calculateAverageLatency(),+ modelBreakdown: {},+ };+ }++ private getStartDate(end: Date, period: UsagePeriod): Date {+ const start = new Date(end);+ switch (period) {+ case 'hour':+ start.setHours(start.getHours() - 1);+ break;+ case 'day':+ start.setDate(start.getDate() - 1);+ break;+ case 'week':+ start.setDate(start.getDate() - 7);+ break;+ case 'month':+ start.setMonth(start.getMonth() - 1);+ break;+ case 'all':+ start.setFullYear(2020);+ break;+ }+ return start;+ }++ private calculateAverageLatency(): number {+ if (this.requestMetrics.size === 0) return 0;++ let total = 0;+ let count = 0;++ this.requestMetrics.forEach((metrics) => {+ if (metrics.latency) {+ total += metrics.latency;+ count++;+ }+ });++ return count > 0 ? total / count : 0;+ }++ /**+ * Track successful request+ */+ protected trackRequest(request: LLMRequest, response: LLMResponse, latency: number): void {+ this.requestCount++;+ this.totalTokens += response.usage.totalTokens;++ if (response.cost) {+ this.totalCost += response.cost.totalCost;+ }++ this.requestMetrics.set(response.id, {+ timestamp: new Date(),+ model: response.model,+ tokens: response.usage.totalTokens,+ cost: response.cost?.totalCost,+ latency,+ });++ // Keep last 1000 metrics+ if (this.requestMetrics.size > 1000) {+ const oldestKey = this.requestMetrics.keys().next().value;+ if (oldestKey) this.requestMetrics.delete(oldestKey);+ }+ }++ /**+ * Track streaming request+ */+ protected trackStreamRequest(+ request: LLMRequest,+ totalTokens: number,+ totalCost: number,+ latency: number+ ): void {+ this.requestCount++;+ this.totalTokens += totalTokens;+ this.totalCost += totalCost;++ this.requestMetrics.set(`stream-${Date.now()}`, {+ timestamp: new Date(),+ model: request.model || this.config.model,+ tokens: totalTokens,+ cost: totalCost,+ latency,+ });+ }++ /**+ * Transform errors to provider errors+ */+ protected transformError(error: unknown): LLMProviderError {+ if (error instanceof LLMProviderError) {+ return error;+ }++ if (error instanceof Error) {+ if (error.message.includes('rate limit')) {+ return new RateLimitError(error.message, this.name);+ }++ if (error.message.includes('timeout') || error.message.includes('ETIMEDOUT')) {+ return new LLMProviderError('Request timed out', 'TIMEOUT', this.name, undefined, true);+ }++ if (error.message.includes('ECONNREFUSED') || error.message.includes('fetch failed')) {+ return new ProviderUnavailableError(this.name, { originalError: error.message });+ }+ }++ return new LLMProviderError(+ error instanceof Error ? error.message : String(error),+ 'UNKNOWN',+ this.name,+ undefined,+ true+ );+ }++ /**+ * Start periodic health checks+ */+ protected startHealthChecks(): void {+ const interval = this.config.cacheTimeout || 300000;++ this.healthCheckInterval = setInterval(() => {+ this.healthCheck().catch((error) => {+ this.logger.error(`Health check failed for ${this.name}`, error);+ });+ }, interval);+ }++ /**+ * Clean up resources+ */+ destroy(): void {+ if (this.healthCheckInterval) {+ clearInterval(this.healthCheckInterval);+ }++ this.requestMetrics.clear();+ this.removeAllListeners();++ this.logger.info(`${this.name} provider destroyed`);+ }+}diff --git a/v3/@claude-flow/providers/src/cohere-provider.ts b/v3/@claude-flow/providers/src/cohere-provider.tsnew file mode 100644index 0000000000..e60644caf2--- /dev/null+++ b/v3/@claude-flow/providers/src/cohere-provider.ts@@ -0,0 +1,423 @@+/**+ * V3 Cohere Provider+ *+ * Supports Command R+, Command R, and Command Light models.+ *+ * @module @claude-flow/providers/cohere-provider+ */++import { BaseProvider, BaseProviderOptions } from './base-provider.js';+import {+ LLMProvider,+ LLMModel,+ LLMRequest,+ LLMResponse,+ LLMStreamEvent,+ ModelInfo,+ ProviderCapabilities,+ HealthCheckResult,+ AuthenticationError,+ RateLimitError,+ LLMProviderError,+} from './types.js';++interface CohereRequest {+ model: string;+ message: string;+ chat_history?: Array<{+ role: 'USER' | 'CHATBOT' | 'SYSTEM';+ message: string;+ }>;+ preamble?: string;+ temperature?: number;+ p?: number;+ k?: number;+ max_tokens?: number;+ stop_sequences?: string[];+ stream?: boolean;+ tools?: Array<{+ name: string;+ description: string;+ parameter_definitions: Record<string, unknown>;+ }>;+}++interface CohereResponse {+ response_id: string;+ text: string;+ generation_id: string;+ chat_history: Array<{ role: string; message: string }>;+ finish_reason: string;+ meta: {+ api_version: { version: string };+ billed_units: {+ input_tokens: number;+ output_tokens: number;+ };+ };+ tool_calls?: Array<{+ name: string;+ parameters: unknown;+ }>;+}++export class CohereProvider extends BaseProvider {+ readonly name: LLMProvider = 'cohere';+ readonly capabilities: ProviderCapabilities = {+ supportedModels: [+ 'command-r-plus',+ 'command-r',+ 'command-light',+ 'command',+ ],+ maxContextLength: {+ 'command-r-plus': 128000,+ 'command-r': 128000,+ 'command-light': 4096,+ 'command': 4096,+ },+ maxOutputTokens: {+ 'command-r-plus': 4096,+ 'command-r': 4096,+ 'command-light': 4096,+ 'command': 4096,+ },+ supportsStreaming: true,+ supportsToolCalling: true,+ supportsSystemMessages: true,+ supportsVision: false,+ supportsAudio: false,+ supportsFineTuning: true,+ supportsEmbeddings: true,+ supportsBatching: false,+ rateLimit: {+ requestsPerMinute: 1000,+ tokensPerMinute: 100000,+ concurrentRequests: 100,+ },+ pricing: {+ 'command-r-plus': {+ promptCostPer1k: 0.003,+ completionCostPer1k: 0.015,+ currency: 'USD',+ },+ 'command-r': {+ promptCostPer1k: 0.0005,+ completionCostPer1k: 0.0015,+ currency: 'USD',+ },+ 'command-light': {+ promptCostPer1k: 0.0003,+ completionCostPer1k: 0.0006,+ currency: 'USD',+ },+ 'command': {+ promptCostPer1k: 0.001,+ completionCostPer1k: 0.002,+ currency: 'USD',+ },+ },+ };++ private baseUrl: string = 'https://api.cohere.ai/v1';+ private headers: Record<string, string> = {};++ constructor(options: BaseProviderOptions) {+ super(options);+ }++ protected async doInitialize(): Promise<void> {+ if (!this.config.apiKey) {+ throw new AuthenticationError('Cohere API key is required', 'cohere');+ }++ this.baseUrl = this.config.apiUrl || 'https://api.cohere.ai/v1';+ this.headers = {+ Authorization: `Bearer ${this.config.apiKey}`,+ 'Content-Type': 'application/json',+ };+ }++ protected async doComplete(request: LLMRequest): Promise<LLMResponse> {+ const cohereRequest = this.buildRequest(request);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), this.config.timeout || 60000);++ try {+ const response = await fetch(`${this.baseUrl}/chat`, {+ method: 'POST',+ headers: this.headers,+ body: JSON.stringify(cohereRequest),+ signal: controller.signal,+ });++ clearTimeout(timeout);++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const data = await response.json() as CohereResponse;+ return this.transformResponse(data, request);+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ }+ }++ protected async *doStreamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent> {+ const cohereRequest = this.buildRequest(request, true);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), (this.config.timeout || 60000) * 2);++ try {+ const response = await fetch(`${this.baseUrl}/chat`, {+ method: 'POST',+ headers: this.headers,+ body: JSON.stringify(cohereRequest),+ signal: controller.signal,+ });++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const reader = response.body!.getReader();+ const decoder = new TextDecoder();+ let buffer = '';+ let inputTokens = 0;+ let outputTokens = 0;++ while (true) {+ const { done, value } = await reader.read();+ if (done) break;++ buffer += decoder.decode(value, { stream: true });+ const lines = buffer.split('\n');+ buffer = lines.pop() || '';++ for (const line of lines) {+ if (!line.trim()) continue;++ try {+ const event = JSON.parse(line);++ if (event.event_type === 'text-generation' && event.text) {+ yield {+ type: 'content',+ delta: { content: event.text },+ };+ } else if (event.event_type === 'stream-end') {+ if (event.response?.meta?.billed_units) {+ inputTokens = event.response.meta.billed_units.input_tokens;+ outputTokens = event.response.meta.billed_units.output_tokens;+ }++ const model = request.model || this.config.model;+ const pricing = this.capabilities.pricing[model];++ yield {+ type: 'done',+ usage: {+ promptTokens: inputTokens,+ completionTokens: outputTokens,+ totalTokens: inputTokens + outputTokens,+ },+ cost: {+ promptCost: (inputTokens / 1000) * pricing.promptCostPer1k,+ completionCost: (outputTokens / 1000) * pricing.completionCostPer1k,+ totalCost:+ (inputTokens / 1000) * pricing.promptCostPer1k ++ (outputTokens / 1000) * pricing.completionCostPer1k,+ currency: 'USD',+ },+ };+ }+ } catch {+ // Ignore parse errors+ }+ }+ }+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ } finally {+ clearTimeout(timeout);+ }+ }++ async listModels(): Promise<LLMModel[]> {+ return this.capabilities.supportedModels;+ }++ async getModelInfo(model: LLMModel): Promise<ModelInfo> {+ const descriptions: Record<string, string> = {+ 'command-r-plus': 'Most capable Cohere model with 128K context',+ 'command-r': 'Balanced Cohere model with 128K context',+ 'command-light': 'Fast and efficient Cohere model',+ 'command': 'Standard Cohere model',+ };++ return {+ model,+ name: model,+ description: descriptions[model] || 'Cohere language model',+ contextLength: this.capabilities.maxContextLength[model] || 4096,+ maxOutputTokens: this.capabilities.maxOutputTokens[model] || 4096,+ supportedFeatures: ['chat', 'completion', 'tool_calling', 'rag'],+ pricing: this.capabilities.pricing[model],+ };+ }++ protected async doHealthCheck(): Promise<HealthCheckResult> {+ try {+ const response = await fetch(`${this.baseUrl}/check-api-key`, {+ method: 'POST',+ headers: this.headers,+ });++ return {+ healthy: response.ok,+ timestamp: new Date(),+ ...(response.ok ? {} : { error: `HTTP ${response.status}` }),+ };+ } catch (error) {+ return {+ healthy: false,+ error: error instanceof Error ? error.message : 'Unknown error',+ timestamp: new Date(),+ };+ }+ }++ private buildRequest(request: LLMRequest, stream = false): CohereRequest {+ // Get the last user message+ const lastUserMessage = [...request.messages].reverse().find((m) => m.role === 'user');+ const systemMessage = request.messages.find((m) => m.role === 'system');++ // Build chat history (exclude last user message)+ const chatHistory = request.messages+ .filter((m) => m !== lastUserMessage && m.role !== 'system')+ .map((msg) => ({+ role: msg.role === 'assistant' ? 'CHATBOT' as const : 'USER' as const,+ message: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),+ }));++ const cohereRequest: CohereRequest = {+ model: request.model || this.config.model,+ message: lastUserMessage+ ? (typeof lastUserMessage.content === 'string'+ ? lastUserMessage.content+ : JSON.stringify(lastUserMessage.content))+ : '',+ stream,+ };++ if (chatHistory.length > 0) {+ cohereRequest.chat_history = chatHistory;+ }++ if (systemMessage) {+ cohereRequest.preamble = typeof systemMessage.content === 'string'+ ? systemMessage.content+ : JSON.stringify(systemMessage.content);+ }++ if (request.temperature !== undefined || this.config.temperature !== undefined) {+ cohereRequest.temperature = request.temperature ?? this.config.temperature;+ }+ if (request.topP !== undefined || this.config.topP !== undefined) {+ cohereRequest.p = request.topP ?? this.config.topP;+ }+ if (request.topK !== undefined || this.config.topK !== undefined) {+ cohereRequest.k = request.topK ?? this.config.topK;+ }+ if (request.maxTokens || this.config.maxTokens) {+ cohereRequest.max_tokens = request.maxTokens || this.config.maxTokens;+ }+ if (request.stopSequences || this.config.stopSequences) {+ cohereRequest.stop_sequences = request.stopSequences || this.config.stopSequences;+ }++ if (request.tools) {+ cohereRequest.tools = request.tools.map((tool) => ({+ name: tool.function.name,+ description: tool.function.description,+ parameter_definitions: tool.function.parameters.properties as Record<string, unknown>,+ }));+ }++ return cohereRequest;+ }++ private transformResponse(data: CohereResponse, request: LLMRequest): LLMResponse {+ const model = request.model || this.config.model;+ const pricing = this.capabilities.pricing[model];++ const inputTokens = data.meta.billed_units.input_tokens;+ const outputTokens = data.meta.billed_units.output_tokens;++ const promptCost = (inputTokens / 1000) * pricing.promptCostPer1k;+ const completionCost = (outputTokens / 1000) * pricing.completionCostPer1k;++ const toolCalls = data.tool_calls?.map((tc) => ({+ id: `tool_${Date.now()}`,+ type: 'function' as const,+ function: {+ name: tc.name,+ arguments: JSON.stringify(tc.parameters),+ },+ }));++ return {+ id: data.response_id,+ model: model as LLMModel,+ provider: 'cohere',+ content: data.text,+ toolCalls: toolCalls?.length ? toolCalls : undefined,+ usage: {+ promptTokens: inputTokens,+ completionTokens: outputTokens,+ totalTokens: inputTokens + outputTokens,+ },+ cost: {+ promptCost,+ completionCost,+ totalCost: promptCost + completionCost,+ currency: 'USD',+ },+ finishReason: data.finish_reason === 'COMPLETE' ? 'stop' : 'length',+ };+ }++ private async handleErrorResponse(response: Response): Promise<never> {+ const errorText = await response.text();+ let errorData: { message?: string };++ try {+ errorData = JSON.parse(errorText);+ } catch {+ errorData = { message: errorText };+ }++ const message = errorData.message || 'Unknown error';++ switch (response.status) {+ case 401:+ throw new AuthenticationError(message, 'cohere', errorData);+ case 429:+ throw new RateLimitError(message, 'cohere', undefined, errorData);+ default:+ throw new LLMProviderError(+ message,+ `COHERE_${response.status}`,+ 'cohere',+ response.status,+ response.status >= 500,+ errorData+ );+ }+ }+}diff --git a/v3/@claude-flow/providers/src/google-provider.ts b/v3/@claude-flow/providers/src/google-provider.tsnew file mode 100644index 0000000000..2b7964e74d--- /dev/null+++ b/v3/@claude-flow/providers/src/google-provider.ts@@ -0,0 +1,429 @@+/**+ * V3 Google (Gemini) Provider+ *+ * Supports Gemini 2.0, 1.5 Pro, and Flash models.+ *+ * @module @claude-flow/providers/google-provider+ */++import { BaseProvider, BaseProviderOptions } from './base-provider.js';+import {+ LLMProvider,+ LLMModel,+ LLMRequest,+ LLMResponse,+ LLMStreamEvent,+ ModelInfo,+ ProviderCapabilities,+ HealthCheckResult,+ AuthenticationError,+ RateLimitError,+ LLMProviderError,+} from './types.js';++interface GeminiRequest {+ contents: Array<{+ role: 'user' | 'model';+ parts: Array<{ text: string }>;+ }>;+ systemInstruction?: {+ parts: Array<{ text: string }>;+ };+ generationConfig?: {+ temperature?: number;+ topP?: number;+ topK?: number;+ maxOutputTokens?: number;+ stopSequences?: string[];+ };+ tools?: Array<{+ functionDeclarations: Array<{+ name: string;+ description: string;+ parameters: unknown;+ }>;+ }>;+}++interface GeminiResponse {+ candidates: Array<{+ content: {+ parts: Array<{ text?: string; functionCall?: { name: string; args: unknown } }>;+ role: string;+ };+ finishReason: string;+ }>;+ usageMetadata: {+ promptTokenCount: number;+ candidatesTokenCount: number;+ totalTokenCount: number;+ };+}++export class GoogleProvider extends BaseProvider {+ readonly name: LLMProvider = 'google';+ readonly capabilities: ProviderCapabilities = {+ supportedModels: [+ 'gemini-2.0-flash',+ 'gemini-1.5-pro',+ 'gemini-1.5-flash',+ 'gemini-pro',+ ],+ maxContextLength: {+ 'gemini-2.0-flash': 1000000,+ 'gemini-1.5-pro': 2000000,+ 'gemini-1.5-flash': 1000000,+ 'gemini-pro': 32000,+ },+ maxOutputTokens: {+ 'gemini-2.0-flash': 8192,+ 'gemini-1.5-pro': 8192,+ 'gemini-1.5-flash': 8192,+ 'gemini-pro': 8192,+ },+ supportsStreaming: true,+ supportsToolCalling: true,+ supportsSystemMessages: true,+ supportsVision: true,+ supportsAudio: true,+ supportsFineTuning: false,+ supportsEmbeddings: true,+ supportsBatching: true,+ rateLimit: {+ requestsPerMinute: 1000,+ tokensPerMinute: 4000000,+ concurrentRequests: 100,+ },+ pricing: {+ 'gemini-2.0-flash': {+ promptCostPer1k: 0.0, // Free tier available+ completionCostPer1k: 0.0,+ currency: 'USD',+ },+ 'gemini-1.5-pro': {+ promptCostPer1k: 0.00125,+ completionCostPer1k: 0.005,+ currency: 'USD',+ },+ 'gemini-1.5-flash': {+ promptCostPer1k: 0.000075,+ completionCostPer1k: 0.0003,+ currency: 'USD',+ },+ 'gemini-pro': {+ promptCostPer1k: 0.0005,+ completionCostPer1k: 0.0015,+ currency: 'USD',+ },+ },+ };++ private baseUrl: string = 'https://generativelanguage.googleapis.com/v1beta';++ constructor(options: BaseProviderOptions) {+ super(options);+ }++ protected async doInitialize(): Promise<void> {+ if (!this.config.apiKey) {+ throw new AuthenticationError('Google API key is required', 'google');+ }++ this.baseUrl = this.config.apiUrl || 'https://generativelanguage.googleapis.com/v1beta';+ }++ protected async doComplete(request: LLMRequest): Promise<LLMResponse> {+ const geminiRequest = this.buildRequest(request);+ const model = request.model || this.config.model;+ const url = `${this.baseUrl}/models/${model}:generateContent?key=${this.config.apiKey}`;++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), this.config.timeout || 60000);++ try {+ const response = await fetch(url, {+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify(geminiRequest),+ signal: controller.signal,+ });++ clearTimeout(timeout);++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const data = await response.json() as GeminiResponse;+ return this.transformResponse(data, request);+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ }+ }++ protected async *doStreamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent> {+ const geminiRequest = this.buildRequest(request);+ const model = request.model || this.config.model;+ const url = `${this.baseUrl}/models/${model}:streamGenerateContent?key=${this.config.apiKey}&alt=sse`;++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), (this.config.timeout || 60000) * 2);++ try {+ const response = await fetch(url, {+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify(geminiRequest),+ signal: controller.signal,+ });++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const reader = response.body!.getReader();+ const decoder = new TextDecoder();+ let buffer = '';+ let totalTokens = 0;++ while (true) {+ const { done, value } = await reader.read();+ if (done) break;++ buffer += decoder.decode(value, { stream: true });+ const lines = buffer.split('\n');+ buffer = lines.pop() || '';++ for (const line of lines) {+ if (line.startsWith('data: ')) {+ const data = line.slice(6);+ if (!data || data === '[DONE]') continue;++ try {+ const chunk: GeminiResponse = JSON.parse(data);+ const candidate = chunk.candidates?.[0];++ if (candidate?.content?.parts) {+ for (const part of candidate.content.parts) {+ if (part.text) {+ yield {+ type: 'content',+ delta: { content: part.text },+ };+ }+ }+ }++ if (chunk.usageMetadata) {+ totalTokens = chunk.usageMetadata.totalTokenCount;+ }+ } catch {+ // Ignore parse errors+ }+ }+ }+ }++ // Final event+ const pricing = this.capabilities.pricing[model];+ const promptTokens = this.estimateTokens(JSON.stringify(request.messages));++ yield {+ type: 'done',+ usage: {+ promptTokens,+ completionTokens: totalTokens - promptTokens,+ totalTokens,+ },+ cost: {+ promptCost: (promptTokens / 1000) * pricing.promptCostPer1k,+ completionCost: ((totalTokens - promptTokens) / 1000) * pricing.completionCostPer1k,+ totalCost:+ (promptTokens / 1000) * pricing.promptCostPer1k ++ ((totalTokens - promptTokens) / 1000) * pricing.completionCostPer1k,+ currency: 'USD',+ },+ };+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ } finally {+ clearTimeout(timeout);+ }+ }++ async listModels(): Promise<LLMModel[]> {+ return this.capabilities.supportedModels;+ }++ async getModelInfo(model: LLMModel): Promise<ModelInfo> {+ const descriptions: Record<string, string> = {+ 'gemini-2.0-flash': 'Latest Gemini 2.0 with multimodal capabilities',+ 'gemini-1.5-pro': 'Most capable Gemini model with 2M context',+ 'gemini-1.5-flash': 'Fast and efficient Gemini model',+ 'gemini-pro': 'Balanced Gemini model',+ };++ return {+ model,+ name: model,+ description: descriptions[model] || 'Google Gemini model',+ contextLength: this.capabilities.maxContextLength[model] || 32000,+ maxOutputTokens: this.capabilities.maxOutputTokens[model] || 8192,+ supportedFeatures: ['chat', 'completion', 'vision', 'audio', 'tool_calling'],+ pricing: this.capabilities.pricing[model],+ };+ }++ protected async doHealthCheck(): Promise<HealthCheckResult> {+ try {+ const url = `${this.baseUrl}/models?key=${this.config.apiKey}`;+ const response = await fetch(url);++ return {+ healthy: response.ok,+ timestamp: new Date(),+ ...(response.ok ? {} : { error: `HTTP ${response.status}` }),+ };+ } catch (error) {+ return {+ healthy: false,+ error: error instanceof Error ? error.message : 'Unknown error',+ timestamp: new Date(),+ };+ }+ }++ private buildRequest(request: LLMRequest): GeminiRequest {+ // Extract system message+ const systemMessage = request.messages.find((m) => m.role === 'system');+ const otherMessages = request.messages.filter((m) => m.role !== 'system');++ // Transform messages+ const contents = otherMessages.map((msg) => ({+ role: msg.role === 'assistant' ? 'model' as const : 'user' as const,+ parts: [{ text: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content) }],+ }));++ const geminiRequest: GeminiRequest = { contents };++ if (systemMessage) {+ geminiRequest.systemInstruction = {+ parts: [{+ text: typeof systemMessage.content === 'string'+ ? systemMessage.content+ : JSON.stringify(systemMessage.content),+ }],+ };+ }++ const generationConfig: GeminiRequest['generationConfig'] = {};++ if (request.temperature !== undefined || this.config.temperature !== undefined) {+ generationConfig.temperature = request.temperature ?? this.config.temperature;+ }+ if (request.topP !== undefined || this.config.topP !== undefined) {+ generationConfig.topP = request.topP ?? this.config.topP;+ }+ if (request.topK !== undefined || this.config.topK !== undefined) {+ generationConfig.topK = request.topK ?? this.config.topK;+ }+ if (request.maxTokens || this.config.maxTokens) {+ generationConfig.maxOutputTokens = request.maxTokens || this.config.maxTokens;+ }+ if (request.stopSequences || this.config.stopSequences) {+ generationConfig.stopSequences = request.stopSequences || this.config.stopSequences;+ }++ if (Object.keys(generationConfig).length > 0) {+ geminiRequest.generationConfig = generationConfig;+ }++ if (request.tools) {+ geminiRequest.tools = [{+ functionDeclarations: request.tools.map((tool) => ({+ name: tool.function.name,+ description: tool.function.description,+ parameters: tool.function.parameters,+ })),+ }];+ }++ return geminiRequest;+ }++ private transformResponse(data: GeminiResponse, request: LLMRequest): LLMResponse {+ const candidate = data.candidates[0];+ const model = request.model || this.config.model;+ const pricing = this.capabilities.pricing[model];++ const textParts = candidate.content.parts.filter((p) => p.text);+ const content = textParts.map((p) => p.text).join('');++ const toolCalls = candidate.content.parts+ .filter((p) => p.functionCall)+ .map((p) => ({+ id: `tool_${Date.now()}`,+ type: 'function' as const,+ function: {+ name: p.functionCall!.name,+ arguments: JSON.stringify(p.functionCall!.args),+ },+ }));++ const promptCost = (data.usageMetadata.promptTokenCount / 1000) * pricing.promptCostPer1k;+ const completionCost =+ (data.usageMetadata.candidatesTokenCount / 1000) * pricing.completionCostPer1k;++ return {+ id: `gemini-${Date.now()}`,+ model: model as LLMModel,+ provider: 'google',+ content,+ toolCalls: toolCalls.length > 0 ? toolCalls : undefined,+ usage: {+ promptTokens: data.usageMetadata.promptTokenCount,+ completionTokens: data.usageMetadata.candidatesTokenCount,+ totalTokens: data.usageMetadata.totalTokenCount,+ },+ cost: {+ promptCost,+ completionCost,+ totalCost: promptCost + completionCost,+ currency: 'USD',+ },+ finishReason: candidate.finishReason === 'STOP' ? 'stop' : 'length',+ };+ }++ private async handleErrorResponse(response: Response): Promise<never> {+ const errorText = await response.text();+ let errorData: { error?: { message?: string } };++ try {+ errorData = JSON.parse(errorText);+ } catch {+ errorData = { error: { message: errorText } };+ }++ const message = errorData.error?.message || 'Unknown error';++ switch (response.status) {+ case 401:+ case 403:+ throw new AuthenticationError(message, 'google', errorData);+ case 429:+ throw new RateLimitError(message, 'google', undefined, errorData);+ default:+ throw new LLMProviderError(+ message,+ `GOOGLE_${response.status}`,+ 'google',+ response.status,+ response.status >= 500,+ errorData+ );+ }+ }+}diff --git a/v3/@claude-flow/providers/src/index.ts b/v3/@claude-flow/providers/src/index.tsnew file mode 100644index 0000000000..335742ca42--- /dev/null+++ b/v3/@claude-flow/providers/src/index.ts@@ -0,0 +1,40 @@+/**+ * @claude-flow/providers+ *+ * Multi-LLM Provider System for Claude Flow V3+ *+ * Supports:+ * - Anthropic (Claude 3.5, 3 Opus, Sonnet, Haiku)+ * - OpenAI (GPT-4o, o1, GPT-4, GPT-3.5)+ * - Google (Gemini 2.0, 1.5 Pro, Flash)+ * - Cohere (Command R+, R, Light)+ * - Ollama (Local: Llama, Mistral, CodeLlama, Phi)+ *+ * Features:+ * - Load balancing (round-robin, latency, cost-based)+ * - Automatic failover+ * - Request caching+ * - Cost optimization (85%+ savings with intelligent routing)+ * - Circuit breaker protection+ * - Health monitoring+ *+ * @module @claude-flow/providers+ */++// Export types+export * from './types.js';++// Export base provider+export { BaseProvider, consoleLogger } from './base-provider.js';+export type { BaseProviderOptions, ILogger } from './base-provider.js';++// Export providers+export { AnthropicProvider } from './anthropic-provider.js';+export { OpenAIProvider } from './openai-provider.js';+export { GoogleProvider } from './google-provider.js';+export { CohereProvider } from './cohere-provider.js';+export { OllamaProvider } from './ollama-provider.js';+export { RuVectorProvider } from './ruvector-provider.js';++// Export provider manager+export { ProviderManager, createProviderManager } from './provider-manager.js';diff --git a/v3/@claude-flow/providers/src/ollama-provider.ts b/v3/@claude-flow/providers/src/ollama-provider.tsnew file mode 100644index 0000000000..ad398c9bac--- /dev/null+++ b/v3/@claude-flow/providers/src/ollama-provider.ts@@ -0,0 +1,408 @@+/**+ * V3 Ollama Provider (Local Models)+ *+ * Supports Llama, Mistral, CodeLlama, Phi, and other local models.+ * Zero cost - runs entirely locally.+ *+ * @module @claude-flow/providers/ollama-provider+ */++import { BaseProvider, BaseProviderOptions } from './base-provider.js';+import {+ LLMProvider,+ LLMModel,+ LLMRequest,+ LLMResponse,+ LLMStreamEvent,+ ModelInfo,+ ProviderCapabilities,+ HealthCheckResult,+ ProviderUnavailableError,+ LLMProviderError,+} from './types.js';++interface OllamaRequest {+ model: string;+ messages: Array<{+ role: 'system' | 'user' | 'assistant';+ content: string;+ }>;+ options?: {+ temperature?: number;+ top_p?: number;+ top_k?: number;+ num_predict?: number;+ stop?: string[];+ };+ stream?: boolean;+ tools?: Array<{+ type: 'function';+ function: {+ name: string;+ description: string;+ parameters: unknown;+ };+ }>;+}++interface OllamaResponse {+ model: string;+ created_at: string;+ message: {+ role: string;+ content: string;+ tool_calls?: Array<{+ function: { name: string; arguments: unknown };+ }>;+ };+ done: boolean;+ total_duration?: number;+ load_duration?: number;+ prompt_eval_count?: number;+ prompt_eval_duration?: number;+ eval_count?: number;+ eval_duration?: number;+}++export class OllamaProvider extends BaseProvider {+ readonly name: LLMProvider = 'ollama';+ readonly capabilities: ProviderCapabilities = {+ supportedModels: [+ 'llama3.2',+ 'llama3.1',+ 'mistral',+ 'mixtral',+ 'codellama',+ 'phi-4',+ 'deepseek-coder',+ ],+ maxContextLength: {+ 'llama3.2': 128000,+ 'llama3.1': 128000,+ 'mistral': 32000,+ 'mixtral': 32000,+ 'codellama': 16000,+ 'phi-4': 16000,+ 'deepseek-coder': 16000,+ },+ maxOutputTokens: {+ 'llama3.2': 8192,+ 'llama3.1': 8192,+ 'mistral': 8192,+ 'mixtral': 8192,+ 'codellama': 8192,+ 'phi-4': 8192,+ 'deepseek-coder': 8192,+ },+ supportsStreaming: true,+ supportsToolCalling: true,+ supportsSystemMessages: true,+ supportsVision: true, // Some models+ supportsAudio: false,+ supportsFineTuning: false,+ supportsEmbeddings: true,+ supportsBatching: false,+ rateLimit: {+ requestsPerMinute: 10000, // Local - no rate limit+ tokensPerMinute: 10000000,+ concurrentRequests: 10,+ },+ // All free - local execution+ pricing: {+ 'llama3.2': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'llama3.1': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'mistral': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'mixtral': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'codellama': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'phi-4': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'deepseek-coder': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ },+ };++ private baseUrl: string = 'http://localhost:11434';++ constructor(options: BaseProviderOptions) {+ super(options);+ }++ protected async doInitialize(): Promise<void> {+ this.baseUrl = this.config.apiUrl || 'http://localhost:11434';++ // Check if Ollama is running+ const health = await this.doHealthCheck();+ if (!health.healthy) {+ this.logger.warn('Ollama server not detected. Ensure Ollama is running locally.');+ }+ }++ protected async doComplete(request: LLMRequest): Promise<LLMResponse> {+ const ollamaRequest = this.buildRequest(request);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), this.config.timeout || 120000);++ try {+ const response = await fetch(`${this.baseUrl}/api/chat`, {+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify(ollamaRequest),+ signal: controller.signal,+ });++ clearTimeout(timeout);++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const data = await response.json() as OllamaResponse;+ return this.transformResponse(data, request);+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ }+ }++ protected async *doStreamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent> {+ const ollamaRequest = this.buildRequest(request, true);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), (this.config.timeout || 120000) * 2);++ try {+ const response = await fetch(`${this.baseUrl}/api/chat`, {+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify(ollamaRequest),+ signal: controller.signal,+ });++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const reader = response.body!.getReader();+ const decoder = new TextDecoder();+ let buffer = '';+ let promptTokens = 0;+ let completionTokens = 0;++ while (true) {+ const { done, value } = await reader.read();+ if (done) break;++ buffer += decoder.decode(value, { stream: true });+ const lines = buffer.split('\n');+ buffer = lines.pop() || '';++ for (const line of lines) {+ if (!line.trim()) continue;++ try {+ const chunk: OllamaResponse = JSON.parse(line);++ if (chunk.message?.content) {+ yield {+ type: 'content',+ delta: { content: chunk.message.content },+ };+ }++ if (chunk.done) {+ promptTokens = chunk.prompt_eval_count || 0;+ completionTokens = chunk.eval_count || 0;++ yield {+ type: 'done',+ usage: {+ promptTokens,+ completionTokens,+ totalTokens: promptTokens + completionTokens,+ },+ cost: {+ promptCost: 0,+ completionCost: 0,+ totalCost: 0,+ currency: 'USD',+ },+ };+ }+ } catch {+ // Ignore parse errors+ }+ }+ }+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ } finally {+ clearTimeout(timeout);+ }+ }++ async listModels(): Promise<LLMModel[]> {+ try {+ const response = await fetch(`${this.baseUrl}/api/tags`);+ if (!response.ok) {+ return this.capabilities.supportedModels;+ }++ const data = await response.json() as { models?: Array<{ name: string }> };+ return data.models?.map((m) => m.name as LLMModel) || this.capabilities.supportedModels;+ } catch {+ return this.capabilities.supportedModels;+ }+ }++ async getModelInfo(model: LLMModel): Promise<ModelInfo> {+ const descriptions: Record<string, string> = {+ 'llama3.2': 'Meta Llama 3.2 - Fast and capable',+ 'llama3.1': 'Meta Llama 3.1 - High performance',+ 'mistral': 'Mistral 7B - Efficient and fast',+ 'mixtral': 'Mixtral 8x7B - Mixture of experts',+ 'codellama': 'Code Llama - Optimized for code',+ 'phi-4': 'Microsoft Phi-4 - Small but powerful',+ 'deepseek-coder': 'DeepSeek Coder - Code specialist',+ };++ return {+ model,+ name: model,+ description: descriptions[model] || 'Local Ollama model',+ contextLength: this.capabilities.maxContextLength[model] || 8192,+ maxOutputTokens: this.capabilities.maxOutputTokens[model] || 4096,+ supportedFeatures: ['chat', 'completion', 'local'],+ pricing: { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ };+ }++ protected async doHealthCheck(): Promise<HealthCheckResult> {+ try {+ const response = await fetch(`${this.baseUrl}/api/tags`);++ return {+ healthy: response.ok,+ timestamp: new Date(),+ details: {+ server: 'ollama',+ local: true,+ },+ ...(response.ok ? {} : { error: `HTTP ${response.status}` }),+ };+ } catch (error) {+ return {+ healthy: false,+ error: error instanceof Error ? error.message : 'Ollama server not reachable',+ timestamp: new Date(),+ details: {+ hint: 'Ensure Ollama is running: ollama serve',+ },+ };+ }+ }++ private buildRequest(request: LLMRequest, stream = false): OllamaRequest {+ const ollamaRequest: OllamaRequest = {+ model: request.model || this.config.model,+ messages: request.messages.map((msg) => ({+ role: msg.role === 'tool' ? 'assistant' : msg.role,+ content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),+ })),+ stream,+ };++ const options: OllamaRequest['options'] = {};++ if (request.temperature !== undefined || this.config.temperature !== undefined) {+ options.temperature = request.temperature ?? this.config.temperature;+ }+ if (request.topP !== undefined || this.config.topP !== undefined) {+ options.top_p = request.topP ?? this.config.topP;+ }+ if (request.topK !== undefined || this.config.topK !== undefined) {+ options.top_k = request.topK ?? this.config.topK;+ }+ if (request.maxTokens || this.config.maxTokens) {+ options.num_predict = request.maxTokens || this.config.maxTokens;+ }+ if (request.stopSequences || this.config.stopSequences) {+ options.stop = request.stopSequences || this.config.stopSequences;+ }++ if (Object.keys(options).length > 0) {+ ollamaRequest.options = options;+ }++ if (request.tools) {+ ollamaRequest.tools = request.tools;+ }++ return ollamaRequest;+ }++ private transformResponse(data: OllamaResponse, request: LLMRequest): LLMResponse {+ const model = request.model || this.config.model;++ const promptTokens = data.prompt_eval_count || 0;+ const completionTokens = data.eval_count || 0;++ const toolCalls = data.message.tool_calls?.map((tc) => ({+ id: `tool_${Date.now()}`,+ type: 'function' as const,+ function: {+ name: tc.function.name,+ arguments: JSON.stringify(tc.function.arguments),+ },+ }));++ return {+ id: `ollama-${Date.now()}`,+ model: model as LLMModel,+ provider: 'ollama',+ content: data.message.content,+ toolCalls: toolCalls?.length ? toolCalls : undefined,+ usage: {+ promptTokens,+ completionTokens,+ totalTokens: promptTokens + completionTokens,+ },+ cost: {+ promptCost: 0,+ completionCost: 0,+ totalCost: 0,+ currency: 'USD',+ },+ finishReason: data.done ? 'stop' : 'length',+ latency: data.total_duration ? data.total_duration / 1e6 : undefined, // Convert ns to ms+ };+ }++ private async handleErrorResponse(response: Response): Promise<never> {+ const errorText = await response.text();+ let errorData: { error?: string };++ try {+ errorData = JSON.parse(errorText);+ } catch {+ errorData = { error: errorText };+ }++ const message = errorData.error || 'Unknown error';++ if (response.status === 0 || message.includes('connection')) {+ throw new ProviderUnavailableError('ollama', {+ message,+ hint: 'Ensure Ollama is running: ollama serve',+ });+ }++ throw new LLMProviderError(+ message,+ `OLLAMA_${response.status}`,+ 'ollama',+ response.status,+ true,+ errorData+ );+ }+}diff --git a/v3/@claude-flow/providers/src/openai-provider.ts b/v3/@claude-flow/providers/src/openai-provider.tsnew file mode 100644index 0000000000..b3e1de1a52--- /dev/null+++ b/v3/@claude-flow/providers/src/openai-provider.ts@@ -0,0 +1,490 @@+/**+ * V3 OpenAI Provider+ *+ * Supports GPT-4o, GPT-4, o1, and other OpenAI models.+ *+ * @module @claude-flow/providers/openai-provider+ */++import { BaseProvider, BaseProviderOptions } from './base-provider.js';+import {+ LLMProvider,+ LLMModel,+ LLMRequest,+ LLMResponse,+ LLMStreamEvent,+ ModelInfo,+ ProviderCapabilities,+ HealthCheckResult,+ AuthenticationError,+ RateLimitError,+ ModelNotFoundError,+ LLMProviderError,+} from './types.js';++interface OpenAIRequest {+ model: string;+ messages: Array<{+ role: 'system' | 'user' | 'assistant' | 'tool';+ content: string;+ name?: string;+ tool_call_id?: string;+ tool_calls?: Array<{+ id: string;+ type: 'function';+ function: { name: string; arguments: string };+ }>;+ }>;+ temperature?: number;+ max_tokens?: number;+ top_p?: number;+ frequency_penalty?: number;+ presence_penalty?: number;+ stop?: string[];+ stream?: boolean;+ tools?: Array<{+ type: 'function';+ function: {+ name: string;+ description: string;+ parameters: unknown;+ };+ }>;+ tool_choice?: 'auto' | 'none' | 'required' | { type: 'function'; function: { name: string } };+}++interface OpenAIResponse {+ id: string;+ object: string;+ created: number;+ model: string;+ choices: Array<{+ index: number;+ message: {+ role: string;+ content: string | null;+ tool_calls?: Array<{+ id: string;+ type: 'function';+ function: { name: string; arguments: string };+ }>;+ };+ finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter';+ }>;+ usage: {+ prompt_tokens: number;+ completion_tokens: number;+ total_tokens: number;+ };+}++export class OpenAIProvider extends BaseProvider {+ readonly name: LLMProvider = 'openai';+ readonly capabilities: ProviderCapabilities = {+ supportedModels: [+ 'gpt-4o',+ 'gpt-4o-mini',+ 'gpt-4-turbo',+ 'gpt-4',+ 'gpt-3.5-turbo',+ 'o1-preview',+ 'o1-mini',+ 'o3-mini',+ ],+ maxContextLength: {+ 'gpt-4o': 128000,+ 'gpt-4o-mini': 128000,+ 'gpt-4-turbo': 128000,+ 'gpt-4': 8192,+ 'gpt-3.5-turbo': 16384,+ 'o1-preview': 128000,+ 'o1-mini': 128000,+ 'o3-mini': 200000,+ },+ maxOutputTokens: {+ 'gpt-4o': 16384,+ 'gpt-4o-mini': 16384,+ 'gpt-4-turbo': 4096,+ 'gpt-4': 8192,+ 'gpt-3.5-turbo': 4096,+ 'o1-preview': 32768,+ 'o1-mini': 65536,+ 'o3-mini': 100000,+ },+ supportsStreaming: true,+ supportsToolCalling: true,+ supportsSystemMessages: true,+ supportsVision: true,+ supportsAudio: true,+ supportsFineTuning: true,+ supportsEmbeddings: true,+ supportsBatching: true,+ rateLimit: {+ requestsPerMinute: 10000,+ tokensPerMinute: 2000000,+ concurrentRequests: 500,+ },+ pricing: {+ 'gpt-4o': {+ promptCostPer1k: 0.0025,+ completionCostPer1k: 0.01,+ currency: 'USD',+ },+ 'gpt-4o-mini': {+ promptCostPer1k: 0.00015,+ completionCostPer1k: 0.0006,+ currency: 'USD',+ },+ 'gpt-4-turbo': {+ promptCostPer1k: 0.01,+ completionCostPer1k: 0.03,+ currency: 'USD',+ },+ 'gpt-4': {+ promptCostPer1k: 0.03,+ completionCostPer1k: 0.06,+ currency: 'USD',+ },+ 'gpt-3.5-turbo': {+ promptCostPer1k: 0.0005,+ completionCostPer1k: 0.0015,+ currency: 'USD',+ },+ 'o1-preview': {+ promptCostPer1k: 0.015,+ completionCostPer1k: 0.06,+ currency: 'USD',+ },+ 'o1-mini': {+ promptCostPer1k: 0.003,+ completionCostPer1k: 0.012,+ currency: 'USD',+ },+ 'o3-mini': {+ promptCostPer1k: 0.0011,+ completionCostPer1k: 0.0044,+ currency: 'USD',+ },+ },+ };++ private baseUrl: string = 'https://api.openai.com/v1';+ private headers: Record<string, string> = {};++ constructor(options: BaseProviderOptions) {+ super(options);+ }++ protected async doInitialize(): Promise<void> {+ if (!this.config.apiKey) {+ throw new AuthenticationError('OpenAI API key is required', 'openai');+ }++ this.baseUrl = this.config.apiUrl || 'https://api.openai.com/v1';+ this.headers = {+ Authorization: `Bearer ${this.config.apiKey}`,+ 'Content-Type': 'application/json',+ };++ if (this.config.providerOptions?.organization) {+ this.headers['OpenAI-Organization'] = this.config.providerOptions.organization as string;+ }+ }++ protected async doComplete(request: LLMRequest): Promise<LLMResponse> {+ const openAIRequest = this.buildRequest(request);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), this.config.timeout || 60000);++ try {+ const response = await fetch(`${this.baseUrl}/chat/completions`, {+ method: 'POST',+ headers: this.headers,+ body: JSON.stringify(openAIRequest),+ signal: controller.signal,+ });++ clearTimeout(timeout);++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const data = await response.json() as OpenAIResponse;+ return this.transformResponse(data, request);+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ }+ }++ protected async *doStreamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent> {+ const openAIRequest = this.buildRequest(request, true);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), (this.config.timeout || 60000) * 2);++ try {+ const response = await fetch(`${this.baseUrl}/chat/completions`, {+ method: 'POST',+ headers: this.headers,+ body: JSON.stringify(openAIRequest),+ signal: controller.signal,+ });++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const reader = response.body!.getReader();+ const decoder = new TextDecoder();+ let buffer = '';++ while (true) {+ const { done, value } = await reader.read();+ if (done) break;++ buffer += decoder.decode(value, { stream: true });+ const lines = buffer.split('\n');+ buffer = lines.pop() || '';++ for (const line of lines) {+ if (line.startsWith('data: ')) {+ const data = line.slice(6);+ if (data === '[DONE]') {+ // Estimate final usage+ const promptTokens = this.estimateTokens(JSON.stringify(request.messages));+ const model = request.model || this.config.model;+ const baseModel = model.includes('/') ? model.split('/').pop()! : model;+ const pricing = this.capabilities.pricing[model] || this.capabilities.pricing[baseModel];+ const promptCostPer1k = pricing?.promptCostPer1k ?? 0;+ const completionCostPer1k = pricing?.completionCostPer1k ?? 0;++ yield {+ type: 'done',+ usage: {+ promptTokens,+ completionTokens: 100, // Estimate+ totalTokens: promptTokens + 100,+ },+ cost: {+ promptCost: (promptTokens / 1000) * promptCostPer1k,+ completionCost: (100 / 1000) * completionCostPer1k,+ totalCost:+ (promptTokens / 1000) * promptCostPer1k ++ (100 / 1000) * completionCostPer1k,+ currency: 'USD',+ },+ };+ continue;+ }++ try {+ const chunk = JSON.parse(data);+ const delta = chunk.choices?.[0]?.delta;++ if (delta?.content) {+ yield {+ type: 'content',+ delta: { content: delta.content },+ };+ }++ if (delta?.tool_calls) {+ for (const toolCall of delta.tool_calls) {+ yield {+ type: 'tool_call',+ delta: {+ toolCall: {+ id: toolCall.id,+ type: 'function',+ function: toolCall.function,+ },+ },+ };+ }+ }+ } catch {+ // Ignore parse errors+ }+ }+ }+ }+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ } finally {+ clearTimeout(timeout);+ }+ }++ async listModels(): Promise<LLMModel[]> {+ return this.capabilities.supportedModels;+ }++ async getModelInfo(model: LLMModel): Promise<ModelInfo> {+ const descriptions: Record<string, string> = {+ 'gpt-4o': 'Most capable GPT-4 model with vision and audio',+ 'gpt-4o-mini': 'Affordable and intelligent small model',+ 'gpt-4-turbo': 'GPT-4 Turbo with vision',+ 'gpt-4': 'High capability model',+ 'gpt-3.5-turbo': 'Fast and efficient model',+ 'o1-preview': 'Reasoning model for complex tasks',+ 'o1-mini': 'Fast reasoning model',+ 'o3-mini': 'Latest reasoning model',+ };++ return {+ model,+ name: model,+ description: descriptions[model] || 'OpenAI language model',+ contextLength: this.capabilities.maxContextLength[model] || 8192,+ maxOutputTokens: this.capabilities.maxOutputTokens[model] || 4096,+ supportedFeatures: [+ 'chat',+ 'completion',+ 'tool_calling',+ ...(model.includes('gpt-4') ? ['vision'] : []),+ ],+ pricing: this.capabilities.pricing[model],+ };+ }++ protected async doHealthCheck(): Promise<HealthCheckResult> {+ try {+ const response = await fetch(`${this.baseUrl}/models`, {+ headers: this.headers,+ });++ return {+ healthy: response.ok,+ timestamp: new Date(),+ ...(response.ok ? {} : { error: `HTTP ${response.status}` }),+ };+ } catch (error) {+ return {+ healthy: false,+ error: error instanceof Error ? error.message : 'Unknown error',+ timestamp: new Date(),+ };+ }+ }++ private buildRequest(request: LLMRequest, stream = false): OpenAIRequest {+ const openAIRequest: OpenAIRequest = {+ model: request.model || this.config.model,+ messages: request.messages.map((msg) => ({+ role: msg.role,+ content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),+ ...(msg.name && { name: msg.name }),+ ...(msg.toolCallId && { tool_call_id: msg.toolCallId }),+ ...(msg.toolCalls && { tool_calls: msg.toolCalls }),+ })),+ stream,+ };++ if (request.temperature !== undefined || this.config.temperature !== undefined) {+ openAIRequest.temperature = request.temperature ?? this.config.temperature;+ }++ if (request.maxTokens || this.config.maxTokens) {+ openAIRequest.max_tokens = request.maxTokens || this.config.maxTokens;+ }++ if (request.topP !== undefined || this.config.topP !== undefined) {+ openAIRequest.top_p = request.topP ?? this.config.topP;+ }++ if (request.frequencyPenalty !== undefined || this.config.frequencyPenalty !== undefined) {+ openAIRequest.frequency_penalty = request.frequencyPenalty ?? this.config.frequencyPenalty;+ }++ if (request.presencePenalty !== undefined || this.config.presencePenalty !== undefined) {+ openAIRequest.presence_penalty = request.presencePenalty ?? this.config.presencePenalty;+ }++ if (request.stopSequences || this.config.stopSequences) {+ openAIRequest.stop = request.stopSequences || this.config.stopSequences;+ }++ if (request.tools) {+ openAIRequest.tools = request.tools;+ openAIRequest.tool_choice = request.toolChoice;+ }++ return openAIRequest;+ }++ private transformResponse(data: OpenAIResponse, request: LLMRequest): LLMResponse {+ const choice = data.choices[0];+ const model = request.model || this.config.model;+ // Handle OpenRouter and other compatible APIs with different model naming+ const baseModel = model.includes('/') ? model.split('/').pop()! : model;+ const pricing = this.capabilities.pricing[model] || this.capabilities.pricing[baseModel];++ // Default pricing if model not found+ const promptCostPer1k = pricing?.promptCostPer1k ?? 0;+ const completionCostPer1k = pricing?.completionCostPer1k ?? 0;++ const promptCost = (data.usage.prompt_tokens / 1000) * promptCostPer1k;+ const completionCost = (data.usage.completion_tokens / 1000) * completionCostPer1k;++ return {+ id: data.id,+ model: model as LLMModel,+ provider: 'openai',+ content: choice.message.content || '',+ toolCalls: choice.message.tool_calls,+ usage: {+ promptTokens: data.usage.prompt_tokens,+ completionTokens: data.usage.completion_tokens,+ totalTokens: data.usage.total_tokens,+ },+ cost: {+ promptCost,+ completionCost,+ totalCost: promptCost + completionCost,+ currency: 'USD',+ },+ finishReason: choice.finish_reason,+ };+ }++ private async handleErrorResponse(response: Response): Promise<never> {+ const errorText = await response.text();+ let errorData: { error?: { message?: string } };++ try {+ errorData = JSON.parse(errorText);+ } catch {+ errorData = { error: { message: errorText } };+ }++ const message = errorData.error?.message || 'Unknown error';++ switch (response.status) {+ case 401:+ throw new AuthenticationError(message, 'openai', errorData);+ case 429:+ const retryAfter = response.headers.get('retry-after');+ throw new RateLimitError(+ message,+ 'openai',+ retryAfter ? parseInt(retryAfter) : undefined,+ errorData+ );+ case 404:+ throw new ModelNotFoundError(this.config.model, 'openai', errorData);+ default:+ throw new LLMProviderError(+ message,+ `OPENAI_${response.status}`,+ 'openai',+ response.status,+ response.status >= 500,+ errorData+ );+ }+ }+}diff --git a/v3/@claude-flow/providers/src/provider-manager.ts b/v3/@claude-flow/providers/src/provider-manager.tsnew file mode 100644index 0000000000..506185afa6--- /dev/null+++ b/v3/@claude-flow/providers/src/provider-manager.ts@@ -0,0 +1,538 @@+/**+ * V3 Provider Manager+ *+ * Orchestrates multiple LLM providers with:+ * - Load balancing (round-robin, latency-based, cost-based)+ * - Automatic failover+ * - Request caching+ * - Cost optimization+ *+ * @module @claude-flow/providers/provider-manager+ */++import { EventEmitter } from 'events';+import {+ ILLMProvider,+ LLMProvider,+ LLMProviderConfig,+ LLMRequest,+ LLMResponse,+ LLMStreamEvent,+ LLMModel,+ ProviderManagerConfig,+ LoadBalancingStrategy,+ HealthCheckResult,+ CostEstimate,+ UsageStats,+ UsagePeriod,+ LLMProviderError,+ isLLMProviderError,+} from './types.js';+import { BaseProviderOptions, ILogger, consoleLogger } from './base-provider.js';+import { AnthropicProvider } from './anthropic-provider.js';+import { OpenAIProvider } from './openai-provider.js';+import { GoogleProvider } from './google-provider.js';+import { CohereProvider } from './cohere-provider.js';+import { OllamaProvider } from './ollama-provider.js';+import { RuVectorProvider } from './ruvector-provider.js';++/**+ * Cache entry for request caching+ */+interface CacheEntry {+ response: LLMResponse;+ timestamp: number;+ hits: number;+}++/**+ * Provider metrics for load balancing+ */+interface ProviderMetrics {+ latency: number;+ errorRate: number;+ cost: number;+ lastUsed: number;+}++/**+ * Provider Manager - Orchestrates multiple LLM providers+ */+export class ProviderManager extends EventEmitter {+ private providers: Map<LLMProvider, ILLMProvider> = new Map();+ private cache: Map<string, CacheEntry> = new Map();+ private metrics: Map<LLMProvider, ProviderMetrics> = new Map();+ private roundRobinIndex = 0;+ private logger: ILogger;++ constructor(+ private config: ProviderManagerConfig,+ logger?: ILogger+ ) {+ super();+ this.logger = logger || consoleLogger;+ }++ /**+ * Initialize all configured providers+ */+ async initialize(): Promise<void> {+ this.logger.info('Initializing provider manager', {+ providerCount: this.config.providers.length,+ });++ const initPromises = this.config.providers.map(async (providerConfig) => {+ try {+ const provider = this.createProvider(providerConfig);+ await provider.initialize();+ this.providers.set(providerConfig.provider, provider);+ this.metrics.set(providerConfig.provider, {+ latency: 0,+ errorRate: 0,+ cost: 0,+ lastUsed: 0,+ });+ this.logger.info(`Provider ${providerConfig.provider} initialized`);+ } catch (error) {+ this.logger.error(`Failed to initialize ${providerConfig.provider}`, error);+ }+ });++ await Promise.all(initPromises);++ this.logger.info('Provider manager initialized', {+ activeProviders: Array.from(this.providers.keys()),+ });+ }++ /**+ * Create a provider instance+ */+ private createProvider(config: LLMProviderConfig): ILLMProvider {+ const options: BaseProviderOptions = {+ config,+ logger: this.logger,+ };++ switch (config.provider) {+ case 'anthropic':+ return new AnthropicProvider(options);+ case 'openai':+ return new OpenAIProvider(options);+ case 'google':+ return new GoogleProvider(options);+ case 'cohere':+ return new CohereProvider(options);+ case 'ollama':+ return new OllamaProvider(options);+ case 'ruvector':+ return new RuVectorProvider(options);+ default:+ throw new Error(`Unknown provider: ${config.provider}`);+ }+ }++ /**+ * Complete a request with automatic provider selection+ */+ async complete(request: LLMRequest, preferredProvider?: LLMProvider): Promise<LLMResponse> {+ // Check cache first+ if (this.config.cache?.enabled) {+ const cached = this.getCached(request);+ if (cached) {+ this.logger.debug('Cache hit', { requestId: request.requestId });+ return cached;+ }+ }++ // Select provider+ const provider = preferredProvider+ ? this.providers.get(preferredProvider)+ : await this.selectProvider(request);++ if (!provider) {+ throw new Error('No available providers');+ }++ const startTime = Date.now();++ try {+ const response = await provider.complete(request);+ this.updateMetrics(provider.name, Date.now() - startTime, false, response.cost?.totalCost || 0);++ // Cache response+ if (this.config.cache?.enabled) {+ this.setCached(request, response);+ }++ this.emit('complete', { provider: provider.name, response });+ return response;+ } catch (error) {+ this.updateMetrics(provider.name, Date.now() - startTime, true, 0);++ // Try fallback+ if (this.config.fallback?.enabled && isLLMProviderError(error)) {+ return this.completWithFallback(request, provider.name, error);+ }++ throw error;+ }+ }++ /**+ * Stream complete with automatic provider selection+ */+ async *streamComplete(+ request: LLMRequest,+ preferredProvider?: LLMProvider+ ): AsyncIterable<LLMStreamEvent> {+ const provider = preferredProvider+ ? this.providers.get(preferredProvider)+ : await this.selectProvider(request);++ if (!provider) {+ throw new Error('No available providers');+ }++ const startTime = Date.now();++ try {+ for await (const event of provider.streamComplete(request)) {+ yield event;+ }++ this.updateMetrics(provider.name, Date.now() - startTime, false, 0);+ } catch (error) {+ this.updateMetrics(provider.name, Date.now() - startTime, true, 0);+ throw error;+ }+ }++ /**+ * Select provider based on load balancing strategy+ */+ private async selectProvider(request: LLMRequest): Promise<ILLMProvider | undefined> {+ const availableProviders = Array.from(this.providers.values()).filter(+ (p) => p.getStatus().available+ );++ if (availableProviders.length === 0) {+ // Try to use any provider+ return this.providers.values().next().value;+ }++ const strategy = this.config.loadBalancing?.strategy || 'round-robin';++ switch (strategy) {+ case 'round-robin':+ return this.selectRoundRobin(availableProviders);+ case 'least-loaded':+ return this.selectLeastLoaded(availableProviders);+ case 'latency-based':+ return this.selectByLatency(availableProviders);+ case 'cost-based':+ return this.selectByCost(availableProviders, request);+ default:+ return availableProviders[0];+ }+ }++ private selectRoundRobin(providers: ILLMProvider[]): ILLMProvider {+ const provider = providers[this.roundRobinIndex % providers.length];+ this.roundRobinIndex++;+ return provider;+ }++ private selectLeastLoaded(providers: ILLMProvider[]): ILLMProvider {+ return providers.reduce((best, current) =>+ current.getStatus().currentLoad < best.getStatus().currentLoad ? current : best+ );+ }++ private selectByLatency(providers: ILLMProvider[]): ILLMProvider {+ return providers.reduce((best, current) => {+ const bestMetrics = this.metrics.get(best.name);+ const currentMetrics = this.metrics.get(current.name);+ return (currentMetrics?.latency || Infinity) < (bestMetrics?.latency || Infinity)+ ? current+ : best;+ });+ }++ private async selectByCost(+ providers: ILLMProvider[],+ request: LLMRequest+ ): Promise<ILLMProvider> {+ const estimates = await Promise.all(+ providers.map(async (p) => ({+ provider: p,+ cost: (await p.estimateCost(request)).estimatedCost.total,+ }))+ );++ return estimates.reduce((best, current) =>+ current.cost < best.cost ? current : best+ ).provider;+ }++ /**+ * Complete with fallback on failure+ */+ private async completWithFallback(+ request: LLMRequest,+ failedProvider: LLMProvider,+ originalError: LLMProviderError+ ): Promise<LLMResponse> {+ const maxAttempts = this.config.fallback?.maxAttempts || 2;+ let attempts = 0;+ let lastError = originalError;++ const remainingProviders = Array.from(this.providers.values()).filter(+ (p) => p.name !== failedProvider+ );++ for (const provider of remainingProviders) {+ if (attempts >= maxAttempts) break;+ attempts++;++ this.logger.info(`Attempting fallback to ${provider.name}`, {+ attempt: attempts,+ originalProvider: failedProvider,+ });++ try {+ const response = await provider.complete(request);+ this.emit('fallback_success', {+ originalProvider: failedProvider,+ fallbackProvider: provider.name,+ attempts,+ });+ return response;+ } catch (error) {+ if (isLLMProviderError(error)) {+ lastError = error;+ }+ }+ }++ this.emit('fallback_exhausted', {+ originalProvider: failedProvider,+ attempts,+ });++ throw lastError;+ }++ /**+ * Update provider metrics+ */+ private updateMetrics(+ provider: LLMProvider,+ latency: number,+ error: boolean,+ cost: number+ ): void {+ const current = this.metrics.get(provider) || {+ latency: 0,+ errorRate: 0,+ cost: 0,+ lastUsed: 0,+ };++ // Exponential moving average for latency+ const alpha = 0.3;+ const newLatency = current.latency === 0 ? latency : alpha * latency + (1 - alpha) * current.latency;++ // Update error rate+ const errorWeight = error ? 1 : 0;+ const newErrorRate = alpha * errorWeight + (1 - alpha) * current.errorRate;++ this.metrics.set(provider, {+ latency: newLatency,+ errorRate: newErrorRate,+ cost: current.cost + cost,+ lastUsed: Date.now(),+ });+ }++ /**+ * Get cached response+ */+ private getCached(request: LLMRequest): LLMResponse | undefined {+ const key = this.getCacheKey(request);+ const entry = this.cache.get(key);++ if (!entry) return undefined;++ const ttl = this.config.cache?.ttl || 300000;+ if (Date.now() - entry.timestamp > ttl) {+ this.cache.delete(key);+ return undefined;+ }++ entry.hits++;+ return entry.response;+ }++ /**+ * Set cached response+ */+ private setCached(request: LLMRequest, response: LLMResponse): void {+ const key = this.getCacheKey(request);++ // Enforce max size+ const maxSize = this.config.cache?.maxSize || 1000;+ if (this.cache.size >= maxSize) {+ // Remove oldest entry+ const oldest = Array.from(this.cache.entries()).sort(+ (a, b) => a[1].timestamp - b[1].timestamp+ )[0];+ if (oldest) this.cache.delete(oldest[0]);+ }++ this.cache.set(key, {+ response,+ timestamp: Date.now(),+ hits: 0,+ });+ }++ /**+ * Generate cache key+ */+ private getCacheKey(request: LLMRequest): string {+ return JSON.stringify({+ messages: request.messages,+ model: request.model,+ temperature: request.temperature,+ maxTokens: request.maxTokens,+ });+ }++ /**+ * Get a specific provider+ */+ getProvider(name: LLMProvider): ILLMProvider | undefined {+ return this.providers.get(name);+ }++ /**+ * List all available providers+ */+ listProviders(): LLMProvider[] {+ return Array.from(this.providers.keys());+ }++ /**+ * Health check all providers+ */+ async healthCheck(): Promise<Map<LLMProvider, HealthCheckResult>> {+ const results = new Map<LLMProvider, HealthCheckResult>();++ await Promise.all(+ Array.from(this.providers.entries()).map(async ([name, provider]) => {+ const result = await provider.healthCheck();+ results.set(name, result);+ })+ );++ return results;+ }++ /**+ * Estimate cost across providers+ */+ async estimateCost(request: LLMRequest): Promise<Map<LLMProvider, CostEstimate>> {+ const estimates = new Map<LLMProvider, CostEstimate>();++ await Promise.all(+ Array.from(this.providers.entries()).map(async ([name, provider]) => {+ const estimate = await provider.estimateCost(request);+ estimates.set(name, estimate);+ })+ );++ return estimates;+ }++ /**+ * Get aggregated usage statistics+ */+ async getUsage(period: UsagePeriod = 'day'): Promise<UsageStats> {+ let totalRequests = 0;+ let totalTokens = { prompt: 0, completion: 0, total: 0 };+ let totalCost = { prompt: 0, completion: 0, total: 0 };+ let totalErrors = 0;+ let totalLatency = 0;+ let count = 0;++ for (const provider of this.providers.values()) {+ const usage = await provider.getUsage(period);+ totalRequests += usage.requests;+ totalTokens.prompt += usage.tokens.prompt;+ totalTokens.completion += usage.tokens.completion;+ totalTokens.total += usage.tokens.total;+ totalCost.prompt += usage.cost.prompt;+ totalCost.completion += usage.cost.completion;+ totalCost.total += usage.cost.total;+ totalErrors += usage.errors;+ totalLatency += usage.averageLatency;+ count++;+ }++ const now = new Date();+ const start = new Date();+ start.setDate(start.getDate() - 1);++ return {+ period: { start, end: now },+ requests: totalRequests,+ tokens: totalTokens,+ cost: { ...totalCost, currency: 'USD' },+ errors: totalErrors,+ averageLatency: count > 0 ? totalLatency / count : 0,+ modelBreakdown: {},+ };+ }++ /**+ * Get provider metrics+ */+ getMetrics(): Map<LLMProvider, ProviderMetrics> {+ return new Map(this.metrics);+ }++ /**+ * Clear cache+ */+ clearCache(): void {+ this.cache.clear();+ this.logger.info('Cache cleared');+ }++ /**+ * Destroy all providers+ */+ destroy(): void {+ for (const provider of this.providers.values()) {+ provider.destroy();+ }+ this.providers.clear();+ this.cache.clear();+ this.metrics.clear();+ this.removeAllListeners();+ this.logger.info('Provider manager destroyed');+ }+}++/**+ * Create and initialize a provider manager+ */+export async function createProviderManager(+ config: ProviderManagerConfig,+ logger?: ILogger+): Promise<ProviderManager> {+ const manager = new ProviderManager(config, logger);+ await manager.initialize();+ return manager;+}diff --git a/v3/@claude-flow/providers/src/ruvector-provider.ts b/v3/@claude-flow/providers/src/ruvector-provider.tsnew file mode 100644index 0000000000..e5e74b88ae--- /dev/null+++ b/v3/@claude-flow/providers/src/ruvector-provider.ts@@ -0,0 +1,579 @@+/**+ * V3 RuVector Provider (via @ruvector/ruvllm)+ *+ * Self-learning LLM orchestration with:+ * - SONA adaptive learning+ * - HNSW vector memory+ * - FastGRNN intelligent routing+ * - SIMD inference optimization+ * - Local model execution (free)+ *+ * @module @claude-flow/providers/ruvector-provider+ */++import { BaseProvider, BaseProviderOptions } from './base-provider.js';+import {+ LLMProvider,+ LLMModel,+ LLMRequest,+ LLMResponse,+ LLMStreamEvent,+ ModelInfo,+ ProviderCapabilities,+ HealthCheckResult,+ ProviderUnavailableError,+ LLMProviderError,+} from './types.js';++/**+ * RuVector LLM configuration+ */+interface RuVectorConfig {+ /** Enable SONA self-learning (default: true) */+ enableSona?: boolean;+ /** SONA learning rate (default: 0.01) */+ sonaLearningRate?: number;+ /** Enable HNSW vector memory (default: true) */+ enableHnsw?: boolean;+ /** HNSW M parameter for graph construction */+ hnswM?: number;+ /** HNSW ef_construction parameter */+ hnswEfConstruction?: number;+ /** Enable FastGRNN routing (default: true) */+ enableFastGrnn?: boolean;+ /** Inference mode: 'simd' | 'standard' */+ inferenceMode?: 'simd' | 'standard';+ /** Router strategy */+ routerStrategy?: 'cost' | 'quality' | 'balanced' | 'speed';+}++interface RuVectorRequest {+ model: string;+ messages: Array<{+ role: 'system' | 'user' | 'assistant';+ content: string;+ }>;+ max_tokens?: number;+ temperature?: number;+ top_p?: number;+ stream?: boolean;+ sona_options?: {+ enabled: boolean;+ learning_rate: number;+ adapt_on_response: boolean;+ };+ router_options?: {+ strategy: string;+ fallback_models: string[];+ };+}++interface RuVectorResponse {+ id: string;+ model: string;+ content: string;+ usage: {+ prompt_tokens: number;+ completion_tokens: number;+ total_tokens: number;+ };+ sona_metrics?: {+ adaptation_applied: boolean;+ quality_score: number;+ patterns_used: number;+ };+ router_metrics?: {+ model_selected: string;+ routing_reason: string;+ latency_ms: number;+ };+ done: boolean;+}++export class RuVectorProvider extends BaseProvider {+ readonly name: LLMProvider = 'custom'; // RuVector is custom provider type+ readonly capabilities: ProviderCapabilities = {+ supportedModels: [+ // RuVector-managed models+ 'ruvector-auto', // Auto-selects best model+ 'ruvector-fast', // Optimized for speed+ 'ruvector-quality', // Optimized for quality+ 'ruvector-balanced', // Balanced speed/quality+ // Local models via ruvLLM+ 'llama3.2',+ 'mistral',+ 'phi-4',+ 'deepseek-coder',+ 'codellama',+ 'qwen2.5',+ ],+ maxContextLength: {+ 'ruvector-auto': 128000,+ 'ruvector-fast': 32000,+ 'ruvector-quality': 128000,+ 'ruvector-balanced': 64000,+ 'llama3.2': 128000,+ 'mistral': 32000,+ 'phi-4': 16000,+ 'deepseek-coder': 16000,+ 'codellama': 16000,+ 'qwen2.5': 32000,+ },+ maxOutputTokens: {+ 'ruvector-auto': 8192,+ 'ruvector-fast': 4096,+ 'ruvector-quality': 8192,+ 'ruvector-balanced': 8192,+ 'llama3.2': 8192,+ 'mistral': 8192,+ 'phi-4': 4096,+ 'deepseek-coder': 8192,+ 'codellama': 8192,+ 'qwen2.5': 8192,+ },+ supportsStreaming: true,+ supportsToolCalling: true,+ supportsSystemMessages: true,+ supportsVision: false,+ supportsAudio: false,+ supportsFineTuning: true, // SONA self-learning+ supportsEmbeddings: true, // HNSW+ supportsBatching: true,+ rateLimit: {+ requestsPerMinute: 10000, // Local - no rate limit+ tokensPerMinute: 10000000,+ concurrentRequests: 100,+ },+ // Free - local execution with SONA optimization+ pricing: {+ 'ruvector-auto': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'ruvector-fast': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'ruvector-quality': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'ruvector-balanced': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'llama3.2': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'mistral': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'phi-4': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'deepseek-coder': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'codellama': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ 'qwen2.5': { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ },+ };++ private baseUrl: string = 'http://localhost:8787';+ private ruvectorConfig: RuVectorConfig = {};+ private ruvllm: unknown; // Dynamic import of @ruvector/ruvllm++ constructor(options: BaseProviderOptions) {+ super(options);+ this.ruvectorConfig = (options.config.providerOptions as RuVectorConfig) || {};+ }++ protected async doInitialize(): Promise<void> {+ this.baseUrl = this.config.apiUrl || 'http://localhost:8787';++ // Try to dynamically import @ruvector/ruvllm+ try {+ this.ruvllm = await import('@ruvector/ruvllm').catch(() => null);+ if (this.ruvllm) {+ this.logger.info('RuVector ruvLLM module loaded');+ }+ } catch {+ this.logger.warn('RuVector ruvLLM module not available, using HTTP API');+ }++ // Check if RuVector server is running+ const health = await this.doHealthCheck();+ if (!health.healthy) {+ this.logger.warn('RuVector server not detected. Using fallback mode.');+ }+ }++ protected async doComplete(request: LLMRequest): Promise<LLMResponse> {+ const ruvectorRequest = this.buildRequest(request);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), this.config.timeout || 120000);++ try {+ const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {+ method: 'POST',+ headers: {+ 'Content-Type': 'application/json',+ ...(this.config.apiKey && { Authorization: `Bearer ${this.config.apiKey}` }),+ },+ body: JSON.stringify(ruvectorRequest),+ signal: controller.signal,+ });++ clearTimeout(timeout);++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const data = await response.json() as RuVectorResponse;+ return this.transformResponse(data, request);+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ }+ }++ protected async *doStreamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent> {+ const ruvectorRequest = this.buildRequest(request, true);++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), (this.config.timeout || 120000) * 2);++ try {+ const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {+ method: 'POST',+ headers: {+ 'Content-Type': 'application/json',+ ...(this.config.apiKey && { Authorization: `Bearer ${this.config.apiKey}` }),+ },+ body: JSON.stringify(ruvectorRequest),+ signal: controller.signal,+ });++ if (!response.ok) {+ await this.handleErrorResponse(response);+ }++ const reader = response.body!.getReader();+ const decoder = new TextDecoder();+ let buffer = '';+ let promptTokens = 0;+ let completionTokens = 0;++ while (true) {+ const { done, value } = await reader.read();+ if (done) break;++ buffer += decoder.decode(value, { stream: true });+ const lines = buffer.split('\n');+ buffer = lines.pop() || '';++ for (const line of lines) {+ if (line.startsWith('data: ')) {+ const data = line.slice(6);+ if (data === '[DONE]') continue;++ try {+ const chunk: RuVectorResponse = JSON.parse(data);++ if (chunk.content) {+ yield {+ type: 'content',+ delta: { content: chunk.content },+ };+ }++ if (chunk.done && chunk.usage) {+ promptTokens = chunk.usage.prompt_tokens;+ completionTokens = chunk.usage.completion_tokens;++ yield {+ type: 'done',+ usage: {+ promptTokens,+ completionTokens,+ totalTokens: promptTokens + completionTokens,+ },+ cost: {+ promptCost: 0,+ completionCost: 0,+ totalCost: 0,+ currency: 'USD',+ },+ };+ }+ } catch {+ // Ignore parse errors+ }+ } else if (line.trim() && !line.startsWith(':')) {+ // Direct JSON response (non-SSE)+ try {+ const chunk: RuVectorResponse = JSON.parse(line);+ if (chunk.content) {+ yield {+ type: 'content',+ delta: { content: chunk.content },+ };+ }+ } catch {+ // Ignore+ }+ }+ }+ }++ // Ensure done event is sent+ if (completionTokens === 0) {+ yield {+ type: 'done',+ usage: {+ promptTokens: this.estimateTokens(JSON.stringify(request.messages)),+ completionTokens: 100,+ totalTokens: this.estimateTokens(JSON.stringify(request.messages)) + 100,+ },+ cost: { promptCost: 0, completionCost: 0, totalCost: 0, currency: 'USD' },+ };+ }+ } catch (error) {+ clearTimeout(timeout);+ throw this.transformError(error);+ } finally {+ clearTimeout(timeout);+ }+ }++ async listModels(): Promise<LLMModel[]> {+ try {+ const response = await fetch(`${this.baseUrl}/v1/models`);+ if (!response.ok) {+ return this.capabilities.supportedModels;+ }++ const data = await response.json() as { data?: Array<{ id: string }> };+ return data.data?.map((m) => m.id as LLMModel) || this.capabilities.supportedModels;+ } catch {+ return this.capabilities.supportedModels;+ }+ }++ async getModelInfo(model: LLMModel): Promise<ModelInfo> {+ const descriptions: Record<string, string> = {+ 'ruvector-auto': 'Auto-selects optimal model with SONA learning',+ 'ruvector-fast': 'Optimized for speed with FastGRNN routing',+ 'ruvector-quality': 'Highest quality with full SONA adaptation',+ 'ruvector-balanced': 'Balanced speed and quality',+ 'llama3.2': 'Meta Llama 3.2 via RuVector',+ 'mistral': 'Mistral 7B via RuVector',+ 'phi-4': 'Microsoft Phi-4 via RuVector',+ 'deepseek-coder': 'DeepSeek Coder via RuVector',+ 'codellama': 'Code Llama via RuVector',+ 'qwen2.5': 'Qwen 2.5 via RuVector',+ };++ return {+ model,+ name: model,+ description: descriptions[model] || 'RuVector-managed local model',+ contextLength: this.capabilities.maxContextLength[model] || 32000,+ maxOutputTokens: this.capabilities.maxOutputTokens[model] || 4096,+ supportedFeatures: [+ 'chat',+ 'completion',+ 'local',+ 'self-learning',+ 'sona',+ 'hnsw-memory',+ ],+ pricing: { promptCostPer1k: 0, completionCostPer1k: 0, currency: 'USD' },+ };+ }++ protected async doHealthCheck(): Promise<HealthCheckResult> {+ try {+ const response = await fetch(`${this.baseUrl}/health`);++ if (response.ok) {+ const data = await response.json() as { sona?: boolean; hnsw?: boolean };+ return {+ healthy: true,+ timestamp: new Date(),+ details: {+ server: 'ruvector',+ sona: data.sona ?? false,+ hnsw: data.hnsw ?? false,+ local: true,+ },+ };+ }++ return {+ healthy: false,+ error: `HTTP ${response.status}`,+ timestamp: new Date(),+ };+ } catch (error) {+ return {+ healthy: false,+ error: error instanceof Error ? error.message : 'RuVector server not reachable',+ timestamp: new Date(),+ details: {+ hint: 'Start RuVector server: npx @ruvector/ruvllm serve',+ },+ };+ }+ }++ private buildRequest(request: LLMRequest, stream = false): RuVectorRequest {+ const ruvectorRequest: RuVectorRequest = {+ model: request.model || this.config.model,+ messages: request.messages.map((msg) => ({+ role: msg.role === 'tool' ? 'assistant' : msg.role,+ content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),+ })),+ stream,+ };++ if (request.temperature !== undefined || this.config.temperature !== undefined) {+ ruvectorRequest.temperature = request.temperature ?? this.config.temperature;+ }+ if (request.maxTokens || this.config.maxTokens) {+ ruvectorRequest.max_tokens = request.maxTokens || this.config.maxTokens;+ }+ if (request.topP !== undefined || this.config.topP !== undefined) {+ ruvectorRequest.top_p = request.topP ?? this.config.topP;+ }++ // SONA options+ if (this.ruvectorConfig.enableSona !== false) {+ ruvectorRequest.sona_options = {+ enabled: true,+ learning_rate: this.ruvectorConfig.sonaLearningRate || 0.01,+ adapt_on_response: true,+ };+ }++ // Router options+ if (this.ruvectorConfig.enableFastGrnn !== false) {+ ruvectorRequest.router_options = {+ strategy: this.ruvectorConfig.routerStrategy || 'balanced',+ fallback_models: ['llama3.2', 'mistral', 'phi-4'],+ };+ }++ return ruvectorRequest;+ }++ private transformResponse(data: RuVectorResponse, request: LLMRequest): LLMResponse {+ const model = request.model || this.config.model;++ return {+ id: data.id || `ruvector-${Date.now()}`,+ model: (data.model || model) as LLMModel,+ provider: 'custom',+ content: data.content,+ usage: {+ promptTokens: data.usage?.prompt_tokens || 0,+ completionTokens: data.usage?.completion_tokens || 0,+ totalTokens: data.usage?.total_tokens || 0,+ },+ cost: {+ promptCost: 0,+ completionCost: 0,+ totalCost: 0,+ currency: 'USD',+ },+ finishReason: data.done ? 'stop' : 'length',+ metadata: {+ sona: data.sona_metrics,+ router: data.router_metrics,+ },+ };+ }++ private async handleErrorResponse(response: Response): Promise<never> {+ const errorText = await response.text();+ let errorData: { error?: string };++ try {+ errorData = JSON.parse(errorText);+ } catch {+ errorData = { error: errorText };+ }++ const message = errorData.error || 'Unknown error';++ if (response.status === 0 || message.includes('connection')) {+ throw new ProviderUnavailableError('custom', {+ message,+ hint: 'Start RuVector server: npx @ruvector/ruvllm serve',+ });+ }++ throw new LLMProviderError(+ message,+ `RUVECTOR_${response.status}`,+ 'custom',+ response.status,+ true,+ errorData+ );+ }++ /**+ * Get SONA learning metrics+ */+ async getSonaMetrics(): Promise<{+ enabled: boolean;+ adaptationsApplied: number;+ qualityScore: number;+ patternsLearned: number;+ }> {+ try {+ const response = await fetch(`${this.baseUrl}/v1/sona/metrics`);+ if (response.ok) {+ return await response.json() as {+ enabled: boolean;+ adaptationsApplied: number;+ qualityScore: number;+ patternsLearned: number;+ };+ }+ } catch {+ // Ignore+ }++ return {+ enabled: false,+ adaptationsApplied: 0,+ qualityScore: 0,+ patternsLearned: 0,+ };+ }++ /**+ * Trigger SONA learning from a conversation+ */+ async triggerSonaLearning(conversationId: string): Promise<boolean> {+ try {+ const response = await fetch(`${this.baseUrl}/v1/sona/learn`, {+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify({ conversation_id: conversationId }),+ });+ return response.ok;+ } catch {+ return false;+ }+ }++ /**+ * Search HNSW memory for similar patterns+ */+ async searchMemory(query: string, limit = 5): Promise<Array<{+ id: string;+ similarity: number;+ content: string;+ }>> {+ try {+ const response = await fetch(`${this.baseUrl}/v1/hnsw/search`, {+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify({ query, limit }),+ });++ if (response.ok) {+ return await response.json() as Array<{ id: string; similarity: number; content: string }>;+ }+ } catch {+ // Ignore+ }++ return [];+ }+}diff --git a/v3/@claude-flow/providers/src/types.ts b/v3/@claude-flow/providers/src/types.tsnew file mode 100644index 0000000000..f9d23d25e1--- /dev/null+++ b/v3/@claude-flow/providers/src/types.ts@@ -0,0 +1,435 @@+/**+ * V3 LLM Provider Types+ *+ * Unified type system for all LLM providers with enhanced+ * cost tracking, model capabilities, and error handling.+ *+ * @module @claude-flow/providers/types+ */++import { EventEmitter } from 'events';++// ===== PROVIDER TYPES =====++export type LLMProvider =+ | 'anthropic'+ | 'openai'+ | 'google'+ | 'cohere'+ | 'ollama'+ | 'ruvector'+ | 'openrouter'+ | 'litellm'+ | 'custom';++export type LLMModel =+ // Anthropic Models (2024-2025)+ | 'claude-3-5-sonnet-20241022'+ | 'claude-3-5-sonnet-latest'+ | 'claude-3-opus-20240229'+ | 'claude-3-sonnet-20240229'+ | 'claude-3-haiku-20240307'+ // OpenAI Models (2024-2025)+ | 'gpt-4o'+ | 'gpt-4o-mini'+ | 'gpt-4-turbo'+ | 'gpt-4'+ | 'gpt-3.5-turbo'+ | 'o1-preview'+ | 'o1-mini'+ | 'o3-mini'+ // Google Models+ | 'gemini-2.0-flash'+ | 'gemini-1.5-pro'+ | 'gemini-1.5-flash'+ | 'gemini-pro'+ // Cohere Models+ | 'command-r-plus'+ | 'command-r'+ | 'command-light'+ | 'command'+ // Ollama (Local) Models+ | 'llama3.2'+ | 'llama3.1'+ | 'mistral'+ | 'mixtral'+ | 'codellama'+ | 'phi-4'+ | 'deepseek-coder'+ // Generic+ | 'custom-model'+ | string;++// ===== MESSAGE TYPES =====++export interface LLMMessage {+ role: 'system' | 'user' | 'assistant' | 'tool';+ content: string | LLMContentPart[];+ name?: string;+ toolCallId?: string;+ toolCalls?: LLMToolCall[];+}++export interface LLMContentPart {+ type: 'text' | 'image' | 'audio';+ text?: string;+ imageUrl?: string;+ imageBase64?: string;+ audioUrl?: string;+}++export interface LLMToolCall {+ id: string;+ type: 'function';+ function: {+ name: string;+ arguments: string;+ };+}++export interface LLMTool {+ type: 'function';+ function: {+ name: string;+ description: string;+ parameters: {+ type: 'object';+ properties: Record<string, unknown>;+ required?: string[];+ };+ };+}++// ===== REQUEST/RESPONSE =====++export interface LLMProviderConfig {+ provider: LLMProvider;+ apiKey?: string;+ apiUrl?: string;+ model: LLMModel;++ // Generation parameters+ temperature?: number;+ maxTokens?: number;+ topP?: number;+ topK?: number;+ frequencyPenalty?: number;+ presencePenalty?: number;+ stopSequences?: string[];++ // Provider-specific options+ providerOptions?: Record<string, unknown>;++ // Performance settings+ timeout?: number;+ retryAttempts?: number;+ retryDelay?: number;++ // Features+ enableStreaming?: boolean;+ enableCaching?: boolean;+ cacheTimeout?: number;++ // Cost optimization+ enableCostOptimization?: boolean;+ maxCostPerRequest?: number;+ fallbackModels?: LLMModel[];+}++export interface LLMRequest {+ messages: LLMMessage[];+ model?: LLMModel;+ temperature?: number;+ maxTokens?: number;+ topP?: number;+ topK?: number;+ frequencyPenalty?: number;+ presencePenalty?: number;+ stopSequences?: string[];+ stream?: boolean;++ // Tool calling+ tools?: LLMTool[];+ toolChoice?: 'auto' | 'none' | 'required' | { type: 'function'; function: { name: string } };++ // Provider-specific options+ providerOptions?: Record<string, unknown>;++ // Cost constraints+ costConstraints?: {+ maxCost?: number;+ preferredModels?: LLMModel[];+ };++ // Request metadata+ requestId?: string;+ metadata?: Record<string, unknown>;+}++export interface LLMResponse {+ id: string;+ model: LLMModel;+ provider: LLMProvider;++ // Content+ content: string;+ toolCalls?: LLMToolCall[];++ // Usage+ usage: {+ promptTokens: number;+ completionTokens: number;+ totalTokens: number;+ };++ // Cost tracking+ cost?: {+ promptCost: number;+ completionCost: number;+ totalCost: number;+ currency: string;+ };++ // Performance+ latency?: number;++ // Metadata+ finishReason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';+ metadata?: Record<string, unknown>;+}++export interface LLMStreamEvent {+ type: 'content' | 'tool_call' | 'error' | 'done';+ delta?: {+ content?: string;+ toolCall?: Partial<LLMToolCall>;+ };+ error?: Error;+ usage?: LLMResponse['usage'];+ cost?: LLMResponse['cost'];+}++// ===== PROVIDER CAPABILITIES =====++export interface ProviderCapabilities {+ supportedModels: LLMModel[];+ maxContextLength: Record<string, number>;+ maxOutputTokens: Record<string, number>;++ // Feature support+ supportsStreaming: boolean;+ supportsToolCalling: boolean;+ supportsSystemMessages: boolean;+ supportsVision: boolean;+ supportsAudio: boolean;++ // Advanced features+ supportsFineTuning: boolean;+ supportsEmbeddings: boolean;+ supportsBatching: boolean;++ // Rate limits+ rateLimit?: {+ requestsPerMinute: number;+ tokensPerMinute: number;+ concurrentRequests: number;+ };++ // Pricing (per 1K tokens)+ pricing: Record<string, {+ promptCostPer1k: number;+ completionCostPer1k: number;+ currency: string;+ }>;+}++// ===== ERROR TYPES =====++export class LLMProviderError extends Error {+ constructor(+ message: string,+ public code: string,+ public provider: LLMProvider,+ public statusCode?: number,+ public retryable: boolean = true,+ public details?: unknown+ ) {+ super(message);+ this.name = 'LLMProviderError';+ }+}++export class RateLimitError extends LLMProviderError {+ constructor(+ message: string,+ provider: LLMProvider,+ public retryAfter?: number,+ details?: unknown+ ) {+ super(message, 'RATE_LIMIT', provider, 429, true, details);+ this.name = 'RateLimitError';+ }+}++export class AuthenticationError extends LLMProviderError {+ constructor(message: string, provider: LLMProvider, details?: unknown) {+ super(message, 'AUTHENTICATION', provider, 401, false, details);+ this.name = 'AuthenticationError';+ }+}++export class ModelNotFoundError extends LLMProviderError {+ constructor(model: string, provider: LLMProvider, details?: unknown) {+ super(`Model ${model} not found`, 'MODEL_NOT_FOUND', provider, 404, false, details);+ this.name = 'ModelNotFoundError';+ }+}++export class ProviderUnavailableError extends LLMProviderError {+ constructor(provider: LLMProvider, details?: unknown) {+ super(`Provider ${provider} is unavailable`, 'PROVIDER_UNAVAILABLE', provider, 503, true, details);+ this.name = 'ProviderUnavailableError';+ }+}++// ===== PROVIDER INTERFACE =====++export interface ILLMProvider extends EventEmitter {+ readonly name: LLMProvider;+ readonly capabilities: ProviderCapabilities;+ config: LLMProviderConfig;++ // Core methods+ initialize(): Promise<void>;+ complete(request: LLMRequest): Promise<LLMResponse>;+ streamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent>;++ // Model management+ listModels(): Promise<LLMModel[]>;+ getModelInfo(model: LLMModel): Promise<ModelInfo>;+ validateModel(model: LLMModel): boolean;++ // Health and status+ healthCheck(): Promise<HealthCheckResult>;+ getStatus(): ProviderStatus;++ // Cost management+ estimateCost(request: LLMRequest): Promise<CostEstimate>;+ getUsage(period?: UsagePeriod): Promise<UsageStats>;++ // Cleanup+ destroy(): void;+}++export interface ModelInfo {+ model: LLMModel;+ name: string;+ description: string;+ contextLength: number;+ maxOutputTokens: number;+ supportedFeatures: string[];+ pricing?: {+ promptCostPer1k: number;+ completionCostPer1k: number;+ currency: string;+ };+ deprecated?: boolean;+ recommendedReplacement?: LLMModel;+}++export interface HealthCheckResult {+ healthy: boolean;+ latency?: number;+ error?: string;+ timestamp: Date;+ details?: Record<string, unknown>;+}++export interface ProviderStatus {+ available: boolean;+ currentLoad: number;+ queueLength: number;+ activeRequests: number;+ rateLimitRemaining?: number;+ rateLimitReset?: Date;+}++export interface CostEstimate {+ estimatedPromptTokens: number;+ estimatedCompletionTokens: number;+ estimatedTotalTokens: number;+ estimatedCost: {+ prompt: number;+ completion: number;+ total: number;+ currency: string;+ };+ confidence: number;+}++export interface UsageStats {+ period: { start: Date; end: Date };+ requests: number;+ tokens: { prompt: number; completion: number; total: number };+ cost: { prompt: number; completion: number; total: number; currency: string };+ errors: number;+ averageLatency: number;+ modelBreakdown: Record<string, { requests: number; tokens: number; cost: number }>;+}++export type UsagePeriod = 'hour' | 'day' | 'week' | 'month' | 'all';++// ===== MANAGER TYPES =====++export type LoadBalancingStrategy = 'round-robin' | 'least-loaded' | 'latency-based' | 'cost-based';++export interface ProviderManagerConfig {+ providers: LLMProviderConfig[];+ defaultProvider?: LLMProvider;+ loadBalancing?: {+ enabled: boolean;+ strategy: LoadBalancingStrategy;+ };+ fallback?: {+ enabled: boolean;+ maxAttempts: number;+ };+ cache?: {+ enabled: boolean;+ ttl: number;+ maxSize: number;+ };+ costOptimization?: {+ enabled: boolean;+ maxCostPerRequest?: number;+ };+}++// ===== TYPE GUARDS =====++export function isLLMResponse(obj: unknown): obj is LLMResponse {+ return (+ typeof obj === 'object' &&+ obj !== null &&+ 'id' in obj &&+ 'content' in obj &&+ 'provider' in obj+ );+}++export function isLLMStreamEvent(obj: unknown): obj is LLMStreamEvent {+ return (+ typeof obj === 'object' &&+ obj !== null &&+ 'type' in obj &&+ ['content', 'tool_call', 'error', 'done'].includes((obj as LLMStreamEvent).type)+ );+}++export function isLLMProviderError(error: unknown): error is LLMProviderError {+ return error instanceof LLMProviderError;+}++export function isRateLimitError(error: unknown): error is RateLimitError {+ return error instanceof RateLimitError;+}diff --git a/v3/@claude-flow/providers/tsconfig.json b/v3/@claude-flow/providers/tsconfig.jsonnew file mode 100644index 0000000000..5c8ca2a3b9--- /dev/null+++ b/v3/@claude-flow/providers/tsconfig.json@@ -0,0 +1,12 @@+{+ "extends": "../../tsconfig.json",+ "compilerOptions": {+ "outDir": "./dist",+ "rootDir": "./src",+ "declaration": true,+ "declarationMap": true,+ "composite": true+ },+ "include": ["src/**/*"],+ "exclude": ["node_modules", "dist", "**/*.test.ts", "**/__tests__/**"]+}diff --git a/v3/pnpm-lock.yaml b/v3/pnpm-lock.yamlindex 7367714854..cfb42c04c3 100644--- a/v3/pnpm-lock.yaml+++ b/v3/pnpm-lock.yaml@@ -21,22 +21,6 @@ importers:specifier: ^1.0.0version: 1.6.1(@types/[email protected])- '@claude-flow/billing':- dependencies:- '@claude-flow/shared':- specifier: ^3.0.0-alpha.1- version: link:../shared- devDependencies:- '@types/node':- specifier: ^20.10.0- version: 20.19.27- typescript:- specifier: ^5.3.0- version: 5.9.3- vitest:- specifier: ^1.0.0- version: 1.6.1(@types/[email protected])-'@claude-flow/cli':dependencies:'@claude-flow/shared':@@ -82,25 +66,6 @@ importers:specifier: ^1.0.0version: 1.6.1(@types/[email protected])- '@claude-flow/federation':- dependencies:- '@claude-flow/shared':- specifier: ^3.0.0-alpha.1- version: link:../shared- '@claude-flow/transport':- specifier: ^3.0.0-alpha.1- version: link:../transport- devDependencies:- '@types/node':- specifier: ^20.10.0- version: 20.19.27- typescript:- specifier: ^5.3.0- version: 5.9.3- vitest:- specifier: ^1.0.0- version: 1.6.1(@types/[email protected])-'@claude-flow/hooks':dependencies:'@claude-flow/memory':@@ -142,11 +107,39 @@ importers:specifier: ^1.0.0version: 1.6.1(@types/[email protected])+ '@claude-flow/mcp':+ dependencies:+ cors:+ specifier: ^2.8.5+ version: 2.8.5+ express:+ specifier: ^4.18.2+ version: 4.22.1+ helmet:+ specifier: ^7.1.0+ version: 7.2.0+ ws:+ specifier: ^8.14.2+ version: 8.18.3+ devDependencies:+ '@types/cors':+ specifier: ^2.8.17+ version: 2.8.19+ '@types/express':+ specifier: ^4.17.21+ version: 4.17.25+ '@types/ws':+ specifier: ^8.5.10+ version: 8.18.1+ vitest:+ specifier: ^1.0.0+ version: 1.6.1(@types/[email protected])+'@claude-flow/memory':dependencies:agentdb:specifier: alpha- version: 2.0.0-alpha.3.4(@types/[email protected])([email protected])([email protected])([email protected])+ version: 2.0.0-alpha.3.4(@types/[email protected])([email protected])([email protected])([email protected])better-sqlite3:specifier: ^11.0.0version: 11.10.0@@ -186,6 +179,31 @@ importers:specifier: ^1.0.0version: 1.6.1(@types/[email protected])+ '@claude-flow/providers':+ dependencies:+ '@ruvector/ruvllm':+ specifier: ^0.2.3+ version: 0.2.4+ events:+ specifier: ^3.3.0+ version: 3.3.0+ devDependencies:+ '@types/node':+ specifier: ^20.0.0+ version: 20.19.27+ dotenv:+ specifier: ^16.4.5+ version: 16.6.1+ tsx:+ specifier: ^4.19.0+ version: 4.21.0+ typescript:+ specifier: ^5.5.0+ version: 5.9.3+ vitest:+ specifier: ^1.6.0+ version: 1.6.1(@types/[email protected])+'@claude-flow/security':dependencies:bcrypt:@@ -219,10 +237,6 @@ importers:version: 1.6.1(@types/[email protected])'@claude-flow/swarm':- dependencies:- '@claude-flow/shared':- specifier: workspace:*- version: link:../shareddevDependencies:vitest:specifier: ^1.0.0@@ -246,22 +260,6 @@ importers:specifier: ^2.0.0version: 2.1.9(@types/[email protected])- '@claude-flow/transport':- dependencies:- '@claude-flow/shared':- specifier: ^3.0.0-alpha.1- version: link:../shared- devDependencies:- '@types/node':- specifier: ^20.10.0- version: 20.19.27- typescript:- specifier: ^5.3.0- version: 5.9.3- vitest:- specifier: ^1.0.0- version: 1.6.1(@types/[email protected])-packages:/@ampproject/[email protected]:@@ -393,7 +391,6 @@ packages:cpu: [ppc64]os: [aix]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -411,7 +408,6 @@ packages:cpu: [arm64]os: [android]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -429,7 +425,6 @@ packages:cpu: [arm]os: [android]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -447,7 +442,6 @@ packages:cpu: [x64]os: [android]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -465,7 +459,6 @@ packages:cpu: [arm64]os: [darwin]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -483,7 +476,6 @@ packages:cpu: [x64]os: [darwin]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -501,7 +493,6 @@ packages:cpu: [arm64]os: [freebsd]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -519,7 +510,6 @@ packages:cpu: [x64]os: [freebsd]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -537,7 +527,6 @@ packages:cpu: [arm64]os: [linux]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -555,7 +544,6 @@ packages:cpu: [arm]os: [linux]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -573,7 +561,6 @@ packages:cpu: [ia32]os: [linux]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -591,7 +578,6 @@ packages:cpu: [loong64]os: [linux]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -609,7 +595,6 @@ packages:cpu: [mips64el]os: [linux]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -627,7 +612,6 @@ packages:cpu: [ppc64]os: [linux]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -645,7 +629,6 @@ packages:cpu: [riscv64]os: [linux]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -663,7 +646,6 @@ packages:cpu: [s390x]os: [linux]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -681,7 +663,6 @@ packages:cpu: [x64]os: [linux]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -690,7 +671,6 @@ packages:cpu: [arm64]os: [netbsd]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -708,7 +688,6 @@ packages:cpu: [x64]os: [netbsd]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -717,7 +696,6 @@ packages:cpu: [arm64]os: [openbsd]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -735,7 +713,6 @@ packages:cpu: [x64]os: [openbsd]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -744,7 +721,6 @@ packages:cpu: [arm64]os: [openharmony]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -762,7 +738,6 @@ packages:cpu: [x64]os: [sunos]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -780,7 +755,6 @@ packages:cpu: [arm64]os: [win32]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -798,7 +772,6 @@ packages:cpu: [ia32]os: [win32]requiresBuild: true- dev: falseoptional: true/@esbuild/[email protected]:@@ -816,7 +789,6 @@ packages:cpu: [x64]os: [win32]requiresBuild: true- dev: falseoptional: true/@gar/[email protected]:@@ -3367,8 +3339,6 @@ packages:dependencies:'@types/connect': 3.4.38'@types/node': 20.19.27- dev: false- optional: true/@types/[email protected]:resolution: {integrity: sha512-ZqS9JGpBxVOvsawzmVt30sP++gSQMTejCkIAQ3VdadOcRE8izTyW66hufvwLeH+YEGP6Js2AW7Gz+RMyvrEbmw==}@@ -3391,8 +3361,6 @@ packages:requiresBuild: truedependencies:'@types/node': 20.19.27- dev: false- optional: true/@types/[email protected]:resolution: {integrity: sha512-8uYXI3Gw35MhiVYhG3s295oihrxRyytcRHjSjqnqZVDDy/xcGBRny7+Xj1Wgfhv5QzRtN2hB2dVRBUX9XW3UcQ==}@@ -3405,12 +3373,18 @@ packages:requiresBuild: truedependencies:'@types/connect': 3.4.38- '@types/express': 5.0.6+ '@types/express': 4.17.25'@types/keygrip': 1.0.6'@types/node': 20.19.27dev: falseoptional: true+ /@types/[email protected]:+ resolution: {integrity: sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==}+ dependencies:+ '@types/node': 20.19.27+ dev: true+/@types/[email protected]:resolution: {integrity: sha512-cMQm7pxu6BxtHyqJ7mQZ2kXWV5SLmugybFdHCBbJ5eHzOo6VhBckEgAT3//rP5FwPHNPeEiq4SmQ5ucBwsOo4Q==}dev: true@@ -3418,26 +3392,21 @@ packages:/@types/[email protected]:resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}- /@types/[email protected]:- resolution: {integrity: sha512-jnHMsrd0Mwa9Cf4IdOzbz543y4XJepXrbia2T4b6+spXC2We3t1y6K44D3mR8XMFSXMCf3/l7rCgddfx7UNVBA==}- requiresBuild: true+ /@types/[email protected]:+ resolution: {integrity: sha512-FvPtiIf1LfhzsaIXhv/PHan/2FeQBbtBDtfX2QfvPxdUelMDEckK08SM6nqo1MIZY3RUlfA+HV8+hFUSio78qg==}dependencies:'@types/node': 20.19.27'@types/qs': 6.14.0'@types/range-parser': 1.2.7'@types/send': 1.2.1- dev: false- optional: true- /@types/[email protected]:- resolution: {integrity: sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==}- requiresBuild: true+ /@types/[email protected]:+ resolution: {integrity: sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==}dependencies:'@types/body-parser': 1.19.6- '@types/express-serve-static-core': 5.1.0- '@types/serve-static': 2.2.0- dev: false- optional: true+ '@types/express-serve-static-core': 4.19.7+ '@types/qs': 6.14.0+ '@types/serve-static': 1.15.10/@types/[email protected]:resolution: {integrity: sha512-TTEwmtjgVbYAzZYWyeHPrrtWnfVkm8tQkP8P21uQifPgMRgjrow3XDEYqucuC8SKZJT7pUnhU/JymvjggxO9vw==}@@ -3448,8 +3417,6 @@ packages:/@types/[email protected]:resolution: {integrity: sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==}requiresBuild: true- dev: false- optional: true/@types/[email protected]:resolution: {integrity: sha512-ED6LB+Z1AVylNTu7hdzuBqOgMnvG/ld6wGCG8wFnAzKX5uyW2K3WD52v0gnLCTK/VLpXtKckgWuyScYK6cSPaw==}@@ -3506,6 +3473,9 @@ packages:dev: falseoptional: true+ /@types/[email protected]:+ resolution: {integrity: sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==}+/@types/[email protected]:resolution: {integrity: sha512-wK1pzsJVVAjYCSZWQoWHziQZbNggXFDUEIGf54g4ZM/ERuP86uGdWeKZWMYlqTPMZfHJJvLPyogXGvCOg87yLQ==}requiresBuild: true@@ -3548,14 +3518,10 @@ packages:/@types/[email protected]:resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==}requiresBuild: true- dev: false- optional: true/@types/[email protected]:resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==}requiresBuild: true- dev: false- optional: true/@types/[email protected](@types/[email protected]):resolution: {integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==}@@ -3571,22 +3537,24 @@ packages:csstype: 3.2.3dev: false+ /@types/[email protected]:+ resolution: {integrity: sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==}+ dependencies:+ '@types/mime': 1.3.5+ '@types/node': 20.19.27+/@types/[email protected]:resolution: {integrity: sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==}requiresBuild: truedependencies:'@types/node': 20.19.27- dev: false- optional: true- /@types/[email protected]:- resolution: {integrity: sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==}- requiresBuild: true+ /@types/[email protected]:+ resolution: {integrity: sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==}dependencies:'@types/http-errors': 2.0.5'@types/node': 20.19.27- dev: false- optional: true+ '@types/send': 0.17.6/@types/[email protected]:resolution: {integrity: sha512-UE7oxhQLLd9gub6JKIAhDq06T0F6FnztwMNRvYgjeQSBeMc1ZG/tA47EwfduvkuQS8apbkM/lpLpWsaCeYsXVg==}@@ -3613,7 +3581,6 @@ packages:resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}dependencies:'@types/node': 20.19.27- dev: false/@vitejs/[email protected]([email protected]):resolution: {integrity: sha512-x+rE6tsxq/gxrEJN3Nv3dIV60lFflPj94c90b+NNo6n1QV1QQUTLoL0MpaOVasUZ0zqVBn7ead1B5ecx1JAGfA==}@@ -3777,6 +3744,14 @@ packages:resolution: {integrity: sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==}dev: false+ resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}+ engines: {node: '>= 0.6'}+ dependencies:+ mime-types: 2.1.35+ negotiator: 0.6.3+ dev: false+resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==}engines: {node: '>= 0.6'}@@ -3845,6 +3820,67 @@ packages:dev: falseoptional: true+ /[email protected](@types/[email protected])([email protected])([email protected])([email protected]):+ resolution: {integrity: sha512-bUqO5o2VpWomh2xGOHdQoX00CGrPcIAH6zDCt5oa0SeJWAO+bbB7SiElb1TxwcrJQKe96HkiSh2T8z4vFypsxg==}+ engines: {node: '>=18.0.0'}+ hasBin: true+ requiresBuild: true+ dependencies:+ '@modelcontextprotocol/sdk': 1.25.1([email protected])([email protected])+ '@opentelemetry/api': 1.9.0+ '@ruvector/attention': 0.1.4+ '@ruvector/gnn': 0.1.22+ '@ruvector/graph-node': 0.1.26+ '@ruvector/router': 0.1.26+ '@ruvector/ruvllm': 0.2.4+ '@ruvector/sona': 0.1.5+ ajv: 8.17.1+ chalk: 5.6.2+ cli-table3: 0.6.5+ commander: 12.1.0+ dotenv: 16.6.1+ inquirer: 9.3.8(@types/[email protected])+ jsonwebtoken: 9.0.3+ marked-terminal: 6.2.0([email protected])+ ora: 7.0.1+ ruvector: 0.1.95([email protected])([email protected])+ ruvector-attention-wasm: 0.1.0+ sql.js: 1.13.0+ zod: 3.25.76+ optionalDependencies:+ '@opentelemetry/auto-instrumentations-node': 0.47.1(@opentelemetry/[email protected])+ '@opentelemetry/exporter-metrics-otlp-http': 0.52.1(@opentelemetry/[email protected])+ '@opentelemetry/exporter-prometheus': 0.52.1(@opentelemetry/[email protected])+ '@opentelemetry/exporter-trace-otlp-http': 0.52.1(@opentelemetry/[email protected])+ '@opentelemetry/resources': 1.30.1(@opentelemetry/[email protected])+ '@opentelemetry/sdk-metrics': 1.30.1(@opentelemetry/[email protected])+ '@opentelemetry/sdk-node': 0.52.1(@opentelemetry/[email protected])+ '@opentelemetry/sdk-trace-base': 1.30.1(@opentelemetry/[email protected])+ '@opentelemetry/semantic-conventions': 1.38.0+ '@xenova/transformers': 2.17.2+ argon2: 0.44.0+ bcrypt: 6.0.0+ better-sqlite3: 11.10.0+ express-rate-limit: 8.2.1([email protected])+ helmet: 8.1.0+ hnswlib-node: 3.0.0+ sharp: 0.32.6+ sqlite: 5.1.1+ sqlite3: 5.1.7+ transitivePeerDependencies:+ - '@cfworker/json-schema'+ - '@types/node'+ - bare-abort-controller+ - bare-buffer+ - bluebird+ - encoding+ - express+ - hono+ - marked+ - react-native-b4a+ - supports-color+ dev: false+/[email protected](@types/[email protected])([email protected])([email protected])([email protected]):resolution: {integrity: sha512-bUqO5o2VpWomh2xGOHdQoX00CGrPcIAH6zDCt5oa0SeJWAO+bbB7SiElb1TxwcrJQKe96HkiSh2T8z4vFypsxg==}engines: {node: '>=18.0.0'}@@ -4208,6 +4244,10 @@ packages:resolution: {integrity: sha512-F2+Hkm9xFaRg+GkaNnbwXNDV5O6pnCFEmqyhvfC/Ic5LbgOWjJh3L+mN/s91rxVL3znE7DYVpW0GJFT+4YBgWw==}dev: true+ resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==}+ dev: false+resolution: {integrity: sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==}dev: true@@ -4404,6 +4444,26 @@ packages:readable-stream: 3.6.2dev: false+ resolution: {integrity: sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==}+ engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}+ dependencies:+ bytes: 3.1.2+ content-type: 1.0.5+ debug: 2.6.9+ depd: 2.0.0+ destroy: 1.2.0+ http-errors: 2.0.1+ iconv-lite: 0.4.24+ on-finished: 2.4.1+ qs: 6.14.1+ raw-body: 2.5.3+ type-is: 1.6.18+ unpipe: 1.0.0+ transitivePeerDependencies:+ - supports-color+ dev: false+resolution: {integrity: sha512-nfDwkulwiZYQIGwxdy0RUmowMhKcFVcYXUU7m4QlKYim1rUtg83xm2yjZ40QjDuc291AJjjeSc9b++AWHSgSHw==}engines: {node: '>=18'}@@ -4788,6 +4848,13 @@ packages:resolution: {integrity: sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==}dev: false+ resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==}+ engines: {node: '>= 0.6'}+ dependencies:+ safe-buffer: 5.2.1+ dev: false+resolution: {integrity: sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==}engines: {node: '>=18'}@@ -4834,6 +4901,10 @@ packages:split2: 4.2.0dev: true+ resolution: {integrity: sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==}+ dev: false+resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==}engines: {node: '>=6.6.0'}@@ -4912,6 +4983,17 @@ packages:engines: {node: '>= 12'}dev: false+ resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==}+ peerDependencies:+ supports-color: '*'+ peerDependenciesMeta:+ supports-color:+ optional: true+ dependencies:+ ms: 2.0.0+ dev: false+resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}engines: {node: '>=6.0'}@@ -4970,6 +5052,11 @@ packages:resolution: {integrity: sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==}dev: true+ resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==}+ engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}+ dev: false+resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}engines: {node: '>=8'}@@ -4997,7 +5084,6 @@ packages:resolution: {integrity: sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==}engines: {node: '>=12'}- dev: falseresolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}@@ -5186,7 +5272,6 @@ packages:'@esbuild/win32-arm64': 0.27.2'@esbuild/win32-ia32': 0.27.2'@esbuild/win32-x64': 0.27.2- dev: falseresolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}@@ -5234,6 +5319,11 @@ packages:- bare-abort-controllerdev: false+ resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}+ engines: {node: '>=0.8.x'}+ dev: false+resolution: {integrity: sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==}engines: {node: '>=18.0.0'}@@ -5298,6 +5388,18 @@ packages:express: 5.2.1dev: false+ resolution: {integrity: sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g==}+ engines: {node: '>= 16'}+ requiresBuild: true+ peerDependencies:+ express: '>= 4.11'+ dependencies:+ express: 4.22.1+ ip-address: 10.0.1+ dev: false+ optional: true+resolution: {integrity: sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g==}engines: {node: '>= 16'}@@ -5310,6 +5412,45 @@ packages:dev: falseoptional: true+ resolution: {integrity: sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==}+ engines: {node: '>= 0.10.0'}+ dependencies:+ accepts: 1.3.8+ array-flatten: 1.1.1+ body-parser: 1.20.4+ content-disposition: 0.5.4+ content-type: 1.0.5+ cookie: 0.7.2+ cookie-signature: 1.0.7+ debug: 2.6.9+ depd: 2.0.0+ encodeurl: 2.0.0+ escape-html: 1.0.3+ etag: 1.8.1+ finalhandler: 1.3.2+ fresh: 0.5.2+ http-errors: 2.0.1+ merge-descriptors: 1.0.3+ methods: 1.1.2+ on-finished: 2.4.1+ parseurl: 1.3.3+ path-to-regexp: 0.1.12+ proxy-addr: 2.0.7+ qs: 6.14.1+ range-parser: 1.2.1+ safe-buffer: 5.2.1+ send: 0.19.2+ serve-static: 1.16.3+ setprototypeof: 1.2.0+ statuses: 2.0.2+ type-is: 1.6.18+ utils-merge: 1.0.1+ vary: 1.1.2+ transitivePeerDependencies:+ - supports-color+ dev: false+resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==}engines: {node: '>= 18'}@@ -5466,6 +5607,21 @@ packages:dependencies:to-regex-range: 5.0.1+ resolution: {integrity: sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==}+ engines: {node: '>= 0.8'}+ dependencies:+ debug: 2.6.9+ encodeurl: 2.0.0+ escape-html: 1.0.3+ on-finished: 2.4.1+ parseurl: 1.3.3+ statuses: 2.0.2+ unpipe: 1.0.0+ transitivePeerDependencies:+ - supports-color+ dev: false+resolution: {integrity: sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==}engines: {node: '>= 18.0.0'}@@ -5550,6 +5706,11 @@ packages:resolution: {integrity: sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==}dev: false+ resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==}+ engines: {node: '>= 0.6'}+ dev: false+resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==}engines: {node: '>= 0.8'}@@ -5747,6 +5908,12 @@ packages:is-stream: 4.0.1dev: false+ resolution: {integrity: sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==}+ dependencies:+ resolve-pkg-maps: 1.0.0+ dev: true+resolution: {integrity: sha512-PI+sPDvHXNPl5WNOErAK05s3j0lgwUzMN6o8cyQrDaKfT3qd7TmNJKeXX+SknI5I0QhG5fVPAEwSY4tRGDtYoQ==}dependencies:@@ -5902,6 +6069,11 @@ packages:function-bind: 1.1.2dev: false+ resolution: {integrity: sha512-ZRiwvN089JfMXokizgqEPXsl2Guk094yExfoDXR0cBYWxtBbaSww/w+vT4WEJsBW2iTUi1GgZ6swmoug3Oy4Xw==}+ engines: {node: '>=16.0.0'}+ dev: false+resolution: {integrity: sha512-jOiHyAZsmnr8LqoPGmCjYAaiuWwjAPLgY8ZX2XrmHawt99/u1y6RgrZMTeoPfpUbV96HOalYgz1qzkRbw54Pmg==}engines: {node: '>=18.0.0'}@@ -6046,6 +6218,13 @@ packages:engines: {node: '>=20.0.0'}dev: false+ resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==}+ engines: {node: '>=0.10.0'}+ dependencies:+ safer-buffer: 2.1.2+ dev: false+resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}engines: {node: '>=0.10.0'}@@ -6718,6 +6897,11 @@ packages:hasBin: truedev: false+ resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==}+ engines: {node: '>= 0.6'}+ dev: false+resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==}engines: {node: '>= 0.8'}@@ -6728,6 +6912,10 @@ packages:engines: {node: '>=16.10'}dev: true+ resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==}+ dev: false+resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==}engines: {node: '>=18'}@@ -6742,6 +6930,11 @@ packages:engines: {node: '>= 8'}dev: true+ resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}+ engines: {node: '>= 0.6'}+ dev: false+resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}engines: {node: '>=8.6'}@@ -6773,6 +6966,12 @@ packages:mime-db: 1.54.0dev: false+ resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}+ engines: {node: '>=4'}+ hasBin: true+ dev: false+resolution: {integrity: sha512-X5ju04+cAzsojXKes0B/S4tcYtFAJ6tTMuSPBEn9CPGlrWr8Fiw7qYeLT0XyH80HSoAoqWCaz+MWKh22P7G1cw==}engines: {node: '>=16'}@@ -6913,6 +7112,10 @@ packages:dev: falseoptional: true+ resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==}+ dev: false+resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}@@ -6930,6 +7133,11 @@ packages:resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}dev: false+ resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}+ engines: {node: '>= 0.6'}+ dev: false+resolution: {integrity: sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==}engines: {node: '>= 0.6'}@@ -7441,6 +7649,10 @@ packages:minipass: 7.1.2dev: false+ resolution: {integrity: sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==}+ dev: false+resolution: {integrity: sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==}dev: false@@ -7721,6 +7933,16 @@ packages:engines: {node: '>= 0.6'}dev: false+ resolution: {integrity: sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==}+ engines: {node: '>= 0.8'}+ dependencies:+ bytes: 3.1.2+ http-errors: 2.0.1+ iconv-lite: 0.4.24+ unpipe: 1.0.0+ dev: false+resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==}engines: {node: '>= 0.10'}@@ -7876,6 +8098,10 @@ packages:engines: {node: '>=8'}dev: true+ resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}+ dev: true+resolution: {integrity: sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==}engines: {node: '>= 0.4'}@@ -8145,6 +8371,27 @@ packages:engines: {node: '>=10'}hasBin: true+ resolution: {integrity: sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==}+ engines: {node: '>= 0.8.0'}+ dependencies:+ debug: 2.6.9+ depd: 2.0.0+ destroy: 1.2.0+ encodeurl: 2.0.0+ escape-html: 1.0.3+ etag: 1.8.1+ fresh: 0.5.2+ http-errors: 2.0.1+ mime: 1.6.0+ ms: 2.1.3+ on-finished: 2.4.1+ range-parser: 1.2.1+ statuses: 2.0.2+ transitivePeerDependencies:+ - supports-color+ dev: false+resolution: {integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==}engines: {node: '>= 18'}@@ -8164,6 +8411,18 @@ packages:- supports-colordev: false+ resolution: {integrity: sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==}+ engines: {node: '>= 0.8.0'}+ dependencies:+ encodeurl: 2.0.0+ escape-html: 1.0.3+ parseurl: 1.3.3+ send: 0.19.2+ transitivePeerDependencies:+ - supports-color+ dev: false+resolution: {integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==}engines: {node: '>= 18'}@@ -8797,6 +9056,17 @@ packages:resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}dev: false+ resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}+ engines: {node: '>=18.0.0'}+ hasBin: true+ dependencies:+ esbuild: 0.27.2+ get-tsconfig: 4.13.0+ optionalDependencies:+ fsevents: 2.3.3+ dev: true+resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}dependencies:@@ -8832,6 +9102,14 @@ packages:engines: {node: '>=16'}dev: true+ resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}+ engines: {node: '>= 0.6'}+ dependencies:+ media-typer: 0.3.0+ mime-types: 2.1.35+ dev: false+resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}engines: {node: '>= 0.6'}@@ -8949,6 +9227,11 @@ packages:resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}+ resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==}+ engines: {node: '>= 0.4.0'}+ dev: false+resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==}hasBin: true