@vertesia/client 0.79.0 → 0.80.0-dev-20251118

package/src/store/FilesApi.ts

@@ -59,12 +59,14 @@ export class FilesApi extends ApiTopic {
         });
     }
 
-    getDownloadUrl(file: string): Promise<GetFileUrlResponse> {
-        return this.post("/download-url", {
-            payload: {
-                file,
-            } satisfies GetFileUrlPayload,
-        });
+    // Strictly typed: provide either simple args or a full payload via a separate method
+    getDownloadUrl(file: string, name?: string, disposition?: "inline" | "attachment"): Promise<GetFileUrlResponse> {
+        const payload: GetFileUrlPayload = { file, name, disposition };
+        return this.post("/download-url", { payload });
+    }
+
+    getDownloadUrlWithOptions(payload: GetFileUrlPayload): Promise<GetFileUrlResponse> {
+        return this.post("/download-url", { payload });
     }
 
     /**
@@ -120,9 +122,9 @@ export class FilesApi extends ApiTopic {
                 if (res.ok) {
                     return res;
                 } else if (res.status === 404) {
-                    throw new Error(`File ${location} not found`); //TODO: type fetch error better with a fetch error class
+                    throw new Error(`File at ${url} not found`); //TODO: type fetch error better with a fetch error class
                 } else if (res.status === 403) {
-                    throw new Error(`File ${location} is forbidden`);
+                    throw new Error(`File at ${url} is forbidden`);
                 } else {
                     console.log(res);
                     throw new Error(

package/src/store/ObjectsApi.ts

@@ -27,24 +27,6 @@ import { StreamSource } from "../StreamSource.js";
 import { AnalyzeDocApi } from "./AnalyzeDocApi.js";
 import { ZenoClient } from "./client.js";
 
-export interface UploadContentObjectPayload
-    extends Omit<CreateContentObjectPayload, "content"> {
-    content?:
-        | StreamSource
-        | File
-        | {
-              // the source URI
-              source: string;
-              // the original name of the input file if any
-              name?: string;
-              // the mime type of the content source.
-              type?: string;
-
-              // the target id in the content store
-              id?: string;
-          };
-}
-
 export interface ComputeFacetsResponse {
     type?: { _id: string; count: number }[];
     location?: { _id: string; count: number }[];
@@ -72,14 +54,16 @@ export class ObjectsApi extends ApiTopic {
         });
     }
 
-    getDownloadUrl(fileUri: string): Promise<{ url: string }> {
+    getDownloadUrl(fileUri: string, name?: string, disposition?: "inline" | "attachment"): Promise<{ url: string }> {
         return this.post("/download-url", {
-            payload: {
-                file: fileUri,
-            } satisfies GetFileUrlPayload,
+            payload: { file: fileUri, name, disposition } satisfies GetFileUrlPayload,
         });
     }
 
+    getDownloadUrlWithOptions(payload: GetFileUrlPayload): Promise<{ url: string }> {
+        return this.post("/download-url", { payload });
+    }
+
     getContentSource(objectId: string): Promise<ContentSource> {
         return this.get(`/${objectId}/content-source`);
     }
@@ -217,7 +201,7 @@ export class ObjectsApi extends ApiTopic {
     }
 
     async create(
-        payload: UploadContentObjectPayload,
+        payload: CreateContentObjectPayload,
         options?: {
             collection_id?: string;
             processing_priority?: ContentObjectProcessingPriority;

package/src/store/TypesApi.ts

@@ -17,7 +17,7 @@ export class TypesApi extends ApiTopic {
      * @returns
      */
     list(payload: ObjectTypeSearchPayload = {}, options?: { layout?: boolean, schema?: boolean }): Promise<ContentObjectTypeItem[]> {
-        const limit = payload.limit || 100;
+        const limit = payload.limit || 2000;
         const offset = payload.offset || 0;
         const query = payload.query || {} as ObjectTypeSearchQuery;
 

package/src/store/WorkflowsApi.ts

@@ -10,6 +10,9 @@ import {
     ListWorkflowInteractionsResponse,
     ListWorkflowRunsPayload,
     ListWorkflowRunsResponse,
+    WebSocketClientMessage,
+    WebSocketServerMessage,
+    WorkflowActionPayload,
     WorkflowDefinitionRef,
     WorkflowRule,
     WorkflowRuleItem,
@@ -56,11 +59,13 @@ export class WorkflowsApi extends ApiTopic {
     }
 
     terminate(workflowId: string, runId: string, reason?: string): Promise<{ message: string }> {
-        return this.post(`/runs/${workflowId}/${runId}/actions/terminate`, { payload: { reason } });
+        const payload: WorkflowActionPayload = { reason };
+        return this.post(`/runs/${workflowId}/${runId}/actions/terminate`, { payload });
     }
 
     cancel(workflowId: string, runId: string, reason?: string): Promise<{ message: string }> {
-        return this.post(`/runs/${workflowId}/${runId}/actions/cancel`, { payload: { reason } });
+        const payload: WorkflowActionPayload = { reason };
+        return this.post(`/runs/${workflowId}/${runId}/actions/cancel`, { payload });
     }
 
     execute(
@@ -248,6 +253,170 @@ export class WorkflowsApi extends ApiTopic {
         });
     }
 
+    /**
+     * Stream workflow messages via WebSocket (for mobile/React Native clients)
+     * @param workflowId The workflow ID
+     * @param runId The run ID
+     * @param onMessage Callback for incoming messages
+     * @param since Optional timestamp to resume from
+     * @returns Promise that resolves with cleanup function and sendSignal helper
+     */
+    async streamMessagesWS(
+        workflowId: string,
+        runId: string,
+        onMessage?: (message: AgentMessage) => void,
+        since?: number
+    ): Promise<{ cleanup: () => void; sendSignal: (signalName: string, data: any) => void }> {
+        return new Promise((resolve, reject) => {
+            let reconnectAttempts = 0;
+            const maxReconnectAttempts = 10;
+            const baseDelay = 1000;
+            const maxDelay = 30000;
+            let ws: WebSocket | null = null;
+            let lastMessageTimestamp = since || 0;
+            let isClosed = false;
+
+            const calculateBackoffDelay = (attempts: number): number => {
+                const exponentialDelay = Math.min(baseDelay * Math.pow(2, attempts), maxDelay);
+                const jitter = Math.random() * 0.1 * exponentialDelay;
+                return exponentialDelay + jitter;
+            };
+
+            const connect = async () => {
+                if (isClosed) return;
+
+                try {
+                    const client = this.client as VertesiaClient;
+                    const wsUrl = new URL(client.workflows.baseUrl + `/runs/${workflowId}/${runId}/ws`);
+
+                    // Replace http/https with ws/wss
+                    wsUrl.protocol = wsUrl.protocol.replace('http', 'ws');
+
+                    // Add query parameters
+                    if (lastMessageTimestamp > 0) {
+                        wsUrl.searchParams.set('since', lastMessageTimestamp.toString());
+                    }
+
+                    const bearerToken = client._auth ? await client._auth() : undefined;
+                    if (!bearerToken) {
+                        reject(new Error('No auth token available'));
+                        return;
+                    }
+
+                    const token = bearerToken.split(' ')[1];
+                    wsUrl.searchParams.set('access_token', token);
+
+                    if (reconnectAttempts > 0) {
+                        console.log(`Reconnecting to WebSocket for run ${runId} (attempt ${reconnectAttempts + 1}/${maxReconnectAttempts})`);
+                    }
+
+                    ws = new WebSocket(wsUrl.href);
+
+                    ws.onopen = () => {
+                        if (reconnectAttempts > 0) {
+                            console.log(`Successfully reconnected to WebSocket for run ${runId}`);
+                        }
+                        reconnectAttempts = 0;
+
+                        // Resolve with helpers on first successful connection
+                        if (!isClosed) {
+                            resolve({
+                                cleanup: () => {
+                                    isClosed = true;
+                                    if (ws) {
+                                        ws.close();
+                                        ws = null;
+                                    }
+                                },
+                                sendSignal: (signalName: string, data: any) => {
+                                    if (ws?.readyState === WebSocket.OPEN) {
+                                        const message: WebSocketClientMessage = {
+                                            type: 'signal',
+                                            signalName,
+                                            data,
+                                            requestId: Date.now()
+                                        };
+                                        ws.send(JSON.stringify(message));
+                                    } else {
+                                        console.warn('WebSocket not open, cannot send signal');
+                                    }
+                                }
+                            });
+                        }
+                    };
+
+                    ws.onmessage = (event: MessageEvent) => {
+                        try {
+                            const message = JSON.parse(event.data) as WebSocketServerMessage;
+
+                            // Handle different message types
+                            if ('workflow_run_id' in message) {
+                                // This is an AgentMessage
+                                const agentMessage = message as AgentMessage;
+
+                                if (agentMessage.timestamp) {
+                                    lastMessageTimestamp = Math.max(lastMessageTimestamp, agentMessage.timestamp);
+                                }
+
+                                if (onMessage) onMessage(agentMessage);
+
+                                // Check for stream completion
+                                const streamIsOver =
+                                    agentMessage.type === AgentMessageType.TERMINATED ||
+                                    (agentMessage.type === AgentMessageType.COMPLETE &&
+                                        (!agentMessage.workstream_id || agentMessage.workstream_id === 'main'));
+
+                                if (streamIsOver) {
+                                    console.log('Closing WebSocket due to workflow completion');
+                                    isClosed = true;
+                                    if (ws) {
+                                        ws.close();
+                                        ws = null;
+                                    }
+                                }
+                            } else if (message.type === 'pong') {
+                                // Heartbeat response
+                                console.debug('Received pong');
+                            } else if (message.type === 'ack') {
+                                console.debug('Signal acknowledged', message);
+                            } else if (message.type === 'error') {
+                                console.error('WebSocket error message', message);
+                            }
+                        } catch (err) {
+                            console.error('Failed to parse WebSocket message', err);
+                        }
+                    };
+
+                    ws.onerror = (err) => {
+                        console.error('WebSocket error', err);
+                    };
+
+                    ws.onclose = () => {
+                        if (!isClosed && reconnectAttempts < maxReconnectAttempts) {
+                            const delay = calculateBackoffDelay(reconnectAttempts);
+                            console.log(`WebSocket closed, reconnecting in ${delay}ms (attempt ${reconnectAttempts + 1}/${maxReconnectAttempts})`);
+                            reconnectAttempts++;
+                            setTimeout(connect, delay);
+                        } else if (reconnectAttempts >= maxReconnectAttempts) {
+                            reject(new Error(`WebSocket connection failed after ${maxReconnectAttempts} attempts`));
+                        }
+                    };
+                } catch (err) {
+                    console.error('Error setting up WebSocket', err);
+                    if (reconnectAttempts < maxReconnectAttempts) {
+                        const delay = calculateBackoffDelay(reconnectAttempts);
+                        reconnectAttempts++;
+                        setTimeout(connect, delay);
+                    } else {
+                        reject(err);
+                    }
+                }
+            };
+
+            connect();
+        });
+    }
+
     rules = new WorkflowsRulesApi(this);
     definitions = new WorkflowsDefinitionApi(this);
 }

package/src/store/client.ts

@@ -13,6 +13,7 @@ import { WorkflowsApi } from "./WorkflowsApi.js";
 
 export interface ZenoClientProps {
     serverUrl?: string;
+    tokenServerUrl?: string;
     apikey?: string;
     onRequest?: (request: Request) => void;
     onResponse?: (response: Response) => void;