flowscale 1.1.0 → 1.3.0

package/dist/types.d.ts

@@ -38,12 +38,21 @@ export interface ExecuteWorkflowResponse {
         run_id: string;
     };
 }
+export interface RunProgress {
+    percentage?: number;
+    current_node?: string;
+}
 export interface GetOutputResponse {
     status: string;
     data: {
-        download_url: string;
-        generation_status: string;
+        run_id?: string;
+        download_url?: string;
+        file_content?: any;
+        generation_status?: string;
+        progress?: RunProgress;
+        errors?: string;
     };
+    errors?: string;
 }
 export interface GetAllOutputsResponse {
     status: string;
@@ -53,6 +62,48 @@ export interface GetAllOutputsResponse {
         generation_status: string;
     }>;
 }
+export type ExecuteWorkflowAsyncIntermediateType = 'workflow_submitted' | 'run_status' | 'output_status' | 'poll_retry' | 'completed';
+export interface ExecuteWorkflowAsyncIntermediateResponse {
+    type: ExecuteWorkflowAsyncIntermediateType;
+    timestamp: string;
+    run_id?: string;
+    workflow_id?: string;
+    attempt?: number;
+    run_status?: string;
+    output_name?: string;
+    output_status?: string;
+    output_names?: string[];
+    pending_outputs?: string[];
+    completed_outputs?: string[];
+    progress?: RunProgress;
+    response?: ExecuteWorkflowResponse | RunDetailResponse | GetOutputResponse | GetAllOutputsResponse | LegacyGetOutputResponse | null;
+    error?: string;
+}
+export interface ExecuteWorkflowAsyncOptions {
+    returnAllOutputs?: boolean;
+    onIntermediateResponse?: (update: ExecuteWorkflowAsyncIntermediateResponse) => void | Promise<void>;
+}
+export interface RunEventsSSEEvent {
+    id?: number | string;
+    event?: string;
+    data: any;
+    raw: string;
+}
+export interface RunEventsSSEOptions {
+    fromSeq?: number;
+    signal?: AbortSignal;
+    onOpen?: (meta: {
+        status: number;
+        contentType: string | null;
+    }) => void | Promise<void>;
+    onEvent?: (event: RunEventsSSEEvent) => void | Promise<void>;
+    onError?: (error: Error) => void | Promise<void>;
+    onClose?: () => void | Promise<void>;
+}
+export interface RunEventsSSEConnection {
+    close: () => void;
+    done: Promise<void>;
+}
 export interface DeprecationWarning {
     message: string;
     migration_guide: string;
@@ -79,6 +130,7 @@ export interface RunDetail {
         url?: string;
     }>;
     output_names?: string[];
+    progress?: RunProgress | null;
     created_at: string;
     started_at?: string;
     completed_at?: string;
@@ -110,26 +162,9 @@ export interface FlowscaleConfig {
     timeout?: number;
     maxRetries?: number;
     retryDelay?: number;
-    WebSocketImpl?: any;
+    fetchImpl?: any;
     proxyMode?: boolean;
     customHeaders?: {
         [key: string]: string;
     };
 }
-export type WebSocketEventCallback = (data: any) => void;
-export interface WebSocketMessage {
-    type: string;
-    data: any;
-}
-export interface WebSocketOptions {
-    onOpen?: () => void;
-    onClose?: (event: CloseEvent | {
-        code: number;
-        reason: string;
-    }) => void;
-    onError?: (error: Event | Error) => void;
-    onMessage?: WebSocketEventCallback;
-    reconnect?: boolean;
-    reconnectInterval?: number;
-    maxReconnectAttempts?: number;
-}

package/examples/backend-proxy-example.js

@@ -166,17 +166,6 @@ app.post('/api/v1/runs/:runId/cancel', authenticateToken, async (req, res) => {
   }
 });
 
-// WebSocket proxy endpoint
-app.get('/api/v1/ws/subscribe', authenticateToken, (req, res) => {
-  // For WebSocket proxying, you'd typically use a WebSocket proxy
-  // This is a simplified example - in production, you'd want to use
-  // a proper WebSocket proxy like http-proxy-middleware
-  res.status(501).json({ 
-    error: 'WebSocket proxying requires additional setup',
-    message: 'Implement WebSocket proxy using http-proxy-middleware or similar'
-  });
-});
-
 // Error handling middleware
 app.use((error, req, res, next) => {
   console.error('Server error:', error);
@@ -191,4 +180,4 @@ app.listen(PORT, () => {
   console.log('- JWT_SECRET: Secret for signing JWT tokens');
 });
 
-module.exports = app;
+module.exports = app;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowscale",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "An NPM library for communicating with the Flowscale APIs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,7 +17,18 @@
     "publish:latest": "npm publish"
   },
   "author": "flowscale",
-  "license": "MIT",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FlowScale-AI/flowscale-js-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/FlowScale-AI/flowscale-js-sdk/issues"
+  },
+  "homepage": "https://github.com/FlowScale-AI/flowscale-js-sdk#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "dependencies": {
     "axios": "^1.7.7",
     "form-data": "^4.0.1"

package/examples/node-websocket-example.js

@@ -1,173 +0,0 @@
-// Node.js WebSocket Example - Using the SDK's built-in WebSocket functionality
-const { FlowscaleAPI } = require('../dist');
-const WebSocket = require('ws');
-
-// Load environment variables
-// In a real application, you should use dotenv or similar
-const apiKey = 'YOUR_API_KEY';
-const baseUrl = 'YOUR_BASE_URL'; // e.g., https://your-url.pod.flowscale.ai
-
-// Initialize the Flowscale API client with WebSocket support
-const flowscale = new FlowscaleAPI({
-  apiKey: apiKey,
-  baseUrl: baseUrl,
-  WebSocketImpl: WebSocket // Pass the 'ws' WebSocket implementation for Node.js
-});
-
-// Now you can use the SDK's WebSocket methods directly!
-const disconnect = flowscale.connectWebSocket({
-  onOpen: () => {
-    console.log('WebSocket connected via SDK!');
-    
-    // Example: Send a message
-    const success = flowscale.sendWebSocketMessage({
-      type: 'subscribe',
-      data: {
-        run_id: 'YOUR_RUN_ID' // Replace with actual run ID
-      }
-    });
-    
-    if (success) {
-      console.log('Message sent successfully');
-    }
-  },
-  onMessage: (message) => {
-    console.log('Received message:', message);
-    
-    // Handle different message types
-    if (message.type === 'run_status_update') {
-      console.log('Run status updated:', message.data);
-    }
-  },
-  onClose: (event) => {
-    console.log('WebSocket connection closed:', event.code, event.reason);
-  },
-  onError: (error) => {
-    console.error('WebSocket error:', error);
-  },
-  reconnect: true,
-  reconnectInterval: 5000,
-  maxReconnectAttempts: 5
-});
-
-// Check connection status
-console.log('Is connected:', flowscale.isWebSocketConnected());
-
-// Keep the process running
-process.on('SIGINT', () => {
-  console.log('Closing WebSocket connection');
-  disconnect(); // Use the disconnect function returned by connectWebSocket
-  process.exit(0);
-});
-
-console.log('WebSocket client running via SDK. Press Ctrl+C to exit.');
-
-// ========================
-// Legacy Example (for reference)
-// ========================
-// If you prefer to implement WebSocket manually, here's the old approach:
-
-/*
-// Create a custom WebSocket implementation for Node.js
-class NodeWebSocketClient {
-  constructor(url) {
-    console.log('Creating WebSocket connection to:', url);
-    
-    this.ws = new WebSocket(url);
-    this.connected = false;
-    
-    this.ws.on('open', () => {
-      console.log('WebSocket connection established');
-      this.connected = true;
-      if (this.onopen) this.onopen();
-    });
-    
-    this.ws.on('message', (data) => {
-      if (this.onmessage) {
-        const event = { data };
-        this.onmessage(event);
-      }
-    });
-    
-    this.ws.on('close', (code, reason) => {
-      console.log(`WebSocket connection closed: ${code} ${reason}`);
-      this.connected = false;
-      if (this.onclose) {
-        const event = { code, reason };
-        this.onclose(event);
-      }
-    });
-    
-    this.ws.on('error', (error) => {
-      console.error('WebSocket error:', error);
-      if (this.onerror) this.onerror(error);
-    });
-  }
-  
-  send(data) {
-    if (this.connected) {
-      this.ws.send(data);
-      return true;
-    }
-    return false;
-  }
-  
-  close() {
-    this.ws.close();
-  }
-}
-
-// Create a WebSocket URL with API key
-const wsUrl = new URL('/api/v1/ws', baseUrl);
-wsUrl.protocol = wsUrl.protocol.replace('http', 'ws');
-wsUrl.searchParams.append('api_key', apiKey);
-
-// Create a WebSocket connection
-const socket = new NodeWebSocketClient(wsUrl.toString());
-
-// Set up event handlers
-socket.onopen = () => {
-  console.log('Connected to Flowscale WebSocket');
-  
-  // Example: Subscribe to a specific run
-  const subscribeMessage = {
-    type: 'subscribe',
-    data: {
-      run_id: 'YOUR_RUN_ID' // Replace with actual run ID
-    }
-  };
-  
-  socket.send(JSON.stringify(subscribeMessage));
-};
-
-socket.onmessage = (event) => {
-  try {
-    const message = JSON.parse(event.data);
-    console.log('Received message:', message);
-    
-    // Handle different message types
-    if (message.type === 'run_status_update') {
-      console.log('Run status updated:', message.data);
-    }
-  } catch (error) {
-    console.error('Failed to parse WebSocket message:', error);
-  }
-};
-
-socket.onclose = (event) => {
-  console.log('WebSocket connection closed:', event.code, event.reason);
-};
-
-socket.onerror = (error) => {
-  console.error('WebSocket error:', error);
-};
-
-// Keep the process running
-process.on('SIGINT', () => {
-  console.log('Closing WebSocket connection');
-  socket.close();
-  process.exit(0);
-});
-
-console.log('WebSocket client running. Press Ctrl+C to exit.');
-*/

package/examples/websocket-example.html

@@ -1,157 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Flowscale WebSocket Example</title>
-    <script src="../dist/index.js"></script>
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            margin: 0;
-            padding: 20px;
-            line-height: 1.6;
-        }
-        #messageContainer {
-            height: 300px;
-            overflow-y: auto;
-            border: 1px solid #ccc;
-            padding: 10px;
-            margin: 10px 0;
-        }
-        .message {
-            padding: 5px;
-            margin-bottom: 5px;
-            border-radius: 4px;
-        }
-        .message-info {
-            background-color: #e0f7fa;
-        }
-        .message-error {
-            background-color: #ffebee;
-        }
-        .message-success {
-            background-color: #e8f5e9;
-        }
-    </style>
-</head>
-<body>
-    <h1>Flowscale WebSocket Example</h1>
-    
-    <div>
-        <label for="apiKey">API Key:</label>
-        <input type="text" id="apiKey" placeholder="Enter your API key">
-    </div>
-    <div>
-        <label for="baseUrl">Base URL:</label>
-        <input type="text" id="baseUrl" placeholder="Enter your base URL (e.g., https://your-url.pod.flowscale.ai)">
-    </div>
-    <div>
-        <button id="connectBtn">Connect WebSocket</button>
-        <button id="disconnectBtn" disabled>Disconnect WebSocket</button>
-    </div>
-    
-    <h3>WebSocket Messages:</h3>
-    <div id="messageContainer"></div>
-    
-    <div>
-        <h3>Send a Message:</h3>
-        <textarea id="messageToSend" placeholder="Enter a JSON message to send" rows="5" cols="50"></textarea>
-        <button id="sendMessageBtn" disabled>Send Message</button>
-    </div>
-    
-    <script>
-        document.addEventListener('DOMContentLoaded', function() {
-            let flowscale;
-            let disconnectWs;
-            
-            function addMessageToContainer(message, type = 'info') {
-                const messageContainer = document.getElementById('messageContainer');
-                const messageElement = document.createElement('div');
-                messageElement.className = `message message-${type}`;
-                messageElement.textContent = typeof message === 'object' ? 
-                    JSON.stringify(message, null, 2) : message;
-                messageContainer.appendChild(messageElement);
-                messageContainer.scrollTop = messageContainer.scrollHeight;
-            }
-            
-            document.getElementById('connectBtn').addEventListener('click', function() {
-                const apiKey = document.getElementById('apiKey').value;
-                const baseUrl = document.getElementById('baseUrl').value;
-                
-                if (!apiKey || !baseUrl) {
-                    addMessageToContainer('Please enter both API Key and Base URL', 'error');
-                    return;
-                }
-                
-                try {
-                    // Initialize the Flowscale API
-                    flowscale = new window.FlowscaleAPI({
-                        apiKey,
-                        baseUrl,
-                        allowDangerouslyExposeApiKey: true // Required for browser environment
-                    });
-                    
-                    addMessageToContainer('Initializing WebSocket connection...', 'info');
-                    
-                    // Connect to WebSocket
-                    disconnectWs = flowscale.connectWebSocket({
-                        onOpen: () => {
-                            addMessageToContainer('WebSocket connection opened', 'success');
-                            document.getElementById('connectBtn').disabled = true;
-                            document.getElementById('disconnectBtn').disabled = false;
-                            document.getElementById('sendMessageBtn').disabled = false;
-                        },
-                        onMessage: (message) => {
-                            addMessageToContainer(message, 'info');
-                        },
-                        onClose: (event) => {
-                            addMessageToContainer(`WebSocket connection closed: ${event.code} ${event.reason}`, 'error');
-                            document.getElementById('connectBtn').disabled = false;
-                            document.getElementById('disconnectBtn').disabled = true;
-                            document.getElementById('sendMessageBtn').disabled = true;
-                        },
-                        onError: (error) => {
-                            addMessageToContainer(`WebSocket error: ${error}`, 'error');
-                        }
-                    });
-                } catch (error) {
-                    addMessageToContainer(`Error: ${error.message}`, 'error');
-                }
-            });
-            
-            document.getElementById('disconnectBtn').addEventListener('click', function() {
-                if (disconnectWs) {
-                    disconnectWs();
-                    disconnectWs = null;
-                    document.getElementById('connectBtn').disabled = false;
-                    document.getElementById('disconnectBtn').disabled = true;
-                    document.getElementById('sendMessageBtn').disabled = true;
-                    addMessageToContainer('WebSocket disconnected', 'info');
-                }
-            });
-            
-            document.getElementById('sendMessageBtn').addEventListener('click', function() {
-                const messageText = document.getElementById('messageToSend').value;
-                if (!messageText) {
-                    addMessageToContainer('Please enter a message to send', 'error');
-                    return;
-                }
-                
-                try {
-                    const message = JSON.parse(messageText);
-                    const success = flowscale.sendWebSocketMessage(message);
-                    
-                    if (success) {
-                        addMessageToContainer(`Message sent: ${messageText}`, 'success');
-                    } else {
-                        addMessageToContainer(`Failed to send message: ${messageText}`, 'error');
-                    }
-                } catch (error) {
-                    addMessageToContainer(`Error sending message: ${error.message}`, 'error');
-                }
-            });
-        });
-    </script>
-</body>
-</html>