Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 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

checkpoint: Manual test

rUv9b33e1b2a0f0
diff --git a/v3/@claude-flow/hooks/src/llm/index.ts b/v3/@claude-flow/hooks/src/llm/index.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.md
new file mode 100644
index 0000000000..471b34be04
--- /dev/null
+++ b/v3/@claude-flow/mcp/README.md
@@ -0,0 +1,428 @@
+# @claude-flow/mcp
+
+[![npm version](https://img.shields.io/npm/v/@claude-flow/mcp.svg)](https://www.npmjs.com/package/@claude-flow/mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![MCP 2025-11-25](https://img.shields.io/badge/MCP-2025--11--25-blue.svg)](https://modelcontextprotocol.io)
+[![Standalone](https://img.shields.io/badge/Module-Standalone-green.svg)](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
+
+MIT
diff --git a/v3/@claude-flow/mcp/__tests__/mcp.test.ts b/v3/@claude-flow/mcp/__tests__/mcp.test.ts
new file mode 100644
index 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.json
new file mode 100644
index 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.yaml
new file mode 100644
index 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
+
+ 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
+
+ resolution: {integrity: sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==}
+ dependencies:
+ '@types/connect': 3.4.38
+ '@types/node': 25.0.3
+ dev: true
+
+ resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==}
+ dependencies:
+ '@types/node': 25.0.3
+ dev: true
+
+ resolution: {integrity: sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==}
+ dependencies:
+ '@types/node': 25.0.3
+ dev: true
+
+ resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+ dev: true
+
+ 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
+
+ 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
+
+ resolution: {integrity: sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==}
+ dev: true
+
+ resolution: {integrity: sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==}
+ dev: true
+
+ resolution: {integrity: sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA==}
+ dependencies:
+ undici-types: 7.16.0
+ dev: true
+
+ resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==}
+ dev: true
+
+ resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==}
+ dev: true
+
+ resolution: {integrity: sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==}
+ dependencies:
+ '@types/mime': 1.3.5
+ '@types/node': 25.0.3
+ dev: true
+
+ resolution: {integrity: sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==}
+ dependencies:
+ '@types/node': 25.0.3
+ dev: true
+
+ 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
+
+ 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: true
diff --git a/v3/@claude-flow/mcp/src/connection-pool.ts b/v3/@claude-flow/mcp/src/connection-pool.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.json
new file mode 100644
index 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.ts
new file mode 100644
index 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.json
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.json
new file mode 100644
index 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.yaml
index 7367714854..cfb42c04c3 100644
--- a/v3/pnpm-lock.yaml
+++ b/v3/pnpm-lock.yaml
@@ -21,22 +21,6 @@ importers:
specifier: ^1.0.0
version: 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.0
version: 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.0
version: 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
better-sqlite3:
specifier: ^11.0.0
version: 11.10.0
@@ -186,6 +179,31 @@ importers:
specifier: ^1.0.0
version: 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:../shared
devDependencies:
vitest:
specifier: ^1.0.0
@@ -246,22 +260,6 @@ importers:
specifier: ^2.0.0
version: 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: false
optional: true
/@esbuild/[email protected]:
@@ -411,7 +408,6 @@ packages:
cpu: [arm64]
os: [android]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -429,7 +425,6 @@ packages:
cpu: [arm]
os: [android]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -447,7 +442,6 @@ packages:
cpu: [x64]
os: [android]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -465,7 +459,6 @@ packages:
cpu: [arm64]
os: [darwin]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -483,7 +476,6 @@ packages:
cpu: [x64]
os: [darwin]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -501,7 +493,6 @@ packages:
cpu: [arm64]
os: [freebsd]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -519,7 +510,6 @@ packages:
cpu: [x64]
os: [freebsd]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -537,7 +527,6 @@ packages:
cpu: [arm64]
os: [linux]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -555,7 +544,6 @@ packages:
cpu: [arm]
os: [linux]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -573,7 +561,6 @@ packages:
cpu: [ia32]
os: [linux]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -591,7 +578,6 @@ packages:
cpu: [loong64]
os: [linux]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -609,7 +595,6 @@ packages:
cpu: [mips64el]
os: [linux]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -627,7 +612,6 @@ packages:
cpu: [ppc64]
os: [linux]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -645,7 +629,6 @@ packages:
cpu: [riscv64]
os: [linux]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -663,7 +646,6 @@ packages:
cpu: [s390x]
os: [linux]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -681,7 +663,6 @@ packages:
cpu: [x64]
os: [linux]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -690,7 +671,6 @@ packages:
cpu: [arm64]
os: [netbsd]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -708,7 +688,6 @@ packages:
cpu: [x64]
os: [netbsd]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -717,7 +696,6 @@ packages:
cpu: [arm64]
os: [openbsd]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -735,7 +713,6 @@ packages:
cpu: [x64]
os: [openbsd]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -744,7 +721,6 @@ packages:
cpu: [arm64]
os: [openharmony]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -762,7 +738,6 @@ packages:
cpu: [x64]
os: [sunos]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -780,7 +755,6 @@ packages:
cpu: [arm64]
os: [win32]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -798,7 +772,6 @@ packages:
cpu: [ia32]
os: [win32]
requiresBuild: true
- dev: false
optional: true
/@esbuild/[email protected]:
@@ -816,7 +789,6 @@ packages:
cpu: [x64]
os: [win32]
requiresBuild: true
- dev: false
optional: true
@@ -3367,8 +3339,6 @@ packages:
dependencies:
'@types/connect': 3.4.38
'@types/node': 20.19.27
- dev: false
- optional: true
resolution: {integrity: sha512-ZqS9JGpBxVOvsawzmVt30sP++gSQMTejCkIAQ3VdadOcRE8izTyW66hufvwLeH+YEGP6Js2AW7Gz+RMyvrEbmw==}
@@ -3391,8 +3361,6 @@ packages:
requiresBuild: true
dependencies:
'@types/node': 20.19.27
- dev: false
- optional: true
resolution: {integrity: sha512-8uYXI3Gw35MhiVYhG3s295oihrxRyytcRHjSjqnqZVDDy/xcGBRny7+Xj1Wgfhv5QzRtN2hB2dVRBUX9XW3UcQ==}
@@ -3405,12 +3373,18 @@ packages:
requiresBuild: true
dependencies:
'@types/connect': 3.4.38
- '@types/express': 5.0.6
+ '@types/express': 4.17.25
'@types/keygrip': 1.0.6
'@types/node': 20.19.27
dev: false
optional: true
+ resolution: {integrity: sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==}
+ dependencies:
+ '@types/node': 20.19.27
+ dev: true
+
resolution: {integrity: sha512-cMQm7pxu6BxtHyqJ7mQZ2kXWV5SLmugybFdHCBbJ5eHzOo6VhBckEgAT3//rP5FwPHNPeEiq4SmQ5ucBwsOo4Q==}
dev: true
@@ -3418,26 +3392,21 @@ packages:
resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
- resolution: {integrity: sha512-jnHMsrd0Mwa9Cf4IdOzbz543y4XJepXrbia2T4b6+spXC2We3t1y6K44D3mR8XMFSXMCf3/l7rCgddfx7UNVBA==}
- requiresBuild: true
+ 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
- resolution: {integrity: sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==}
- requiresBuild: true
+ 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
resolution: {integrity: sha512-TTEwmtjgVbYAzZYWyeHPrrtWnfVkm8tQkP8P21uQifPgMRgjrow3XDEYqucuC8SKZJT7pUnhU/JymvjggxO9vw==}
@@ -3448,8 +3417,6 @@ packages:
resolution: {integrity: sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==}
requiresBuild: true
- dev: false
- optional: true
resolution: {integrity: sha512-ED6LB+Z1AVylNTu7hdzuBqOgMnvG/ld6wGCG8wFnAzKX5uyW2K3WD52v0gnLCTK/VLpXtKckgWuyScYK6cSPaw==}
@@ -3506,6 +3473,9 @@ packages:
dev: false
optional: true
+ resolution: {integrity: sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==}
+
resolution: {integrity: sha512-wK1pzsJVVAjYCSZWQoWHziQZbNggXFDUEIGf54g4ZM/ERuP86uGdWeKZWMYlqTPMZfHJJvLPyogXGvCOg87yLQ==}
requiresBuild: true
@@ -3548,14 +3518,10 @@ packages:
resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==}
requiresBuild: true
- dev: false
- optional: true
resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==}
requiresBuild: true
- dev: false
- optional: true
resolution: {integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==}
@@ -3571,22 +3537,24 @@ packages:
csstype: 3.2.3
dev: false
+ resolution: {integrity: sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==}
+ dependencies:
+ '@types/mime': 1.3.5
+ '@types/node': 20.19.27
+
resolution: {integrity: sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==}
requiresBuild: true
dependencies:
'@types/node': 20.19.27
- dev: false
- optional: true
- resolution: {integrity: sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==}
- requiresBuild: true
+ 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
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
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: false
optional: true
+ 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-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
+
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.2
dev: 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.0
dev: 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: false
resolution: {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: false
resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
@@ -5234,6 +5319,11 @@ packages:
- bare-abort-controller
dev: 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.1
dev: 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: false
optional: 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.1
dev: 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.2
dev: 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: true
dev: 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.0
dev: 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: false
optional: 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.2
dev: 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-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-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