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

package/src/helpers/ContextLimiter.ts

@@ -1,228 +0,0 @@
-import { AgentMessage, MessageRole } from '@multiplayer-app/ai-agent-types';
-
-/**
- * Options for limiting chat context
- */
-export interface ContextLimitOptions {
-  /**
-   * Maximum number of messages to include in context.
-   * Default: 50 (common practice: 20-100 messages depending on use case)
-   */
-  maxMessages?: number;
-  
-  /**
-   * Maximum token count (if token counting is implemented).
-   * This is a future enhancement - currently not used.
-   */
-  maxTokens?: number;
-  
-  /**
-   * Whether to always keep the first user message (often contains important context).
-   * Default: true
-   */
-  keepFirstUserMessage?: boolean;
-  
-  /**
-   * Whether to keep all system messages (if any exist).
-   * Default: true
-   */
-  keepSystemMessages?: boolean;
-}
-
-/**
- * Common practices for limiting AI context:
- * 
- * 1. **Message Count Limiting** (implemented here)
- *    - Keep only the last N messages
- *    - Most common and simplest approach
- *    - Typical values: 20-100 messages depending on use case
- * 
- * 2. **Token-Based Limiting** (future enhancement)
- *    - Count tokens and keep messages until hitting token budget
- *    - More accurate for cost control
- *    - Requires token counting library (e.g., tiktoken, @anthropic-ai/tokenizer)
- * 
- * 3. **Hybrid Approach** (future enhancement)
- *    - Combine message count with token budget as safety check
- *    - Best of both worlds
- * 
- * 4. **Sliding Window with Summary** (advanced)
- *    - Keep recent messages + summarize older ones
- *    - Requires summarization step
- * 
- * 5. **Priority-Based** (implemented via keepFirstUserMessage)
- *    - Always keep system messages, first user message, and recent messages
- *    - Preserves important context while limiting size
- */
-export class ContextLimiter {
-  /**
-   * Limits the context by keeping only the most recent messages
-   * while preserving important messages (first user message, system messages).
-   * 
-   * @param messages - All messages from the chat (assumed to be in chronological order)
-   * @param options - Limiting options
-   * @returns Limited array of messages in original order
-   */
-  static limitContext(
-    messages: AgentMessage[],
-    options: ContextLimitOptions = {}
-  ): AgentMessage[] {
-    const {
-      maxMessages = 5,
-      keepFirstUserMessage = true,
-      keepSystemMessages = true,
-    } = options;
-
-    // If we have fewer messages than the limit, return all
-    if (messages.length <= maxMessages) {
-      return messages;
-    }
-
-    // Separate system messages from the rest
-    const systemMessages: AgentMessage[] = [];
-    const nonSystemMessages: AgentMessage[] = [];
-    
-    messages.forEach((msg) => {
-      if (msg.role === MessageRole.System && keepSystemMessages) {
-        systemMessages.push(msg);
-      } else {
-        nonSystemMessages.push(msg);
-      }
-    });
-
-    // Find the first user message (if we need to keep it)
-    const firstUserMessageIndex = keepFirstUserMessage
-      ? nonSystemMessages.findIndex((msg) => msg.role === MessageRole.User)
-      : -1;
-    const firstUserMessage = firstUserMessageIndex >= 0
-      ? nonSystemMessages[firstUserMessageIndex]
-      : undefined;
-
-    // Calculate how many recent messages we can keep
-    // Reserve slots for: system messages
-    let availableSlots = maxMessages - systemMessages.length;
-    const shouldKeepFirstUser = keepFirstUserMessage && firstUserMessage !== undefined;
-
-    // Get the most recent messages (from the end)
-    // We'll check if first user is in recent messages after slicing
-    const recentCount = Math.max(0, availableSlots);
-    const recentStartIndex = Math.max(0, nonSystemMessages.length - recentCount);
-    const recentMessages = nonSystemMessages.slice(recentStartIndex);
-
-    // Check if first user message is already in recent messages
-    const firstUserInRecent = shouldKeepFirstUser && firstUserMessage
-      ? recentMessages.some((msg) => msg.id === firstUserMessage.id)
-      : false;
-
-    // If first user is not in recent and we need to keep it, we need to make room
-    if (shouldKeepFirstUser && firstUserMessage && !firstUserInRecent) {
-      // Remove the oldest recent message to make room for first user message
-      if (recentMessages.length > 0) {
-        recentMessages.shift();
-      }
-    }
-
-    // Build the set of messages to keep
-    const messagesToKeep = new Set<string>();
-    
-    // Add system messages
-    systemMessages.forEach((msg) => messagesToKeep.add(msg.id));
-    
-    // Add first user message if needed
-    if (shouldKeepFirstUser && firstUserMessage) {
-      messagesToKeep.add(firstUserMessage.id);
-    }
-    
-    // Add recent messages
-    recentMessages.forEach((msg) => messagesToKeep.add(msg.id));
-
-    // Reconstruct in original order
-    return messages.filter((msg) => messagesToKeep.has(msg.id));
-  }
-
-  /**
-   * Estimates token count for a message (rough approximation).
-   * For accurate token counting, use a proper tokenizer library.
-   * 
-   * This is a simple approximation: ~4 characters per token for English text.
-   * 
-   * @param message - Message to estimate tokens for
-   * @returns Estimated token count
-   */
-  static estimateTokens(message: AgentMessage): number {
-    const content = typeof message.content === 'string' 
-      ? message.content 
-      : JSON.stringify(message.content);
-    
-    // Rough approximation: 1 token ≈ 4 characters for English
-    // This is a simplified estimate - actual tokenization varies by model
-    const baseTokens = Math.ceil(content.length / 4);
-    
-    // Add overhead for message structure (role, formatting, etc.)
-    const overhead = 10;
-    
-    // Add tokens for tool calls if present
-    const toolCallTokens = message.toolCalls?.reduce((acc, toolCall) => {
-      const inputTokens = Math.ceil(JSON.stringify(toolCall.input).length / 4);
-      const outputTokens = toolCall.output 
-        ? Math.ceil(JSON.stringify(toolCall.output).length / 4)
-        : 0;
-      return acc + inputTokens + outputTokens + 20; // 20 for tool call structure
-    }, 0) || 0;
-    
-    return baseTokens + overhead + toolCallTokens;
-  }
-
-  /**
-   * Limits context by token count (future enhancement).
-   * Currently not implemented - requires proper tokenizer.
-   * 
-   * @param messages - All messages from the chat
-   * @param maxTokens - Maximum token count
-   * @returns Limited array of messages
-   */
-  static limitByTokens(
-    messages: AgentMessage[],
-    maxTokens: number
-  ): AgentMessage[] {
-    // This is a placeholder for token-based limiting
-    // To implement properly, you would:
-    // 1. Install a tokenizer (e.g., tiktoken for OpenAI, @anthropic-ai/tokenizer for Claude)
-    // 2. Count tokens for each message
-    // 3. Keep messages from the end until hitting the token limit
-    // 4. Always keep system messages and optionally first user message
-    
-    let totalTokens = 0;
-    const limitedMessages: AgentMessage[] = [];
-    
-    // Keep system messages first
-    const systemMessages = messages.filter(
-      (msg) => msg.role === MessageRole.System
-    );
-    systemMessages.forEach((msg) => {
-      const tokens = this.estimateTokens(msg);
-      if (totalTokens + tokens <= maxTokens) {
-        limitedMessages.push(msg);
-        totalTokens += tokens;
-      }
-    });
-    
-    // Then keep messages from the end
-    const nonSystemMessages = messages
-      .filter((msg) => msg.role !== MessageRole.System)
-      .reverse();
-    
-    for (const message of nonSystemMessages) {
-      const tokens = this.estimateTokens(message);
-      if (totalTokens + tokens <= maxTokens) {
-        limitedMessages.unshift(message); // Add to beginning to maintain order
-        totalTokens += tokens;
-      } else {
-        break;
-      }
-    }
-    
-    return limitedMessages;
-  }
-}
-

package/src/helpers/FileHelper.ts

@@ -1,197 +0,0 @@
-import type { AgentAttachment } from '@multiplayer-app/ai-agent-types';
-import { AgentAttachmentType } from '@multiplayer-app/ai-agent-types';
-import { s3 } from '../libs/s3';
-import { logger } from '../libs/logger';
-import { PDFParse } from 'pdf-parse';
-import {config} from "../config";
-
-export interface ProcessedAttachment extends AgentAttachment {
-  extractedText?: string;
-  processingStatus?: 'pending' | 'processed' | 'failed';
-}
-
-/**
- * Checks if an attachment is an image
- */
-export function isImage(attachment: AgentAttachment): boolean {
-  if (attachment.type !== AgentAttachmentType.File) return false;
-  const mimeType = attachment.mimeType || '';
-  return mimeType.startsWith('image/');
-}
-
-/**
- * Checks if an attachment is a document that can have text extracted
- */
-export function isDocument(attachment: AgentAttachment): boolean {
-  if (attachment.type !== AgentAttachmentType.File) return false;
-  const mimeType = attachment.mimeType || '';
-  return mimeType.startsWith('text/') || mimeType.startsWith('application/')
-}
-
-/**
- * Extracts text from a document attachment
- */
-export async function extractTextFromDocument(
-  attachment: AgentAttachment
-): Promise<string | undefined> {
-  if (!isDocument(attachment) || attachment.type !== AgentAttachmentType.File) {
-    logger.debug('Attachment is not a document or not a file type', {
-      attachmentId: attachment.id,
-      type: attachment.type,
-      mimeType: attachment.mimeType
-    });
-    return undefined;
-  }
-
-  try {
-    const mimeType = attachment.mimeType || '';
-
-    // All files are stored in S3 (s3Key is in metadata)
-    if (attachment.metadata?.s3Key) {
-      const s3Key = attachment.metadata.s3Key as string;
-      const bucket = config.s3.bucket;
-      if (mimeType === 'application/pdf') {
-        const buffer = await s3.downloadFileAsByteArray(s3Key, bucket);
-        if (buffer) {
-          // Convert Uint8Array to Buffer
-          const nodeBuffer = Buffer.from(buffer);
-          return await extractTextFromPDF(nodeBuffer);
-        }
-      } else if (
-        mimeType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
-      ) {
-        const buffer = await s3.downloadFileAsByteArray(s3Key, bucket);
-        if (buffer) {
-          // Convert Uint8Array to Buffer
-          const nodeBuffer = Buffer.from(buffer);
-          return await extractTextFromDOCX(nodeBuffer);
-        }
-      } else {
-        const text = await s3.downloadFileAsString(s3Key, bucket);
-        return text || undefined;
-      }
-    }
-
-    return undefined;
-  } catch (error) {
-    logger.error('Failed to extract text from document', { error, attachmentId: attachment.id });
-    return undefined;
-  }
-}
-
-/**
- * Extracts text from PDF buffer
- */
-async function extractTextFromPDF(buffer: Buffer): Promise<string | undefined> {
-  try {
-    const {PDFParse} = await import('pdf-parse');
-    const parser = new PDFParse({ data: buffer });
-    const text = (await parser.getText()).text || '';
-
-    // Limit extracted text size
-    const maxSize = Number(process.env.MAX_EXTRACTED_TEXT_SIZE) || 51200;
-    return text.length > maxSize ? text.substring(0, maxSize) + '...' : text;
-  } catch (error) {
-    logger.warn('PDF text extraction failed (pdf-parse may not be installed)', { error });
-    return undefined;
-  }
-}
-
-/**
- * Extracts text from DOCX buffer
- */
-async function extractTextFromDOCX(buffer: Buffer): Promise<string | undefined> {
-  try {
-    const mammoth = await import('mammoth');
-    const result = await mammoth.extractRawText({ buffer });
-    const text = result.value || '';
-
-    // Limit extracted text size
-    const maxSize = Number(process.env.MAX_EXTRACTED_TEXT_SIZE) || 51200;
-    return text.length > maxSize ? text.substring(0, maxSize) + '...' : text;
-  } catch (error) {
-    logger.warn('DOCX text extraction failed (mammoth may not be installed)', { error });
-    return undefined;
-  }
-}
-
-/**
- * Processes an attachment and extracts content as needed
- */
-export async function processAttachment(
-  attachment: AgentAttachment
-): Promise<ProcessedAttachment> {
-  const processed: ProcessedAttachment = { ...attachment };
-
-  // Only process file attachments
-  if (attachment.type !== AgentAttachmentType.File) {
-    return processed;
-  }
-
-  // Check if text extraction is enabled
-  const enableTextExtraction = process.env.ENABLE_TEXT_EXTRACTION !== 'false';
-
-  if (enableTextExtraction && isDocument(attachment)) {
-    try {
-      processed.processingStatus = 'pending';
-      const extractedText = await extractTextFromDocument(attachment);
-      if (extractedText) {
-        processed.extractedText = extractedText;
-        processed.processingStatus = 'processed';
-      } else {
-        processed.processingStatus = 'failed';
-      }
-    } catch (error) {
-      logger.error('Failed to process document attachment', { error, attachmentId: attachment.id });
-      processed.processingStatus = 'failed';
-    }
-  }
-
-  return processed;
-}
-
-/**
- * Prepares an image attachment for vision API
- */
-export async function prepareImageForVisionAPI(attachment: AgentAttachment): Promise<{
-  type: 'image_url';
-  image_url: { url: string };
-} | null> {
-  if (!isImage(attachment) || attachment.type !== AgentAttachmentType.File) {
-    return null;
-  }
-
-  // All files are stored in S3 - generate presigned download URL
-  if (attachment.metadata?.s3Key) {
-    try {
-      const s3Key = attachment.metadata.s3Key as string;
-      const bucket = config.s3.bucket;
-      const buffer = await s3.downloadFileAsByteArray(s3Key, bucket);
-      if(!buffer) {
-        return null;
-      }
-      const mimeType = attachment.mimeType || 'image/png';
-      return {
-        type: 'image_url',
-        image_url: {
-          url: `data:${mimeType};base64,${Buffer.from(buffer).toString('base64')}`,
-        },
-      };
-    } catch (error) {
-      logger.error('Failed to generate presigned URL for S3 image', { error, attachmentId: attachment.id });
-      return null;
-    }
-  }
-
-  // Fallback: If we have a URL (backward compatibility)
-  if (attachment.url) {
-    return {
-      type: 'image_url',
-      image_url: {
-        url: attachment.url,
-      },
-    };
-  }
-
-  return null;
-}

package/src/helpers/SetupHelper.ts

@@ -1,35 +0,0 @@
-import { logger } from '../libs/logger';
-import { agentStore, ModelStore } from '../store';
-import { redisService, kafkaService, ModelFetcher } from '../services';
-import { s3 } from "../libs/s3";
-import { config } from "../config";
-import { AgentChatRepository, AgentMessageRepository } from '@multiplayer-app/ai-agent-db';
-
-export async function fetchModels() {
-    try {
-      const modelFetcher = new ModelFetcher();
-      const models = await modelFetcher.fetchAllModels();
-      ModelStore.getInstance().setModels(models);
-    } catch (error) {
-      logger.error('Failed to fetch models on startup:', error);
-      throw error;
-    }
-}
-
-export function startServices(agentChatRepository: AgentChatRepository, agentMessageRepository: AgentMessageRepository) {
-  kafkaService.setRepositories(agentChatRepository, agentMessageRepository);
-
-  return Promise.all([
-    kafkaService.start(),
-    agentStore.initialize(),
-    fetchModels(),
-    s3.ensureBucketExists(config.s3.bucket),
-  ])
-}
-
-export function stopServices() {
-  return Promise.all([
-    redisService.disconnect(),
-    kafkaService.stop()
-  ])
-}

package/src/helpers/index.ts

@@ -1,5 +0,0 @@
-export * from './AIHelper';
-export * from './ConfigHelper';
-export * from './ContextLimiter';
-export * from './FileHelper';
-export * from './SetupHelper';

package/src/index.ts

@@ -1,18 +0,0 @@
-export { kafkaService } from './services/KafkaService';
-export { redisService } from './services/RedisService';
-export { socketService } from './services/SocketService';
-export { agentStore, AgentProcessEventType } from './store/AgentStore';
-export type { AgentProcessEvent, AgentProcessListener, AgentProcess, AgentProcessEventPayload } from './store/AgentStore';
-export { ConfigStore } from './store/ConfigStore';
-export { ModelStore } from './store/ModelStore';
-export { ArtifactStore } from './store/ArtifactStore';
-export { ChatProcessor, ModelsProcessor } from './processors';
-export { startServices, stopServices } from './helpers/SetupHelper';
-export { createProposeFormValuesTool, proposeFormValuesToolName } from './tools/proposeFormValuesTool';
-export { s3 } from './libs/s3';
-export { setLogger, getLogger, logger, type AgentLogger } from './libs/logger';
-
-export * as store from "./store";
-export * as services from "./services";
-export * as processors from "./processors";
-export * as helpers from "./helpers";

package/src/libs/index.ts

@@ -1,3 +0,0 @@
-export * from './kafka';
-export * from './logger';
-export * from './s3';

package/src/libs/kafka/config.ts

@@ -1,4 +0,0 @@
-export const SERVICE_NAME = process.env.npm_package_name
-export const KAFKA_URI = (process.env.KAFKA_URI as string || 'localhost:9092').split(',')
-export const KAFKA_CLIENT_ID = process.env.KAFKA_CLIENT_ID as string || SERVICE_NAME
-export const KAFKA_SESSION_TIMEOUT = Number.parseInt(process.env.KAFKA_SESSION_TIMEOUT || '30000')

package/src/libs/kafka/consumer.ts

@@ -1,161 +0,0 @@
-import { Consumer, ConsumerRunConfig, IHeaders, Message } from 'kafkajs'
-import logger from '../logger'
-import { kafka } from './kafka'
-import { KAFKA_SESSION_TIMEOUT } from './config'
-
-const startTimer = () => {
-  const startTime = process.hrtime()
-  return startTime
-}
-const getDuration = (startTime) => {
-  const diff = process.hrtime(startTime)
-  return diff[0] * 1e3 + diff[1] * 1e-6
-}
-
-export type KafkaConsumerListener = (key, value, headers?: IHeaders) => void | Promise<void>
-export class KafkaConsumer {
-  private consumer: Consumer
-  private listeners: Record<string, KafkaConsumerListener[]> = {}
-  private lastHeartbeat: number = 0
-
-  constructor(groupId: string) {
-    this.consumer = kafka.consumer({
-      groupId,
-      sessionTimeout: KAFKA_SESSION_TIMEOUT,
-    })
-    this.consumer.on(this.consumer.events.HEARTBEAT, ({ timestamp }) => {
-      this.lastHeartbeat = timestamp
-    })
-    this.consumer.on(this.consumer.events.REQUEST_TIMEOUT, ({ timestamp }) => {
-      this.lastHeartbeat = 0
-    })
-    this.consumer.on(this.consumer.events.CRASH, ({ timestamp }) => {
-      this.lastHeartbeat = 0
-    })
-  }
-
-  public async isConnected() {
-    if (Date.now() - this.lastHeartbeat < KAFKA_SESSION_TIMEOUT) {
-      return true
-    }
-    try {
-      const { state } = await this.consumer.describeGroup()
-      return ['CompletingRebalance', 'PreparingRebalance', 'Stable'].includes(state)
-    } catch (err) {
-      return false
-    }
-  }
-
-  public async connect() {
-    await this.consumer.connect()
-  }
-
-  public async disconnect() {
-    await this.consumer.disconnect()
-  }
-
-  public async subscribe(topic: string, listener: KafkaConsumerListener) {
-    logger.info({ topic }, '[KAFKAJS] Subscribing for topic')
-
-    if (!this.listeners[topic]) {
-      this.listeners[topic] = []
-    }
-    this.listeners[topic].push(listener)
-  }
-
-  private async listenFnWrapper(
-    topic: string,
-    message: Message,
-  ) {
-
-    const parseStartTime = startTimer()
-    try {
-      if (!this.listeners[topic]?.length) {
-        logger.error(`[KAFKAJS] Missing handler for topic ${topic}`)
-      }
-
-      if (!message?.value) {
-        return
-      }
-
-      const key = message?.key?.toString('utf8')
-      const value = JSON.parse(message.value.toString('utf8'))
-      const headers = message.headers
-
-      logger.debug(
-        {
-          topic,
-          key,
-          value,
-        },
-        `[KAFKAJS] Received message from topic ${topic}`,
-      )
-
-      await Promise.all(this.listeners[topic].map(func => func(key, value, headers)))
-
-      logger.debug({
-        key,
-        topic,
-        duration: getDuration(parseStartTime),
-      }, '[KAFKAJS] Done with processing data from kafka')
-    } catch (err) {
-      logger.error(err, '[KAFKAJS] Error on handling incoming message')
-    }
-  }
-
-  public async listen(options: Omit<ConsumerRunConfig, 'eachMessage' | 'eachBatch'> = {
-    partitionsConsumedConcurrently: 3, autoCommit: true,
-  }) {
-    const topics = Object.keys(this.listeners)
-
-    await this.consumer.subscribe({
-      topics,
-      fromBeginning: true,
-    })
-
-    await this.consumer.run({
-      autoCommit: true,
-      ...options,
-      eachMessage: async ({ topic, message }) => this.listenFnWrapper(topic, message),
-    })
-  }
-
-  public async listenBatch(options: Omit<ConsumerRunConfig, 'eachMessage' | 'eachBatch'>) {
-    const topics = Object.keys(this.listeners)
-
-    await this.consumer.subscribe({
-      topics,
-      fromBeginning: true,
-    })
-
-    await this.consumer.run({
-      eachBatchAutoResolve: true,
-      ...options,
-      eachBatch: async ({
-        batch,
-        resolveOffset,
-        heartbeat,
-        commitOffsetsIfNecessary,
-        uncommittedOffsets,
-        isRunning,
-        isStale,
-        pause,
-      }) => {
-        for (const message of batch.messages) {
-          if (!this.listeners[batch.topic]?.length) {
-            logger.error(`[KAFKAJS] Missing handler for topic ${batch.topic}`)
-          }
-
-          try {
-            await Promise.all(batch.messages.map(message => this.listenFnWrapper(batch.topic, message)))
-          } catch (batchError) {
-            logger.error(batchError, '[KAFKAJS] Batch fn error')
-          }
-
-          resolveOffset(message.offset)
-          await heartbeat()
-        }
-      },
-    })
-  }
-}

package/src/libs/kafka/index.ts

@@ -1,2 +0,0 @@
-export * from './consumer'
-export * from './producer'

package/src/libs/kafka/kafka.ts

@@ -1,27 +0,0 @@
-import { Kafka, logLevel } from 'kafkajs'
-import { KAFKA_CLIENT_ID, KAFKA_URI } from './config'
-import { KafkaJsLogCreator } from '../logger'
-
-
-const toBunyanLogLevel = level => {
-  switch (level) {
-    case logLevel.ERROR:
-    case logLevel.NOTHING:
-      return 'error'
-    case logLevel.WARN:
-      return 'warn'
-    case logLevel.INFO:
-      return 'info'
-    case logLevel.DEBUG:
-      return 'debug'
-    default:
-      return 'info'
-  }
-}
-
-
-export const kafka = new Kafka({
-  clientId: KAFKA_CLIENT_ID,
-  brokers: KAFKA_URI,
-  logCreator: KafkaJsLogCreator(toBunyanLogLevel),
-})