onairos 1.0.3 → 1.0.5

package/SDK-README.md

@@ -0,0 +1,345 @@
+# Onairos SDK
+
+A unified SDK that wraps OpenAI, Anthropic Claude, and Google Gemini APIs with built-in RAG (Retrieval-Augmented Generation) capabilities for personalized AI interactions.
+
+## 🚀 Features
+
+- **Unified API**: Single interface for OpenAI, Anthropic, and Google Gemini
+- **RAG Enhancement**: Automatic memory storage and retrieval for personalized responses
+- **Drop-in Replacement**: Minimal code changes from existing OpenAI implementations
+- **Session Management**: JWT-based user authentication and isolation
+- **Privacy-Focused**: Stores selected memory data, not raw conversations
+- **Multi-Provider Support**: Seamlessly switch between different LLM providers
+- **Memory Management**: Built-in vector storage with Pinecone integration
+
+## 📦 Installation
+
+```bash
+npm install onairos
+```
+
+## 🔧 Setup
+
+### Environment Variables
+
+Create a `.env` file with your API keys:
+
+```env
+OPENAI_API_KEY=your-openai-api-key
+ANTHROPIC_API_KEY=your-anthropic-api-key
+GOOGLE_API_KEY=your-google-api-key
+PINECONE_API_KEY=your-pinecone-api-key
+PINECONE_ENVIRONMENT=your-pinecone-environment
+JWT_SECRET=your-super-secret-jwt-key
+```
+
+### Basic Setup
+
+```javascript
+import { OnairosClient } from 'onairos';
+
+const onairos = new OnairosClient({
+  openaiApiKey: process.env.OPENAI_API_KEY,
+  anthropicApiKey: process.env.ANTHROPIC_API_KEY, // Optional
+  googleApiKey: process.env.GOOGLE_API_KEY, // Optional
+  pineconeApiKey: process.env.PINECONE_API_KEY,
+  pineconeEnvironment: process.env.PINECONE_ENVIRONMENT,
+  jwtSecret: process.env.JWT_SECRET
+});
+
+// Initialize the SDK
+await onairos.initialize();
+```
+
+## 🔄 Migration from OpenAI
+
+### Before (OpenAI)
+```javascript
+import OpenAI from 'openai';
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+const response = await openai.chat.completions.create({
+  model: 'gpt-4',
+  messages: [
+    { role: 'user', content: 'What is artificial intelligence?' }
+  ]
+});
+```
+
+### After (Onairos)
+```javascript
+import { OnairosClient } from 'onairos';
+const onairos = new OnairosClient(config);
+
+const userId = 'user-123';
+const sessionToken = onairos.generateSessionToken(userId);
+
+const response = await onairos.completions({
+  model: 'gpt-4', // or 'claude-3-sonnet-20240229' or 'gemini-pro'
+  messages: [
+    { role: 'user', content: 'What is artificial intelligence?' }
+  ],
+  userId,
+  sessionToken
+});
+```
+
+## 🎯 Usage Examples
+
+### Basic Completion
+
+```javascript
+const response = await onairos.completions({
+  model: 'gpt-4',
+  messages: [
+    { role: 'user', content: 'Hello, how are you?' }
+  ],
+  userId: 'user-123',
+  sessionToken: sessionToken,
+  options: {
+    temperature: 0.7,
+    max_tokens: 150
+  }
+});
+
+console.log(response.choices[0].message.content);
+```
+
+### Multi-Provider Usage
+
+```javascript
+// OpenAI GPT-4
+const gptResponse = await onairos.completions({
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'Explain quantum computing' }],
+  userId, sessionToken
+});
+
+// Anthropic Claude
+const claudeResponse = await onairos.completions({
+  model: 'claude-3-sonnet-20240229',
+  messages: [{ role: 'user', content: 'Explain quantum computing' }],
+  userId, sessionToken
+});
+
+// Google Gemini
+const geminiResponse = await onairos.completions({
+  model: 'gemini-pro',
+  messages: [{ role: 'user', content: 'Explain quantum computing' }],
+  userId, sessionToken
+});
+```
+
+### RAG Memory Enhancement
+
+The SDK automatically stores and retrieves relevant user context:
+
+```javascript
+// First interaction - stores user preference
+await onairos.completions({
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'My favorite programming language is Python' }],
+  userId, sessionToken
+});
+
+// Later interaction - automatically uses stored context
+const response = await onairos.completions({
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'What language should I use for my next project?' }],
+  userId, sessionToken
+});
+// Response will consider the user's Python preference
+```
+
+### Memory Management
+
+```javascript
+// Get user's stored memories
+const memories = await onairos.getUserMemory(userId);
+console.log(`User has ${memories.length} stored memories`);
+
+// Clear user's memory
+await onairos.clearUserMemory(userId);
+
+// Store custom memory
+await onairos.memoryManager.storeCustomMemory(
+  userId, 
+  "User prefers concise explanations", 
+  "preference"
+);
+```
+
+### Session Management
+
+```javascript
+// Generate session token
+const sessionToken = onairos.generateSessionToken(userId, {
+  expiresIn: '24h',
+  additionalClaims: { role: 'premium' }
+});
+
+// Validate session
+try {
+  const decoded = await onairos.sessionManager.validateSession(sessionToken);
+  console.log('Valid session for user:', decoded.userId);
+} catch (error) {
+  console.log('Invalid session:', error.message);
+}
+
+// Generate guest token
+const guestToken = onairos.sessionManager.generateGuestToken();
+```
+
+## 🤖 Supported Models
+
+### OpenAI
+- `gpt-4`
+- `gpt-4-turbo`
+- `gpt-3.5-turbo`
+- `o1-preview`
+- `o1-mini`
+
+### Anthropic
+- `claude-3-opus-20240229`
+- `claude-3-sonnet-20240229`
+- `claude-3-haiku-20240307`
+- `claude-3-5-sonnet-20241022`
+
+### Google
+- `gemini-pro`
+- `gemini-pro-vision`
+- `gemini-1.5-pro`
+- `gemini-1.5-flash`
+
+## 🧠 How RAG Works
+
+1. **Memory Extraction**: After each interaction, the SDK extracts meaningful information (preferences, goals, context) rather than storing raw conversations
+2. **Vector Storage**: Extracted memories are embedded and stored in Pinecone vector database
+3. **Context Retrieval**: Before each new query, relevant memories are retrieved using semantic search
+4. **Prompt Enhancement**: Retrieved context is automatically injected into the prompt
+5. **Privacy Protection**: Only selected, meaningful data is stored, ensuring user privacy
+
+## 🔒 Security Features
+
+- **JWT Authentication**: Secure session management with configurable expiration
+- **User Isolation**: Each user's memory is completely isolated
+- **Privacy-First**: Only meaningful insights are stored, not raw conversations
+- **Session Validation**: All requests require valid session tokens
+- **API Key Management**: Secure handling of multiple provider API keys
+
+## 📊 Response Format
+
+The SDK returns responses in OpenAI-compatible format:
+
+```javascript
+{
+  "id": "onairos-1234567890",
+  "object": "chat.completion",
+  "created": 1234567890,
+  "model": "gpt-4",
+  "choices": [{
+    "index": 0,
+    "message": {
+      "role": "assistant",
+      "content": "Response content here..."
+    },
+    "finish_reason": "stop"
+  }],
+  "usage": {
+    "prompt_tokens": 10,
+    "completion_tokens": 20,
+    "total_tokens": 30
+  }
+}
+```
+
+## 🛠️ Advanced Configuration
+
+### Custom Memory Extraction
+
+```javascript
+import { extractMemory } from 'onairos';
+
+// Custom memory extraction logic
+const customMemory = extractMemory({
+  query: "I love hiking in the mountains",
+  response: "That's great! Mountain hiking is excellent exercise..."
+});
+```
+
+### Direct Component Access
+
+```javascript
+import { LLMWrapper, MemoryManager, SessionManager } from 'onairos';
+
+// Use components independently
+const llm = new LLMWrapper({ openaiApiKey: 'your-key' });
+const memory = new MemoryManager({ pineconeApiKey: 'your-key' });
+const session = new SessionManager({ jwtSecret: 'your-secret' });
+```
+
+## 🧪 Testing
+
+Run the test suite:
+
+```bash
+node test-sdk.js
+```
+
+Or run the simple example:
+
+```bash
+node example-usage.js
+```
+
+## 📝 TypeScript Support
+
+The SDK includes full TypeScript definitions:
+
+```typescript
+import { OnairosClient, CompletionParams, CompletionResponse } from 'onairos';
+
+const client: OnairosClient = new OnairosClient(config);
+
+const params: CompletionParams = {
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'Hello' }],
+  userId: 'user-123',
+  sessionToken: 'token'
+};
+
+const response: CompletionResponse = await client.completions(params);
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the Apache-2.0 License - see the [LICENSE](LICENSE) file for details.
+
+## 🆘 Support
+
+- 📧 Email: support@onairos.uk
+- 🌐 Website: https://onairos.uk
+- 📚 Documentation: https://docs.onairos.uk
+- 🐛 Issues: https://github.com/zd819/onairos-npm/issues
+
+## 🎉 Benefits
+
+✅ **Unified API** - One interface for all major LLM providers  
+✅ **RAG Enhancement** - Automatic personalization with memory  
+✅ **Drop-in Replacement** - Minimal migration effort  
+✅ **Privacy-Focused** - Selective memory storage  
+✅ **Session Security** - JWT-based authentication  
+✅ **Multi-Provider** - Switch between models seamlessly  
+✅ **Production Ready** - Built for scale and reliability  
+
+---
+
+Made with ❤️ by the Onairos team 

package/debug-overlay.html

@@ -0,0 +1,226 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Debug Onairos Overlay</title>
+    <script src="https://unpkg.com/react@18/umd/react.development.js"></script>
+    <script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"></script>
+    <script src="https://unpkg.com/framer-motion@10/dist/framer-motion.umd.js"></script>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        body {
+            margin: 0;
+            padding: 20px;
+            font-family: Arial, sans-serif;
+            background-color: #f0f0f0;
+        }
+        .debug-container {
+            max-width: 800px;
+            margin: 0 auto;
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+        }
+        .debug-log {
+            background: #f8f9fa;
+            border: 1px solid #dee2e6;
+            border-radius: 4px;
+            padding: 10px;
+            margin: 10px 0;
+            font-family: monospace;
+            font-size: 12px;
+            max-height: 300px;
+            overflow-y: auto;
+        }
+    </style>
+</head>
+<body>
+    <div class="debug-container">
+        <h1>Debug Onairos Overlay</h1>
+        
+        <div>
+            <h3>Step 1: Check if bundle loads</h3>
+            <div id="bundle-status">Loading...</div>
+        </div>
+        
+        <div>
+            <h3>Step 2: Check Onairos object</h3>
+            <div id="onairos-status">Checking...</div>
+        </div>
+        
+        <div>
+            <h3>Step 3: Create button</h3>
+            <div id="button-container"></div>
+            <div id="button-status">Waiting...</div>
+        </div>
+        
+        <div>
+            <h3>Step 4: Test overlay</h3>
+            <button id="test-overlay-btn" onclick="testOverlay()" style="padding: 10px 20px; background: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer;">
+                Test Overlay Manually
+            </button>
+            <div id="overlay-status">Ready to test</div>
+        </div>
+        
+        <div>
+            <h3>Debug Log:</h3>
+            <div id="debug-log" class="debug-log"></div>
+        </div>
+    </div>
+
+    <script src="./dist/onairos.bundle.js"></script>
+    <script>
+        let onairosComponent = null;
+        let root = null;
+        
+        function log(message) {
+            const logDiv = document.getElementById('debug-log');
+            const timestamp = new Date().toLocaleTimeString();
+            logDiv.innerHTML += `<div>[${timestamp}] ${message}</div>`;
+            logDiv.scrollTop = logDiv.scrollHeight;
+            console.log(`[DEBUG] ${message}`);
+        }
+        
+        function updateStatus(elementId, message, isError = false) {
+            const element = document.getElementById(elementId);
+            element.textContent = message;
+            element.style.color = isError ? 'red' : 'green';
+        }
+        
+        // Step 1: Check bundle
+        log('Checking if bundle loaded...');
+        if (typeof window.Onairos !== 'undefined') {
+            updateStatus('bundle-status', '✓ Bundle loaded successfully');
+            log('Bundle loaded successfully');
+        } else {
+            updateStatus('bundle-status', '✗ Bundle failed to load', true);
+            log('ERROR: Bundle failed to load');
+        }
+        
+        // Check if framer-motion is available
+        log('Checking framer-motion availability...');
+        if (typeof window.FramerMotion !== 'undefined') {
+            log('✓ Framer Motion loaded successfully');
+            window['framer-motion'] = window.FramerMotion;
+        } else {
+            log('⚠️ Framer Motion not found - animations may not work');
+        }
+        
+        // Step 2: Check Onairos object
+        setTimeout(() => {
+            log('Checking Onairos object...');
+            if (window.Onairos && window.Onairos.Onairos) {
+                updateStatus('onairos-status', '✓ Onairos component found');
+                log('Onairos component found');
+                log('Available properties: ' + Object.keys(window.Onairos).join(', '));
+                
+                // Step 3: Create button
+                createButton();
+            } else {
+                updateStatus('onairos-status', '✗ Onairos component not found', true);
+                log('ERROR: Onairos component not found');
+                if (window.Onairos) {
+                    log('Available properties: ' + Object.keys(window.Onairos).join(', '));
+                }
+            }
+        }, 100);
+        
+        function createButton() {
+            log('Creating Onairos button...');
+            try {
+                const buttonContainer = document.getElementById('button-container');
+                
+                // Use React 18's createRoot instead of ReactDOM.render
+                if (ReactDOM.createRoot) {
+                    root = ReactDOM.createRoot(buttonContainer);
+                    
+                    onairosComponent = React.createElement(window.Onairos.Onairos, {
+                        requestData: {
+                            personality: {
+                                type: 'Personality',
+                                descriptions: ['Basic personality traits'],
+                                reward: 10
+                            }
+                        },
+                        webpageName: 'Debug Test Page',
+                        onComplete: (result) => {
+                            log('Onboarding completed: ' + JSON.stringify(result));
+                            updateStatus('overlay-status', '✓ Onboarding completed');
+                        },
+                        visualType: 'full',
+                        buttonType: 'pill',
+                        textColor: 'black'
+                    });
+                    
+                    root.render(onairosComponent);
+                    updateStatus('button-status', '✓ Button created successfully');
+                    log('Button created and rendered with React 18 createRoot');
+                } else {
+                    // Fallback to legacy ReactDOM.render
+                    onairosComponent = React.createElement(window.Onairos.Onairos, {
+                        requestData: {
+                            personality: {
+                                type: 'Personality',
+                                descriptions: ['Basic personality traits'],
+                                reward: 10
+                            }
+                        },
+                        webpageName: 'Debug Test Page',
+                        onComplete: (result) => {
+                            log('Onboarding completed: ' + JSON.stringify(result));
+                            updateStatus('overlay-status', '✓ Onboarding completed');
+                        },
+                        visualType: 'full',
+                        buttonType: 'pill',
+                        textColor: 'black'
+                    });
+                    
+                    ReactDOM.render(onairosComponent, buttonContainer);
+                    updateStatus('button-status', '✓ Button created successfully (legacy)');
+                    log('Button created and rendered with legacy ReactDOM.render');
+                }
+            } catch (error) {
+                updateStatus('button-status', '✗ Failed to create button: ' + error.message, true);
+                log('ERROR creating button: ' + error.message);
+                console.error('Full error:', error);
+            }
+        }
+        
+        function testOverlay() {
+            log('Testing overlay manually...');
+            updateStatus('overlay-status', 'Testing overlay...');
+            
+            // Try to trigger the overlay directly
+            const button = document.querySelector('.OnairosConnect');
+            if (button) {
+                log('Found Onairos button, clicking...');
+                button.click();
+                updateStatus('overlay-status', 'Button clicked');
+            } else {
+                log('ERROR: Could not find Onairos button');
+                updateStatus('overlay-status', '✗ Button not found', true);
+            }
+        }
+        
+        // Capture all console logs
+        const originalLog = console.log;
+        const originalError = console.error;
+        
+        console.log = function(...args) {
+            if (args[0] && args[0].includes && args[0].includes('🔥')) {
+                log('CONSOLE: ' + args.join(' '));
+            }
+            originalLog.apply(console, args);
+        };
+        
+        console.error = function(...args) {
+            log('ERROR: ' + args.join(' '));
+            originalError.apply(console, args);
+        };
+        
+        log('Debug page initialized');
+    </script>
+</body>
+</html> 

package/dist/data_request_iframe.html

@@ -0,0 +1,12 @@
+<!doctype html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Onairos Terminal</title><style>body {
+      margin: 0;
+      padding: 0;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+      background-color: transparent;
+      overflow: hidden;
+    }
+    
+    #root {
+      width: 100%;
+      height: 100vh;
+    }</style><script defer="defer" src="iframe.bundle.js"></script></head><body><div id="root"></div><script src="data_request_page.js"></script></body></html>