@emilshirokikh/slyos-sdk 1.0.0

package/README.md

@@ -0,0 +1,48 @@
+# @belto/slyos-sdk
+
+On-device AI that runs locally in browsers and Node.js. Save 98.5% vs cloud APIs.
+
+## Installation
+```bash
+npm install @belto/slyos-sdk
+```
+
+## Quick Start
+```javascript
+import SlyOS from '@belto/slyos-sdk';
+
+// Initialize
+const sdk = new SlyOS({
+  apiKey: 'your-api-key'
+});
+await sdk.initialize();
+
+// Load model (downloads once, ~200MB)
+await sdk.loadModel('quantum-360m');
+
+// Generate AI responses
+const response = await sdk.generate('quantum-360m', 'Hello!');
+console.log(response);
+```
+
+## Features
+
+- ✅ **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
+
+## Platform Support
+
+- Web (Chrome, Safari, Edge)
+- Node.js (v18+)
+- React Native (coming soon)
+
+## Documentation
+
+Full docs at: https://docs.slyos.com
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+interface SlyOSConfig {
+    apiKey: string;
+    apiUrl?: string;
+}
+interface ModelInfo {
+    id: string;
+    name: string;
+    displayName: string;
+    size: number;
+    requirements: {
+        minMemoryMB: number;
+        minStorageMB: number;
+        platforms: string[];
+    };
+}
+declare class SlyOS {
+    private apiKey;
+    private apiUrl;
+    private api;
+    private deviceId;
+    private models;
+    constructor(config: SlyOSConfig);
+    private generateDeviceId;
+    initialize(): Promise<void>;
+    private detectPlatform;
+    private getMemoryInfo;
+    getAvailableModels(): Promise<ModelInfo[]>;
+    loadModel(modelId: string): Promise<void>;
+    generate(modelId: string, prompt: string, options?: any): Promise<string>;
+    private sendTelemetry;
+    getDeviceId(): string;
+}
+export default SlyOS;
+export { SlyOS, SlyOSConfig, ModelInfo };

package/dist/index.js

@@ -0,0 +1,156 @@
+import axios from 'axios';
+import { pipeline } from '@huggingface/transformers';
+class SlyOS {
+    constructor(config) {
+        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)}`;
+    }
+    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;
+    }
+    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 [];
+        }
+    }
+    async loadModel(modelId) {
+        console.log(`📥 Loading model: ${modelId}`);
+        const startTime = Date.now();
+        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
+            });
+        }
+        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)
+            });
+            throw error;
+        }
+    }
+    async generate(modelId, prompt, options) {
+        if (!this.models.has(modelId)) {
+            await this.loadModel(modelId);
+        }
+        const generator = this.models.get(modelId);
+        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 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)
+            });
+            throw error;
+        }
+    }
+    async sendTelemetry(data) {
+        try {
+            await this.api.post('/telemetry', {
+                device_id: this.deviceId,
+                ...data
+            });
+        }
+        catch (error) {
+            console.error('Failed to send telemetry:', error);
+        }
+    }
+    getDeviceId() {
+        return this.deviceId;
+    }
+}
+export default SlyOS;
+export { SlyOS };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@emilshirokikh/slyos-sdk",
+  "version": "1.0.0",
+  "description": "SlyOS - On-Device AI SDK for Web and Node.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "on-device",
+    "machine-learning",
+    "llm",
+    "transformers",
+    "slyos"
+  ],
+  "author": "Emil Shirokikh",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/emilshirokikh/slyos-sdk.git"
+  },
+  "dependencies": {
+    "axios": "^1.6.5",
+    "@huggingface/transformers": "^3.1.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,204 @@
+import axios, { AxiosInstance } from 'axios';
+import { pipeline } from '@huggingface/transformers';
+
+interface SlyOSConfig {
+  apiKey: string;
+  apiUrl?: string;
+}
+
+interface ModelInfo {
+  id: string;
+  name: string;
+  displayName: string;
+  size: number;
+  requirements: {
+    minMemoryMB: number;
+    minStorageMB: number;
+    platforms: string[];
+  };
+}
+
+class SlyOS {
+  private apiKey: string;
+  private apiUrl: string;
+  private api: AxiosInstance;
+  private deviceId: string;
+  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.deviceId = this.generateDeviceId();
+  }
+
+  private generateDeviceId(): string {
+    return `device-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  async initialize(): Promise<void> {
+    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);
+    }
+  }
+
+  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';
+  }
+
+  private getMemoryInfo(): number {
+    // @ts-ignore
+    return (navigator.deviceMemory || 4) * 1024;
+  }
+
+  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 [];
+    }
+  }
+
+  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'
+      });
+
+      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
+      });
+
+    } 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)
+      });
+
+      throw error;
+    }
+  }
+
+  async generate(modelId: string, prompt: string, options?: any): Promise<string> {
+    if (!this.models.has(modelId)) {
+      await this.loadModel(modelId);
+    }
+
+    const generator = this.models.get(modelId);
+    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 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)
+      });
+
+      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 };

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}