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

package/src/services/SocketService.ts

@@ -1,153 +0,0 @@
-import { Server as SocketIOServer } from 'socket.io';
-import type { Server as HTTPServer } from 'http';
-import { createAdapter } from '@socket.io/redis-adapter';
-import type { AgentChatResponse, AgentMessage } from '@multiplayer-app/ai-agent-types';
-import { SocketIOEvents, SocketIOConfig } from '@multiplayer-app/ai-agent-types';
-import { redisService } from './RedisService';
-import { logger } from '../libs/logger';
-export interface SocketError extends Error {
-  message: string
-  data?: {
-    code: number
-  }
-}
-
-export class SocketIOError extends Error implements SocketError {
-  public data: { code: number }
-
-  constructor(message: string, code: number) {
-    super(message)
-    this.data = { code }
-  }
-}
-
-type Middleware = <REQUEST = any, RESPONSE = any>(request: REQUEST, response: RESPONSE, next?: (error?: SocketError) => void) => void | Promise<void>;
-
-const authWrap = (middleware?: Middleware, reqParams?: Record<string, string>) => async (socket, next) => {
-  if (!middleware) {
-    return next();
-  }
-  const req = socket.request as any
-
-  const _headers = Object.fromEntries(
-    Object.entries(socket?.handshake?.auth || {})
-      .map(([key, value]) => ([key.toLowerCase(), value])),
-  ) as any
-
-  req.headers = {
-    ...(req.headers || {}),
-    ...(_headers),
-  }
-
-  if (reqParams) {
-    req.params = reqParams
-  }
-  
-  try {
-    await middleware(req, {}, (err: any) => {
-      if (err) {
-        return next(new SocketIOError(err.message, err?.statusCode || 401))
-      }
-      return next()
-    })
-  } catch (error: any) {
-    return next(new SocketIOError(error?.message || 'Authorization failed', error?.statusCode || 401))
-  }
-}
-
-
-export class SocketService {
-  private io: SocketIOServer | null = null;
-  
-  async initialize(httpServer: HTTPServer, authorizationMiddleware?: Middleware): Promise<void> {
-    this.io = new SocketIOServer(httpServer, {
-      cors: {
-        origin: true,
-        credentials: true
-      },
-      path: SocketIOConfig.Path
-    });
-
-    // Set up Redis adapter for multi-server support
-    try {
-      const { pubClient, subClient } = await redisService.getPubSubClients('socketio');
-      this.io.adapter(createAdapter(pubClient, subClient));
-      logger.debug('Socket.IO Redis adapter initialized');
-    } catch (error) {
-      logger.error('Failed to initialize Redis adapter for Socket.IO:', error);
-      // Continue without adapter - single server mode
-      logger.warn('Socket.IO running without Redis adapter (single server mode)');
-    }
-
-    this.io.use(authWrap(authorizationMiddleware))
-
-    this.io.on('connection', (socket) => {
-      // Extract userId from handshake auth or query
-      const userId = (socket.request as any).userId as string
-
-      // Reject connection if no userId is provided
-      if (!userId) {
-        logger.debug(`Socket connection rejected: no userId provided for socket ${socket.id}`);
-        socket.disconnect(true);
-        return;
-      }
-
-      // Join user-specific room
-      const userRoom = `${SocketIOConfig.UserRoomPrefix}${userId}`;
-      socket.join(userRoom);
-
-      logger.debug(`Socket connected: ${socket.id} for user: ${userId}`);
-
-      socket.on('disconnect', () => {
-        logger.debug(`Socket disconnected: ${socket.id} for user: ${userId}`);
-      });
-    });
-  }
-
-  /**
-   * Emit a new chat event to a specific user
-   */
-  emitNewChat(userId: string, chat: AgentChatResponse): void {
-    if (!this.io) return;
-    const userRoom = `${SocketIOConfig.UserRoomPrefix}${userId}`;
-    this.io.to(userRoom).emit(SocketIOEvents.ChatNew, chat);
-    logger.debug(`Emitted ${SocketIOEvents.ChatNew} to user ${userId}:`, { chatId: chat.id });
-  }
-
-  /**
-   * Emit a new message event to a specific user
-   */
-  emitMessageUpdate(userId: string | undefined, message: AgentMessage, excludeSocketId?: string): void {
-    if (!this.io || !userId) return;
-    const userRoom = `${SocketIOConfig.UserRoomPrefix}${userId}`;
-
-    if (excludeSocketId) {
-      this.io.to(userRoom).except(excludeSocketId).emit(SocketIOEvents.MessageNew, message);
-    } else {
-      this.io.to(userRoom).emit(SocketIOEvents.MessageNew, message);
-    }
-  }
-
-  /**
-   * Emit a chat update event to a specific user
-   */
-  emitChatUpdate(userId: string, chat: AgentChatResponse, excludeSocketId?: string): void {
-    if (!this.io) return;
-    const userRoom = `${SocketIOConfig.UserRoomPrefix}${userId}`;
-    if (excludeSocketId) {
-      this.io.to(userRoom).except(excludeSocketId).emit(SocketIOEvents.ChatUpdate, chat);
-    } else {
-      this.io.to(userRoom).emit(SocketIOEvents.ChatUpdate, chat);
-    }
-  }
-
-  /**
-   * Get the Socket.IO server instance
-   */
-  getIO(): SocketIOServer | null {
-    return this.io;
-  }
-}
-
-// Singleton instance
-export const socketService = new SocketService();

package/src/services/index.ts

@@ -1,6 +0,0 @@
-export * from './AIService';
-export * from './KafkaService';
-export * from './RedisService';
-export * from './SocketService';
-export * from './ModelFetcher';
-export * from './InternalEventsHandler';

package/src/store/AgentStore.ts

@@ -1,138 +0,0 @@
-import { InternalEventsHandler } from "../services/InternalEventsHandler";
-import { AgentMessage } from "@multiplayer-app/ai-agent-types";
-
-
-export type AgentProcessListener = (payload: AgentProcessEvent) => void;
-
-export interface AgentProcess {
-  chatId: string;
-  abortController: AbortController;
-  listeners: AgentProcessListener[];
-}
-
-export enum AgentProcessEventType {
-  Stop = 'stop',
-  Finished = 'finished',
-  Error = 'error',
-  Aborted = 'aborted',
-  Update = 'update',
-}
-
-export type AgentProcessEvent = {
-  type: AgentProcessEventType.Update;
-  data: AgentMessage;
-} | {
-  type: AgentProcessEventType.Finished;
-  data: AgentMessage;
-} | {
-  type: AgentProcessEventType.Error;
-  data: Error;
-} | {
-  type: AgentProcessEventType.Aborted;
-  data: void;
-} | {
-  type: AgentProcessEventType.Stop;
-  data: void;
-}
-
-export interface AgentProcessEventPayload {
-  chatId: string;
-  event: AgentProcessEvent;
-}
-
-export class AgentStore {
-  private readonly internalEventsHandler = new InternalEventsHandler('agent-events');
-  private readonly agentProcesses = new Map<string, AgentProcess>();
-
-  async initialize() {
-    await this.internalEventsHandler.listen<AgentProcessEventPayload>((payload: AgentProcessEventPayload) => {
-      switch (payload.event.type) {
-        case AgentProcessEventType.Stop:
-          this.stopAgentProcess(payload.chatId);
-          break;
-        case AgentProcessEventType.Finished:
-        case AgentProcessEventType.Error:
-        case AgentProcessEventType.Aborted:
-          this.publishEvent(payload.chatId, payload.event);
-          this.unregisterAgentProcess(payload.chatId);
-          break;
-        default:
-          this.publishEvent(payload.chatId, payload.event);
-          break;
-      }
-    });
-  }
-
-  async shareAgentProcessEvent(chatId: string, event: AgentProcessEvent) {
-    try {
-      await this.internalEventsHandler.publish<AgentProcessEventPayload>({ chatId, event });
-    } catch (error) {
-      // Fallback: publish locally if Redis fails
-      if (event.type === AgentProcessEventType.Stop) {
-        // Stop must actually abort the running controller, not just notify listeners.
-        this.stopAgentProcess(chatId);
-        return;
-      }
-      this.publishEvent(chatId, event);
-      // If this is a terminal event, also unregister locally
-      if (
-        event.type === AgentProcessEventType.Finished ||
-        event.type === AgentProcessEventType.Error ||
-        event.type === AgentProcessEventType.Aborted
-      ) {
-        this.unregisterAgentProcess(chatId);
-      }
-    }
-  }
-
-  registerAgentProcess(chatId: string): AbortController {
-    if (!this.agentProcesses.has(chatId)) {
-      this.agentProcesses.set(chatId, {
-        chatId,
-        abortController: new AbortController(),
-        listeners: [],
-      });
-    }
-    return this.agentProcesses.get(chatId)!.abortController;
-  }
-
-  unregisterAgentProcess(chatId: string) {
-    this.agentProcesses.delete(chatId);
-  }
-
-  addListener(chatId: string, listener: AgentProcessListener): boolean {
-    const agentProcess = this.agentProcesses.get(chatId);
-    if (agentProcess) {
-      agentProcess.listeners.push(listener);
-      return true;
-    }
-    return false;
-  }
-
-  removeListener(chatId: string, listener: AgentProcessListener) {
-    const agentProcess = this.agentProcesses.get(chatId);
-    if (agentProcess) {
-      agentProcess.listeners = agentProcess.listeners.filter((l) => l !== listener);
-    }
-  }
-
-  publishEvent(chatId: string, event: AgentProcessEvent) {
-    const agentProcess = this.agentProcesses.get(chatId);
-    if (agentProcess) {
-      agentProcess.listeners.forEach((listener) => listener(event));
-    }
-  }
-
-  private stopAgentProcess(chatId: string) {
-    const agentProcess = this.agentProcesses.get(chatId);
-    if (agentProcess) {
-      agentProcess.abortController.abort();
-      this.publishEvent(chatId, { type: AgentProcessEventType.Aborted, data: undefined });
-      // This is terminal. If we keep the process registered, the next send reuses an already-aborted controller
-      // and immediately aborts again, which looks like "next messages not processing".
-      this.unregisterAgentProcess(chatId);
-    }
-  }
-}
-
-export const agentStore = new AgentStore();

package/src/store/ArtifactStore.ts

@@ -1,29 +0,0 @@
-import type { AgentArtifact } from '@multiplayer-app/ai-agent-types';
-
-/**
- * Simple in-memory store for artifacts.
- * In the future, this could be moved to MongoDB or a separate collection.
- */
-export class ArtifactStore {
-  private artifacts = new Map<string, AgentArtifact[]>();
-
-  listArtifacts(chatId: string): AgentArtifact[] {
-    return this.artifacts.get(chatId) ?? [];
-  }
-
-  setArtifacts(chatId: string, artifacts: AgentArtifact[]): void {
-    this.artifacts.set(chatId, artifacts);
-  }
-
-  addArtifact(chatId: string, artifact: AgentArtifact): void {
-    const artifacts = this.artifacts.get(chatId) ?? [];
-    artifacts.unshift(artifact);
-    // Keep only the last 5 artifacts
-    this.artifacts.set(chatId, artifacts.slice(0, 5));
-  }
-
-  deleteArtifacts(chatId: string): void {
-    this.artifacts.delete(chatId);
-  }
-}
-

package/src/store/ConfigStore.test.ts

@@ -1,314 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { ConfigStore } from './ConfigStore';
-
-describe('ConfigStore', () => {
-  let configStore: ConfigStore;
-
-  beforeEach(() => {
-    configStore = ConfigStore.getInstance();
-    configStore.clear();
-  });
-
-  describe('isModelAllowed', () => {
-    describe('when no allowedModels are configured', () => {
-      it('should allow all models', () => {
-        configStore.loadConfig({ agents: [] });
-
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('anthropic/claude-3-5-sonnet')).toBe(true);
-        expect(configStore.isModelAllowed('any-model')).toBe(true);
-      });
-    });
-
-    describe('wildcard patterns', () => {
-      it('should allow all models if no provider is specified', () => {
-        configStore.loadConfig({ agents: [], models: ['gpt-4'] });
-
-        expect(configStore.isModelAllowed('gpt-4')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4')).toBe(true);
-        expect(configStore.isModelAllowed('anyprovider/gpt-4')).toBe(true);
-      });
-      it('should restrict by provider if it is specified', () => {
-        configStore.loadConfig({ agents: [], models: ['openai/gpt-4'] });
-
-        expect(configStore.isModelAllowed('gpt-4')).toBe(false);
-        expect(configStore.isModelAllowed('openai/gpt-4')).toBe(true);
-        expect(configStore.isModelAllowed('anyprovider/gpt-4')).toBe(false);
-      });
-
-      it('should use provider parameter when model id is provided separately', () => {
-        configStore.loadConfig({ agents: [], models: ['openai/gpt-4'] });
-
-        // When provider is provided and model doesn't have provider prefix, construct as 'provider/model'
-        expect(configStore.isModelAllowed('gpt-4', 'openai')).toBe(true);
-        expect(configStore.isModelAllowed('gpt-4', 'anthropic')).toBe(false);
-        
-        // When model already has provider prefix, use it as-is (provider parameter is ignored)
-        expect(configStore.isModelAllowed('openai/gpt-4', 'openrouter')).toBe(true);
-        expect(configStore.isModelAllowed('openrouter/openai/gpt-4', 'openrouter')).toBe(false);
-      });
-
-      it('should handle OpenRouter provider with full model path in id', () => {
-        configStore.loadConfig({ agents: [], models: ['openai/gpt-4'] });
-
-        // For OpenRouter, the model id already contains the full path
-        expect(configStore.isModelAllowed('openai/gpt-4', 'openrouter')).toBe(true);
-        expect(configStore.isModelAllowed('anthropic/claude-3-5-sonnet', 'openrouter')).toBe(false);
-      });
-
-      it('should match patterns with wildcard at the end', () => {
-        configStore.loadConfig({
-          models: ['openai/gpt-4*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4-turbo')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4o-mini')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-3.5-turbo')).toBe(false);
-        expect(configStore.isModelAllowed('anthropic/claude-3-5-sonnet')).toBe(false);
-      });
-
-      it('should match patterns with wildcard at the beginning', () => {
-        configStore.loadConfig({
-          models: ['*/gpt-4o'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openrouter/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('custom/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4-turbo')).toBe(false);
-      });
-
-      it('should match patterns with wildcard in the middle', () => {
-        configStore.loadConfig({
-          models: ['openai/gpt-*o'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-3.5-turbo')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4-turbo')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4')).toBe(false);
-      });
-
-      it('should match patterns with multiple wildcards', () => {
-        configStore.loadConfig({
-          models: ['openai/*-*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4-turbo')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt4')).toBe(false);
-      });
-
-      it('should match provider wildcard patterns', () => {
-        configStore.loadConfig({
-          models: ['anthropic/*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('anthropic/claude-3-5-sonnet')).toBe(true);
-        expect(configStore.isModelAllowed('anthropic/claude-3-opus')).toBe(true);
-        expect(configStore.isModelAllowed('anthropic/claude-2')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(false);
-        expect(configStore.isModelAllowed('openrouter/gpt-4o')).toBe(false);
-      });
-
-      it('should match openrouter wildcard patterns', () => {
-        configStore.loadConfig({
-          models: ['openrouter/*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openrouter/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openrouter/claude-3-5-sonnet')).toBe(true);
-        expect(configStore.isModelAllowed('openrouter/any-model')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(false);
-      });
-    });
-
-    describe('exact matches', () => {
-      it('should match exact model identifiers', () => {
-        configStore.loadConfig({
-          models: ['openai/gpt-4o', 'anthropic/claude-3-5-sonnet'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('anthropic/claude-3-5-sonnet')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4-turbo')).toBe(false);
-        expect(configStore.isModelAllowed('anthropic/claude-3-opus')).toBe(false);
-      });
-    });
-
-    describe('multiple patterns', () => {
-      it('should allow models matching any pattern', () => {
-        configStore.loadConfig({
-          models: ['openai/gpt-4*', 'anthropic/*', 'openrouter/*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4-turbo')).toBe(true);
-        expect(configStore.isModelAllowed('anthropic/claude-3-5-sonnet')).toBe(true);
-        expect(configStore.isModelAllowed('openrouter/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('google/gemini-pro')).toBe(false);
-      });
-
-      it('should handle overlapping patterns correctly', () => {
-        configStore.loadConfig({
-          models: ['openai/*', 'openai/gpt-4*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-3.5-turbo')).toBe(true);
-        expect(configStore.isModelAllowed('openai/davinci')).toBe(true);
-      });
-    });
-
-    describe('edge cases', () => {
-      it('should handle empty model string', () => {
-        configStore.loadConfig({
-          models: ['openai/*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('')).toBe(false);
-      });
-
-      it('should handle patterns with special regex characters', () => {
-        configStore.loadConfig({
-          models: ['openai/gpt-4.5*', 'model.with.dots*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openai/gpt-4.5')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4.5-turbo')).toBe(true);
-        expect(configStore.isModelAllowed('model.with.dots')).toBe(true);
-        expect(configStore.isModelAllowed('model.with.dots-v2')).toBe(true);
-      });
-
-      it('should escape special characters correctly', () => {
-        configStore.loadConfig({
-          models: ['model+plus*', 'model(version)*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('model+plus')).toBe(true);
-        expect(configStore.isModelAllowed('model+plus-v2')).toBe(true);
-        expect(configStore.isModelAllowed('model(version)')).toBe(true);
-        expect(configStore.isModelAllowed('model(version)-v2')).toBe(true);
-      });
-
-      it('should handle patterns with question marks and other special chars', () => {
-        configStore.loadConfig({
-          models: ['model?test*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('model?test')).toBe(true);
-        expect(configStore.isModelAllowed('model?test-v2')).toBe(true);
-      });
-
-      it('should handle patterns with brackets', () => {
-        configStore.loadConfig({
-          models: ['model[version]*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('model[version]')).toBe(true);
-        expect(configStore.isModelAllowed('model[version]-v2')).toBe(true);
-      });
-
-      it('should handle patterns with dollar signs and caret', () => {
-        configStore.loadConfig({
-          models: ['model$test*', 'model^test*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('model$test')).toBe(true);
-        expect(configStore.isModelAllowed('model$test-v2')).toBe(true);
-        expect(configStore.isModelAllowed('model^test')).toBe(true);
-        expect(configStore.isModelAllowed('model^test-v2')).toBe(true);
-      });
-    });
-
-    describe('real-world examples', () => {
-      it('should match examples from config.json', () => {
-        configStore.loadConfig({
-          models: ['openai/gpt-4*', 'anthropic/*'],
-          agents: []
-        });
-
-        // OpenAI GPT-4 variants
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4-turbo')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4')).toBe(true);
-        expect(configStore.isModelAllowed('openai/gpt-4o-mini')).toBe(true);
-
-        // Anthropic models
-        expect(configStore.isModelAllowed('anthropic/claude-3-5-sonnet-20241022')).toBe(true);
-        expect(configStore.isModelAllowed('anthropic/claude-3-opus-20240229')).toBe(true);
-        expect(configStore.isModelAllowed('anthropic/claude-2.1')).toBe(true);
-
-        // Should not match
-        expect(configStore.isModelAllowed('openai/gpt-3.5-turbo')).toBe(false);
-        expect(configStore.isModelAllowed('google/gemini-pro')).toBe(false);
-        expect(configStore.isModelAllowed('openrouter/gpt-4o')).toBe(false);
-      });
-
-      it('should match openrouter pattern', () => {
-        configStore.loadConfig({
-          models: ['openrouter/*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openrouter/openai/gpt-4o')).toBe(true);
-        expect(configStore.isModelAllowed('openrouter/anthropic/claude-3-5-sonnet')).toBe(true);
-        expect(configStore.isModelAllowed('openrouter/meta-llama/llama-3-70b-instruct')).toBe(true);
-      });
-    });
-
-    describe('getAllowedModels', () => {
-      it('should return a copy of allowed models', () => {
-        const models = ['openai/gpt-4*', 'anthropic/*'];
-        configStore.loadConfig({
-          models,
-          agents: []
-        });
-
-        const allowed = configStore.getAllowedModels();
-        expect(allowed).toEqual(models);
-        expect(allowed).not.toBe(configStore.getAllowedModels()); // Should be a new array
-      });
-
-      it('should return empty array when no models configured', () => {
-        configStore.loadConfig({ agents: [] });
-        expect(configStore.getAllowedModels()).toEqual([]);
-      });
-    });
-
-
-    describe('clear method', () => {
-      it('should clear allowedModels when clear is called', () => {
-        configStore.loadConfig({
-          models: ['openai/gpt-4*'],
-          agents: []
-        });
-
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-
-        configStore.clear();
-
-        // After clear, should allow all (no patterns configured)
-        expect(configStore.isModelAllowed('openai/gpt-4o')).toBe(true);
-        expect(configStore.getAllowedModels()).toEqual([]);
-      });
-    });
-  });
-});