onairos 2.0.7 → 2.0.9

package/src/sdk/MemoryManager.js

@@ -1,290 +0,0 @@
-import { Pinecone } from '@pinecone-database/pinecone';
-import OpenAI from 'openai';
-import { extractMemory } from '../utils/extractMemory.js';
-import { v4 as uuidv4 } from 'uuid';
-
-/**
- * Memory Manager for RAG functionality
- * Handles vector storage, memory extraction, and retrieval
- */
-export class MemoryManager {
-  constructor({ pineconeApiKey, pineconeEnvironment, indexName, openaiApiKey }) {
-    this.pinecone = new Pinecone({
-      apiKey: pineconeApiKey,
-      environment: pineconeEnvironment
-    });
-    
-    this.openai = new OpenAI({ apiKey: openaiApiKey });
-    this.indexName = indexName || 'onairos-memory';
-    this.index = null;
-    this.embeddingModel = 'text-embedding-3-small';
-    this.embeddingDimension = 1536;
-  }
-
-  /**
-   * Initialize the memory manager and create index if needed
-   */
-  async initialize() {
-    try {
-      // Check if index exists
-      const indexList = await this.pinecone.listIndexes();
-      const indexExists = indexList.indexes?.some(index => index.name === this.indexName);
-
-      if (!indexExists) {
-        // Create index if it doesn't exist
-        await this.pinecone.createIndex({
-          name: this.indexName,
-          dimension: this.embeddingDimension,
-          metric: 'cosine',
-          spec: {
-            serverless: {
-              cloud: 'aws',
-              region: 'us-east-1'
-            }
-          }
-        });
-
-        // Wait for index to be ready
-        await this._waitForIndexReady();
-      }
-
-      this.index = this.pinecone.index(this.indexName);
-    } catch (error) {
-      console.warn(`Failed to initialize Pinecone index: ${error.message}`);
-      // Continue without vector storage for development
-    }
-  }
-
-  /**
-   * Wait for index to be ready
-   */
-  async _waitForIndexReady() {
-    let attempts = 0;
-    const maxAttempts = 30;
-    
-    while (attempts < maxAttempts) {
-      try {
-        const indexStats = await this.pinecone.describeIndex(this.indexName);
-        if (indexStats.status?.ready) {
-          return;
-        }
-      } catch (error) {
-        // Index might not be ready yet
-      }
-      
-      await new Promise(resolve => setTimeout(resolve, 2000));
-      attempts++;
-    }
-    
-    throw new Error('Index failed to become ready within timeout');
-  }
-
-  /**
-   * Generate embedding for text using OpenAI
-   * @param {string} text - Text to embed
-   * @returns {Promise<Array>} Embedding vector
-   */
-  async getEmbedding(text) {
-    try {
-      const response = await this.openai.embeddings.create({
-        model: this.embeddingModel,
-        input: text.substring(0, 8000), // Limit text length
-        encoding_format: 'float'
-      });
-      
-      return response.data[0].embedding;
-    } catch (error) {
-      console.error('Failed to generate embedding:', error.message);
-      return null;
-    }
-  }
-
-  /**
-   * Store interaction in vector database
-   * @param {string} userId - User identifier
-   * @param {string} query - User query
-   * @param {string} response - Assistant response
-   */
-  async storeInteraction(userId, query, response) {
-    try {
-      // Extract selected memory data (not raw interactions)
-      const memoryData = extractMemory({ query, response });
-      
-      if (!memoryData || !this.index) {
-        return; // Skip if no meaningful memory or no index
-      }
-
-      // Generate embedding for the memory data
-      const embedding = await this.getEmbedding(memoryData);
-      
-      if (!embedding) {
-        return; // Skip if embedding generation failed
-      }
-
-      // Store in vector database
-      const vectorId = `${userId}-${uuidv4()}`;
-      
-      await this.index.upsert([{
-        id: vectorId,
-        values: embedding,
-        metadata: {
-          userId,
-          data: memoryData,
-          timestamp: new Date().toISOString(),
-          query: query.substring(0, 500), // Store truncated query for context
-          type: 'memory'
-        }
-      }]);
-
-      console.log(`Stored memory for user ${userId}: ${memoryData.substring(0, 100)}...`);
-    } catch (error) {
-      console.error('Failed to store interaction:', error.message);
-    }
-  }
-
-  /**
-   * Retrieve relevant memory for a query using RAG
-   * @param {string} userId - User identifier
-   * @param {string} query - Current query
-   * @returns {Promise<Array>} Array of relevant memory data
-   */
-  async retrieveMemory(userId, query) {
-    try {
-      if (!this.index || !query.trim()) {
-        return [];
-      }
-
-      // Generate embedding for the query
-      const queryEmbedding = await this.getEmbedding(query);
-      
-      if (!queryEmbedding) {
-        return [];
-      }
-
-      // Search for similar memories
-      const searchResults = await this.index.query({
-        vector: queryEmbedding,
-        topK: 5,
-        filter: {
-          userId: { $eq: userId },
-          type: { $eq: 'memory' }
-        },
-        includeMetadata: true
-      });
-
-      // Extract and return relevant memory data
-      const memories = searchResults.matches
-        .filter(match => match.score > 0.7) // Only high-confidence matches
-        .map(match => match.metadata.data)
-        .filter(data => data && data.length > 0);
-
-      return [...new Set(memories)]; // Remove duplicates
-    } catch (error) {
-      console.error('Failed to retrieve memory:', error.message);
-      return [];
-    }
-  }
-
-  /**
-   * Clear all memory for a specific user
-   * @param {string} userId - User identifier
-   */
-  async clearUserMemory(userId) {
-    try {
-      if (!this.index) {
-        return;
-      }
-
-      // Query all vectors for the user
-      const queryResults = await this.index.query({
-        vector: new Array(this.embeddingDimension).fill(0),
-        topK: 10000,
-        filter: {
-          userId: { $eq: userId }
-        },
-        includeMetadata: false
-      });
-
-      // Delete all user vectors
-      const vectorIds = queryResults.matches.map(match => match.id);
-      
-      if (vectorIds.length > 0) {
-        await this.index.deleteMany(vectorIds);
-        console.log(`Cleared ${vectorIds.length} memory entries for user ${userId}`);
-      }
-    } catch (error) {
-      console.error('Failed to clear user memory:', error.message);
-    }
-  }
-
-  /**
-   * Get user memory summary
-   * @param {string} userId - User identifier
-   * @returns {Promise<Array>} Array of memory entries with metadata
-   */
-  async getUserMemory(userId) {
-    try {
-      if (!this.index) {
-        return [];
-      }
-
-      const queryResults = await this.index.query({
-        vector: new Array(this.embeddingDimension).fill(0),
-        topK: 100,
-        filter: {
-          userId: { $eq: userId },
-          type: { $eq: 'memory' }
-        },
-        includeMetadata: true
-      });
-
-      return queryResults.matches.map(match => ({
-        id: match.id,
-        data: match.metadata.data,
-        timestamp: match.metadata.timestamp,
-        query: match.metadata.query
-      }));
-    } catch (error) {
-      console.error('Failed to get user memory:', error.message);
-      return [];
-    }
-  }
-
-  /**
-   * Store custom memory entry
-   * @param {string} userId - User identifier
-   * @param {string} memoryData - Memory data to store
-   * @param {string} category - Memory category (optional)
-   */
-  async storeCustomMemory(userId, memoryData, category = 'custom') {
-    try {
-      if (!this.index || !memoryData.trim()) {
-        return;
-      }
-
-      const embedding = await this.getEmbedding(memoryData);
-      
-      if (!embedding) {
-        return;
-      }
-
-      const vectorId = `${userId}-${category}-${uuidv4()}`;
-      
-      await this.index.upsert([{
-        id: vectorId,
-        values: embedding,
-        metadata: {
-          userId,
-          data: memoryData,
-          timestamp: new Date().toISOString(),
-          category,
-          type: 'memory'
-        }
-      }]);
-
-      console.log(`Stored custom memory for user ${userId}: ${memoryData.substring(0, 100)}...`);
-    } catch (error) {
-      console.error('Failed to store custom memory:', error.message);
-    }
-  }
-} 

package/src/sdk/OnairosClient.js

@@ -1,152 +0,0 @@
-import { LLMWrapper } from './LLMWrapper.js';
-import { MemoryManager } from './MemoryManager.js';
-import { SessionManager } from './SessionManager.js';
-
-/**
- * Main Onairos SDK Client
- * Provides a unified completion API with RAG-enhanced personalization
- */
-export class OnairosClient {
-  constructor({ 
-    openaiApiKey, 
-    anthropicApiKey, 
-    googleApiKey,
-    pineconeApiKey, 
-    pineconeEnvironment, 
-    jwtSecret,
-    indexName = 'onairos-memory'
-  }) {
-    this.llmWrapper = new LLMWrapper({ 
-      openaiApiKey, 
-      anthropicApiKey, 
-      googleApiKey 
-    });
-    
-    this.memoryManager = new MemoryManager({ 
-      pineconeApiKey, 
-      pineconeEnvironment,
-      indexName,
-      openaiApiKey // For embeddings
-    });
-    
-    this.sessionManager = new SessionManager({ jwtSecret });
-  }
-
-  /**
-   * Initialize the client (sets up vector store)
-   */
-  async initialize() {
-    await this.memoryManager.initialize();
-  }
-
-  /**
-   * Create a completion with RAG enhancement
-   * @param {Object} params - Completion parameters
-   * @param {string} params.model - Model name (e.g., 'gpt-4', 'claude-3-sonnet', 'gemini-pro')
-   * @param {Array} params.messages - Array of message objects
-   * @param {string} params.userId - User identifier
-   * @param {string} params.sessionToken - Session token for validation
-   * @param {Object} params.options - Additional options (temperature, max_tokens, etc.)
-   * @returns {Promise<Object>} Completion response
-   */
-  async completions({ model, messages, userId, sessionToken, options = {} }) {
-    try {
-      // Validate session
-      const { userId: validatedUserId } = await this.sessionManager.validateSession(sessionToken);
-      if (validatedUserId !== userId) {
-        throw new Error('Invalid session: User ID mismatch');
-      }
-
-      // Extract query text from the last message
-      const lastMessage = messages[messages.length - 1];
-      const query = typeof lastMessage.content === 'string' 
-        ? lastMessage.content 
-        : lastMessage.content[0]?.text || '';
-
-      // Retrieve relevant memory data using RAG
-      const memoryContext = await this.memoryManager.retrieveMemory(userId, query);
-
-      // Construct prompt with RAG context if memory exists
-      let augmentedMessages = [...messages];
-      if (memoryContext.length > 0) {
-        const contextMessage = {
-          role: 'system',
-          content: `Context from previous interactions: ${memoryContext.join(' | ')}`
-        };
-        
-        // Insert context before the last user message
-        augmentedMessages = [
-          ...messages.slice(0, -1),
-          contextMessage,
-          lastMessage
-        ];
-      }
-
-      // Call LLM with augmented messages
-      const response = await this.llmWrapper.createCompletion({ 
-        model, 
-        messages: augmentedMessages,
-        options
-      });
-
-      // Extract and store selected memory data
-      await this.memoryManager.storeInteraction(userId, query, response.content);
-
-      return {
-        id: response.id || `onairos-${Date.now()}`,
-        object: 'chat.completion',
-        created: Math.floor(Date.now() / 1000),
-        model: model,
-        choices: [{
-          index: 0,
-          message: {
-            role: 'assistant',
-            content: response.content
-          },
-          finish_reason: response.finish_reason || 'stop'
-        }],
-        usage: response.usage || {
-          prompt_tokens: 0,
-          completion_tokens: 0,
-          total_tokens: 0
-        }
-      };
-
-    } catch (error) {
-      throw new Error(`Onairos completion failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Create a completion (alias for completions for OpenAI compatibility)
-   */
-  async create(params) {
-    return this.completions(params);
-  }
-
-  /**
-   * Generate a session token for a user
-   * @param {string} userId - User identifier
-   * @returns {string} JWT session token
-   */
-  generateSessionToken(userId) {
-    return this.sessionManager.generateSessionToken(userId);
-  }
-
-  /**
-   * Clear memory for a specific user
-   * @param {string} userId - User identifier
-   */
-  async clearUserMemory(userId) {
-    await this.memoryManager.clearUserMemory(userId);
-  }
-
-  /**
-   * Get user memory summary
-   * @param {string} userId - User identifier
-   * @returns {Promise<Array>} Array of memory entries
-   */
-  async getUserMemory(userId) {
-    return this.memoryManager.getUserMemory(userId);
-  }
-} 

package/src/sdk/SessionManager.js

@@ -1,257 +0,0 @@
-import jwt from 'jsonwebtoken';
-import { v4 as uuidv4 } from 'uuid';
-
-/**
- * Session Manager for user authentication and isolation
- * Handles JWT token generation and validation
- */
-export class SessionManager {
-  constructor({ jwtSecret }) {
-    if (!jwtSecret) {
-      throw new Error('JWT secret is required for session management');
-    }
-    this.jwtSecret = jwtSecret;
-    this.defaultExpiration = '24h'; // Default session duration
-  }
-
-  /**
-   * Generate a session token for a user
-   * @param {string} userId - User identifier
-   * @param {Object} options - Token options
-   * @param {string} options.expiresIn - Token expiration time
-   * @param {Object} options.additionalClaims - Additional claims to include
-   * @returns {string} JWT session token
-   */
-  generateSessionToken(userId, options = {}) {
-    try {
-      const {
-        expiresIn = this.defaultExpiration,
-        additionalClaims = {}
-      } = options;
-
-      const sessionId = `session_${uuidv4()}`;
-      const issuedAt = Math.floor(Date.now() / 1000);
-
-      const payload = {
-        userId,
-        sessionId,
-        iat: issuedAt,
-        type: 'onairos_session',
-        ...additionalClaims
-      };
-
-      const token = jwt.sign(payload, this.jwtSecret, {
-        expiresIn,
-        issuer: 'onairos-sdk',
-        audience: 'onairos-client'
-      });
-
-      return token;
-    } catch (error) {
-      throw new Error(`Failed to generate session token: ${error.message}`);
-    }
-  }
-
-  /**
-   * Validate a session token
-   * @param {string} token - JWT token to validate
-   * @returns {Promise<Object>} Decoded token payload
-   */
-  async validateSession(token) {
-    return new Promise((resolve, reject) => {
-      if (!token) {
-        reject(new Error('No token provided'));
-        return;
-      }
-
-      jwt.verify(token, this.jwtSecret, {
-        issuer: 'onairos-sdk',
-        audience: 'onairos-client'
-      }, (err, decoded) => {
-        if (err) {
-          if (err.name === 'TokenExpiredError') {
-            reject(new Error('Session token has expired'));
-          } else if (err.name === 'JsonWebTokenError') {
-            reject(new Error('Invalid session token'));
-          } else {
-            reject(new Error(`Token validation failed: ${err.message}`));
-          }
-          return;
-        }
-
-        // Validate token type
-        if (decoded.type !== 'onairos_session') {
-          reject(new Error('Invalid token type'));
-          return;
-        }
-
-        resolve(decoded);
-      });
-    });
-  }
-
-  /**
-   * Refresh a session token
-   * @param {string} token - Current token to refresh
-   * @param {Object} options - Refresh options
-   * @returns {Promise<string>} New session token
-   */
-  async refreshSession(token, options = {}) {
-    try {
-      const decoded = await this.validateSession(token);
-      
-      // Generate new token with same user ID but new session ID
-      return this.generateSessionToken(decoded.userId, {
-        expiresIn: options.expiresIn || this.defaultExpiration,
-        additionalClaims: options.additionalClaims || {}
-      });
-    } catch (error) {
-      throw new Error(`Failed to refresh session: ${error.message}`);
-    }
-  }
-
-  /**
-   * Extract user ID from token without full validation
-   * @param {string} token - JWT token
-   * @returns {string|null} User ID or null if invalid
-   */
-  extractUserId(token) {
-    try {
-      const decoded = jwt.decode(token);
-      return decoded?.userId || null;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Check if token is expired
-   * @param {string} token - JWT token
-   * @returns {boolean} True if expired
-   */
-  isTokenExpired(token) {
-    try {
-      const decoded = jwt.decode(token);
-      if (!decoded || !decoded.exp) {
-        return true;
-      }
-      
-      const currentTime = Math.floor(Date.now() / 1000);
-      return decoded.exp < currentTime;
-    } catch (error) {
-      return true;
-    }
-  }
-
-  /**
-   * Get token expiration time
-   * @param {string} token - JWT token
-   * @returns {Date|null} Expiration date or null if invalid
-   */
-  getTokenExpiration(token) {
-    try {
-      const decoded = jwt.decode(token);
-      if (!decoded || !decoded.exp) {
-        return null;
-      }
-      
-      return new Date(decoded.exp * 1000);
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Create a guest session token (for anonymous users)
-   * @param {Object} options - Token options
-   * @returns {string} Guest session token
-   */
-  generateGuestToken(options = {}) {
-    const guestId = `guest_${uuidv4()}`;
-    return this.generateSessionToken(guestId, {
-      expiresIn: options.expiresIn || '1h',
-      additionalClaims: {
-        type: 'guest',
-        ...options.additionalClaims
-      }
-    });
-  }
-
-  /**
-   * Validate session and ensure user access
-   * @param {string} token - Session token
-   * @param {string} expectedUserId - Expected user ID
-   * @returns {Promise<Object>} Validation result
-   */
-  async validateUserAccess(token, expectedUserId) {
-    try {
-      const decoded = await this.validateSession(token);
-      
-      if (decoded.userId !== expectedUserId) {
-        throw new Error('User ID mismatch - access denied');
-      }
-
-      return {
-        valid: true,
-        userId: decoded.userId,
-        sessionId: decoded.sessionId,
-        isGuest: decoded.type === 'guest'
-      };
-    } catch (error) {
-      return {
-        valid: false,
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Generate API key for server-to-server communication
-   * @param {string} clientId - Client identifier
-   * @param {Array} scopes - API scopes
-   * @returns {string} API key token
-   */
-  generateApiKey(clientId, scopes = []) {
-    try {
-      const payload = {
-        clientId,
-        scopes,
-        type: 'api_key',
-        iat: Math.floor(Date.now() / 1000)
-      };
-
-      return jwt.sign(payload, this.jwtSecret, {
-        issuer: 'onairos-sdk',
-        audience: 'onairos-api'
-      });
-    } catch (error) {
-      throw new Error(`Failed to generate API key: ${error.message}`);
-    }
-  }
-
-  /**
-   * Validate API key
-   * @param {string} apiKey - API key to validate
-   * @returns {Promise<Object>} Validation result
-   */
-  async validateApiKey(apiKey) {
-    return new Promise((resolve, reject) => {
-      jwt.verify(apiKey, this.jwtSecret, {
-        issuer: 'onairos-sdk',
-        audience: 'onairos-api'
-      }, (err, decoded) => {
-        if (err) {
-          reject(new Error(`Invalid API key: ${err.message}`));
-          return;
-        }
-
-        if (decoded.type !== 'api_key') {
-          reject(new Error('Invalid key type'));
-          return;
-        }
-
-        resolve(decoded);
-      });
-    });
-  }
-}