opencloud-platform-sdk 1.2.0 → 2.0.0

package/README.md

@@ -1,209 +1,191 @@
-# @opencloud/sdk
+# opencloud-platform-sdk
 
-Official SDK for **OpenCloud** - The AI App Marketplace with pay-per-use model.
+Official SDK for **OpenCloud** - Monetize your AI apps with ease.
 
-Build AI-powered apps that automatically handle payments and AI API calls through OpenCloud's platform.
+**You control the AI, we handle the payments.**
 
-## Features
+## What's New in v2.0
 
-- ✅ Call 100+ AI models (GPT-4, Claude, Gemini, Llama, etc.) via OpenRouter
-- ✅ Automatic payment processing (70% to creators, 30% to platform)
-- ✅ No API keys needed - OpenCloud handles everything
-- ✅ TypeScript support with full type definitions
-- ✅ Works in browsers and Node.js
-- ✅ Zero dependencies
+- **Use your own AI** - OpenAI, Anthropic, your own model, whatever you want
+- **Set your own price** - Charge what you want per use
+- **85/15 split** - You keep 85%, platform takes 15%
 
 ## Installation
 
 ```bash
-npm install @opencloud/sdk
-# or
-pnpm add @opencloud/sdk
-# or
-yarn add @opencloud/sdk
+npm install opencloud-platform-sdk
 ```
 
 ## Quick Start
 
-### For React/Next.js Apps
-
 ```typescript
-import { opencloud } from '@opencloud/sdk';
+import { opencloud } from 'opencloud-platform-sdk';
 
-// Initialize with your app ID
+// 1. Initialize with your app ID
 opencloud.init({ appId: 'your-app-slug' });
 
-// Call AI models
-const response = await opencloud.callAI({
-  model: 'openai/gpt-4',
-  prompt: 'Write a tagline for my startup'
-});
-
-console.log(response.text); // AI-generated response
-console.log(response.cost); // $0.10 (or your app's price per use)
-```
-
-### For HTML/Vanilla JS
-
-```html
-<script src="https://opencloud.com/sdk/platform-sdk.js"></script>
-
-<script>
-  PlatformSDK.init({ appId: 'your-app-slug' });
+// 2. Check if user can afford
+const canUse = await opencloud.canAfford();
+if (!canUse) {
+  opencloud.requestTopUp();
+  return;
+}
 
-  async function generate() {
-    const result = await PlatformSDK.callAI({
-      model: 'anthropic/claude-3-5-sonnet',
-      prompt: 'Generate a logo description'
-    });
+// 3. Call YOUR OWN AI (you control this)
+const response = await fetch('https://api.openai.com/v1/chat/completions', {
+  method: 'POST',
+  headers: { 'Authorization': 'Bearer YOUR_API_KEY' },
+  body: JSON.stringify({
+    model: 'gpt-4',
+    messages: [{ role: 'user', content: 'Hello!' }]
+  })
+});
 
-    console.log(result.text);
-  }
-</script>
+// 4. Charge the user
+const result = await opencloud.trackUsage({ action: 'chat' });
+console.log('Charged:', result.charged);
+console.log('User balance:', result.userBalance);
 ```
 
 ## API Reference
 
 ### `opencloud.init(config)`
 
-Initialize the SDK with your app configuration.
+Initialize the SDK.
 
 ```typescript
 opencloud.init({
-  appId: 'your-app-slug',  // Required: Your app's unique identifier
-  apiUrl: 'https://opencloud.com'  // Optional: Platform URL (defaults to current origin)
+  appId: 'your-app-slug',  // Required
+  apiUrl: 'https://opencloud.app'  // Optional
 });
 ```
 
-### `opencloud.callAI(params)`
+### `opencloud.canAfford()`
 
-Call an AI model through OpenCloud's platform.
+Check if user has enough balance.
 
 ```typescript
-const response = await opencloud.callAI({
-  model: 'openai/gpt-4',  // Required: Model identifier
-  prompt: 'Your prompt here',  // Required: The prompt to send
-  options: {  // Optional: Additional model parameters
-    temperature: 0.7,
-    max_tokens: 1000
-  }
+const canUse = await opencloud.canAfford();
+if (!canUse) {
+  opencloud.requestTopUp();
+  return;
+}
+```
+
+### `opencloud.trackUsage(options)`
+
+Charge the user. This is the main method to monetize your app.
+
+```typescript
+const result = await opencloud.trackUsage({
+  action: 'chat_message',  // Optional: for analytics
+  metadata: { model: 'gpt-4' }  // Optional: extra data
 });
 
-// Response structure:
+// Response:
 {
   success: true,
-  text: "AI-generated response...",
-  usage: {
-    promptTokens: 10,
-    completionTokens: 50,
-    totalTokens: 60
-  },
-  cost: 0.10,  // Amount charged to user
-  model: "openai/gpt-4"
+  charged: 0.10,
+  userBalance: 4.90,
+  transactionId: 'tx_abc123'
 }
 ```
 
-### `opencloud.getBalance()`
+### `opencloud.withUsage(fn, options)` (Optional)
 
-Get the current user's token balance.
+Convenience method that combines canAfford + your code + trackUsage.
 
 ```typescript
-const balance = await opencloud.getBalance();
-console.log(`Balance: $${balance}`);
+const response = await opencloud.withUsage(async () => {
+  // Your AI call here - only runs if user can pay
+  return await myAICall();
+}, { action: 'chat' });
 ```
 
-### `opencloud.requestTopUp()`
+### `opencloud.getBalance()`
 
-Request the user to purchase more tokens (opens payment dialog).
+Get user's current balance.
 
 ```typescript
-try {
-  await opencloud.callAI({...});
-} catch (error) {
-  if (error.message.includes('Insufficient balance')) {
-    await opencloud.requestTopUp();
-  }
-}
+const balance = await opencloud.getBalance();
+console.log(`Balance: $${balance}`);
 ```
 
-## Supported AI Models
+### `opencloud.getAppPrice()`
 
-OpenCloud uses OpenRouter, giving you access to 100+ models:
+Get your app's price per use.
 
-**OpenAI:**
-- `openai/gpt-4`
-- `openai/gpt-4-turbo`
-- `openai/gpt-3.5-turbo`
-
-**Anthropic:**
-- `anthropic/claude-3-5-sonnet`
-- `anthropic/claude-3-haiku`
-- `anthropic/claude-3-opus`
+```typescript
+const price = await opencloud.getAppPrice();
+console.log(`Price: $${price}`);
+```
 
-**Google:**
-- `google/gemini-pro`
-- `google/gemini-pro-vision`
+### `opencloud.requestTopUp()`
 
-**Meta:**
-- `meta-llama/llama-3-70b`
-- `meta-llama/llama-3-8b`
+Open the payment dialog for user to add credits.
 
-**And many more!** See [OpenRouter docs](https://openrouter.ai/docs) for full list.
+```typescript
+opencloud.requestTopUp();
+```
 
-## Example Apps
+### `opencloud.getUserInfo()`
 
-### Text Summarizer
+Get current user information.
 
 ```typescript
-import { opencloud } from '@opencloud/sdk';
+const user = await opencloud.getUserInfo();
+// { id, email, balance, username }
+```
 
-opencloud.init({ appId: 'text-summarizer' });
+### `opencloud.isPreview()`
 
-async function summarize(text: string) {
-  const response = await opencloud.callAI({
-    model: 'anthropic/claude-3-haiku',  // Fast and cheap
-    prompt: `Summarize this text in 3 bullet points:\n\n${text}`
-  });
+Check if running in development mode (localhost, etc).
 
-  return response.text;
+```typescript
+if (opencloud.isPreview()) {
+  console.log('Preview mode - no real charges');
 }
 ```
 
-### Image Description Generator
+## Revenue Model
 
-```typescript
-import { opencloud } from '@opencloud/sdk';
+**85/15 split** - You keep most of what you earn!
 
-opencloud.init({ appId: 'image-describer' });
+```
+User pays:     $0.10 per use
+├─ You get:    $0.085 (85%)
+└─ Platform:   $0.015 (15%)
+```
 
-async function describeImage(imageUrl: string) {
-  const response = await opencloud.callAI({
-    model: 'google/gemini-pro-vision',
-    prompt: 'Describe this image in detail',
-    options: {
-      image: imageUrl
-    }
-  });
+## Error Handling
 
-  return response.text;
+```typescript
+try {
+  await opencloud.trackUsage({ action: 'chat' });
+} catch (error) {
+  if (error.message === 'INSUFFICIENT_BALANCE') {
+    opencloud.requestTopUp();
+  }
 }
 ```
 
-## Revenue Model
+## Preview Mode
 
-OpenCloud uses a **70/30 revenue split**:
+When running locally (localhost, etc), the SDK automatically enters preview mode:
+- `trackUsage()` doesn't charge real money
+- `getBalance()` returns 999.99
+- `canAfford()` always returns true
 
-- **70%** goes to you (the app creator)
-- **30%** goes to OpenCloud (platform fee)
+This lets you develop without worrying about charges.
 
-Example:
-```
-User pays:     $0.10 per use
-AI cost:       -$0.03 (OpenAI API)
-Net revenue:   $0.07
-├─ You get:    $0.049 (70%)
-└─ Platform:   $0.021 (30%)
-```
+## Publishing Your App
+
+1. Deploy your app to Vercel via [opencloud.app/deploy](/deploy)
+2. Go to [opencloud.app/publish](/publish)
+3. Select your deployed project
+4. Set name, description, and **price per use**
+5. Sign the creator agreement (85/15 split)
+6. Publish!
 
 ## TypeScript Support
 
@@ -213,35 +195,17 @@ Full TypeScript definitions included:
 import {
   opencloud,
   OpenCloudSDK,
-  AICallParams,
-  AIResponse,
-  OpenCloudConfig
-} from '@opencloud/sdk';
-
-const params: AICallParams = {
-  model: 'openai/gpt-4',
-  prompt: 'Hello world'
-};
-
-const response: AIResponse = await opencloud.callAI(params);
+  TrackUsageParams,
+  TrackUsageResponse,
+  UserInfo
+} from 'opencloud-platform-sdk';
 ```
 
-## Publishing Your App
-
-1. Build your app with the SDK
-2. Go to [opencloud.com/publish](https://opencloud.com/publish)
-3. Upload your app or connect GitHub
-4. Set pricing and details
-5. Test with $5 free credits
-6. Publish to marketplace!
-
 ## Support
 
-- 📚 [Documentation](https://opencloud.com/docs)
-- 💬 [Discord Community](https://discord.gg/opencloud)
-- 🐛 [Report Issues](https://github.com/opencloud/sdk/issues)
-- ✉️ support@opencloud.com
+- Docs: [opencloud.app/docs](/docs)
+- Issues: [github.com/opencloud/sdk](https://github.com/opencloud/sdk/issues)
 
 ## License
 
-MIT © OpenCloud
+MIT

package/dist/index.d.mts

@@ -1,101 +1,130 @@
 /**
- * opencloud-platform-sdk v1.2.0
+ * opencloud-platform-sdk v2.0.0
  * Official SDK for OpenCloud - AI App Marketplace
  *
- * Features:
- * - Automatic preview/production mode detection
- * - Works in bolt.diy/WebContainers preview
- * - Auto-detects API keys from bolt.diy builder
- * - Seamless transition to production with credits
+ * New Model:
+ * - Creators use their own AI/APIs
+ * - SDK only tracks usage and charges end users
+ * - Creators set price per use, platform takes 15% commission
  */
 interface OpenCloudConfig {
     appId: string;
     apiUrl?: string;
-    previewApiKey?: string;
 }
-interface AICallParams {
-    model: string;
-    prompt: string;
-    options?: Record<string, any>;
+interface TrackUsageParams {
+    action?: string;
+    metadata?: Record<string, any>;
 }
-interface AIResponse {
+interface TrackUsageResponse {
     success: boolean;
-    text: string;
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-    cost: number;
-    model: string;
-    mode: 'preview' | 'production';
+    charged: number;
+    userBalance: number;
+    transactionId: string;
 }
 interface UserSession {
     token: string;
 }
+interface UserInfo {
+    id: string;
+    email: string;
+    balance: number;
+    username?: string;
+}
 declare class OpenCloudSDK {
     private config;
     private heartbeatInterval?;
     private _isPreviewMode;
+    private _cachedSession;
     constructor();
-    /**
-     * Detect if running in preview/development mode
-     */
     private detectPreviewMode;
     /**
-     * Check if currently in preview mode
+     * Check if running in preview/development mode
      */
     isPreview(): boolean;
     /**
-     * Initialize the SDK
+     * Initialize the SDK with your app ID
      */
     init(options: OpenCloudConfig): void;
     /**
-     * Set API key for preview mode
+     * Track a usage event and charge the user
+     * Call this BEFORE or AFTER your AI/API call
+     *
+     * Example:
+     * ```
+     * // Check if user can afford it first
+     * const canUse = await opencloud.canAfford();
+     * if (!canUse) {
+     *   opencloud.requestTopUp();
+     *   return;
+     * }
+     *
+     * // Do your AI call
+     * const result = await myAICall();
+     *
+     * // Track the usage (charges user)
+     * await opencloud.trackUsage({ action: 'chat_message' });
+     * ```
      */
-    setPreviewApiKey(key: string, provider?: 'openrouter' | 'anthropic' | 'openai'): void;
+    trackUsage(params?: TrackUsageParams): Promise<TrackUsageResponse>;
     /**
-     * Get API key for preview mode
-     * Checks in order: config, localStorage, bolt.diy cookies
+     * Check if the user can afford to use the app
+     * Returns true if user has enough balance
      */
-    private getPreviewApiKey;
+    canAfford(): Promise<boolean>;
     /**
-     * Call an AI model - automatically uses preview or production mode
+     * Get current user's balance
      */
-    callAI(params: AICallParams): Promise<AIResponse>;
+    getBalance(): Promise<number>;
     /**
-     * Call AI in preview mode (direct to OpenRouter/provider)
+     * Get current user info
      */
-    private callAIPreview;
+    getUserInfo(): Promise<UserInfo>;
     /**
-     * Call AI in production mode (through OpenCloud API)
+     * Get the price per use for this app
      */
-    private callAIProduction;
+    getAppPrice(): Promise<number>;
     /**
-     * Get current user's balance (production only)
+     * Request user to add more credits
+     * Opens the top-up modal or redirects to payment page
      */
-    getBalance(): Promise<number>;
+    requestTopUp(): void;
     /**
-     * Request user to purchase more tokens
+     * Check if user is authenticated
      */
-    requestTopUp(): Promise<void>;
+    isAuthenticated(): Promise<boolean>;
     /**
-     * Start sending heartbeats
+     * Request user to log in
      */
+    requestLogin(): void;
     private startHeartbeat;
-    /**
-     * Send heartbeat to platform
-     */
     private sendHeartbeat;
+    private getUserSession;
     /**
-     * Get user session token
+     * Clear cached session (call on logout)
      */
-    private getUserSession;
+    clearSession(): void;
     /**
-     * Cleanup
+     * Cleanup resources
      */
     destroy(): void;
+    /**
+     * Execute a function and automatically charge the user
+     * This is a convenience method that combines canAfford + your code + trackUsage
+     *
+     * @param fn - The async function to execute (your AI call, etc.)
+     * @param options - Optional tracking options
+     * @returns The result of your function
+     *
+     * Example:
+     * ```typescript
+     * const result = await opencloud.withUsage(async () => {
+     *   const response = await fetch('https://api.openai.com/...', { ... });
+     *   return await response.json();
+     * }, { action: 'chat_message' });
+     * ```
+     */
+    withUsage<T>(fn: () => Promise<T>, options?: TrackUsageParams): Promise<T>;
 }
 declare const opencloud: OpenCloudSDK;
 
-export { type AICallParams, type AIResponse, type OpenCloudConfig, OpenCloudSDK, type UserSession, opencloud };
+export { type OpenCloudConfig, OpenCloudSDK, type TrackUsageParams, type TrackUsageResponse, type UserInfo, type UserSession, opencloud };