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

package/src/processors/ModelsProcessor.ts

@@ -1,34 +0,0 @@
-import { ModelStore } from "../store";
-
-const providerNames: Record<string, string> = {
-    openai: 'OpenAI',
-    anthropic: 'Anthropic',
-    google: 'Google',
-    openrouter: 'OpenRouter'
-};
-export class ModelsProcessor {
-  
-   async getModels() {
-    const modelStore = ModelStore.getInstance();
-  
-    if (!modelStore.hasModels()) {
-      // Return empty if models haven't been loaded yet
-      return {
-        models: [],
-        providers: []
-      };
-    }
-  
-    const models = modelStore.getModels();
-    const providers = modelStore.getProviders();
-  
-    return {
-      models,
-      providers: providers.map((providerId) => ({
-        id: providerId,
-        name: providerNames[providerId] || providerId,
-        models: modelStore.getModelsByProvider(providerId)
-      }))
-    };
-  }  
-}

package/src/processors/index.ts

@@ -1,2 +0,0 @@
-export * from './ChatProcessor';
-export * from './ModelsProcessor';

package/src/services/AIService.ts

@@ -1,241 +0,0 @@
-import { openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { google } from '@ai-sdk/google';
-import { z } from 'zod';
-import {
-  generateText,
-  streamText,
-  type LanguageModel,
-  ModelMessage,
-  ToolSet,
-  tool,
-  Tool,
-  ToolExecutionOptions,
-} from 'ai';
-import type { AgentApiTool, AgentLocalFunctionTool, AgentConfig, ToolChoice, AgentTool, ModelOption, AdditionalContext} from '@multiplayer-app/ai-agent-types';
-import { AgentToolType } from '@multiplayer-app/ai-agent-types';
-import { ModelStore } from '../store/ModelStore';
-import { createOpenRouter } from '@openrouter/ai-sdk-provider';
-import { config } from '../config';
-import { logger } from '../libs/logger';
-export interface GenerateTextOptions {
-  messages: ModelMessage[],
-  system?: string;
-  temperature?: number;
-  maxOutputTokens?: number;
-  topP?: number;
-  toolChoice?: ToolChoice<ToolSet>;
-  tools?: ToolSet;
-  model?: string;
-  signal?: AbortSignal;
-}
-
-export interface StreamTextOptions extends GenerateTextOptions {
-  onChunk?: (chunk: any) => void;
-  onError?: (error: Error) => void;
-  onFinish?: (data: { text: string, finishReason: string, usage: any, response: any, steps: any, totalUsage: any }) => void;
-  onAbort?: (data: any) => void;
-  onStepFinish?: (step: any) => void;
-}
-
-export interface LocalFunctionTool extends Omit<Tool, 'title'> {
-  title: string;
-}
-
-export class AIService {
-  private modelStore: ModelStore;
-
-  constructor(modelStore: ModelStore) {
-    this.modelStore = modelStore;
-  }
-
-  getLanguageModel(modelId: string | undefined, websearchEnabled: boolean): LanguageModel {
-    const selectedModel = modelId || config.ai.defaultModel || this.modelStore.getModels()[0].id;
-    const model = selectedModel ?
-      this.modelStore.getModelById(selectedModel) :
-      this.modelStore.getModels()[0]; //get first model if no model is selected
-    if (!model) {
-      throw new Error(`Model with id "${selectedModel}" is not available. Ensure you have appropriate key in the environment variables.`);
-    }
-    return this.createLanguageModel(model, websearchEnabled);
-  }
-
-  /**
-   * Create a language model instance based on the provider
-   */
-  private createLanguageModel(model: ModelOption, websearchEnabled = false): LanguageModel {
-    const provider = model.provider || 'openai'; // Default to openai if provider not specified
-    switch (provider) {
-      case 'openai':
-        return openai(model.id)
-      case 'anthropic':
-        return anthropic(model.id)
-      case 'google':
-        return google(model.id)
-      case 'openrouter':
-        return createOpenRouter({
-          apiKey: config.ai.openrouterApiKey,
-        })(model.id, { plugins: websearchEnabled ? [{ id: "web", engine: undefined, max_results: 2 }] : [] }) as unknown as LanguageModel;
-      default:
-        throw new Error(`Unsupported provider: ${provider}`);
-    }
-  }
-
-  private getWebSearchTool(modelId?: string): Tool | undefined {
-    const selectedModel = modelId || config.ai.defaultModel || this.modelStore.getModels()[0].id;
-    const model = selectedModel ?
-      this.modelStore.getModelById(selectedModel) :
-      this.modelStore.getModels()[0]; //get first model if no model is selected
-    if (!model) {
-      throw new Error(`Model with id "${selectedModel}" is not available. Ensure you have appropriate key in the environment variables.`);
-    }
-    switch (model.provider) {
-      case 'openai':
-        return openai.tools.webSearch() as Tool
-      case 'anthropic':
-        return anthropic.tools.webSearch_20250305() as Tool
-      case 'google':
-        return google.tools.googleSearch({}) as Tool
-      case 'openrouter': // is set through plugins
-        return undefined
-      default:
-        return undefined;
-    }
-  }
-
-  private getTool(toolConfig: AgentTool<LocalFunctionTool>, modelId?: string, context?: AdditionalContext): Tool | undefined {
-    if (toolConfig.type === AgentToolType.API_TOOL) {
-      const data = toolConfig.data as AgentApiTool;
-      return tool<{ body: Record<string, any>, queryParams: Record<string, any> }, any>({
-        title: data.title,
-        description: data.description,
-        needsApproval: data.needsApproval,
-        inputSchema: z.object({
-          body: data.body ? data.body : z.any().optional(),
-          queryParams: data.queryParams ? data.queryParams : z.any().optional()
-        }),
-        execute: async (input: { body: Record<string, any>, queryParams: Record<string, any> }) => {
-          try {
-            let url = data.url;
-            const params: RequestInit = { method: data.method }
-            if (data.body) {
-              params.body = JSON.stringify(input.body);
-            }
-            if (data.queryParams) {
-              url = url + '?' + new URLSearchParams(input.queryParams as Record<string, string>).toString();
-            }
-            if (data.headersToPass) {
-              params.headers = data.headersToPass.reduce((acc, headerName) => {
-                acc[headerName] = context?.headers?.[headerName] ?? '';
-                return acc;
-              }, {})
-            }
-
-              const response = await fetch(url, params);
-              const result = await response.json();
-              return result;
-            } catch (error) {
-              return error;
-            }
-          }
-      })
-    }
-
-    if (toolConfig.type === AgentToolType.WEB_SEARCH) {
-      return this.getWebSearchTool(modelId);
-    }
-    if (toolConfig.type === AgentToolType.LOCAL_FUNCTION) {
-      const data = toolConfig.data as AgentLocalFunctionTool<Tool>;
-      // Support both "tool definition" objects and already-constructed Tool instances.
-      if (data && typeof data.execute === 'function') {
-        type ExecuteInput = Parameters<typeof data.execute>[0];
-        return tool({
-          ...data,
-          execute: async (input: ExecuteInput, options?: ToolExecutionOptions) => {
-            return data.execute(input, context, options)
-          }
-        });
-      }
-      return tool(data as Tool);
-    }
-    return undefined;
-  }
-
-
-  // getToolLoopAgent(config: AgentConfig, modelId?: string): Agent<ToolSet, never, never> {
-  //   const tools: ToolSet = config.tools.reduce((acc, toolConfig) => {
-  //     const tool = this.getTool(toolConfig, modelId);
-  //     if (tool && toolConfig.data?.name) {
-  //       acc[toolConfig.data.name] = tool
-  //     }
-  //     return acc;
-  //   }, {} as ToolSet);
-
-  //   return new Agent({
-  //     model: this.getLanguageModel(modelId || config.defaultModel),
-  //     system: config.systemPrompt,
-  //     tools,
-  //     ...(config.outputSchema ? { output: Output.object({ schema: config.outputSchema})} : {})
-  //   });
-  // }
-
-  getAgentOptions(config: AgentConfig<LocalFunctionTool>, modelId?: string, context?: AdditionalContext): Omit<GenerateTextOptions, 'messages'> & {name: string} {
-    const tools: ToolSet = config.tools.reduce((acc, toolConfig) => {
-      const tool = this.getTool(toolConfig, modelId, context);
-      if (tool && toolConfig.data?.title) {
-        acc[toolConfig.data.title] = tool
-      }
-      return acc;
-    }, {} as ToolSet);
-    return {
-      model: modelId || config.defaultModel,
-      tools,
-      system: config.systemPrompt,
-      toolChoice: config.toolChoice,
-      name: config.name,
-    };
-  }
-
-
-  async generateText(options: GenerateTextOptions): Promise<string> {
-    const websearchEnabled = !!options.tools?.[AgentToolType.WEB_SEARCH];
-    try {
-      const { text } = await generateText({
-        ...options,
-        model: this.getLanguageModel(options.model, websearchEnabled),
-      });
-
-      return text;
-    } catch (error) {
-      logger.error(error);
-      throw new Error(`Failed to generate text: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  streamText(options: StreamTextOptions): ReturnType<typeof streamText> {
-    const { onError, onChunk, onFinish, onStepFinish } = options;
-
-    const websearchEnabled = !!options.tools?.[AgentToolType.WEB_SEARCH];
-    try {
-      return streamText({
-        ...options,
-        model: this.getLanguageModel(options.model, websearchEnabled),
-        onError({ error }) {
-          logger.error(error);
-          onError?.(error as Error);
-        },
-        onChunk(chunk) {
-          onChunk?.(chunk);
-        },
-        onFinish({ text, finishReason, usage, response, steps, totalUsage }) {
-          onFinish?.({ text, finishReason, usage, response, steps, totalUsage });
-        },
-        onStepFinish(step) {
-          onStepFinish?.(step);
-        }
-      });
-    } catch (error) {
-      throw new Error(`Failed to stream text: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-}

package/src/services/InternalEventsHandler.ts

@@ -1,61 +0,0 @@
-import { redisService } from './RedisService';
-import { logger } from '../libs/logger';
-
-type RedisPubSubClient = Awaited<ReturnType<typeof redisService.getPubSubClients>>['pubClient'];
-
-/**
- * Lightweight Redis pub/sub helper to share events across service replicas.
- */
-export class InternalEventsHandler<T = unknown> {
-  constructor(private readonly channel: string) {}
-
-  private pubClient: RedisPubSubClient | null = null;
-  private subClient: RedisPubSubClient | null = null;
-  private initialized = false;
-  private subscribed = false;
-
-  private async ensureClients(): Promise<void> {
-    if (this.initialized) return;
-
-    const { pubClient, subClient } = await redisService.getPubSubClients(this.channel);
-    this.pubClient = pubClient;
-    this.subClient = subClient;
-    this.initialized = true;
-  }
-
-  /**
-   * Publish a payload to a channel.
-   */
-  async publish<T>(payload: T): Promise<number> {
-    await this.ensureClients();
-    if (!this.pubClient) {
-      throw new Error('Redis pub client not available');
-    }
-    const message = JSON.stringify(payload);
-    return this.pubClient.publish(this.channel, message);
-  }
-
-  /**
-   * Subscribe to a channel and handle messages.
-   */
-  async listen<T>(handler: (payload: T) => void | Promise<void>): Promise<void> {
-    await this.ensureClients();
-    if (!this.subClient) {
-      throw new Error('Redis sub client not available');
-    }
-
-    if (this.subscribed) {
-      return;
-    }
-    this.subscribed = true;
-
-    await this.subClient.subscribe(this.channel, async (message) => {
-      try {
-        const parsed = JSON.parse(message) as T;
-        await handler(parsed);
-      } catch (error) {
-        logger.error(`InternalEventsHandler failed to process message on ${this.channel}:`, error);
-      }
-    });
-  }
-}

package/src/services/KafkaService.ts

@@ -1,142 +0,0 @@
-import { KafkaConsumer, KafkaProducer } from '../libs/kafka'
-import { config } from '../config'
-
-import { AIHelper } from '../helpers/AIHelper'
-import {logger} from "../libs/logger";
-import {socketService} from "./SocketService";
-import type { AgentChatRepository, AgentMessageRepository } from '@multiplayer-app/ai-agent-db';
-
-enum BackgroundChatProcessingEvent {
-  Start = 'start',
-}
-
-class KafkaService {
-  private kafkaConsumer: KafkaConsumer
-  private kafkaProducer: KafkaProducer
-  private chatRepository?: AgentChatRepository
-  private messageRepository?: AgentMessageRepository
-
-  private readonly MAX_RETRIES = 5
-  private readonly BASE_DELAY_MS = 1000 // 1 second base delay
-  private readonly MAX_DELAY_MS = 60000 // 60 seconds max delay
-
-  constructor(chatRepository?: AgentChatRepository, messageRepository?: AgentMessageRepository) {
-    this.kafkaConsumer = new KafkaConsumer(config.kafka.groupId)
-    this.kafkaProducer = new KafkaProducer()
-    this.chatRepository = chatRepository
-    this.messageRepository = messageRepository
-  }
-
-  setRepositories(chatRepository: AgentChatRepository, messageRepository: AgentMessageRepository) {
-    this.chatRepository = chatRepository
-    this.messageRepository = messageRepository
-  }
-
-  async start() {
-    await Promise.all([this.connect(), this.kafkaProducer.connect()])
-  }
-
-  async stop() {
-    await Promise.all([this.kafkaConsumer.disconnect(), this.kafkaProducer.disconnect()])
-  }
-
-  async sendStartBackgroundAgentEvent(chatId: string) {
-    await this.kafkaProducer.send(config.kafka.backgroundChatProcessingTopic, { event: BackgroundChatProcessingEvent.Start, chatId })
-  }
-
-  async sendChatTitleGenerationEvent(chatId: string, retryCount: number = 0) {
-    await this.kafkaProducer.send(config.kafka.chatTitleGenerationTopic, { chatId, retryCount })
-  }
-
-  private async sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms))
-  }
-
-  private calculateBackoffDelay(retryCount: number): number {
-    // Exponential backoff: baseDelay * 2^retryCount with jitter
-    const exponentialDelay = this.BASE_DELAY_MS * Math.pow(2, retryCount)
-    // Add jitter (random 0-25% of delay) to prevent thundering herd
-    const jitter = Math.random() * 0.25 * exponentialDelay
-    const delay = exponentialDelay + jitter
-    // Cap at max delay
-    return Math.min(delay, this.MAX_DELAY_MS)
-  }
-
-  async onBackgroundAgentEvent(key, message: { event: BackgroundChatProcessingEvent, chatId: string }) {
-    switch (message.event) {
-      case BackgroundChatProcessingEvent.Start:
-        await this.onStartBackgroundAgentEvent(message.chatId)
-        break
-    }
-  }
-
-  async onChatTitleGenerationEvent(key, message: { chatId: string; retryCount?: number }) {
-    if (!this.chatRepository || !this.messageRepository) {
-      logger.warn('KafkaService: Repositories not set, skipping chat title generation')
-      return
-    }
-    const retryCount = message.retryCount ?? 0
-    try {
-      const chat = await this.chatRepository.findById(message.chatId)
-      if (!chat) {
-        return
-      }
-      const messages = await this.messageRepository.findByChatId(message.chatId)
-      if (messages.length === 0) {
-        return
-      }
-      
-      const title = await AIHelper.generateTitleForMessage(chat.contextKey, messages)
-      await this.chatRepository.update(chat.id, {title})
-      // Update the chat object with the new title before emitting
-      const updatedChat = {
-        ...chat,
-        title
-      }
-      if (chat.userId) socketService.emitChatUpdate(chat.userId, {...updatedChat, messages});
-    } catch (error) {
-      logger.error(`KafkaService: Error generating chat title for chatId ${message.chatId}, retryCount: ${retryCount}`, error)
-      
-      if (retryCount < this.MAX_RETRIES) {
-        const delay = this.calculateBackoffDelay(retryCount)
-        logger.info(`KafkaService: Retrying chat title generation for chatId ${message.chatId} after ${Math.round(delay)}ms (attempt ${retryCount + 1}/${this.MAX_RETRIES})`)
-        
-        await this.sleep(delay)
-        await this.sendChatTitleGenerationEvent(message.chatId, retryCount + 1)
-      } else {
-        logger.error(`KafkaService: Max retries (${this.MAX_RETRIES}) exceeded for chat title generation, chatId: ${message.chatId}`)
-      }
-    }
-  }
-
-  async onStartBackgroundAgentEvent(chatId: string) {
-    if (!this.chatRepository || !this.messageRepository) {
-      logger.warn('KafkaService: Repositories not set, skipping background agent event')
-      return
-    }
-    const chat = await this.chatRepository.findById(chatId)
-    if (!chat) {
-      return
-    }
-    const messages = await this.messageRepository.findByChatId(chatId)
-    if (messages.length === 0) {
-      return
-    }
-
-    // TODO: Implement background agent processing
-
-  }
-
-  async connect() {
-    await this.kafkaConsumer.connect()
-    await this.kafkaConsumer.subscribe(config.kafka.chatTitleGenerationTopic, this.onChatTitleGenerationEvent.bind(this))
-    await this.kafkaConsumer.subscribe(config.kafka.backgroundChatProcessingTopic, this.onBackgroundAgentEvent.bind(this))
-    await this.kafkaConsumer.listen()
-  }
-
-  async disconnect() {
-    await this.kafkaConsumer.disconnect()
-  }
-}
-export const kafkaService = new KafkaService()
-