@multiplayer-app/ai-agent-node 0.0.1 → 0.1.0-beta.2

package/src/services/ModelFetcher.ts

@@ -1,286 +0,0 @@
-import type { ModelOption } from '@multiplayer-app/ai-agent-types';
-import { config as appConfig } from '../config';
-import { logger } from '../libs/logger';
-
-export interface ModelFetcherConfig {
-  openaiApiKey?: string;
-  anthropicApiKey?: string;
-  googleApiKey?: string;
-  openrouterApiKey?: string;
-}
-
-export interface FetchedModel {
-  id: string;
-  provider: string;
-  label?: string;
-  description?: string;
-}
-
-export class ModelFetcher {
-  private config: ModelFetcherConfig;
-
-  constructor(config: ModelFetcherConfig = {}) {
-    this.config = {
-      openaiApiKey: config.openaiApiKey || appConfig.ai.openaiApiKey,
-      anthropicApiKey: config.anthropicApiKey || appConfig.ai.anthropicApiKey,
-      googleApiKey: config.googleApiKey || appConfig.ai.googleApiKey,
-      openrouterApiKey: config.openrouterApiKey || appConfig.ai.openrouterApiKey
-    };
-  }
-
-  /**
-   * Analyze environment and fetch models for all available providers
-   */
-  async fetchAllModels(): Promise<ModelOption[]> {
-    logger.info('Fetching available AI models...');
-    const allModels: ModelOption[] = [];
-    const providers = this.detectAvailableProviders();
-
-    for (const provider of providers) {
-      try {
-        const models = await this.fetchModelsForProvider(provider);
-        allModels.push(...models);
-      } catch (error) {
-        logger.warn(`Failed to fetch models for provider ${provider}:`, error instanceof Error ? error.message : 'Unknown error');
-      }
-    }
-
-    return allModels;
-  }
-
-  /**
-   * Detect which providers are available based on API keys
-   */
-  private detectAvailableProviders(): string[] {
-    const providers: string[] = [];
-    
-    if (this.config.openrouterApiKey) {
-      providers.push('openrouter');
-      return providers;
-    }
-
-    if (this.config.openaiApiKey) {
-      providers.push('openai');
-    }
-    if (this.config.anthropicApiKey) {
-      providers.push('anthropic');
-    }
-    if (this.config.googleApiKey) {
-      providers.push('google');
-    }
-    return providers;
-  }
-
-  /**
-   * Fetch models for a specific provider
-   */
-  async fetchModelsForProvider(provider: string): Promise<ModelOption[]> {
-    switch (provider) {
-      case 'openai':
-        return this.fetchOpenAIModels();
-      case 'anthropic':
-        return this.fetchAnthropicModels();
-      case 'google':
-        return this.fetchGoogleModels();
-      case 'openrouter':
-        return this.fetchOpenRouterModels();
-      default:
-        throw new Error(`Unsupported provider: ${provider}`);
-    }
-  }
-
-  /**
-   * Fetch models from OpenAI
-   */
-  private async fetchOpenAIModels(): Promise<ModelOption[]> {
-    if (!this.config.openaiApiKey) {
-      return [];
-    }
-
-    try {
-      const response = await fetch('https://api.openai.com/v1/models', {
-        headers: {
-          'Authorization': `Bearer ${this.config.openaiApiKey}`,
-          'Content-Type': 'application/json'
-        }
-      });
-
-      if (!response.ok) {
-        throw new Error(`OpenAI API returned ${response.status}: ${response.statusText}`);
-      }
-
-      const data = await response.json();
-      const models: ModelOption[] = (data.data || [])
-        .filter((model: any) => model.id.startsWith('gpt-') || model.id.startsWith('o1'))
-        .map((model: any) => ({
-          id: model.id,
-          provider: 'openai',
-          label: this.formatModelLabel(model.id),
-          description: this.getModelDescription(model.id, 'openai')
-        }));
-
-      return models;
-    } catch (error) {
-      logger.error('Failed to fetch OpenAI models:', error);
-      return [];
-    }
-  }
-
-  /**
-   * Fetch models from Anthropic
-   */
-  private async fetchAnthropicModels(): Promise<ModelOption[]> {
-    if (!this.config.anthropicApiKey) {
-      return [];
-    }
-
-    try {
-      const response = await fetch('https://api.anthropic.com/v1/models', {
-        headers: {
-          'x-api-key': this.config.anthropicApiKey,
-          'anthropic-version': '2023-06-01',
-          'Content-Type': 'application/json'
-        }
-      });
-
-      if (!response.ok) {
-        throw new Error(`Anthropic API returned ${response.status}: ${response.statusText}`);
-      }
-
-      const data = await response.json();
-      const models: ModelOption[] = (data.data || [])
-        .filter((model: any) => model.id && model.id.startsWith('claude-'))
-        .map((model: any) => ({
-          id: model.id,
-          provider: 'anthropic',
-          label: this.formatModelLabel(model.id),
-          description: this.getModelDescription(model.id, 'anthropic')
-        }));
-
-      return models;
-    } catch (error) {
-      logger.error('Failed to fetch Anthropic models:', error);
-      return [];
-    }
-  }
-
-  /**
-   * Fetch models from Google
-   */
-  private async fetchGoogleModels(): Promise<ModelOption[]> {
-    if (!this.config.googleApiKey) {
-      return [];
-    }
-
-    try {
-      // Google SDK doesn't have a models.list() endpoint
-      // Return known Google models
-      return [
-        {
-          id: 'gemini-2.0-flash-exp',
-          provider: 'google',
-          label: 'Gemini 2.0 Flash',
-          description: 'Google\'s latest fast and efficient model'
-        },
-        {
-          id: 'gemini-1.5-pro',
-          provider: 'google',
-          label: 'Gemini 1.5 Pro',
-          description: 'Google\'s advanced multimodal model'
-        },
-        {
-          id: 'gemini-1.5-flash',
-          provider: 'google',
-          label: 'Gemini 1.5 Flash',
-          description: 'Fast and efficient Gemini model'
-        },
-        {
-          id: 'gemini-pro',
-          provider: 'google',
-          label: 'Gemini Pro',
-          description: 'Google Gemini Pro model'
-        }
-      ];
-    } catch (error) {
-      logger.error('Failed to fetch Google models:', error);
-      return [];
-    }
-  }
-
-  /**
-   * Fetch models from OpenRouter
-   */
-  private async fetchOpenRouterModels(): Promise<ModelOption[]> {
-    if (!this.config.openrouterApiKey) {
-      return [];
-    }
-
-    try {
-      const response = await fetch('https://openrouter.ai/api/v1/models?supported_parameters=tools', {
-        headers: {
-          'Authorization': `Bearer ${this.config.openrouterApiKey}`,
-          'Content-Type': 'application/json'
-        }
-      });
-
-      if (!response.ok) {
-        throw new Error(`OpenRouter API returned ${response.status}: ${response.statusText}`);
-      }
-
-      const data = await response.json();
-      const models: ModelOption[] = (data.data || []).map((model: any) => ({
-        id: model.id,
-        provider: model.id.split('/')[0],
-        label: model.name || this.formatModelLabel(model.id),
-        description: model.description || `OpenRouter model: ${model.id}`
-      }))
-      .filter((model: ModelOption) => 
-        model.provider === 'openai' || 
-        model.provider === 'anthropic' || 
-        model.provider === 'google')
-      .map((model: ModelOption) => ({
-        ...model,
-        provider: 'openrouter'
-      }));
-      return models;
-    } catch (error) {
-      logger.error('Failed to fetch OpenRouter models:', error);
-      return [];
-    }
-  }
-
-  /**
-   * Format model ID into a readable label
-   */
-  private formatModelLabel(modelId: string): string {
-    // Convert "gpt-4o" to "GPT-4o"
-    return modelId
-      .split('-')
-      .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-      .join(' ');
-  }
-
-  /**
-   * Get description for known models
-   */
-  private getModelDescription(modelId: string, provider: string): string | undefined {
-    const descriptions: Record<string, string> = {
-      // OpenAI models
-      'gpt-4o': 'OpenAI\'s most advanced multimodal model',
-      'gpt-4o-mini': 'Faster and more affordable GPT-4o variant',
-      'gpt-4-turbo': 'High-performance GPT-4 variant',
-      'gpt-4': 'OpenAI GPT-4 model',
-      'gpt-3.5-turbo': 'Fast and efficient GPT-3.5 model',
-      'o1-preview': 'OpenAI O1 reasoning model',
-      'o1-mini': 'OpenAI O1 Mini reasoning model',
-      // Anthropic models
-      'claude-3-5-sonnet-20241022': 'Anthropic\'s latest and most capable model',
-      'claude-3.5-sonnet-20241022': 'Anthropic\'s latest and most capable model',
-      'claude-3-opus-20240229': 'Anthropic\'s most powerful model',
-      'claude-3-sonnet-20240229': 'Balanced performance and speed',
-      'claude-3-haiku-20240307': 'Fastest and most affordable Claude model'
-    };
-
-    return descriptions[modelId] || `${provider} model: ${modelId}`;
-  }
-}

package/src/services/RedisService.ts

@@ -1,285 +0,0 @@
-import { createClient, RedisClientType } from 'redis';
-import { config, getRedisUrl } from '../config';
-import { logger } from '../libs/logger';
-
-export interface RedisConfig {
-  url?: string;
-  host?: string;
-  port?: number;
-  password?: string;
-  database?: number;
-}
-
-type RedisPubSubClient = ReturnType<typeof createClient>;
-type RedisPubSubPair = { pubClient: RedisPubSubClient; subClient: RedisPubSubClient };
-
-export class RedisService {
-  private client: RedisClientType | null = null;
-  private pubSubClients: Map<string, RedisPubSubPair> = new Map();
-  private isConnected: boolean = false;
-
-  /**
-   * Initialize Redis client connection
-   */
-  async initialize(redisConfigOverride?: RedisConfig): Promise<void> {
-    if (this.client && this.isConnected) {
-      logger.info('Redis client already initialized');
-      return;
-    }
-
-    const redisUrl = redisConfigOverride?.url || 
-                     config.redis.url || 
-                     `redis://${redisConfigOverride?.host || config.redis.host}:${redisConfigOverride?.port || config.redis.port}`;
-
-    const redisConfig: any = {
-      url: redisUrl
-    };
-
-    if (redisConfigOverride?.password || config.redis.password) {
-      redisConfig.password = redisConfigOverride?.password || config.redis.password;
-    }
-
-    if (redisConfigOverride?.database !== undefined || config.redis.database !== undefined) {
-      redisConfig.database = redisConfigOverride?.database ?? config.redis.database ?? 0;
-    }
-
-    this.client = createClient(redisConfig);
-
-    this.client.on('error', (err) => {
-      logger.error('Redis Client Error:', err);
-      this.isConnected = false;
-    });
-
-    this.client.on('connect', () => {
-      logger.info('Redis Client connecting...');
-    });
-
-    this.client.on('ready', () => {
-      logger.info('Redis Client ready');
-      this.isConnected = true;
-    });
-
-    this.client.on('reconnecting', () => {
-      logger.info('Redis Client reconnecting...');
-    });
-
-    this.client.on('end', () => {
-      logger.info('Redis Client connection ended');
-      this.isConnected = false;
-    });
-
-    try {
-      await this.client.connect();
-      logger.info('Redis client connected successfully');
-    } catch (error) {
-      logger.error('Failed to connect to Redis:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Get a value by key
-   */
-  async get(key: string): Promise<string | null> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    return await this.client.get(key);
-  }
-
-  /**
-   * Set a key-value pair
-   */
-  async set(key: string, value: string, options?: { EX?: number; PX?: number }): Promise<void> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    await this.client.set(key, value, options);
-  }
-
-  /**
-   * Delete a key
-   */
-  async del(key: string): Promise<number> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    return await this.client.del(key);
-  }
-
-  /**
-   * Check if a key exists
-   */
-  async exists(key: string): Promise<number> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    return await this.client.exists(key);
-  }
-
-  /**
-   * Set expiration on a key
-   * @returns true if the timeout was set, false if the key doesn't exist
-   */
-  async expire(key: string, seconds: number): Promise<boolean> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    return (await this.client.expire(key, seconds)) === 1;
-  }
-
-  /**
-   * Get TTL (time to live) of a key
-   */
-  async ttl(key: string): Promise<number> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    return await this.client.ttl(key);
-  }
-
-  /**
-   * Increment a key's value
-   */
-  async incr(key: string): Promise<number> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    return await this.client.incr(key);
-  }
-
-  /**
-   * Decrement a key's value
-   */
-  async decr(key: string): Promise<number> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    return await this.client.decr(key);
-  }
-
-  /**
-   * Get multiple keys
-   */
-  async mGet(keys: string[]): Promise<(string | null)[]> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    return await this.client.mGet(keys);
-  }
-
-  /**
-   * Set multiple key-value pairs
-   */
-  async mSet(keyValuePairs: Record<string, string>): Promise<void> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    await this.client.mSet(keyValuePairs);
-  }
-
-  /**
-   * Get all keys matching a pattern
-   */
-  async keys(pattern: string): Promise<string[]> {
-    if (!this.client || !this.isConnected) {
-      throw new Error('Redis client not initialized or not connected');
-    }
-    return await this.client.keys(pattern);
-  }
-
-  /**
-   * Get the Redis client instance
-   */
-  getClient(): RedisClientType | null {
-    return this.client;
-  }
-
-  /**
-   * Get or create pub/sub clients for Socket.IO adapter
-   * These are separate clients needed for the Redis adapter
-   */
-  async getPubSubClients(name: string = 'default'): Promise<RedisPubSubPair> {
-    const existingPair = this.pubSubClients.get(name);
-    if (existingPair) {
-      return existingPair;
-    }
-
-    const redisUrl = getRedisUrl();
-    const redisConfig: any = {
-      url: redisUrl
-    };
-
-    if (config.redis.password) {
-      redisConfig.password = config.redis.password;
-    }
-
-    if (config.redis.database !== undefined) {
-      redisConfig.database = config.redis.database;
-    }
-
-    // Create pub client
-    const pubClient = createClient(redisConfig);
-
-    // Create sub client as duplicate of pub client
-    const subClient = pubClient.duplicate();
-
-    // Set up error handlers
-    pubClient.on('error', (err) => {
-      logger.error('Redis Pub Client Error:', err);
-    });
-
-    subClient.on('error', (err) => {
-      logger.error('Redis Sub Client Error:', err);
-    });
-
-    // Connect both clients
-    try {
-      await Promise.all([pubClient.connect(), subClient.connect()]);
-      logger.info(`Redis pub/sub clients connected successfully for ${name}`);
-      const pair = { pubClient, subClient };
-      this.pubSubClients.set(name, pair);
-      return pair;
-    } catch (error) {
-      logger.error(`Failed to connect Redis pub/sub clients for ${name}:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Check if the client is connected
-   */
-  isClientConnected(): boolean {
-    return this.isConnected;
-  }
-
-  /**
-   * Disconnect from Redis
-   */
-  async disconnect(): Promise<void> {
-    const disconnectPromises: Promise<void>[] = [];
-
-    if (this.client) {
-      disconnectPromises.push(this.client.quit().then(() => {
-        this.client = null;
-      }));
-    }
-
-    this.pubSubClients.forEach(({ pubClient, subClient }) => {
-      disconnectPromises.push(
-        pubClient.quit().then(() => undefined).catch(() => undefined)
-      );
-      disconnectPromises.push(
-        subClient.quit().then(() => undefined).catch(() => undefined)
-      );
-    });
-    this.pubSubClients.clear();
-
-    await Promise.all(disconnectPromises);
-    this.isConnected = false;
-    logger.info('Redis clients disconnected');
-  }
-}
-// Singleton instance
-export const redisService = new RedisService();
-