@multiplayer-app/ai-agent-node 0.0.1

package/src/services/SocketService.ts

@@ -0,0 +1,153 @@
+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

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

package/src/store/AgentStore.ts

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,314 @@
+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([]);
+      });
+    });
+  });
+});