@ceo-ai/sdk 1.0.0

package/README.md

@@ -0,0 +1,422 @@
+## SDK README  
+  
+### `ceo-sdk/README.md`  
+  
+ 
+## @ceo-ai/sdk  
+  
+Lightweight Node.js SDK for the CEO.AI API. Zero external dependencies — uses only Node.js built-in modules.  
+  
+## Installation  
+  
+
+```bash  
+npm install @ceo-ai/sdk  
+```
+  
+  
+## Quick Start  
+  
+
+```javascript  
+const { CeoAI } = require('@ceo-ai/sdk');  
+  
+const ceo = new CeoAI({ apiKey: 'sk_live_your_api_key_here' });  
+  
+// Send a prompt and wait for the result  
+const { response, metadata } = await ceo.promptAndWait('What was our Q4 revenue?');  
+  
+console.log(response);  
+// => { answer: "Q4 revenue was $12.5M, representing a 15% increase..." }  
+  
+console.log(metadata);  
+// => { agentId: '...', agentName: 'Financial Analyst', model: 'claude-sonnet-4-5', estimatedCredits: 10}  
+```
+  
+  
+## API Reference  
+  
+### `new CeoAI(options)`  
+  
+Create a new client instance.  
+  
+
+```javascript  
+const ceo = new CeoAI({  
+    apiKey: 'sk_live_...',       // Required  
+    endpoint: 'https://...',     // Optional. Default: 'https://ingest.api.ceo.ai'  
+    timeout: 30000,              // Optional. Request timeout in ms. Default: 30000  
+    pollInterval: 2000,          // Optional. Default polling interval in ms. Default: 2000  
+    pollTimeout: 120000          // Optional. Default polling timeout in ms. Default: 120000  
+});  
+```
+  
+  
+| Option | Type | Required | Default | Description |  
+|--------|------|----------|---------|-------------|  
+| `apiKey` | `string` | ✅ | — | Your API key (`sk_live_...`) |  
+| `endpoint` | `string` | — | `https://ingest.api.ceo.ai` | API endpoint URL |  
+| `timeout` | `number` | — | `30000` | HTTP request timeout in ms |  
+| `pollInterval` | `number` | — | `2000` | Default interval between poll attempts in ms |  
+| `pollTimeout` | `number` | — | `120000` | Default max time to wait when polling in ms |  
+  
+---  
+  
+### `ceo.prompt(prompt, options?)`  
+  
+Send a prompt to your AI agent. Returns immediately with a presigned URL where results will be written.  
+  
+
+```javascript  
+const result = await ceo.prompt('What was our Q4 revenue?');  
+  
+console.log(result);  
+// {  
+//   presignedUrl: 'https://ceo-ai-api-output-results.s3.amazonaws.com/...',  
+//   message: 'Processing request',  
+//   estimatedCredits: 10,  
+//   agentId: 'abc-123',  
+//   agentName: 'Financial Analyst',  
+//   model: 'claude-sonnet-4-5',  
+//   tenantId: 'tenant-456'  
+// }  
+```
+  
+  
+**Parameters:**  
+  
+| Parameter | Type | Required | Description |  
+|-----------|------|----------|-------------|  
+| `prompt` | `string` | ✅ | The prompt text to send |  
+| `options.ragMode` | `boolean` | — | Enable/disable RAG. Default: `true` (server-side) |  
+| `options.conversationHistory` | `Array` | — | Previous messages for context |  
+  
+**Returns:** `Promise<PromptResponse>`  
+  
+---  
+  
+### `ceo.promptAndWait(prompt, options?)`  
+  
+Send a prompt and automatically poll until the result is ready. This is the most convenient method for typical usage.  
+  
+
+```javascript  
+const { response, metadata } = await ceo.promptAndWait('What was our Q4 revenue?', {  
+    pollInterval: 3000,  
+    pollTimeout: 60000,  
+    onPoll: (attempt, elapsed) => {  
+        console.log(`Waiting... attempt ${attempt} (${elapsed}ms)`);  
+    }  
+});  
+  
+console.log(response);  // The AI response  
+console.log(metadata);  // Agent/model/credits info  
+```
+  
+  
+**Parameters:**  
+  
+| Parameter | Type | Required | Description |  
+|-----------|------|----------|-------------|  
+| `prompt` | `string` | ✅ | The prompt text to send |  
+| `options.ragMode` | `boolean` | — | Enable/disable RAG |  
+| `options.conversationHistory` | `Array` | — | Previous messages for context |  
+| `options.pollInterval` | `number` | — | Override polling interval in ms |  
+| `options.pollTimeout` | `number` | — | Override polling timeout in ms |  
+| `options.onPoll` | `Function` | — | Callback: `(attempt, elapsed) => {}` |  
+  
+**Returns:** `Promise<{ response: any, metadata: Object }>`  
+  
+---  
+  
+### `ceo.pollForResult(presignedUrl, options?)`  
+  
+Poll a presigned URL until content is available. Useful when you've stored a presigned URL from a previous `prompt()` call and want to check for results later.  
+  
+
+```javascript  
+const result = await ceo.pollForResult(presignedUrl, {  
+    interval: 3000,  
+    timeout: 60000,  
+    onPoll: (attempt, elapsed) => {  
+        console.log(`Attempt ${attempt} (${elapsed}ms elapsed)`);  
+    }  
+});  
+```
+  
+  
+**Parameters:**  
+  
+| Parameter | Type | Required | Description |  
+|-----------|------|----------|-------------|  
+| `presignedUrl` | `string` | ✅ | The presigned URL to poll |  
+| `options.interval` | `number` | — | Polling interval in ms |  
+| `options.timeout` | `number` | — | Max wait time in ms |  
+| `options.onPoll` | `Function` | — | Callback: `(attempt, elapsed) => {}` |  
+  
+**Returns:** `Promise<Object | string>` — Parsed JSON if possible, raw string otherwise.  
+  
+---  
+  
+### `CeoAPIError`  
+  
+Custom error class thrown for API errors.  
+  
+
+```javascript  
+const { CeoAI, CeoAPIError } = require('@ceo-ai/sdk');  
+  
+try {  
+    await ceo.promptAndWait('Hello');  
+} catch (error) {  
+    if (error instanceof CeoAPIError) {  
+        console.log(error.message);      // Error message  
+        console.log(error.statusCode);   // HTTP status code  
+        console.log(error.details);      // Additional details (if any)  
+  
+        // Convenience getters  
+        error.isAuthError;            // true if 401  
+        error.isInsufficientCredits;  // true if 402  
+        error.isRateLimited;          // true if 429  
+        error.isTimeout;              // true if 408  
+    }  
+}  
+```
+  
+  
+## Usage Examples  
+  
+### Simple Query  
+  
+
+```javascript  
+const { CeoAI } = require('@ceo-ai/sdk');  
+  
+const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
+  
+const { response } = await ceo.promptAndWait('Summarize our sales this quarter');  
+console.log(response);  
+```
+  
+  
+### Fire and Forget (Store URL for Later)  
+  
+
+```javascript  
+const { CeoAI } = require('@ceo-ai/sdk');  
+  
+const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
+  
+// Submit the prompt  
+const submission = await ceo.prompt('Generate a detailed report');  
+console.log('Presigned URL:', submission.presignedUrl);  
+  
+// Store submission.presignedUrl in your database  
+// ...  
+  
+// Later (even in a different process), retrieve the result:  
+const result = await ceo.pollForResult(storedPresignedUrl);  
+console.log(result);  
+```
+  
+  
+### Conversation History  
+  
+
+```javascript  
+const { CeoAI } = require('@ceo-ai/sdk');  
+  
+const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
+  
+// First message  
+const first = await ceo.promptAndWait('What was our Q4 revenue?');  
+console.log(first.response);  
+  
+// Follow-up with context  
+const second = await ceo.promptAndWait('How does that compare to Q3?', {  
+    conversationHistory: [  
+        { role: 'user', content: 'What was our Q4 revenue?' },  
+        { role: 'assistant', content: JSON.stringify(first.response) }  
+    ]  
+});  
+console.log(second.response);  
+```
+  
+  
+### Disable RAG Mode  
+  
+
+```javascript  
+const { response } = await ceo.promptAndWait('What is 2 + 2?', {  
+    ragMode: false  
+});  
+```
+  
+  
+### Progress Tracking  
+  
+
+```javascript  
+const { response } = await ceo.promptAndWait('Complex analysis...', {  
+    pollInterval: 3000,  
+    pollTimeout: 300000, // 5 minutes  
+    onPoll: (attempt, elapsed) => {  
+        const seconds = Math.round(elapsed / 1000);  
+        console.log(`⏳ Waiting for response... ${seconds}s (attempt ${attempt})`);  
+    }  
+});  
+```
+  
+  
+### Error Handling  
+  
+
+```javascript  
+const { CeoAI, CeoAPIError } = require('@ceo-ai/sdk');  
+  
+const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
+  
+try {  
+    const { response } = await ceo.promptAndWait('What was our Q4 revenue?');  
+    console.log(response);  
+  
+} catch (error) {  
+    if (error instanceof CeoAPIError) {  
+        switch (true) {  
+            case error.isAuthError:  
+                console.error('❌ Invalid or expired API key');  
+                console.error('   Get a new key at https://app.ceo.ai/apikeys');  
+                break;  
+  
+            case error.isInsufficientCredits:  
+                console.error('❌ Insufficient credits');  
+                console.error(`   Required: ${error.details?.requiredCredits}`);  
+                console.error(`   Available: ${error.details?.availableCredits}`);  
+                console.error('   Add credits at https://app.ceo.ai/usercredits');  
+                break;  
+  
+            case error.isTimeout:  
+                console.error('❌ Request timed out');  
+                console.error('   Try increasing pollTimeout');  
+                break;  
+  
+            case error.isRateLimited:  
+                console.error('❌ Rate limited. Please wait and try again.');  
+                break;  
+  
+            default:  
+                console.error(`❌ API error (${error.statusCode}): ${error.message}`);  
+        }  
+    } else {  
+        console.error('❌ Unexpected error:', error.message);  
+    }  
+}  
+```
+  
+  
+### Express.js Integration  
+  
+
+```javascript  
+const express = require('express');  
+const { CeoAI, CeoAPIError } = require('@ceo-ai/sdk');  
+  
+const app = express();  
+app.use(express.json());  
+  
+const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
+  
+// Async endpoint — returns presigned URL  
+app.post('/api/ask', async (req, res) => {  
+    try {  
+        const result = await ceo.prompt(req.body.question);  
+        res.json({  
+            presignedUrl: result.presignedUrl,  
+            estimatedCredits: result.estimatedCredits  
+        });  
+    } catch (error) {  
+        if (error instanceof CeoAPIError) {  
+            res.status(error.statusCode).json({ error: error.message });  
+        } else {  
+            res.status(500).json({ error: 'Internal server error' });  
+        }  
+    }  
+});  
+  
+// Sync endpoint — waits for result  
+app.post('/api/ask/sync', async (req, res) => {  
+    try {  
+        const { response, metadata } = await ceo.promptAndWait(req.body.question, {  
+            pollTimeout: 60000  
+        });  
+        res.json({ response, metadata });  
+    } catch (error) {  
+        if (error instanceof CeoAPIError) {  
+            res.status(error.statusCode).json({  
+                error: error.message,  
+                details: error.details  
+            });  
+        } else {  
+            res.status(500).json({ error: 'Internal server error' });  
+        }  
+    }  
+});  
+  
+app.listen(3000);  
+```
+  
+  
+### Batch Processing  
+  
+
+```javascript  
+const { CeoAI } = require('@ceo-ai/sdk');  
+  
+const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
+  
+const questions = [  
+    'What was Q1 revenue?',  
+    'What was Q2 revenue?',  
+    'What was Q3 revenue?',  
+    'What was Q4 revenue?'  
+];  
+  
+// Submit all prompts concurrently  
+const submissions = await Promise.all(  
+    questions.map(q => ceo.prompt(q))  
+);  
+  
+console.log(`Submitted ${submissions.length} prompts`);  
+  
+// Wait a bit, then collect all results  
+await new Promise(r => setTimeout(r, 10000));  
+  
+const results = await Promise.all(  
+    submissions.map(s => ceo.pollForResult(s.presignedUrl, {  
+        timeout: 60000  
+    }))  
+);  
+  
+results.forEach((result, i) => {  
+    console.log(`\n--- ${questions[i]} ---`);  
+    console.log(result);  
+});  
+```
+  
+  
+## Getting Your API Key  
+  
+1. Log in to the [CEO.AI Dashboard](https://app.ceo.ai)  
+2. Navigate to **API Keys**  
+3. Click **Create API Key** (NB: you must have a paid subscription to create api keys) 
+4. Select the agent you want to use  
+5. Copy the generated key — it will only be shown once  
+  
+## Requirements  
+  
+- Node.js 16 or later  
+- Zero external dependencies  
+  
+## License  
+  
+MIT  

package/lib/index.d.ts

@@ -0,0 +1,58 @@
+export interface CeoAIOptions {  
+    apiKey: string;  
+    endpoint?: string;  
+    timeout?: number;  
+    pollInterval?: number;  
+    pollTimeout?: number;  
+}  
+  
+export interface PromptOptions {  
+    ragMode?: boolean;  
+    conversationHistory?: Array<{ role: string; content: string }>;  
+}  
+  
+export interface PromptResponse {  
+    presignedUrl: string;  
+    message: string;  
+    estimatedCredits: number;  
+    agentId: string;  
+    agentName: string;  
+    model: string;  
+    tenantId: string;  
+}  
+  
+export interface PollOptions {  
+    interval?: number;  
+    timeout?: number;  
+    onPoll?: (attempt: number, elapsed: number) => void;  
+}  
+  
+export interface PromptAndWaitOptions extends PromptOptions, PollOptions {}  
+  
+export interface PromptAndWaitResponse {  
+    response: any;  
+    metadata: {  
+        agentId: string;  
+        agentName: string;  
+        model: string;  
+        estimatedCredits: number;  
+        tenantId: string;  
+    };  
+}  
+  
+export declare class CeoAPIError extends Error {  
+    statusCode: number;  
+    details: any;  
+    readonly isAuthError: boolean;  
+    readonly isInsufficientCredits: boolean;  
+    readonly isRateLimited: boolean;  
+    readonly isTimeout: boolean;  
+    constructor(message: string, statusCode: number, details?: any);  
+}  
+  
+export declare class CeoAI {  
+    constructor(options: CeoAIOptions);  
+    prompt(prompt: string, options?: PromptOptions): Promise<PromptResponse>;  
+    promptAndWait(prompt: string, options?: PromptAndWaitOptions): Promise<PromptAndWaitResponse>;  
+    pollForResult(presignedUrl: string, options?: PollOptions): Promise<any>;  
+}  

package/lib/index.js

@@ -0,0 +1,311 @@
+const https = require('https');  
+const http = require('http');  
+  
+class CeoAI {  
+    /**  
+     * @param {Object} options  
+     * @param {string} options.apiKey - Your API key (sk_live_...)  
+     * @param {string} [options.endpoint] - API endpoint URL  
+     * @param {number} [options.timeout] - Request timeout in ms  
+     * @param {number} [options.pollInterval] - Default polling interval in ms  
+     * @param {number} [options.pollTimeout] - Default polling timeout in ms  
+     */  
+    constructor(options = {}) {  
+        if (!options.apiKey) {  
+            throw new Error('apiKey is required');  
+        }  
+  
+        if (!options.apiKey.startsWith('sk_live_')) {  
+            throw new Error('Invalid API key format. Expected sk_live_...');  
+        }  
+  
+        this.apiKey = options.apiKey;  
+        this.endpoint = options.endpoint || 'https://ingestion.api.ceo.ai';  
+        this.timeout = options.timeout || 30000;  
+        this.pollInterval = options.pollInterval || 2000;  
+        this.pollTimeout = options.pollTimeout || 120000;  
+    }  
+  
+    /**  
+     * Send a prompt to your agent.  
+     * Returns the presigned URL and metadata without waiting for results.  
+     *  
+     * @param {string} prompt - The prompt text  
+     * @param {Object} [options]  
+     * @param {boolean} [options.ragMode] - Enable/disable RAG (defaults to true on server)  
+     * @param {Array} [options.conversationHistory] - Previous conversation messages  
+     * @returns {Promise<PromptResponse>}  
+     *  
+     * @example  
+     * const ceo = new CeoAI({ apiKey: 'sk_live_...' });  
+     * const result = await ceo.prompt('What was Q4 revenue?');  
+     * console.log(result.presignedUrl);  
+     */  
+    async prompt(prompt, options = {}) {  
+        if (!prompt || typeof prompt !== 'string') {  
+            throw new Error('prompt must be a non-empty string');  
+        }  
+  
+        const body = {  
+            prompt,  
+            ...(options.ragMode !== undefined && { ragMode: options.ragMode }),  
+            ...(options.conversationHistory && { conversationHistory: options.conversationHistory })  
+        };  
+  
+        const response = await this._request('POST', this.endpoint, body);  
+  
+        if (response.error) {  
+            throw new CeoAPIError(  
+                response.error || response.message,  
+                response.code || response.statusCode,  
+                response.details  
+            );  
+        }  
+  
+        return response.data || response;  
+    }  
+  
+    /**  
+     * Send a prompt and wait for the result.  
+     * This is a convenience method that combines prompt() + pollForResult().  
+     *  
+     * @param {string} prompt - The prompt text  
+     * @param {Object} [options]  
+     * @param {boolean} [options.ragMode] - Enable/disable RAG  
+     * @param {Array} [options.conversationHistory] - Previous conversation messages  
+     * @param {number} [options.pollInterval] - Polling interval in ms  
+     * @param {number} [options.pollTimeout] - Max wait time in ms  
+     * @param {Function} [options.onPoll] - Callback on each poll attempt: (attempt, elapsed) => {}  
+     * @returns {Promise<Object>} The AI response  
+     *  
+     * @example  
+     * const ceo = new CeoAI({ apiKey: 'sk_live_...' });  
+     * const result = await ceo.promptAndWait('What was Q4 revenue?');  
+     * console.log(result);  
+     */  
+    async promptAndWait(prompt, options = {}) {  
+        const {  
+            ragMode,  
+            conversationHistory,  
+            pollInterval,  
+            pollTimeout,  
+            onPoll  
+        } = options;  
+  
+        const submission = await this.prompt(prompt, { ragMode, conversationHistory });  
+  
+        if (!submission.presignedUrl) {  
+            throw new Error('No presigned URL returned from API');  
+        }  
+  
+        const result = await this.pollForResult(submission.presignedUrl, {  
+            interval: pollInterval,  
+            timeout: pollTimeout,  
+            onPoll  
+        });  
+  
+        return {  
+            response: result,  
+            metadata: {  
+                agentId: submission.agentId,  
+                agentName: submission.agentName,  
+                model: submission.model,  
+                estimatedCredits: submission.estimatedCredits,  
+                tenantId: submission.tenantId  
+            }  
+        };  
+    }  
+  
+    /**  
+     * Poll a presigned URL until content is available.  
+     *  
+     * @param {string} presignedUrl - The presigned URL to poll  
+     * @param {Object} [options]  
+     * @param {number} [options.interval] - Polling interval in ms  
+     * @param {number} [options.timeout] - Max wait time in ms  
+     * @param {Function} [options.onPoll] - Callback on each attempt: (attempt, elapsed) => {}  
+     * @returns {Promise<Object|string>} The result content  
+     *  
+     * @example  
+     * const result = await ceo.pollForResult(presignedUrl, {  
+     *   interval: 3000,  
+     *   timeout: 60000,  
+     *   onPoll: (attempt) => console.log(`Attempt ${attempt}...`)  
+     * });  
+     */  
+    async pollForResult(presignedUrl, options = {}) {  
+        const {  
+            interval = this.pollInterval,  
+            timeout = this.pollTimeout,  
+            onPoll = null  
+        } = options;  
+  
+        const startTime = Date.now();  
+        let attempt = 0;  
+  
+        while (Date.now() - startTime < timeout) {  
+            attempt++;  
+            const elapsed = Date.now() - startTime;  
+  
+            if (onPoll) {  
+                onPoll(attempt, elapsed);  
+            }  
+  
+            try {  
+                const result = await this._fetch(presignedUrl);  
+                if (result !== null) {  
+                    try {  
+                        return JSON.parse(result);  
+                    } catch {  
+                        return result;  
+                    }  
+                }  
+            } catch (error) {  
+                // 403/404 = object not written yet, keep polling  
+                if (error.statusCode === 403 || error.statusCode === 404) {  
+                    // Expected — not ready yet  
+                } else {  
+                    throw error;  
+                }  
+            }  
+  
+            await this._sleep(interval);  
+        }  
+  
+        throw new CeoAPIError(  
+            `Polling timed out after ${timeout}ms (${attempt} attempts)`,  
+            408  
+        );  
+    }  
+  
+    /**  
+     * Make an HTTP request to the API  
+     * @private  
+     */  
+    _request(method, url, body = null) {  
+        return new Promise((resolve, reject) => {  
+            const parsedUrl = new URL(url);  
+            const isHttps = parsedUrl.protocol === 'https:';  
+            const lib = isHttps ? https : http;  
+  
+            const payload = body ? JSON.stringify(body) : null;  
+  
+            const options = {  
+                hostname: parsedUrl.hostname,  
+                port: parsedUrl.port || (isHttps ? 443 : 80),  
+                path: parsedUrl.pathname + parsedUrl.search,  
+                method,  
+                headers: {  
+                    'Authorization': `Bearer ${this.apiKey}`,  
+                    'Content-Type': 'application/json',  
+                    'User-Agent': `ceo-ai-sdk-node/1.0.0`,  
+                    ...(payload && { 'Content-Length': Buffer.byteLength(payload) })  
+                }  
+            };  
+  
+            const req = lib.request(options, (res) => {  
+                let data = '';  
+                res.on('data', (chunk) => { data += chunk; });  
+                res.on('end', () => {  
+                    try {  
+                        const parsed = JSON.parse(data);  
+                        if (res.statusCode >= 400) {  
+                            parsed.statusCode = res.statusCode;  
+                        }  
+                        resolve(parsed);  
+                    } catch {  
+                        resolve({ data: data, statusCode: res.statusCode });  
+                    }  
+                });  
+            });  
+  
+            req.on('error', reject);  
+            req.setTimeout(this.timeout, () => {  
+                req.destroy();  
+                reject(new CeoAPIError('Request timed out', 408));  
+            });  
+  
+            if (payload) req.write(payload);  
+            req.end();  
+        });  
+    }  
+  
+    /**  
+     * Fetch a URL (for presigned URL polling)  
+     * @private  
+     */  
+    _fetch(url) {  
+        return new Promise((resolve, reject) => {  
+            const parsedUrl = new URL(url);  
+            const isHttps = parsedUrl.protocol === 'https:';  
+            const lib = isHttps ? https : http;  
+  
+            const req = lib.get(url, (res) => {  
+                if (res.statusCode === 403 || res.statusCode === 404) {  
+                    const error = new CeoAPIError('Not ready', res.statusCode);  
+                    res.resume();  
+                    reject(error);  
+                    return;  
+                }  
+  
+                let data = '';  
+                res.on('data', (chunk) => { data += chunk; });  
+                res.on('end', () => {  
+                    if (res.statusCode >= 200 && res.statusCode < 300 && data.length > 0) {  
+                        resolve(data);  
+                    } else {  
+                        resolve(null);  
+                    }  
+                });  
+            });  
+  
+            req.on('error', reject);  
+            req.setTimeout(10000, () => {  
+                req.destroy();  
+                reject(new CeoAPIError('Fetch timed out', 408));  
+            });  
+        });  
+    }  
+  
+    /**  
+     * @private  
+     */  
+    _sleep(ms) {  
+        return new Promise((resolve) => setTimeout(resolve, ms));  
+    }  
+}  
+  
+/**  
+ * Custom error class for CEO.AI API errors  
+ */  
+class CeoAPIError extends Error {  
+    /**  
+     * @param {string} message  
+     * @param {number} statusCode  
+     * @param {Object} [details]  
+     */  
+    constructor(message, statusCode, details = null) {  
+        super(message);  
+        this.name = 'CeoAPIError';  
+        this.statusCode = statusCode;  
+        this.details = details;  
+    }  
+  
+    get isAuthError() {  
+        return this.statusCode === 401;  
+    }  
+  
+    get isInsufficientCredits() {  
+        return this.statusCode === 402;  
+    }  
+  
+    get isRateLimited() {  
+        return this.statusCode === 429;  
+    }  
+  
+    get isTimeout() {  
+        return this.statusCode === 408;  
+    }  
+}  
+  
+module.exports = { CeoAI, CeoAPIError };  

package/package.json

@@ -0,0 +1,13 @@
+{  
+  "name": "@ceo-ai/sdk",  
+  "version": "1.0.0",  
+  "description": "Node.js SDK for CEO.AI API",  
+  "main": "lib/index.js",  
+  "types": "lib/index.d.ts",  
+  "files": [  
+    "lib/"  
+  ],
+  "scripts":{"test":"node test/index.test.js"},  
+  "keywords": ["ceo-ai", "sdk", "ai", "api", "ai-agents"],  
+  "license": "MIT"  
+}