skytells 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Skytells, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,229 @@
+# Skytells JavaScript/TypeScript SDK
+
+The official JavaScript/TypeScript SDK for interacting with the [Skytells](https://skytells.ai) API. Edge-compatible with Cloudflare Pages, Vercel Edge Functions, and more.
+
+## Installation
+
+```bash
+npm install skytells
+# or
+yarn add skytells
+# or
+pnpm add skytells
+```
+
+## Quick Start
+
+```typescript
+import { createClient } from 'skytells';
+
+// Initialize the client with your API key
+const skytells = createClient('your-api-key-here');
+
+// Make a prediction
+async function makePrediction() {
+  try {
+    const prediction = await skytells.predict({
+      model: 'model-name',
+      input: {
+        prompt: 'Your prompt here'
+      }
+    });
+    
+    console.log('Prediction ID:', prediction.id);
+    console.log('Status:', prediction.status);
+    console.log('Output:', prediction.output);
+  } catch (error) {
+    console.error('Error making prediction:', error);
+  }
+}
+
+// List available models
+async function listModels() {
+  try {
+    const models = await skytells.listModels();
+    console.log('Available models:', models);
+  } catch (error) {
+    console.error('Error listing models:', error);
+  }
+}
+
+// Get a prediction by ID
+async function getPrediction(id) {
+  try {
+    const prediction = await skytells.getPrediction(id);
+    console.log('Prediction:', prediction);
+  } catch (error) {
+    console.error('Error getting prediction:', error);
+  }
+}
+```
+
+## Edge Compatibility
+
+This SDK is fully compatible with edge environments including:
+
+- Cloudflare Workers and Pages
+- Vercel Edge Functions
+- Netlify Edge Functions
+- Deno Deploy
+- Any environment with Fetch API support
+
+To use a custom API endpoint or proxy:
+
+```typescript
+import { createClient } from 'skytells';
+
+// Use a custom API endpoint or proxy
+const client = createClient('your-api-key', {
+  baseUrl: 'https://your-proxy.example.com/v1'
+});
+```
+
+## API Reference
+
+### Creating a Client
+
+```typescript
+import { createClient } from 'skytells';
+
+// With API key (authenticated)
+const client = createClient('your-api-key');
+
+// Without API key (unauthenticated, limited functionality)
+const unauthenticatedClient = createClient();
+
+// With options
+const clientWithOptions = createClient('your-api-key', {
+  baseUrl: 'https://api.skytells.ai/v1', // Custom API URL
+  timeout: 30000 // Custom timeout in ms
+});
+```
+
+### Predictions
+
+#### Make a Prediction
+
+```typescript
+const prediction = await client.predict({
+  model: 'model-name',
+  input: {
+    // Model-specific inputs
+    prompt: 'Your prompt here',
+    // Other parameters...
+  }
+});
+```
+
+#### Get a Prediction by ID
+
+```typescript
+const prediction = await client.getPrediction('prediction-id');
+```
+
+#### Stream a Prediction
+
+```typescript
+const prediction = await client.streamPrediction('prediction-id');
+```
+
+#### Cancel a Prediction
+
+```typescript
+const prediction = await client.cancelPrediction('prediction-id');
+```
+
+#### Delete a Prediction
+
+```typescript
+const prediction = await client.deletePrediction('prediction-id');
+```
+
+### Models
+
+#### List All Models
+
+```typescript
+const models = await client.listModels();
+```
+
+## TypeScript Support
+
+This SDK is built with TypeScript and provides full type definitions for all methods and responses.
+
+## Error Handling
+
+All API methods return promises that may reject with a `SkytellsError`. The SDK parses API error responses into this structured format:
+
+```typescript
+import { createClient, SkytellsError } from 'skytells';
+
+try {
+  const prediction = await client.predict({
+    model: 'model-name',
+    input: { prompt: 'Your prompt' }
+  });
+} catch (error) {
+  if (error instanceof SkytellsError) {
+    console.error('Error message:', error.message);
+    console.error('Error ID:', error.errorId);      // Example: "VALIDATION_ERROR"
+    console.error('Error details:', error.details);  // Detailed error information
+    console.error('HTTP status:', error.httpStatus); // HTTP status code (e.g., 422)
+  } else {
+    console.error('Unknown error:', error);
+  }
+}
+```
+
+### Common Error IDs
+
+- `VALIDATION_ERROR` - Request parameters failed validation
+- `AUTHENTICATION_ERROR` - Invalid or missing API key
+- `RATE_LIMIT_EXCEEDED` - Too many requests
+- `RESOURCE_NOT_FOUND` - The requested resource doesn't exist
+- `NETWORK_ERROR` - Connection issue with the API
+- `REQUEST_TIMEOUT` - Request took too long to complete
+- `SERVER_ERROR` - The server responded with a non-JSON response (e.g., HTML error page)
+- `INVALID_JSON` - The server returned invalid JSON content
+
+### Non-JSON Response Handling
+
+The SDK automatically handles cases when the server doesn't respond with valid JSON:
+
+```typescript
+try {
+  const models = await client.listModels();
+} catch (error) {
+  if (error instanceof SkytellsError) {
+    if (error.errorId === 'SERVER_ERROR') {
+      console.error('The server returned a non-JSON response:', error.message);
+      console.error('Response content excerpt:', error.details);
+      // This could indicate a server outage or maintenance
+    } else if (error.errorId === 'INVALID_JSON') {
+      console.error('The server returned malformed JSON:', error.message);
+      console.error('Response content excerpt:', error.details);
+      // This could indicate an API bug or server issue
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the SDK
+npm run build
+
+# Run tests
+npm test
+
+# Run linting
+npm run lint
+```
+
+## License
+
+MIT 

package/dist/client.cjs

@@ -0,0 +1,59 @@
+const { HTTP } = require("./http.js");
+const { ENDPOINTS } = require("./endpoints.js");
+export class SkytellsClient {
+    /**
+     * Creates a new Skytells client
+     * @param apiKey Your Skytells API key
+     * @param options Configuration options
+     */
+    constructor(apiKey, options = {}) {
+        this.http = new HTTP(apiKey, options.baseUrl, options.timeout);
+    }
+    /**
+     * Send a prediction request to the Skytells API
+     * @param payload The prediction request parameters
+     * @returns A promise that resolves to the prediction response
+     */
+    async predict(payload) {
+        return this.http.request('POST', ENDPOINTS.PREDICT, payload);
+    }
+    /**
+     * Get a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    async getPrediction(id) {
+        return this.http.request('GET', ENDPOINTS.PREDICTION_BY_ID(id));
+    }
+    /**
+     * List all available models
+     * @returns A promise that resolves to an array of models
+     */
+    async listModels() {
+        return this.http.request('GET', ENDPOINTS.MODELS);
+    }
+    /**
+     * Stream a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    async streamPrediction(id) {
+        return this.http.request('GET', ENDPOINTS.STREAM_PREDICTION_BY_ID(id));
+    }
+    /**
+     * Cancel a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    async cancelPrediction(id) {
+        return this.http.request('POST', ENDPOINTS.CANCEL_PREDICTION_BY_ID(id));
+    }
+    /**
+     * Delete a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    async deletePrediction(id) {
+        return this.http.request('DELETE', ENDPOINTS.DELETE_PREDICTION_BY_ID(id));
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,45 @@
+import { PredictionRequest, PredictionResponse, Model, ClientOptions } from './types/index.js';
+export declare class SkytellsClient {
+    private http;
+    /**
+     * Creates a new Skytells client
+     * @param apiKey Your Skytells API key
+     * @param options Configuration options
+     */
+    constructor(apiKey?: string, options?: ClientOptions);
+    /**
+     * Send a prediction request to the Skytells API
+     * @param payload The prediction request parameters
+     * @returns A promise that resolves to the prediction response
+     */
+    predict(payload: PredictionRequest): Promise<PredictionResponse>;
+    /**
+     * Get a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    getPrediction(id: string): Promise<PredictionResponse>;
+    /**
+     * List all available models
+     * @returns A promise that resolves to an array of models
+     */
+    listModels(): Promise<Model[]>;
+    /**
+     * Stream a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    streamPrediction(id: string): Promise<PredictionResponse>;
+    /**
+     * Cancel a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    cancelPrediction(id: string): Promise<PredictionResponse>;
+    /**
+     * Delete a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    deletePrediction(id: string): Promise<PredictionResponse>;
+}

package/dist/client.js

@@ -0,0 +1,59 @@
+import { HTTP } from './http.js';
+import { ENDPOINTS } from './endpoints.js';
+export class SkytellsClient {
+    /**
+     * Creates a new Skytells client
+     * @param apiKey Your Skytells API key
+     * @param options Configuration options
+     */
+    constructor(apiKey, options = {}) {
+        this.http = new HTTP(apiKey, options.baseUrl, options.timeout);
+    }
+    /**
+     * Send a prediction request to the Skytells API
+     * @param payload The prediction request parameters
+     * @returns A promise that resolves to the prediction response
+     */
+    async predict(payload) {
+        return this.http.request('POST', ENDPOINTS.PREDICT, payload);
+    }
+    /**
+     * Get a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    async getPrediction(id) {
+        return this.http.request('GET', ENDPOINTS.PREDICTION_BY_ID(id));
+    }
+    /**
+     * List all available models
+     * @returns A promise that resolves to an array of models
+     */
+    async listModels() {
+        return this.http.request('GET', ENDPOINTS.MODELS);
+    }
+    /**
+     * Stream a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    async streamPrediction(id) {
+        return this.http.request('GET', ENDPOINTS.STREAM_PREDICTION_BY_ID(id));
+    }
+    /**
+     * Cancel a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    async cancelPrediction(id) {
+        return this.http.request('POST', ENDPOINTS.CANCEL_PREDICTION_BY_ID(id));
+    }
+    /**
+     * Delete a prediction by ID
+     * @param id The prediction ID
+     * @returns A promise that resolves to the prediction response
+     */
+    async deletePrediction(id) {
+        return this.http.request('DELETE', ENDPOINTS.DELETE_PREDICTION_BY_ID(id));
+    }
+}

package/dist/endpoints.cjs

@@ -0,0 +1,9 @@
+const API_BASE_URL = module.exports.API_BASE_URL = "https://api.skytells.ai/v1";
+const ENDPOINTS = module.exports.ENDPOINTS = {
+    PREDICT: "/predict",
+    MODELS: "/models",
+    PREDICTION_BY_ID: (id) => `/predictions/${id}`,
+    STREAM_PREDICTION_BY_ID: (id) => `/predictions/${id}/stream`,
+    CANCEL_PREDICTION_BY_ID: (id) => `/predictions/${id}/cancel`,
+    DELETE_PREDICTION_BY_ID: (id) => `/predictions/${id}/delete`,
+};

package/dist/endpoints.d.ts

@@ -0,0 +1,9 @@
+export declare const API_BASE_URL = "https://api.skytells.ai/v1";
+export declare const ENDPOINTS: {
+    PREDICT: string;
+    MODELS: string;
+    PREDICTION_BY_ID: (id: string) => string;
+    STREAM_PREDICTION_BY_ID: (id: string) => string;
+    CANCEL_PREDICTION_BY_ID: (id: string) => string;
+    DELETE_PREDICTION_BY_ID: (id: string) => string;
+};

package/dist/endpoints.js

@@ -0,0 +1,9 @@
+export const API_BASE_URL = "https://api.skytells.ai/v1";
+export const ENDPOINTS = {
+    PREDICT: "/predict",
+    MODELS: "/models",
+    PREDICTION_BY_ID: (id) => `/predictions/${id}`,
+    STREAM_PREDICTION_BY_ID: (id) => `/predictions/${id}/stream`,
+    CANCEL_PREDICTION_BY_ID: (id) => `/predictions/${id}/cancel`,
+    DELETE_PREDICTION_BY_ID: (id) => `/predictions/${id}/delete`,
+};

package/dist/http.cjs

@@ -0,0 +1,118 @@
+const { API_BASE_URL } = require("./endpoints.js");
+const { SkytellsError } = require("./types/shared.types.js");
+// Default timeout in milliseconds
+// 60 seconds
+const DEFAULT_TIMEOUT = 60000;
+export class HTTP {
+    constructor(apiKey, baseUrl = API_BASE_URL, timeout = DEFAULT_TIMEOUT) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+        this.timeout = timeout;
+    }
+    async request(method, path, data) {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['x-api-key'] = this.apiKey;
+        }
+        const options = {
+            method,
+            headers,
+        };
+        if (method === 'POST' && data) {
+            options.body = JSON.stringify(data);
+        }
+        // Add AbortController for timeout handling
+        const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+        if (controller) {
+            options.signal = controller.signal;
+        }
+        // Set up timeout if AbortController is available
+        let timeoutId = null;
+        if (controller) {
+            timeoutId = setTimeout(() => {
+                controller.abort();
+            }, this.timeout);
+        }
+        try {
+            // Use native fetch which is available in modern browsers and edge environments
+            const response = await fetch(`${this.baseUrl}${path}`, options);
+            // Get the response content type to check if it's JSON
+            const contentType = response.headers.get('content-type') || '';
+            const isJsonResponse = contentType.includes('application/json');
+            // Handle non-JSON responses properly
+            if (!isJsonResponse) {
+                // If not JSON, get the text for error details
+                let responseText = '';
+                try {
+                    responseText = await response.text();
+                    // Truncate if too long to avoid huge error messages
+                    if (responseText.length > 500) {
+                        responseText = responseText.substring(0, 500) + '... [truncated]';
+                    }
+                }
+                catch (textError) {
+                    responseText = 'Could not read response body';
+                }
+                throw new SkytellsError(`Server responded with non-JSON content (${contentType})`, 'SERVER_ERROR', `Status: ${response.status}, Content: ${responseText}`, response.status);
+            }
+            // Try to parse as JSON
+            let responseData;
+            try {
+                responseData = await response.json();
+            }
+            catch (error) {
+                // Get response text for better error details
+                let responseText = '';
+                try {
+                    // Need to clone response since we already tried to read it as JSON
+                    responseText = await response.clone().text();
+                    if (responseText.length > 500) {
+                        responseText = responseText.substring(0, 500) + '... [truncated]';
+                    }
+                }
+                catch (textError) {
+                    responseText = 'Could not read response body';
+                }
+                throw new SkytellsError('Invalid JSON response', 'INVALID_JSON', `The server returned invalid JSON. Status: ${response.status}, Content: ${responseText}`, response.status);
+            }
+            // Check if the response indicates an error
+            if (!response.ok || (responseData && responseData.status === false)) {
+                if (responseData && responseData.error) {
+                    // API returned a structured error
+                    throw new SkytellsError(responseData.error.message || responseData.response || 'API error occurred', responseData.error.error_id || 'UNKNOWN_ERROR', responseData.error.details || responseData.response || 'No additional details', responseData.error.http_status || response.status);
+                }
+                else if (responseData && responseData.response) {
+                    // Simple error with just a response message
+                    throw new SkytellsError(responseData.response, 'API_ERROR', responseData.response, response.status);
+                }
+                else {
+                    // Generic HTTP error
+                    throw new SkytellsError(`HTTP error ${response.status}`, 'HTTP_ERROR', `The server returned status code ${response.status}`, response.status);
+                }
+            }
+            return responseData;
+        }
+        catch (error) {
+            // Check if it's an abort error (timeout)
+            if (error && typeof error === 'object' && 'name' in error && error.name === 'AbortError') {
+                throw new SkytellsError(`Request timed out after ${this.timeout}ms`, 'REQUEST_TIMEOUT', `The request took longer than ${this.timeout}ms to complete`, 408 // Request Timeout status code
+                );
+            }
+            // Re-throw original error
+            if (error instanceof SkytellsError) {
+                throw error;
+            }
+            // Network or other errors
+            throw new SkytellsError(error instanceof Error ? error.message : 'Network error occurred', 'NETWORK_ERROR', 'A network error occurred while communicating with the API', 0 // No HTTP status for network errors
+            );
+        }
+        finally {
+            // Clear timeout if it was set
+            if (timeoutId !== null) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+}

package/dist/http.d.ts

@@ -0,0 +1,7 @@
+export declare class HTTP {
+    private apiKey?;
+    private baseUrl;
+    private timeout;
+    constructor(apiKey?: string, baseUrl?: string, timeout?: number);
+    request<T>(method: 'GET' | 'POST' | 'DELETE', path: string, data?: Record<string, unknown>): Promise<T>;
+}

package/dist/http.js

@@ -0,0 +1,118 @@
+import { API_BASE_URL } from './endpoints.js';
+import { SkytellsError } from './types/shared.types.js';
+// Default timeout in milliseconds
+// 60 seconds
+const DEFAULT_TIMEOUT = 60000;
+export class HTTP {
+    constructor(apiKey, baseUrl = API_BASE_URL, timeout = DEFAULT_TIMEOUT) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+        this.timeout = timeout;
+    }
+    async request(method, path, data) {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['x-api-key'] = this.apiKey;
+        }
+        const options = {
+            method,
+            headers,
+        };
+        if (method === 'POST' && data) {
+            options.body = JSON.stringify(data);
+        }
+        // Add AbortController for timeout handling
+        const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+        if (controller) {
+            options.signal = controller.signal;
+        }
+        // Set up timeout if AbortController is available
+        let timeoutId = null;
+        if (controller) {
+            timeoutId = setTimeout(() => {
+                controller.abort();
+            }, this.timeout);
+        }
+        try {
+            // Use native fetch which is available in modern browsers and edge environments
+            const response = await fetch(`${this.baseUrl}${path}`, options);
+            // Get the response content type to check if it's JSON
+            const contentType = response.headers.get('content-type') || '';
+            const isJsonResponse = contentType.includes('application/json');
+            // Handle non-JSON responses properly
+            if (!isJsonResponse) {
+                // If not JSON, get the text for error details
+                let responseText = '';
+                try {
+                    responseText = await response.text();
+                    // Truncate if too long to avoid huge error messages
+                    if (responseText.length > 500) {
+                        responseText = responseText.substring(0, 500) + '... [truncated]';
+                    }
+                }
+                catch (textError) {
+                    responseText = 'Could not read response body';
+                }
+                throw new SkytellsError(`Server responded with non-JSON content (${contentType})`, 'SERVER_ERROR', `Status: ${response.status}, Content: ${responseText}`, response.status);
+            }
+            // Try to parse as JSON
+            let responseData;
+            try {
+                responseData = await response.json();
+            }
+            catch (error) {
+                // Get response text for better error details
+                let responseText = '';
+                try {
+                    // Need to clone response since we already tried to read it as JSON
+                    responseText = await response.clone().text();
+                    if (responseText.length > 500) {
+                        responseText = responseText.substring(0, 500) + '... [truncated]';
+                    }
+                }
+                catch (textError) {
+                    responseText = 'Could not read response body';
+                }
+                throw new SkytellsError('Invalid JSON response', 'INVALID_JSON', `The server returned invalid JSON. Status: ${response.status}, Content: ${responseText}`, response.status);
+            }
+            // Check if the response indicates an error
+            if (!response.ok || (responseData && responseData.status === false)) {
+                if (responseData && responseData.error) {
+                    // API returned a structured error
+                    throw new SkytellsError(responseData.error.message || responseData.response || 'API error occurred', responseData.error.error_id || 'UNKNOWN_ERROR', responseData.error.details || responseData.response || 'No additional details', responseData.error.http_status || response.status);
+                }
+                else if (responseData && responseData.response) {
+                    // Simple error with just a response message
+                    throw new SkytellsError(responseData.response, 'API_ERROR', responseData.response, response.status);
+                }
+                else {
+                    // Generic HTTP error
+                    throw new SkytellsError(`HTTP error ${response.status}`, 'HTTP_ERROR', `The server returned status code ${response.status}`, response.status);
+                }
+            }
+            return responseData;
+        }
+        catch (error) {
+            // Check if it's an abort error (timeout)
+            if (error && typeof error === 'object' && 'name' in error && error.name === 'AbortError') {
+                throw new SkytellsError(`Request timed out after ${this.timeout}ms`, 'REQUEST_TIMEOUT', `The request took longer than ${this.timeout}ms to complete`, 408 // Request Timeout status code
+                );
+            }
+            // Re-throw original error
+            if (error instanceof SkytellsError) {
+                throw error;
+            }
+            // Network or other errors
+            throw new SkytellsError(error instanceof Error ? error.message : 'Network error occurred', 'NETWORK_ERROR', 'A network error occurred while communicating with the API', 0 // No HTTP status for network errors
+            );
+        }
+        finally {
+            // Clear timeout if it was set
+            if (timeoutId !== null) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+}

package/dist/index.cjs

@@ -0,0 +1,14 @@
+const { SkytellsClient } = require("./client.js");
+/**
+ * Create a new Skytells API client
+ * @param apiKey Optional API key for authenticated requests
+ * @param options Optional client configuration
+ * @returns A new Skytells client instance
+ */
+function createClient(apiKey, options = {}) {
+    return new SkytellsClient(apiKey, options);
+}
+export * from './types/index.js';
+module.exports = { SkytellsClient } from './client.js';
+module.exports = { API_BASE_URL } from './endpoints.js';
+module.exports = { SkytellsError } from './types/shared.types.js';

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { SkytellsClient } from './client.js';
+import { ClientOptions } from './types/shared.types.js';
+/**
+ * Create a new Skytells API client
+ * @param apiKey Optional API key for authenticated requests
+ * @param options Optional client configuration
+ * @returns A new Skytells client instance
+ */
+export declare function createClient(apiKey?: string, options?: ClientOptions): SkytellsClient;
+export * from './types/index.js';
+export { SkytellsClient } from './client.js';
+export { API_BASE_URL } from './endpoints.js';
+export { SkytellsError } from './types/shared.types.js';

package/dist/index.js

@@ -0,0 +1,14 @@
+import { SkytellsClient } from './client.js';
+/**
+ * Create a new Skytells API client
+ * @param apiKey Optional API key for authenticated requests
+ * @param options Optional client configuration
+ * @returns A new Skytells client instance
+ */
+export function createClient(apiKey, options = {}) {
+    return new SkytellsClient(apiKey, options);
+}
+export * from './types/index.js';
+export { SkytellsClient } from './client.js';
+export { API_BASE_URL } from './endpoints.js';
+export { SkytellsError } from './types/shared.types.js';

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './predict.types.js';
+export * from './model.types.js';
+export * from './shared.types.js';

package/dist/types/index.js

@@ -0,0 +1,3 @@
+export * from './predict.types.js';
+export * from './model.types.js';
+export * from './shared.types.js';

package/dist/types/model.types.d.ts

@@ -0,0 +1,13 @@
+export interface Model {
+    name: string;
+    description?: string;
+    namespace: string;
+    type: string;
+    billable?: boolean;
+    pricing?: {
+        amount: number;
+        currency: string;
+        unit: string;
+    };
+    status: string;
+}

package/dist/types/model.types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/predict.types.d.ts

@@ -0,0 +1,80 @@
+export interface PredictionRequest {
+    /**
+     * Model to use for the prediction
+     */
+    model: string;
+    /**
+     * Input to the prediction
+     */
+    input: Record<string, any>;
+    /**
+     * Webhook to receive prediction events
+     */
+    webhook?: {
+        url: string;
+        events: string[];
+    };
+    /**
+     * Whether to wait for the prediction to complete
+     * @default false
+     */
+    await?: boolean;
+    /**
+     * Whether to stream the prediction events
+     * @default false
+     */
+    stream?: boolean;
+}
+export declare enum PredictionStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    SUCCEEDED = "succeeded",
+    FAILED = "failed",
+    CANCELLED = "cancelled",
+    STARTING = "starting",
+    STARTED = "started"
+}
+export interface PredictionResponse {
+    status: PredictionStatus;
+    id: string;
+    response: string;
+    stream: boolean;
+    input: Record<string, any>;
+    output?: string[];
+    created_at: string;
+    started_at: string;
+    completed_at: string;
+    updated_at: string;
+    privacy: string;
+    model?: {
+        name: string;
+        type: string;
+    };
+    webhook?: {
+        url: string;
+        events: string[];
+    };
+    metrics?: {
+        image_count: number;
+        predict_time: number;
+    };
+    metadata?: {
+        billing?: {
+            credits_used: number;
+        };
+        storage?: {
+            files: {
+                name: string;
+                type: string;
+                size: number;
+                url: string;
+            }[];
+        };
+    };
+    urls?: {
+        get?: string;
+        cancel?: string;
+        stream?: string;
+        delete?: string;
+    };
+}

package/dist/types/predict.types.js

@@ -0,0 +1,10 @@
+export var PredictionStatus;
+(function (PredictionStatus) {
+    PredictionStatus["PENDING"] = "pending";
+    PredictionStatus["PROCESSING"] = "processing";
+    PredictionStatus["SUCCEEDED"] = "succeeded";
+    PredictionStatus["FAILED"] = "failed";
+    PredictionStatus["CANCELLED"] = "cancelled";
+    PredictionStatus["STARTING"] = "starting";
+    PredictionStatus["STARTED"] = "started";
+})(PredictionStatus || (PredictionStatus = {}));

package/dist/types/shared.types.d.ts

@@ -0,0 +1,20 @@
+export interface ApiError {
+    status: boolean;
+    response: string;
+    error: {
+        http_status: number;
+        message: string;
+        details: string;
+        error_id: string;
+    };
+}
+export interface ClientOptions {
+    baseUrl?: string;
+    timeout?: number;
+}
+export declare class SkytellsError extends Error {
+    errorId: string;
+    details: string;
+    httpStatus: number;
+    constructor(message: string, errorId: string, details: string, httpStatus?: number);
+}

package/dist/types/shared.types.js

@@ -0,0 +1,11 @@
+export class SkytellsError extends Error {
+    constructor(message, errorId, details, httpStatus) {
+        super(message);
+        this.name = 'SkytellsError';
+        this.errorId = errorId;
+        this.details = details;
+        this.httpStatus = httpStatus || 0;
+        // This is needed for proper instanceof checks in some environments
+        Object.setPrototypeOf(this, SkytellsError.prototype);
+    }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "skytells",
+  "version": "1.0.0",
+  "description": "Official Skytells JavaScript/TypeScript SDK - Edge compatible",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "node build.js",
+    "build:types": "tsc --emitDeclarationOnly",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/skytells/ts-sdk.git"
+  },
+  "keywords": [
+    "ai",
+    "skytells",
+    "skytells-ai",
+    "skytells-sdk",
+    "edge",
+    "cloudflare",
+    "vercel-edge",
+    "netlify-edge"
+  ],
+  "author": "Skytells, Inc.",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/skytells/ts-sdk/issues"
+  },
+  "homepage": "https://github.com/skytells/ts-sdk#readme",
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.40.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.8.2"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  }
+}