@emilshirokikh/slyos-sdk 1.2.2 → 1.3.0

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) {
@@ -500,5 +501,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.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

@@ -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 ────────────────────────────────────
@@ -625,7 +715,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,
+};