@emilshirokikh/slyos-sdk 1.0.0 → 1.1.0

package/README.md

@@ -1,48 +1,326 @@
-# @belto/slyos-sdk
+# 🔥 @emilshirokikh/slyos-sdk
 
-On-device AI that runs locally in browsers and Node.js. Save 98.5% vs cloud APIs.
+Official SDK for SlyOS on-device AI platform. Run AI models locally in browsers and Node.js.
 
-## Installation
+---
+
+## 📦 Installation
 ```bash
-npm install @belto/slyos-sdk
+npm install @emilshirokikh/slyos-sdk
 ```
 
-## Quick Start
+**npm:** https://www.npmjs.com/package/@emilshirokikh/slyos-sdk
+
+---
+
+## 🚀 Quick Start
 ```javascript
-import SlyOS from '@belto/slyos-sdk';
+import SlyOS from '@emilshirokikh/slyos-sdk';
 
-// Initialize
+// 1. Initialize
 const sdk = new SlyOS({
-  apiKey: 'your-api-key'
+  apiKey: 'sk_live_your_api_key'
 });
 await sdk.initialize();
 
-// Load model (downloads once, ~200MB)
+// 2. Load model (downloads ~200MB once)
 await sdk.loadModel('quantum-360m');
 
-// Generate AI responses
-const response = await sdk.generate('quantum-360m', 'Hello!');
+// 3. Generate responses
+const response = await sdk.generate('quantum-360m', 
+  'What is artificial intelligence?',
+  {
+    temperature: 0.7,
+    maxTokens: 100,
+    topP: 0.9
+  }
+);
+
 console.log(response);
+// AI runs locally - zero cost!
+```
+
+---
+
+## 📚 API Reference
+
+### Constructor
+```typescript
+new SlyOS(config: SlyOSConfig)
+```
+
+**Config:**
+```typescript
+{
+  apiKey: string;      // Get from dashboard
+  apiUrl?: string;     // Optional, defaults to production
+}
+```
+
+---
+
+### Methods
+
+#### `initialize()`
+Authenticates with SlyOS backend and registers device.
+```javascript
+await sdk.initialize();
+```
+
+**Returns:** `Promise<void>`
+
+---
+
+#### `loadModel(modelId)`
+Downloads and caches AI model locally.
+```javascript
+await sdk.loadModel('quantum-360m');
+```
+
+**Parameters:**
+- `modelId` (string): Model identifier
+  - `quantum-135m` - 80MB, fastest
+  - `quantum-360m` - 200MB, recommended
+  - `quantum-1.7b` - 1GB, high quality
+  - `quantum-3b` - 1.7GB, best quality
+
+**Returns:** `Promise<void>`
+
+**First call:** Downloads model (~1-2 min)  
+**Subsequent calls:** Uses cached model (<1 sec)
+
+---
+
+#### `generate(modelId, prompt, options?)`
+Generates AI response locally.
+```javascript
+const response = await sdk.generate('quantum-360m', 
+  'Tell me about your menu',
+  {
+    temperature: 0.7,
+    maxTokens: 150,
+    topP: 0.9
+  }
+);
+```
+
+**Parameters:**
+- `modelId` (string): Model to use
+- `prompt` (string): Input text
+- `options` (object, optional):
+  - `temperature` (0-2): Creativity (default: 0.7)
+  - `maxTokens` (10-2000): Max response length (default: 100)
+  - `topP` (0-1): Nucleus sampling (default: 0.9)
+
+**Returns:** `Promise<string>` - Generated text
+
+---
+
+## 🌐 Platform Support
+
+| Platform | Status | Notes |
+|----------|--------|-------|
+| **Chrome** | ✅ Supported | Recommended |
+| **Safari** | ✅ Supported | iOS 16+ |
+| **Edge** | ✅ Supported | Chromium-based |
+| **Firefox** | ⚠️ Limited | Some models work |
+| **Node.js** | ✅ Supported | v18+ |
+| **React Native** | 🚧 Coming Soon | Q2 2026 |
+
+---
+
+## 💡 Usage Examples
+
+### Basic Chatbot
+```javascript
+import SlyOS from '@emilshirokikh/slyos-sdk';
+
+const sdk = new SlyOS({ apiKey: 'sk_live_...' });
+await sdk.initialize();
+await sdk.loadModel('quantum-360m');
+
+async function chat(userMessage) {
+  return await sdk.generate('quantum-360m', userMessage);
+}
+
+const response = await chat('What are your hours?');
+console.log(response);
+```
+
+---
+
+### With System Prompt
+```javascript
+const systemPrompt = `You are a helpful assistant for McDonald's. 
+Help with menu, hours, and nutrition. Be friendly and concise.`;
+
+const userMessage = 'What breakfast items do you have?';
+const fullPrompt = `${systemPrompt}\n\nCustomer: ${userMessage}\nAssistant:`;
+
+const response = await sdk.generate('quantum-360m', fullPrompt, {
+  temperature: 0.7,
+  maxTokens: 150
+});
+```
+
+---
+
+### React Integration
+```jsx
+import { useState, useEffect } from 'react';
+import SlyOS from '@emilshirokikh/slyos-sdk';
+
+function Chatbot() {
+  const [sdk, setSdk] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [response, setResponse] = useState('');
+
+  useEffect(() => {
+    async function init() {
+      const client = new SlyOS({ apiKey: 'sk_live_...' });
+      await client.initialize();
+      await client.loadModel('quantum-360m');
+      setSdk(client);
+      setLoading(false);
+    }
+    init();
+  }, []);
+
+  async function handleChat(message) {
+    const reply = await sdk.generate('quantum-360m', message);
+    setResponse(reply);
+  }
+
+  if (loading) return <div>Loading AI...</div>;
+  
+  return (
+    <div>
+      <button onClick={() => handleChat('Hello!')}>
+        Chat
+      </button>
+      <p>{response}</p>
+    </div>
+  );
+}
+```
+
+---
+
+## 🔧 Advanced Configuration
+
+### Custom Backend URL
+```javascript
+const sdk = new SlyOS({
+  apiKey: 'sk_live_...',
+  apiUrl: 'https://api.slyos.world'
+});
 ```
 
-## Features
+---
+
+### Multiple Models
+```javascript
+await sdk.loadModel('quantum-360m');
+await sdk.loadModel('quantum-1.7b');
+
+// Use different models
+const fast = await sdk.generate('quantum-360m', 'Quick question?');
+const detailed = await sdk.generate('quantum-1.7b', 'Complex question?');
+```
+
+---
+
+## 📊 Performance
+
+### Benchmarks (Quantum 360M)
+
+| Metric | Browser | Node.js |
+|--------|---------|---------|
+| First load | 60-120s | 30-60s |
+| Cached load | <1s | <0.5s |
+| Inference | 35 tok/s | 50 tok/s |
+| Memory | 500MB | 300MB |
+
+---
+
+## 🐛 Troubleshooting
+
+### Model won't load
+```javascript
+// Check browser console for errors
+// Ensure 2GB+ RAM available
+// Try smaller model (quantum-135m)
+```
+
+### CORS errors
+```javascript
+// Backend must allow your domain
+// Check CORS_ORIGIN environment variable
+```
+
+### Slow inference
+```javascript
+// Use smaller model
+// Reduce maxTokens
+// Check CPU/RAM availability
+```
+
+---
+
+## 🔒 Security
+
+- API keys stored client-side (localStorage)
+- All inference happens locally (private)
+- Telemetry sent to SlyOS (anonymized)
+- No user data sent to cloud
+
+---
+
+## 📦 Package Info
+
+- **Package:** `@emilshirokikh/slyos-sdk`
+- **Version:** 1.0.0
+- **License:** MIT
+- **Size:** 13.5 KB (unpacked)
+- **Dependencies:** axios, @huggingface/transformers
+
+---
+
+## 🤝 Contributing
+```bash
+# Clone repo
+git clone https://github.com/BeltoAI/sly.git
+cd sly/sdk
+
+# Install dependencies
+npm install
+
+# Make changes to src/index.ts
+
+# Build
+npm run build
+
+# Test locally
+npm link
+```
+
+---
+
+## 📄 License
 
-- ✅ **Zero API costs** - AI runs on user's device
-- ✅ **Privacy-first** - Data never leaves device
-- ✅ **Works offline** - No internet required after download
-- ✅ **Auto-scaling** - No server capacity planning
-- ✅ **Real-time** - Sub-second response times
+MIT - See LICENSE file
 
-## Platform Support
+---
 
-- Web (Chrome, Safari, Edge)
-- Node.js (v18+)
-- React Native (coming soon)
+## 🙏 Credits
 
-## Documentation
+Built with Hugging Face Transformers.js
 
-Full docs at: https://docs.slyos.com
+---
 
-## License
+## 📞 Support
 
-MIT
+- **npm:** https://www.npmjs.com/package/@emilshirokikh/slyos-sdk
+- **GitHub:** https://github.com/BeltoAI/sly
+- **Docs:** See main README.md
+- **Email:** support@slyos.world

package/dist/index.d.ts

@@ -2,33 +2,28 @@ interface SlyOSConfig {
     apiKey: string;
     apiUrl?: string;
 }
-interface ModelInfo {
-    id: string;
-    name: string;
-    displayName: string;
-    size: number;
-    requirements: {
-        minMemoryMB: number;
-        minStorageMB: number;
-        platforms: string[];
-    };
+interface GenerateOptions {
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+}
+interface TranscribeOptions {
+    language?: string;
+    returnTimestamps?: boolean;
 }
 declare class SlyOS {
     private apiKey;
     private apiUrl;
-    private api;
     private deviceId;
+    private token;
     private models;
     constructor(config: SlyOSConfig);
-    private generateDeviceId;
     initialize(): Promise<void>;
-    private detectPlatform;
-    private getMemoryInfo;
-    getAvailableModels(): Promise<ModelInfo[]>;
+    getAvailableModels(): Record<string, {
+        models: string[];
+    }>;
     loadModel(modelId: string): Promise<void>;
-    generate(modelId: string, prompt: string, options?: any): Promise<string>;
-    private sendTelemetry;
-    getDeviceId(): string;
+    generate(modelId: string, prompt: string, options?: GenerateOptions): Promise<string>;
+    transcribe(modelId: string, audioInput: any, options?: TranscribeOptions): Promise<string>;
 }
 export default SlyOS;
-export { SlyOS, SlyOSConfig, ModelInfo };

package/dist/index.js

@@ -1,156 +1,205 @@
 import axios from 'axios';
-import { pipeline } from '@huggingface/transformers';
+import { pipeline, env } from '@huggingface/transformers';
+// @ts-ignore - Force CPU in Node.js
+if (env.backends?.onnx?.wasm) {
+    env.backends.onnx.wasm.proxy = false;
+}
+const modelMap = {
+    // LLM models (1B+)
+    'quantum-1.7b': {
+        hfModel: 'HuggingFaceTB/SmolLM2-1.7B-Instruct',
+        task: 'text-generation',
+        category: 'llm',
+    },
+    'quantum-3b': {
+        hfModel: 'meta-llama/Llama-3.2-3B-Instruct',
+        task: 'text-generation',
+        category: 'llm',
+    },
+    'quantum-code-3b': {
+        hfModel: 'Qwen/Qwen2.5-Coder-3B-Instruct',
+        task: 'text-generation',
+        category: 'llm',
+    },
+    'quantum-8b': {
+        hfModel: 'meta-llama/Llama-3.1-8B-Instruct',
+        task: 'text-generation',
+        category: 'llm',
+    },
+    // STT models
+    'voicecore-base': {
+        hfModel: 'onnx-community/whisper-base',
+        task: 'automatic-speech-recognition',
+        category: 'stt',
+    },
+    'voicecore-small': {
+        hfModel: 'onnx-community/whisper-small',
+        task: 'automatic-speech-recognition',
+        category: 'stt',
+    },
+};
 class SlyOS {
     constructor(config) {
+        this.token = null;
         this.models = new Map();
         this.apiKey = config.apiKey;
-        this.apiUrl = config.apiUrl || 'http://slyos-prod.eba-qjz3cmgq.us-east-2.elasticbeanstalk.com';
-        this.api = axios.create({
-            baseURL: `${this.apiUrl}/api`,
-            headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json'
-            }
-        });
-        this.deviceId = this.generateDeviceId();
-    }
-    generateDeviceId() {
-        return `device-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        this.apiUrl = config.apiUrl || 'https://api.slyos.world';
+        this.deviceId = `device-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     }
     async initialize() {
-        console.log('🔥 SlyOS SDK Initializing...');
-        try {
-            await this.api.post('/devices/register', {
-                device_id: this.deviceId,
-                platform: this.detectPlatform(),
-                os_version: navigator.userAgent,
-                total_memory_mb: this.getMemoryInfo(),
-                cpu_cores: navigator.hardwareConcurrency || 4
-            });
-            console.log('✅ Device registered:', this.deviceId);
-        }
-        catch (error) {
-            console.error('Failed to register device:', error);
-        }
-    }
-    detectPlatform() {
-        const ua = navigator.userAgent.toLowerCase();
-        if (ua.includes('iphone') || ua.includes('ipad'))
-            return 'ios';
-        if (ua.includes('android'))
-            return 'android';
-        return 'web';
-    }
-    getMemoryInfo() {
-        // @ts-ignore
-        return (navigator.deviceMemory || 4) * 1024;
+        // Authenticate using API key
+        const authRes = await axios.post(`${this.apiUrl}/api/auth/sdk`, {
+            apiKey: this.apiKey,
+        });
+        this.token = authRes.data.token;
+        // Register this device
+        await axios.post(`${this.apiUrl}/api/devices/register`, {
+            device_id: this.deviceId,
+            platform: typeof window !== 'undefined' ? 'web' : 'nodejs',
+            os_version: typeof window !== 'undefined' ? navigator.userAgent : process.version,
+            total_memory_mb: 4096,
+            cpu_cores: 4,
+            has_gpu: false,
+        }, {
+            headers: { Authorization: `Bearer ${this.token}` },
+        });
     }
-    async getAvailableModels() {
-        try {
-            const res = await this.api.get('/models');
-            return res.data.map((m) => ({
-                id: m.model_id,
-                name: m.name,
-                displayName: m.display_name,
-                size: m.size_q4,
-                requirements: {
-                    minMemoryMB: parseInt(m.memory_required) || 512,
-                    minStorageMB: m.size_q4 + 100,
-                    platforms: ['ios', 'android', 'web']
-                }
-            }));
-        }
-        catch (error) {
-            console.error('Failed to fetch models:', error);
-            return [];
+    getAvailableModels() {
+        const grouped = { llm: [], stt: [] };
+        for (const [id, info] of Object.entries(modelMap)) {
+            if (!grouped[info.category])
+                grouped[info.category] = [];
+            grouped[info.category].push(id);
         }
+        return Object.fromEntries(Object.entries(grouped).map(([cat, models]) => [cat, { models }]));
     }
     async loadModel(modelId) {
-        console.log(`📥 Loading model: ${modelId}`);
-        const startTime = Date.now();
+        const info = modelMap[modelId];
+        if (!info) {
+            throw new Error(`Unknown model "${modelId}". Available: ${Object.keys(modelMap).join(', ')}`);
+        }
         try {
-            const modelMap = {
-                'quantum-135m': 'HuggingFaceTB/SmolLM2-135M-Instruct',
-                'quantum-360m': 'HuggingFaceTB/SmolLM2-360M-Instruct',
-                'quantum-1.7b': 'HuggingFaceTB/SmolLM2-1.7B-Instruct'
-            };
-            const hfModel = modelMap[modelId] || modelMap['quantum-360m'];
-            const generator = await pipeline('text-generation', hfModel, {
-                device: 'webgpu',
-                dtype: 'q4'
-            });
-            this.models.set(modelId, generator);
-            const loadTime = Date.now() - startTime;
-            console.log(`✅ Model loaded in ${loadTime}ms`);
-            await this.sendTelemetry({
-                event_type: 'model_load',
-                model_id: modelId,
-                latency_ms: loadTime,
-                success: true
+            const pipe = await pipeline(info.task, info.hfModel, {
+                device: 'cpu',
+                dtype: 'fp32',
             });
+            this.models.set(modelId, { pipe, info });
+            if (this.token) {
+                await axios.post(`${this.apiUrl}/api/telemetry`, {
+                    device_id: this.deviceId,
+                    event_type: 'model_load',
+                    model_id: modelId,
+                    success: true,
+                }, {
+                    headers: { Authorization: `Bearer ${this.token}` },
+                }).catch(() => { });
+            }
         }
         catch (error) {
-            console.error('Failed to load model:', error);
-            await this.sendTelemetry({
-                event_type: 'model_load',
-                model_id: modelId,
-                success: false,
-                error_message: String(error)
-            });
+            if (this.token) {
+                await axios.post(`${this.apiUrl}/api/telemetry`, {
+                    device_id: this.deviceId,
+                    event_type: 'model_load',
+                    model_id: modelId,
+                    success: false,
+                    error_message: error.message,
+                }, {
+                    headers: { Authorization: `Bearer ${this.token}` },
+                }).catch(() => { });
+            }
             throw error;
         }
     }
-    async generate(modelId, prompt, options) {
+    async generate(modelId, prompt, options = {}) {
         if (!this.models.has(modelId)) {
             await this.loadModel(modelId);
         }
-        const generator = this.models.get(modelId);
+        const { pipe, info } = this.models.get(modelId);
+        if (info.category !== 'llm') {
+            throw new Error(`Model "${modelId}" is not an LLM. Use transcribe() for STT models.`);
+        }
         const startTime = Date.now();
         try {
-            const result = await generator(prompt, {
-                max_new_tokens: options?.maxTokens || 100,
-                temperature: options?.temperature || 0.7,
-                top_p: options?.topP || 0.9,
-                ...options
+            const result = await pipe(prompt, {
+                max_new_tokens: options.maxTokens || 100,
+                temperature: options.temperature || 0.7,
+                top_p: options.topP || 0.9,
+                do_sample: true,
             });
-            const latency = Date.now() - startTime;
             const response = result[0].generated_text;
-            const tokens = response.split(' ').length;
-            await this.sendTelemetry({
-                event_type: 'inference',
-                model_id: modelId,
-                latency_ms: latency,
-                tokens_generated: tokens,
-                success: true
-            });
-            console.log(`⚡ Generated ${tokens} tokens in ${latency}ms`);
+            const latency = Date.now() - startTime;
+            if (this.token) {
+                await axios.post(`${this.apiUrl}/api/telemetry`, {
+                    device_id: this.deviceId,
+                    event_type: 'inference',
+                    model_id: modelId,
+                    latency_ms: latency,
+                    tokens_generated: response.split(' ').length,
+                    success: true,
+                }, {
+                    headers: { Authorization: `Bearer ${this.token}` },
+                }).catch(() => { });
+            }
             return response;
         }
         catch (error) {
-            console.error('Generation failed:', error);
-            await this.sendTelemetry({
-                event_type: 'inference',
-                model_id: modelId,
-                success: false,
-                error_message: String(error)
-            });
+            if (this.token) {
+                await axios.post(`${this.apiUrl}/api/telemetry`, {
+                    device_id: this.deviceId,
+                    event_type: 'inference',
+                    model_id: modelId,
+                    success: false,
+                    error_message: error.message,
+                }, {
+                    headers: { Authorization: `Bearer ${this.token}` },
+                }).catch(() => { });
+            }
             throw error;
         }
     }
-    async sendTelemetry(data) {
+    async transcribe(modelId, audioInput, options = {}) {
+        if (!this.models.has(modelId)) {
+            await this.loadModel(modelId);
+        }
+        const { pipe, info } = this.models.get(modelId);
+        if (info.category !== 'stt') {
+            throw new Error(`Model "${modelId}" is not an STT model. Use generate() for LLMs.`);
+        }
+        const startTime = Date.now();
         try {
-            await this.api.post('/telemetry', {
-                device_id: this.deviceId,
-                ...data
+            const result = await pipe(audioInput, {
+                language: options.language || 'en',
+                return_timestamps: options.returnTimestamps || false,
             });
+            const text = result.text;
+            const latency = Date.now() - startTime;
+            if (this.token) {
+                await axios.post(`${this.apiUrl}/api/telemetry`, {
+                    device_id: this.deviceId,
+                    event_type: 'inference',
+                    model_id: modelId,
+                    latency_ms: latency,
+                    success: true,
+                }, {
+                    headers: { Authorization: `Bearer ${this.token}` },
+                }).catch(() => { });
+            }
+            return text;
         }
         catch (error) {
-            console.error('Failed to send telemetry:', error);
+            if (this.token) {
+                await axios.post(`${this.apiUrl}/api/telemetry`, {
+                    device_id: this.deviceId,
+                    event_type: 'inference',
+                    model_id: modelId,
+                    success: false,
+                    error_message: error.message,
+                }, {
+                    headers: { Authorization: `Bearer ${this.token}` },
+                }).catch(() => { });
+            }
+            throw error;
         }
     }
-    getDeviceId() {
-        return this.deviceId;
-    }
 }
 export default SlyOS;
-export { SlyOS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emilshirokikh/slyos-sdk",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "SlyOS - On-Device AI SDK for Web and Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,204 +1,257 @@
-import axios, { AxiosInstance } from 'axios';
-import { pipeline } from '@huggingface/transformers';
+import axios from 'axios';
+import { pipeline, env } from '@huggingface/transformers';
+
+// @ts-ignore - Force CPU in Node.js
+if (env.backends?.onnx?.wasm) {
+  env.backends.onnx.wasm.proxy = false;
+}
 
 interface SlyOSConfig {
   apiKey: string;
   apiUrl?: string;
 }
 
+interface GenerateOptions {
+  temperature?: number;
+  maxTokens?: number;
+  topP?: number;
+}
+
+interface TranscribeOptions {
+  language?: string;
+  returnTimestamps?: boolean;
+}
+
+type ModelCategory = 'llm' | 'tts' | 'stt';
+
 interface ModelInfo {
-  id: string;
-  name: string;
-  displayName: string;
-  size: number;
-  requirements: {
-    minMemoryMB: number;
-    minStorageMB: number;
-    platforms: string[];
-  };
+  hfModel: string;
+  task: string;
+  category: ModelCategory;
 }
 
+const modelMap: Record<string, ModelInfo> = {
+  // LLM models (1B+)
+  'quantum-1.7b': {
+    hfModel: 'HuggingFaceTB/SmolLM2-1.7B-Instruct',
+    task: 'text-generation',
+    category: 'llm',
+  },
+  'quantum-3b': {
+    hfModel: 'meta-llama/Llama-3.2-3B-Instruct',
+    task: 'text-generation',
+    category: 'llm',
+  },
+  'quantum-code-3b': {
+    hfModel: 'Qwen/Qwen2.5-Coder-3B-Instruct',
+    task: 'text-generation',
+    category: 'llm',
+  },
+  'quantum-8b': {
+    hfModel: 'meta-llama/Llama-3.1-8B-Instruct',
+    task: 'text-generation',
+    category: 'llm',
+  },
+  // STT models
+  'voicecore-base': {
+    hfModel: 'onnx-community/whisper-base',
+    task: 'automatic-speech-recognition',
+    category: 'stt',
+  },
+  'voicecore-small': {
+    hfModel: 'onnx-community/whisper-small',
+    task: 'automatic-speech-recognition',
+    category: 'stt',
+  },
+};
+
 class SlyOS {
   private apiKey: string;
   private apiUrl: string;
-  private api: AxiosInstance;
   private deviceId: string;
+  private token: string | null = null;
   private models: Map<string, any> = new Map();
 
   constructor(config: SlyOSConfig) {
     this.apiKey = config.apiKey;
-    this.apiUrl = config.apiUrl || 'http://slyos-prod.eba-qjz3cmgq.us-east-2.elasticbeanstalk.com';
-    
-    this.api = axios.create({
-      baseURL: `${this.apiUrl}/api`,
-      headers: {
-        'Authorization': `Bearer ${this.apiKey}`,
-        'Content-Type': 'application/json'
-      }
+    this.apiUrl = config.apiUrl || 'https://api.slyos.world';
+    this.deviceId = `device-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  async initialize(): Promise<void> {
+    // Authenticate using API key
+    const authRes = await axios.post(`${this.apiUrl}/api/auth/sdk`, {
+      apiKey: this.apiKey,
     });
+    this.token = authRes.data.token;
 
-    this.deviceId = this.generateDeviceId();
+    // Register this device
+    await axios.post(`${this.apiUrl}/api/devices/register`, {
+      device_id: this.deviceId,
+      platform: typeof window !== 'undefined' ? 'web' : 'nodejs',
+      os_version: typeof window !== 'undefined' ? navigator.userAgent : process.version,
+      total_memory_mb: 4096,
+      cpu_cores: 4,
+      has_gpu: false,
+    }, {
+      headers: { Authorization: `Bearer ${this.token}` },
+    });
   }
 
-  private generateDeviceId(): string {
-    return `device-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  getAvailableModels(): Record<string, { models: string[] }> {
+    const grouped: Record<string, string[]> = { llm: [], stt: [] };
+    for (const [id, info] of Object.entries(modelMap)) {
+      if (!grouped[info.category]) grouped[info.category] = [];
+      grouped[info.category].push(id);
+    }
+    return Object.fromEntries(
+      Object.entries(grouped).map(([cat, models]) => [cat, { models }])
+    );
   }
 
-  async initialize(): Promise<void> {
-    console.log('🔥 SlyOS SDK Initializing...');
-    
+  async loadModel(modelId: string): Promise<void> {
+    const info = modelMap[modelId];
+    if (!info) {
+      throw new Error(
+        `Unknown model "${modelId}". Available: ${Object.keys(modelMap).join(', ')}`
+      );
+    }
+
     try {
-      await this.api.post('/devices/register', {
-        device_id: this.deviceId,
-        platform: this.detectPlatform(),
-        os_version: navigator.userAgent,
-        total_memory_mb: this.getMemoryInfo(),
-        cpu_cores: navigator.hardwareConcurrency || 4
+      const pipe = await pipeline(info.task as any, info.hfModel, {
+        device: 'cpu',
+        dtype: 'fp32',
       });
-      console.log('✅ Device registered:', this.deviceId);
-    } catch (error) {
-      console.error('Failed to register device:', error);
-    }
-  }
+      this.models.set(modelId, { pipe, info });
 
-  private detectPlatform(): string {
-    const ua = navigator.userAgent.toLowerCase();
-    if (ua.includes('iphone') || ua.includes('ipad')) return 'ios';
-    if (ua.includes('android')) return 'android';
-    return 'web';
+      if (this.token) {
+        await axios.post(`${this.apiUrl}/api/telemetry`, {
+          device_id: this.deviceId,
+          event_type: 'model_load',
+          model_id: modelId,
+          success: true,
+        }, {
+          headers: { Authorization: `Bearer ${this.token}` },
+        }).catch(() => {});
+      }
+    } catch (error: any) {
+      if (this.token) {
+        await axios.post(`${this.apiUrl}/api/telemetry`, {
+          device_id: this.deviceId,
+          event_type: 'model_load',
+          model_id: modelId,
+          success: false,
+          error_message: error.message,
+        }, {
+          headers: { Authorization: `Bearer ${this.token}` },
+        }).catch(() => {});
+      }
+      throw error;
+    }
   }
 
-  private getMemoryInfo(): number {
-    // @ts-ignore
-    return (navigator.deviceMemory || 4) * 1024;
-  }
+  async generate(modelId: string, prompt: string, options: GenerateOptions = {}): Promise<string> {
+    if (!this.models.has(modelId)) {
+      await this.loadModel(modelId);
+    }
 
-  async getAvailableModels(): Promise<ModelInfo[]> {
-    try {
-      const res = await this.api.get('/models');
-      return res.data.map((m: any) => ({
-        id: m.model_id,
-        name: m.name,
-        displayName: m.display_name,
-        size: m.size_q4,
-        requirements: {
-          minMemoryMB: parseInt(m.memory_required) || 512,
-          minStorageMB: m.size_q4 + 100,
-          platforms: ['ios', 'android', 'web']
-        }
-      }));
-    } catch (error) {
-      console.error('Failed to fetch models:', error);
-      return [];
+    const { pipe, info } = this.models.get(modelId);
+    if (info.category !== 'llm') {
+      throw new Error(`Model "${modelId}" is not an LLM. Use transcribe() for STT models.`);
     }
-  }
 
-  async loadModel(modelId: string): Promise<void> {
-    console.log(`📥 Loading model: ${modelId}`);
-    
     const startTime = Date.now();
 
     try {
-      const modelMap: Record<string, string> = {
-        'quantum-135m': 'HuggingFaceTB/SmolLM2-135M-Instruct',
-        'quantum-360m': 'HuggingFaceTB/SmolLM2-360M-Instruct',
-        'quantum-1.7b': 'HuggingFaceTB/SmolLM2-1.7B-Instruct'
-      };
-
-      const hfModel = modelMap[modelId] || modelMap['quantum-360m'];
-      
-      const generator = await pipeline('text-generation', hfModel, {
-        device: 'webgpu',
-        dtype: 'q4'
+      const result = await pipe(prompt, {
+        max_new_tokens: options.maxTokens || 100,
+        temperature: options.temperature || 0.7,
+        top_p: options.topP || 0.9,
+        do_sample: true,
       });
 
-      this.models.set(modelId, generator);
-
-      const loadTime = Date.now() - startTime;
-      console.log(`✅ Model loaded in ${loadTime}ms`);
-
-      await this.sendTelemetry({
-        event_type: 'model_load',
-        model_id: modelId,
-        latency_ms: loadTime,
-        success: true
-      });
+      const response = result[0].generated_text;
+      const latency = Date.now() - startTime;
 
-    } catch (error) {
-      console.error('Failed to load model:', error);
-      
-      await this.sendTelemetry({
-        event_type: 'model_load',
-        model_id: modelId,
-        success: false,
-        error_message: String(error)
-      });
+      if (this.token) {
+        await axios.post(`${this.apiUrl}/api/telemetry`, {
+          device_id: this.deviceId,
+          event_type: 'inference',
+          model_id: modelId,
+          latency_ms: latency,
+          tokens_generated: response.split(' ').length,
+          success: true,
+        }, {
+          headers: { Authorization: `Bearer ${this.token}` },
+        }).catch(() => {});
+      }
 
+      return response;
+    } catch (error: any) {
+      if (this.token) {
+        await axios.post(`${this.apiUrl}/api/telemetry`, {
+          device_id: this.deviceId,
+          event_type: 'inference',
+          model_id: modelId,
+          success: false,
+          error_message: error.message,
+        }, {
+          headers: { Authorization: `Bearer ${this.token}` },
+        }).catch(() => {});
+      }
       throw error;
     }
   }
 
-  async generate(modelId: string, prompt: string, options?: any): Promise<string> {
+  async transcribe(modelId: string, audioInput: any, options: TranscribeOptions = {}): Promise<string> {
     if (!this.models.has(modelId)) {
       await this.loadModel(modelId);
     }
 
-    const generator = this.models.get(modelId);
+    const { pipe, info } = this.models.get(modelId);
+    if (info.category !== 'stt') {
+      throw new Error(`Model "${modelId}" is not an STT model. Use generate() for LLMs.`);
+    }
+
     const startTime = Date.now();
 
     try {
-      const result = await generator(prompt, {
-        max_new_tokens: options?.maxTokens || 100,
-        temperature: options?.temperature || 0.7,
-        top_p: options?.topP || 0.9,
-        ...options
+      const result = await pipe(audioInput, {
+        language: options.language || 'en',
+        return_timestamps: options.returnTimestamps || false,
       });
 
+      const text = result.text;
       const latency = Date.now() - startTime;
-      const response = result[0].generated_text;
-      const tokens = response.split(' ').length;
-
-      await this.sendTelemetry({
-        event_type: 'inference',
-        model_id: modelId,
-        latency_ms: latency,
-        tokens_generated: tokens,
-        success: true
-      });
-
-      console.log(`⚡ Generated ${tokens} tokens in ${latency}ms`);
-
-      return response;
 
-    } catch (error) {
-      console.error('Generation failed:', error);
-      
-      await this.sendTelemetry({
-        event_type: 'inference',
-        model_id: modelId,
-        success: false,
-        error_message: String(error)
-      });
+      if (this.token) {
+        await axios.post(`${this.apiUrl}/api/telemetry`, {
+          device_id: this.deviceId,
+          event_type: 'inference',
+          model_id: modelId,
+          latency_ms: latency,
+          success: true,
+        }, {
+          headers: { Authorization: `Bearer ${this.token}` },
+        }).catch(() => {});
+      }
 
+      return text;
+    } catch (error: any) {
+      if (this.token) {
+        await axios.post(`${this.apiUrl}/api/telemetry`, {
+          device_id: this.deviceId,
+          event_type: 'inference',
+          model_id: modelId,
+          success: false,
+          error_message: error.message,
+        }, {
+          headers: { Authorization: `Bearer ${this.token}` },
+        }).catch(() => {});
+      }
       throw error;
     }
   }
-
-  private async sendTelemetry(data: any): Promise<void> {
-    try {
-      await this.api.post('/telemetry', {
-        device_id: this.deviceId,
-        ...data
-      });
-    } catch (error) {
-      console.error('Failed to send telemetry:', error);
-    }
-  }
-
-  getDeviceId(): string {
-    return this.deviceId;
-  }
 }
 
 export default SlyOS;
-export { SlyOS, SlyOSConfig, ModelInfo };