@emilshirokikh/slyos-sdk 1.2.2 → 1.3.1

package/create-chatbot.sh

@@ -0,0 +1,506 @@
+#!/bin/bash
+
+#################################################################################
+# Slyos Chatbot Setup Script
+#
+# This script creates a fully functional interactive chatbot using the Slyos SDK.
+# Supports both Mac and Windows (via bash/powershell).
+#
+# Usage:
+#   ./create-chatbot.sh [--api-key YOUR_KEY] [--model MODEL_NAME]
+#
+# Examples:
+#   ./create-chatbot.sh
+#   ./create-chatbot.sh --api-key sk_123456789 --model quantum-1.7b
+#################################################################################
+
+set -e
+
+# Color codes for terminal output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Default values
+API_KEY=""
+MODEL="quantum-1.7b"
+SLYOS_SERVER="https://slyos-prod.eba-qjz3cmgq.us-east-2.elasticbeanstalk.com"
+PROJECT_NAME="slyos-chatbot"
+
+#################################################################################
+# Helper Functions
+#################################################################################
+
+print_header() {
+  echo -e "\n${BLUE}╔════════════════════════════════════════════════════════════╗${NC}"
+  echo -e "${BLUE}║${NC}        ${CYAN}Slyos Interactive Chatbot Setup${NC}               ${BLUE}║${NC}"
+  echo -e "${BLUE}╚════════════════════════════════════════════════════════════╝${NC}\n"
+}
+
+print_step() {
+  echo -e "${CYAN}▶${NC} $1"
+}
+
+print_success() {
+  echo -e "${GREEN}✓${NC} $1"
+}
+
+print_error() {
+  echo -e "${RED}✗${NC} $1" >&2
+}
+
+print_info() {
+  echo -e "${YELLOW}ℹ${NC} $1"
+}
+
+#################################################################################
+# Argument Parsing
+#################################################################################
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --api-key)
+      API_KEY="$2"
+      shift 2
+      ;;
+    --model)
+      MODEL="$2"
+      shift 2
+      ;;
+    -h|--help)
+      echo "Usage: $0 [OPTIONS]"
+      echo ""
+      echo "Options:"
+      echo "  --api-key KEY     Slyos API key (prompted if not provided)"
+      echo "  --model MODEL     AI model to use (default: quantum-1.7b)"
+      echo "  -h, --help        Show this help message"
+      exit 0
+      ;;
+    *)
+      print_error "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+#################################################################################
+# Main Setup
+#################################################################################
+
+print_header
+
+# Prompt for API key if not provided
+if [ -z "$API_KEY" ]; then
+  if [ -t 0 ]; then
+    print_step "Enter your Slyos API key (or press Enter for placeholder)"
+    read -r -p "  API Key: " API_KEY
+  fi
+
+  if [ -z "$API_KEY" ]; then
+    API_KEY="YOUR_API_KEY"
+    print_info "Using placeholder API key — set SLYOS_API_KEY in .env later"
+  else
+    print_success "API key configured"
+  fi
+else
+  print_success "API key provided via arguments"
+fi
+
+# Confirm model selection
+print_step "AI Model Configuration"
+echo -e "  Current model: ${YELLOW}${MODEL}${NC}"
+
+# Only prompt interactively if stdin is a terminal (not piped)
+if [ -t 0 ]; then
+  read -p "  Use this model? (y/n, default: y): " -r -n 1
+  echo
+  if [[ ! $REPLY =~ ^[Yy]?$ ]]; then
+    read -p "  Enter model name: " -r MODEL
+  fi
+fi
+print_success "Model configured: ${YELLOW}${MODEL}${NC}"
+
+# Check if project already exists
+if [ -d "$PROJECT_NAME" ]; then
+  if [ -t 0 ]; then
+    print_error "Project folder '$PROJECT_NAME' already exists!"
+    read -p "  Remove existing folder and continue? (y/n): " -r -n 1
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+      rm -rf "$PROJECT_NAME"
+      print_success "Existing folder removed"
+    else
+      print_error "Setup cancelled"
+      exit 1
+    fi
+  else
+    # Non-interactive: auto-remove
+    rm -rf "$PROJECT_NAME"
+    print_success "Existing folder removed"
+  fi
+fi
+
+# Create project directory
+print_step "Creating project directory: ${CYAN}$PROJECT_NAME${NC}"
+mkdir -p "$PROJECT_NAME"
+cd "$PROJECT_NAME"
+print_success "Project directory created"
+
+# Initialize npm
+print_step "Initializing npm package"
+npm init -y > /dev/null 2>&1
+print_success "npm initialized"
+
+# Update package.json to use ES modules
+print_step "Configuring ES module support"
+cat > package.json << 'EOF'
+{
+  "name": "slyos-chatbot",
+  "version": "1.0.0",
+  "description": "Interactive chatbot powered by Slyos SDK",
+  "main": "app.mjs",
+  "type": "module",
+  "scripts": {
+    "start": "node app.mjs",
+    "chat": "node app.mjs"
+  },
+  "keywords": ["chatbot", "slyos", "ai"],
+  "author": "",
+  "license": "MIT"
+}
+EOF
+print_success "Package configuration updated"
+
+# Install Slyos SDK + dotenv
+print_step "Installing dependencies"
+print_info "This may take a moment..."
+npm install @emilshirokikh/slyos-sdk dotenv > /dev/null 2>&1
+print_success "Dependencies installed"
+
+# Create the chatbot application
+print_step "Creating interactive chatbot application: ${CYAN}app.mjs${NC}"
+
+cat > app.mjs << 'CHATBOT_EOF'
+#!/usr/bin/env node
+
+import 'dotenv/config';
+import readline from 'readline';
+import SlyOS from '@emilshirokikh/slyos-sdk';
+
+// Color codes for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m'
+};
+
+// Configuration
+const config = {
+  apiKey: process.env.SLYOS_API_KEY || 'YOUR_API_KEY',
+  model: process.env.SLYOS_MODEL || 'quantum-1.7b',
+  server: process.env.SLYOS_SERVER || 'https://slyos-prod.eba-qjz3cmgq.us-east-2.elasticbeanstalk.com'
+};
+
+// Initialize SlyOS SDK
+let sdk;
+try {
+  sdk = new SlyOS({
+    apiKey: config.apiKey,
+    onProgress: (e) => console.log(`${colors.dim}[${e.progress}%] ${e.message}${colors.reset}`)
+  });
+} catch (error) {
+  console.error(`${colors.red}Error initializing SDK:${colors.reset}`, error.message);
+  process.exit(1);
+}
+
+// Create readline interface
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  terminal: true
+});
+
+// Note: conversation history is not used for generation with small models
+// They work better with single prompts
+
+/**
+ * Print welcome banner
+ */
+function printWelcome() {
+  console.clear();
+  console.log(`${colors.bright}${colors.cyan}╔════════════════════════════════════════════════════════════╗${colors.reset}`);
+  console.log(`${colors.bright}${colors.cyan}║${colors.reset}                                                              ${colors.bright}${colors.cyan}║${colors.reset}`);
+  console.log(`${colors.bright}${colors.cyan}║${colors.reset}  ${colors.bright}Welcome to the Slyos Interactive Chatbot${colors.reset}             ${colors.bright}${colors.cyan}║${colors.reset}`);
+  console.log(`${colors.bright}${colors.cyan}║${colors.reset}                                                              ${colors.bright}${colors.cyan}║${colors.reset}`);
+  console.log(`${colors.bright}${colors.cyan}╚════════════════════════════════════════════════════════════╝${colors.reset}\n`);
+
+  console.log(`${colors.blue}Model:${colors.reset} ${colors.yellow}${config.model}${colors.reset}`);
+  console.log(`${colors.blue}Server:${colors.reset} ${colors.yellow}${config.server}${colors.reset}`);
+  if (config.apiKey === 'YOUR_API_KEY') {
+    console.log(`${colors.red}⚠ Using placeholder API key - set SLYOS_API_KEY environment variable${colors.reset}`);
+  }
+  console.log(`\n${colors.bright}Commands:${colors.reset}`);
+  console.log(`  ${colors.green}Type your message and press Enter to chat${colors.reset}`);
+  console.log(`  ${colors.green}Type 'clear' to clear conversation history${colors.reset}`);
+  console.log(`  ${colors.green}Type 'exit' or 'quit' to end the session${colors.reset}`);
+  console.log(`\n${colors.bright}${colors.cyan}─────────────────────────────────────────────────────────────${colors.reset}\n`);
+}
+
+/**
+ * Send message to AI and get response
+ */
+async function sendMessage(userMessage) {
+  try {
+    console.log(`${colors.dim}Thinking...${colors.reset}`);
+
+    // Use chatCompletion (OpenAI-compatible) — handles prompt formatting for any model
+    const response = await sdk.chatCompletion(config.model, {
+      messages: [
+        { role: 'system', content: 'You are a helpful AI assistant. Give short, direct answers.' },
+        { role: 'user', content: userMessage }
+      ],
+      max_tokens: 200,
+      temperature: 0.7
+    });
+
+    let assistantMessage = response?.choices?.[0]?.message?.content || '';
+
+    // Light cleanup — stop at any hallucinated role prefixes
+    assistantMessage = assistantMessage
+      .split(/\n\s*(User|Human|System):/i)[0]
+      .trim();
+
+    if (!assistantMessage) {
+      assistantMessage = '(No response generated — try rephrasing your question)';
+    }
+
+    console.log(`\n${colors.bright}${colors.magenta}AI:${colors.reset} ${assistantMessage}\n`);
+  } catch (error) {
+    console.error(`\n${colors.red}Error:${colors.reset} ${error.message}\n`);
+  }
+}
+
+/**
+ * Prompt user for input
+ */
+function promptUser() {
+  rl.question(`${colors.bright}${colors.green}You:${colors.reset} `, async (input) => {
+    const message = input.trim();
+
+    if (!message) {
+      promptUser();
+      return;
+    }
+
+    // Handle commands
+    if (message.toLowerCase() === 'exit' || message.toLowerCase() === 'quit') {
+      console.log(`\n${colors.bright}${colors.cyan}Thank you for chatting! Goodbye.${colors.reset}\n`);
+      rl.close();
+      process.exit(0);
+    }
+
+    if (message.toLowerCase() === 'clear') {
+      console.clear();
+      printWelcome();
+      console.log(`${colors.green}✓ Screen cleared${colors.reset}\n`);
+      promptUser();
+      return;
+    }
+
+    // Send message to AI
+    await sendMessage(message);
+    promptUser();
+  });
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  printWelcome();
+
+  try {
+    console.log(`${colors.cyan}Initializing SlyOS...${colors.reset}`);
+    await sdk.initialize();
+
+    console.log(`${colors.cyan}Loading model: ${config.model}...${colors.reset}`);
+    await sdk.loadModel(config.model);
+
+    console.log(`${colors.green}Ready! Start chatting below.${colors.reset}\n`);
+    console.log(`${colors.bright}${colors.cyan}─────────────────────────────────────────────────────────────${colors.reset}\n`);
+  } catch (error) {
+    console.error(`${colors.red}Failed to initialize: ${error.message}${colors.reset}`);
+    console.error(`${colors.dim}Make sure your API key is correct and you have internet access.${colors.reset}`);
+    process.exit(1);
+  }
+
+  promptUser();
+}
+
+// Handle process termination gracefully
+process.on('SIGINT', () => {
+  console.log(`\n${colors.bright}${colors.cyan}Session ended. Goodbye!${colors.reset}\n`);
+  rl.close();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  rl.close();
+  process.exit(0);
+});
+
+// Start the chatbot
+main();
+CHATBOT_EOF
+
+chmod +x app.mjs
+print_success "Chatbot application created"
+
+# Create .env.example file
+print_step "Creating environment configuration example"
+cat > .env.example << 'ENV_EOF'
+# Slyos SDK Configuration
+SLYOS_API_KEY=your_api_key_here
+SLYOS_MODEL=quantum-1.7b
+SLYOS_SERVER=https://slyos-prod.eba-qjz3cmgq.us-east-2.elasticbeanstalk.com
+ENV_EOF
+print_success "Environment configuration template created"
+
+# Create README
+print_step "Creating README documentation"
+cat > README.md << 'README_EOF'
+# Slyos Interactive Chatbot
+
+A simple yet powerful interactive chatbot powered by the Slyos SDK.
+
+## Features
+
+- Interactive command-line interface with colored output
+- Conversation history management
+- Easy API configuration
+- Cross-platform support (Mac, Windows, Linux)
+
+## Installation
+
+1. Clone or download this project
+2. Install dependencies: `npm install`
+3. Configure your API key (see Configuration)
+
+## Configuration
+
+### Environment Variables
+
+Set these environment variables before running:
+
+```bash
+export SLYOS_API_KEY=your_api_key_here
+export SLYOS_MODEL=quantum-1.7b
+export SLYOS_SERVER=https://slyos-prod.eba-qjz3cmgq.us-east-2.elasticbeanstalk.com
+```
+
+Or create a `.env` file based on `.env.example`.
+
+## Running the Chatbot
+
+### Direct Method
+```bash
+npm start
+```
+
+### With Environment Variables
+```bash
+SLYOS_API_KEY=your_key npm start
+```
+
+### Manual
+```bash
+node app.mjs
+```
+
+## Usage
+
+Once the chatbot starts:
+
+- **Chat**: Type your message and press Enter
+- **Clear History**: Type `clear` to reset conversation
+- **Exit**: Type `exit` or `quit` to end session
+- **Interrupt**: Press Ctrl+C to exit anytime
+
+## API Response Format
+
+The chatbot supports multiple response formats from the SDK:
+
+- `response.content` - Primary response text
+- `response.text` - Alternative response field
+- Direct string response - Fallback format
+
+## Troubleshooting
+
+### "Error initializing SDK"
+- Check that your API key is valid
+- Verify the Slyos server is accessible
+- Ensure internet connection is active
+
+### "Cannot find module '@emilshirokikh/slyos-sdk'"
+- Run `npm install` to install dependencies
+- Check npm log: `npm list`
+
+### Placeholder API Key Warning
+- Set the `SLYOS_API_KEY` environment variable with your actual key
+- Or update `config.apiKey` in `app.mjs`
+
+## System Requirements
+
+- Node.js 14+ (14.17.0 or higher recommended)
+- npm 6+
+- Internet connection for API access
+
+## License
+
+MIT
+README_EOF
+print_success "README created"
+
+# Set up environment with provided values
+print_step "Configuring environment variables"
+cat > .env << ENV_SETUP_EOF
+SLYOS_API_KEY=${API_KEY}
+SLYOS_MODEL=${MODEL}
+SLYOS_SERVER=${SLYOS_SERVER}
+ENV_SETUP_EOF
+print_success "Environment configured"
+
+# Final summary
+echo ""
+echo -e "${BLUE}╔════════════════════════════════════════════════════════════╗${NC}"
+echo -e "${BLUE}║${NC}            ${GREEN}✓ Setup Complete!${NC}                          ${BLUE}║${NC}"
+echo -e "${BLUE}╚════════════════════════════════════════════════════════════╝${NC}"
+echo ""
+echo -e "${CYAN}Project Details:${NC}"
+echo "  Location: ${YELLOW}$(pwd)${NC}"
+echo "  API Key: ${YELLOW}${API_KEY}${NC}"
+echo "  Model: ${YELLOW}${MODEL}${NC}"
+echo ""
+echo -e "${CYAN}Next Steps:${NC}"
+echo "  1. Review the .env file and update your API key if needed"
+echo "  2. Run the chatbot: ${YELLOW}npm start${NC}"
+echo "  3. Type messages to chat with the AI"
+echo "  4. Type 'exit' to quit"
+echo ""
+echo -e "${GREEN}Ready to chat! 🚀${NC}"
+echo ""
+
+# Tell user how to start (can't auto-run when piped because stdin is closed)
+echo -e "${CYAN}To start chatting, run:${NC}"
+echo ""
+echo -e "  ${YELLOW}cd ${PROJECT_NAME} && npm start${NC}"
+echo ""

package/dist/index.d.ts

@@ -31,12 +31,81 @@ interface ProgressEvent {
     detail?: any;
 }
 interface SlyEvent {
-    type: 'auth' | 'device_registered' | 'device_profiled' | 'model_download_start' | 'model_download_progress' | 'model_loaded' | 'inference_start' | 'inference_complete' | 'error';
+    type: 'auth' | 'device_registered' | 'device_profiled' | 'model_download_start' | 'model_download_progress' | 'model_loaded' | 'inference_start' | 'inference_complete' | 'error' | 'fallback_success' | 'fallback_error';
     data?: any;
     timestamp: number;
 }
 type ProgressCallback = (event: ProgressEvent) => void;
 type EventCallback = (event: SlyEvent) => void;
+interface OpenAIMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+interface OpenAIChatCompletionRequest {
+    messages: OpenAIMessage[];
+    temperature?: number;
+    top_p?: number;
+    max_tokens?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string | string[];
+}
+interface OpenAIChoice {
+    index: number;
+    message: OpenAIMessage;
+    finish_reason: string;
+}
+interface OpenAIUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+interface OpenAIChatCompletionResponse {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: OpenAIChoice[];
+    usage: OpenAIUsage;
+}
+interface BedrockTextGenerationConfig {
+    maxTokenCount?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    stopSequences?: string[];
+}
+interface BedrockInvokeRequest {
+    inputText: string;
+    textGenerationConfig?: BedrockTextGenerationConfig;
+}
+interface BedrockResult {
+    outputText: string;
+    tokenCount: number;
+}
+interface BedrockInvokeResponse {
+    results: BedrockResult[];
+    input_text_token_count?: number;
+}
+type FallbackProvider = 'openai' | 'bedrock';
+interface FallbackConfig {
+    provider: FallbackProvider;
+    apiKey: string;
+    model: string;
+    region?: string;
+}
+interface SlyOSConfigWithFallback extends SlyOSConfig {
+    fallback?: FallbackConfig;
+}
+interface OpenAICompatibleClient {
+    chat: {
+        completions: {
+            create(request: OpenAIChatCompletionRequest & {
+                model: string;
+            }): Promise<OpenAIChatCompletionResponse>;
+        };
+    };
+}
 declare class SlyOS {
     private apiKey;
     private apiUrl;
@@ -46,7 +115,8 @@ declare class SlyOS {
     private deviceProfile;
     private onProgress;
     private onEvent;
-    constructor(config: SlyOSConfig);
+    private fallbackConfig;
+    constructor(config: SlyOSConfigWithFallback);
     private emitProgress;
     private emitEvent;
     analyzeDevice(): Promise<DeviceProfile>;
@@ -75,6 +145,19 @@ declare class SlyOS {
     }): Promise<void>;
     generate(modelId: string, prompt: string, options?: GenerateOptions): Promise<string>;
     transcribe(modelId: string, audioInput: any, options?: TranscribeOptions): Promise<string>;
+    chatCompletion(modelId: string, request: OpenAIChatCompletionRequest): Promise<OpenAIChatCompletionResponse>;
+    bedrockInvoke(modelId: string, request: BedrockInvokeRequest): Promise<BedrockInvokeResponse>;
+    private fallbackToOpenAI;
+    private fallbackToBedrock;
+    private fallbackToOpenAICloud;
+    private fallbackToBedrockCloud;
+    private invokeBedrockCloud;
+    private mapModelToOpenAI;
+    static openaiCompatible(config: {
+        apiKey: string;
+        apiUrl?: string;
+        fallback?: FallbackConfig;
+    }): OpenAICompatibleClient;
 }
 export default SlyOS;
-export type { SlyOSConfig, GenerateOptions, TranscribeOptions, DeviceProfile, ProgressEvent, SlyEvent, QuantizationLevel, ModelCategory };
+export type { SlyOSConfig, SlyOSConfigWithFallback, GenerateOptions, TranscribeOptions, DeviceProfile, ProgressEvent, SlyEvent, QuantizationLevel, ModelCategory, OpenAIMessage, OpenAIChatCompletionRequest, OpenAIChatCompletionResponse, OpenAIChoice, OpenAIUsage, BedrockTextGenerationConfig, BedrockInvokeRequest, BedrockInvokeResponse, BedrockResult, FallbackConfig, FallbackProvider, OpenAICompatibleClient, };

package/dist/index.js

@@ -153,6 +153,7 @@ class SlyOS {
         this.deviceId = `device-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         this.onProgress = config.onProgress || null;
         this.onEvent = config.onEvent || null;
+        this.fallbackConfig = config.fallback || null;
     }
     // ── Progress & Event Helpers ────────────────────────────────────
     emitProgress(stage, progress, message, detail) {
@@ -412,7 +413,12 @@ class SlyOS {
                 top_p: options.topP || 0.9,
                 do_sample: true,
             });
-            const response = result[0].generated_text;
+            const rawOutput = result[0].generated_text;
+            // HuggingFace transformers returns the prompt + generated text concatenated.
+            // Strip the original prompt so we only return the NEW tokens.
+            const response = rawOutput.startsWith(prompt)
+                ? rawOutput.slice(prompt.length).trim()
+                : rawOutput.trim();
             const latency = Date.now() - startTime;
             const tokensGenerated = response.split(/\s+/).length;
             const tokensPerSec = (tokensGenerated / (latency / 1000)).toFixed(1);
@@ -500,5 +506,277 @@ class SlyOS {
             throw error;
         }
     }
+    // ── OpenAI Compatibility ────────────────────────────────────────────
+    async chatCompletion(modelId, request) {
+        try {
+            // Convert OpenAI message format to a prompt string
+            const prompt = request.messages
+                .map(msg => {
+                if (msg.role === 'system') {
+                    return `System: ${msg.content}`;
+                }
+                else if (msg.role === 'user') {
+                    return `User: ${msg.content}`;
+                }
+                else {
+                    return `Assistant: ${msg.content}`;
+                }
+            })
+                .join('\n\n');
+            const response = await this.generate(modelId, prompt, {
+                temperature: request.temperature,
+                maxTokens: request.max_tokens,
+                topP: request.top_p,
+            });
+            // Estimate token counts (rough approximation: ~4 chars per token)
+            const promptTokens = Math.ceil(prompt.length / 4);
+            const completionTokens = Math.ceil(response.length / 4);
+            return {
+                id: `chat-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                object: 'chat.completion',
+                created: Math.floor(Date.now() / 1000),
+                model: modelId,
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: 'assistant',
+                            content: response,
+                        },
+                        finish_reason: 'stop',
+                    },
+                ],
+                usage: {
+                    prompt_tokens: promptTokens,
+                    completion_tokens: completionTokens,
+                    total_tokens: promptTokens + completionTokens,
+                },
+            };
+        }
+        catch (error) {
+            // Fallback to cloud provider if configured
+            if (this.fallbackConfig?.provider === 'openai') {
+                return this.fallbackToOpenAI(modelId, request);
+            }
+            else if (this.fallbackConfig?.provider === 'bedrock') {
+                return this.fallbackToBedrock(modelId, request);
+            }
+            throw error;
+        }
+    }
+    // ── AWS Bedrock Compatibility ──────────────────────────────────────
+    async bedrockInvoke(modelId, request) {
+        try {
+            const response = await this.generate(modelId, request.inputText, {
+                temperature: request.textGenerationConfig?.temperature,
+                maxTokens: request.textGenerationConfig?.maxTokenCount,
+                topP: request.textGenerationConfig?.topP,
+            });
+            // Estimate token counts
+            const inputTokens = Math.ceil(request.inputText.length / 4);
+            const outputTokens = Math.ceil(response.length / 4);
+            return {
+                results: [
+                    {
+                        outputText: response,
+                        tokenCount: outputTokens,
+                    },
+                ],
+                input_text_token_count: inputTokens,
+            };
+        }
+        catch (error) {
+            // Fallback to cloud provider if configured
+            if (this.fallbackConfig?.provider === 'bedrock') {
+                return this.fallbackToBedrockCloud(modelId, request);
+            }
+            else if (this.fallbackConfig?.provider === 'openai') {
+                return this.fallbackToOpenAICloud(modelId, request);
+            }
+            throw error;
+        }
+    }
+    // ── Fallback: OpenAI Cloud ────────────────────────────────────────
+    async fallbackToOpenAI(modelId, request) {
+        if (!this.fallbackConfig) {
+            throw new Error('OpenAI fallback not configured');
+        }
+        const mappedModel = this.mapModelToOpenAI(modelId);
+        const payload = {
+            model: this.fallbackConfig.model || mappedModel,
+            messages: request.messages,
+            temperature: request.temperature,
+            max_tokens: request.max_tokens,
+            top_p: request.top_p,
+            frequency_penalty: request.frequency_penalty,
+            presence_penalty: request.presence_penalty,
+            stop: request.stop,
+        };
+        try {
+            const response = await axios.post('https://api.openai.com/v1/chat/completions', payload, {
+                headers: {
+                    Authorization: `Bearer ${this.fallbackConfig.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            this.emitEvent('fallback_success', { provider: 'openai', originalModel: modelId, mappedModel: this.fallbackConfig.model });
+            return response.data;
+        }
+        catch (error) {
+            this.emitProgress('error', 0, `OpenAI fallback failed: ${error.message}`);
+            this.emitEvent('fallback_error', { provider: 'openai', error: error.message });
+            throw error;
+        }
+    }
+    async fallbackToBedrock(modelId, request) {
+        if (!this.fallbackConfig) {
+            throw new Error('Bedrock fallback not configured');
+        }
+        // Convert OpenAI format to Bedrock's expected format (simplified)
+        const lastMessage = request.messages[request.messages.length - 1];
+        const inputText = lastMessage.content;
+        const bedrockResponse = await this.invokeBedrockCloud(inputText, {
+            temperature: request.temperature,
+            maxTokenCount: request.max_tokens,
+            topP: request.top_p,
+        });
+        // Convert Bedrock response back to OpenAI format
+        const promptTokens = Math.ceil(inputText.length / 4);
+        const completionTokens = bedrockResponse.results[0].tokenCount;
+        this.emitEvent('fallback_success', { provider: 'bedrock', originalModel: modelId, mappedModel: this.fallbackConfig.model });
+        return {
+            id: `chat-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: modelId,
+            choices: [
+                {
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content: bedrockResponse.results[0].outputText,
+                    },
+                    finish_reason: 'stop',
+                },
+            ],
+            usage: {
+                prompt_tokens: promptTokens,
+                completion_tokens: completionTokens,
+                total_tokens: promptTokens + completionTokens,
+            },
+        };
+    }
+    async fallbackToOpenAICloud(modelId, request) {
+        if (!this.fallbackConfig) {
+            throw new Error('OpenAI fallback not configured');
+        }
+        const mappedModel = this.mapModelToOpenAI(modelId);
+        const payload = {
+            model: this.fallbackConfig.model || mappedModel,
+            messages: [{ role: 'user', content: request.inputText }],
+            temperature: request.textGenerationConfig?.temperature,
+            max_tokens: request.textGenerationConfig?.maxTokenCount,
+            top_p: request.textGenerationConfig?.topP,
+        };
+        try {
+            const response = await axios.post('https://api.openai.com/v1/chat/completions', payload, {
+                headers: {
+                    Authorization: `Bearer ${this.fallbackConfig.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            const outputText = response.data.choices[0].message.content;
+            const inputTokens = Math.ceil(request.inputText.length / 4);
+            const outputTokens = response.data.usage.completion_tokens;
+            this.emitEvent('fallback_success', { provider: 'openai', originalModel: modelId, mappedModel: this.fallbackConfig.model });
+            return {
+                results: [
+                    {
+                        outputText,
+                        tokenCount: outputTokens,
+                    },
+                ],
+                input_text_token_count: inputTokens,
+            };
+        }
+        catch (error) {
+            this.emitProgress('error', 0, `OpenAI fallback failed: ${error.message}`);
+            this.emitEvent('fallback_error', { provider: 'openai', error: error.message });
+            throw error;
+        }
+    }
+    async fallbackToBedrockCloud(modelId, request) {
+        if (!this.fallbackConfig) {
+            throw new Error('Bedrock fallback not configured');
+        }
+        try {
+            return await this.invokeBedrockCloud(request.inputText, request.textGenerationConfig);
+        }
+        catch (error) {
+            this.emitProgress('error', 0, `Bedrock fallback failed: ${error.message}`);
+            this.emitEvent('fallback_error', { provider: 'bedrock', error: error.message });
+            throw error;
+        }
+    }
+    async invokeBedrockCloud(inputText, config) {
+        if (!this.fallbackConfig) {
+            throw new Error('Bedrock fallback not configured');
+        }
+        const region = this.fallbackConfig.region || 'us-east-1';
+        const model = this.fallbackConfig.model || 'anthropic.claude-3-sonnet-20240229-v1:0';
+        // Bedrock endpoint format: https://bedrock-runtime.{region}.amazonaws.com/model/{modelId}/invoke
+        const endpoint = `https://bedrock-runtime.${region}.amazonaws.com/model/${model}/invoke`;
+        const payload = {
+            inputText,
+            textGenerationConfig: {
+                maxTokenCount: config?.maxTokenCount || 256,
+                temperature: config?.temperature || 0.7,
+                topP: config?.topP || 0.9,
+                topK: config?.topK,
+                stopSequences: config?.stopSequences,
+            },
+        };
+        try {
+            const response = await axios.post(endpoint, payload, {
+                headers: {
+                    Authorization: `Bearer ${this.fallbackConfig.apiKey}`,
+                    'Content-Type': 'application/json',
+                    'X-Amz-Target': 'AmazonBedrockRuntime.InvokeModel',
+                },
+            });
+            this.emitEvent('fallback_success', { provider: 'bedrock', model });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Bedrock invocation failed: ${error.message}`);
+        }
+    }
+    mapModelToOpenAI(slyModelId) {
+        const modelMapping = {
+            'quantum-1.7b': 'gpt-4o-mini',
+            'quantum-3b': 'gpt-4o',
+            'quantum-code-3b': 'gpt-4o',
+            'quantum-8b': 'gpt-4-turbo',
+        };
+        return modelMapping[slyModelId] || 'gpt-4o-mini';
+    }
+    // ── Static OpenAI Compatible Factory ────────────────────────────────
+    static openaiCompatible(config) {
+        const instance = new SlyOS({
+            apiKey: config.apiKey,
+            apiUrl: config.apiUrl,
+            fallback: { ...config.fallback, provider: config.fallback?.provider || 'openai' },
+        });
+        return {
+            chat: {
+                completions: {
+                    async create(request) {
+                        const { model, ...chatRequest } = request;
+                        return instance.chatCompletion(model, chatRequest);
+                    },
+                },
+            },
+        };
+    }
 }
 export default SlyOS;

package/package.json

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

package/src/index.ts

@@ -55,7 +55,7 @@ interface ProgressEvent {
 }
 
 interface SlyEvent {
-  type: 'auth' | 'device_registered' | 'device_profiled' | 'model_download_start' | 'model_download_progress' | 'model_loaded' | 'inference_start' | 'inference_complete' | 'error';
+  type: 'auth' | 'device_registered' | 'device_profiled' | 'model_download_start' | 'model_download_progress' | 'model_loaded' | 'inference_start' | 'inference_complete' | 'error' | 'fallback_success' | 'fallback_error';
   data?: any;
   timestamp: number;
 }
@@ -63,6 +63,94 @@ interface SlyEvent {
 type ProgressCallback = (event: ProgressEvent) => void;
 type EventCallback = (event: SlyEvent) => void;
 
+// ─── OpenAI Compatibility Types ──────────────────────────────────────
+
+interface OpenAIMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+interface OpenAIChatCompletionRequest {
+  messages: OpenAIMessage[];
+  temperature?: number;
+  top_p?: number;
+  max_tokens?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  stop?: string | string[];
+}
+
+interface OpenAIChoice {
+  index: number;
+  message: OpenAIMessage;
+  finish_reason: string;
+}
+
+interface OpenAIUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+}
+
+interface OpenAIChatCompletionResponse {
+  id: string;
+  object: 'chat.completion';
+  created: number;
+  model: string;
+  choices: OpenAIChoice[];
+  usage: OpenAIUsage;
+}
+
+// ─── AWS Bedrock Compatibility Types ─────────────────────────────────
+
+interface BedrockTextGenerationConfig {
+  maxTokenCount?: number;
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  stopSequences?: string[];
+}
+
+interface BedrockInvokeRequest {
+  inputText: string;
+  textGenerationConfig?: BedrockTextGenerationConfig;
+}
+
+interface BedrockResult {
+  outputText: string;
+  tokenCount: number;
+}
+
+interface BedrockInvokeResponse {
+  results: BedrockResult[];
+  input_text_token_count?: number;
+}
+
+// ─── Fallback Configuration ─────────────────────────────────────────
+
+type FallbackProvider = 'openai' | 'bedrock';
+
+interface FallbackConfig {
+  provider: FallbackProvider;
+  apiKey: string;
+  model: string;
+  region?: string; // for Bedrock
+}
+
+interface SlyOSConfigWithFallback extends SlyOSConfig {
+  fallback?: FallbackConfig;
+}
+
+// ─── OpenAI Compatible Client ───────────────────────────────────────
+
+interface OpenAICompatibleClient {
+  chat: {
+    completions: {
+      create(request: OpenAIChatCompletionRequest & { model: string }): Promise<OpenAIChatCompletionResponse>;
+    };
+  };
+}
+
 // ─── Model Registry ─────────────────────────────────────────────────
 
 const modelMap: Record<string, ModelInfo> = {
@@ -218,13 +306,15 @@ class SlyOS {
   private deviceProfile: DeviceProfile | null = null;
   private onProgress: ProgressCallback | null;
   private onEvent: EventCallback | null;
+  private fallbackConfig: FallbackConfig | null;
 
-  constructor(config: SlyOSConfig) {
+  constructor(config: SlyOSConfigWithFallback) {
     this.apiKey = config.apiKey;
     this.apiUrl = config.apiUrl || 'https://api.slyos.world';
     this.deviceId = `device-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     this.onProgress = config.onProgress || null;
     this.onEvent = config.onEvent || null;
+    this.fallbackConfig = config.fallback || null;
   }
 
   // ── Progress & Event Helpers ────────────────────────────────────
@@ -525,7 +615,12 @@ class SlyOS {
         do_sample: true,
       });
 
-      const response = result[0].generated_text;
+      const rawOutput = result[0].generated_text;
+      // HuggingFace transformers returns the prompt + generated text concatenated.
+      // Strip the original prompt so we only return the NEW tokens.
+      const response = rawOutput.startsWith(prompt)
+        ? rawOutput.slice(prompt.length).trim()
+        : rawOutput.trim();
       const latency = Date.now() - startTime;
       const tokensGenerated = response.split(/\s+/).length;
       const tokensPerSec = (tokensGenerated / (latency / 1000)).toFixed(1);
@@ -625,7 +720,329 @@ class SlyOS {
       throw error;
     }
   }
+
+  // ── OpenAI Compatibility ────────────────────────────────────────────
+
+  async chatCompletion(modelId: string, request: OpenAIChatCompletionRequest): Promise<OpenAIChatCompletionResponse> {
+    try {
+      // Convert OpenAI message format to a prompt string
+      const prompt = request.messages
+        .map(msg => {
+          if (msg.role === 'system') {
+            return `System: ${msg.content}`;
+          } else if (msg.role === 'user') {
+            return `User: ${msg.content}`;
+          } else {
+            return `Assistant: ${msg.content}`;
+          }
+        })
+        .join('\n\n');
+
+      const response = await this.generate(modelId, prompt, {
+        temperature: request.temperature,
+        maxTokens: request.max_tokens,
+        topP: request.top_p,
+      });
+
+      // Estimate token counts (rough approximation: ~4 chars per token)
+      const promptTokens = Math.ceil(prompt.length / 4);
+      const completionTokens = Math.ceil(response.length / 4);
+
+      return {
+        id: `chat-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: modelId,
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: response,
+            },
+            finish_reason: 'stop',
+          },
+        ],
+        usage: {
+          prompt_tokens: promptTokens,
+          completion_tokens: completionTokens,
+          total_tokens: promptTokens + completionTokens,
+        },
+      };
+    } catch (error: any) {
+      // Fallback to cloud provider if configured
+      if (this.fallbackConfig?.provider === 'openai') {
+        return this.fallbackToOpenAI(modelId, request);
+      } else if (this.fallbackConfig?.provider === 'bedrock') {
+        return this.fallbackToBedrock(modelId, request);
+      }
+      throw error;
+    }
+  }
+
+  // ── AWS Bedrock Compatibility ──────────────────────────────────────
+
+  async bedrockInvoke(modelId: string, request: BedrockInvokeRequest): Promise<BedrockInvokeResponse> {
+    try {
+      const response = await this.generate(modelId, request.inputText, {
+        temperature: request.textGenerationConfig?.temperature,
+        maxTokens: request.textGenerationConfig?.maxTokenCount,
+        topP: request.textGenerationConfig?.topP,
+      });
+
+      // Estimate token counts
+      const inputTokens = Math.ceil(request.inputText.length / 4);
+      const outputTokens = Math.ceil(response.length / 4);
+
+      return {
+        results: [
+          {
+            outputText: response,
+            tokenCount: outputTokens,
+          },
+        ],
+        input_text_token_count: inputTokens,
+      };
+    } catch (error: any) {
+      // Fallback to cloud provider if configured
+      if (this.fallbackConfig?.provider === 'bedrock') {
+        return this.fallbackToBedrockCloud(modelId, request);
+      } else if (this.fallbackConfig?.provider === 'openai') {
+        return this.fallbackToOpenAICloud(modelId, request);
+      }
+      throw error;
+    }
+  }
+
+  // ── Fallback: OpenAI Cloud ────────────────────────────────────────
+
+  private async fallbackToOpenAI(modelId: string, request: OpenAIChatCompletionRequest): Promise<OpenAIChatCompletionResponse> {
+    if (!this.fallbackConfig) {
+      throw new Error('OpenAI fallback not configured');
+    }
+
+    const mappedModel = this.mapModelToOpenAI(modelId);
+    const payload = {
+      model: this.fallbackConfig.model || mappedModel,
+      messages: request.messages,
+      temperature: request.temperature,
+      max_tokens: request.max_tokens,
+      top_p: request.top_p,
+      frequency_penalty: request.frequency_penalty,
+      presence_penalty: request.presence_penalty,
+      stop: request.stop,
+    };
+
+    try {
+      const response = await axios.post('https://api.openai.com/v1/chat/completions', payload, {
+        headers: {
+          Authorization: `Bearer ${this.fallbackConfig.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+      });
+
+      this.emitEvent('fallback_success', { provider: 'openai', originalModel: modelId, mappedModel: this.fallbackConfig.model });
+      return response.data;
+    } catch (error: any) {
+      this.emitProgress('error', 0, `OpenAI fallback failed: ${error.message}`);
+      this.emitEvent('fallback_error', { provider: 'openai', error: error.message });
+      throw error;
+    }
+  }
+
+  private async fallbackToBedrock(modelId: string, request: OpenAIChatCompletionRequest): Promise<OpenAIChatCompletionResponse> {
+    if (!this.fallbackConfig) {
+      throw new Error('Bedrock fallback not configured');
+    }
+
+    // Convert OpenAI format to Bedrock's expected format (simplified)
+    const lastMessage = request.messages[request.messages.length - 1];
+    const inputText = lastMessage.content;
+
+    const bedrockResponse = await this.invokeBedrockCloud(inputText, {
+      temperature: request.temperature,
+      maxTokenCount: request.max_tokens,
+      topP: request.top_p,
+    });
+
+    // Convert Bedrock response back to OpenAI format
+    const promptTokens = Math.ceil(inputText.length / 4);
+    const completionTokens = bedrockResponse.results[0].tokenCount;
+
+    this.emitEvent('fallback_success', { provider: 'bedrock', originalModel: modelId, mappedModel: this.fallbackConfig.model });
+
+    return {
+      id: `chat-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      object: 'chat.completion',
+      created: Math.floor(Date.now() / 1000),
+      model: modelId,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: 'assistant',
+            content: bedrockResponse.results[0].outputText,
+          },
+          finish_reason: 'stop',
+        },
+      ],
+      usage: {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens,
+      },
+    };
+  }
+
+  private async fallbackToOpenAICloud(modelId: string, request: BedrockInvokeRequest): Promise<BedrockInvokeResponse> {
+    if (!this.fallbackConfig) {
+      throw new Error('OpenAI fallback not configured');
+    }
+
+    const mappedModel = this.mapModelToOpenAI(modelId);
+    const payload = {
+      model: this.fallbackConfig.model || mappedModel,
+      messages: [{ role: 'user', content: request.inputText }],
+      temperature: request.textGenerationConfig?.temperature,
+      max_tokens: request.textGenerationConfig?.maxTokenCount,
+      top_p: request.textGenerationConfig?.topP,
+    };
+
+    try {
+      const response = await axios.post('https://api.openai.com/v1/chat/completions', payload, {
+        headers: {
+          Authorization: `Bearer ${this.fallbackConfig.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+      });
+
+      const outputText = response.data.choices[0].message.content;
+      const inputTokens = Math.ceil(request.inputText.length / 4);
+      const outputTokens = response.data.usage.completion_tokens;
+
+      this.emitEvent('fallback_success', { provider: 'openai', originalModel: modelId, mappedModel: this.fallbackConfig.model });
+
+      return {
+        results: [
+          {
+            outputText,
+            tokenCount: outputTokens,
+          },
+        ],
+        input_text_token_count: inputTokens,
+      };
+    } catch (error: any) {
+      this.emitProgress('error', 0, `OpenAI fallback failed: ${error.message}`);
+      this.emitEvent('fallback_error', { provider: 'openai', error: error.message });
+      throw error;
+    }
+  }
+
+  private async fallbackToBedrockCloud(modelId: string, request: BedrockInvokeRequest): Promise<BedrockInvokeResponse> {
+    if (!this.fallbackConfig) {
+      throw new Error('Bedrock fallback not configured');
+    }
+
+    try {
+      return await this.invokeBedrockCloud(request.inputText, request.textGenerationConfig);
+    } catch (error: any) {
+      this.emitProgress('error', 0, `Bedrock fallback failed: ${error.message}`);
+      this.emitEvent('fallback_error', { provider: 'bedrock', error: error.message });
+      throw error;
+    }
+  }
+
+  private async invokeBedrockCloud(inputText: string, config?: BedrockTextGenerationConfig): Promise<BedrockInvokeResponse> {
+    if (!this.fallbackConfig) {
+      throw new Error('Bedrock fallback not configured');
+    }
+
+    const region = this.fallbackConfig.region || 'us-east-1';
+    const model = this.fallbackConfig.model || 'anthropic.claude-3-sonnet-20240229-v1:0';
+
+    // Bedrock endpoint format: https://bedrock-runtime.{region}.amazonaws.com/model/{modelId}/invoke
+    const endpoint = `https://bedrock-runtime.${region}.amazonaws.com/model/${model}/invoke`;
+
+    const payload = {
+      inputText,
+      textGenerationConfig: {
+        maxTokenCount: config?.maxTokenCount || 256,
+        temperature: config?.temperature || 0.7,
+        topP: config?.topP || 0.9,
+        topK: config?.topK,
+        stopSequences: config?.stopSequences,
+      },
+    };
+
+    try {
+      const response = await axios.post(endpoint, payload, {
+        headers: {
+          Authorization: `Bearer ${this.fallbackConfig.apiKey}`,
+          'Content-Type': 'application/json',
+          'X-Amz-Target': 'AmazonBedrockRuntime.InvokeModel',
+        },
+      });
+
+      this.emitEvent('fallback_success', { provider: 'bedrock', model });
+      return response.data;
+    } catch (error: any) {
+      throw new Error(`Bedrock invocation failed: ${error.message}`);
+    }
+  }
+
+  private mapModelToOpenAI(slyModelId: string): string {
+    const modelMapping: Record<string, string> = {
+      'quantum-1.7b': 'gpt-4o-mini',
+      'quantum-3b': 'gpt-4o',
+      'quantum-code-3b': 'gpt-4o',
+      'quantum-8b': 'gpt-4-turbo',
+    };
+    return modelMapping[slyModelId] || 'gpt-4o-mini';
+  }
+
+  // ── Static OpenAI Compatible Factory ────────────────────────────────
+
+  static openaiCompatible(config: { apiKey: string; apiUrl?: string; fallback?: FallbackConfig }): OpenAICompatibleClient {
+    const instance = new SlyOS({
+      apiKey: config.apiKey,
+      apiUrl: config.apiUrl,
+      fallback: { ...config.fallback, provider: config.fallback?.provider || 'openai' } as FallbackConfig,
+    });
+
+    return {
+      chat: {
+        completions: {
+          async create(request: OpenAIChatCompletionRequest & { model: string }): Promise<OpenAIChatCompletionResponse> {
+            const { model, ...chatRequest } = request;
+            return instance.chatCompletion(model, chatRequest);
+          },
+        },
+      },
+    };
+  }
 }
 
 export default SlyOS;
-export type { SlyOSConfig, GenerateOptions, TranscribeOptions, DeviceProfile, ProgressEvent, SlyEvent, QuantizationLevel, ModelCategory };
+export type {
+  SlyOSConfig,
+  SlyOSConfigWithFallback,
+  GenerateOptions,
+  TranscribeOptions,
+  DeviceProfile,
+  ProgressEvent,
+  SlyEvent,
+  QuantizationLevel,
+  ModelCategory,
+  OpenAIMessage,
+  OpenAIChatCompletionRequest,
+  OpenAIChatCompletionResponse,
+  OpenAIChoice,
+  OpenAIUsage,
+  BedrockTextGenerationConfig,
+  BedrockInvokeRequest,
+  BedrockInvokeResponse,
+  BedrockResult,
+  FallbackConfig,
+  FallbackProvider,
+  OpenAICompatibleClient,
+};