@vertesia/client 0.78.0-dev-28b447d → 0.79.0

package/src/client.ts

@@ -16,6 +16,8 @@ import { RunsApi } from "./RunsApi.js";
 import { ZenoClient } from "./store/client.js";
 import TrainingApi from "./TrainingApi.js";
 import UsersApi from "./UsersApi.js";
+import { VERSION, VERSION_HEADER } from "./store/version.js";
+
 
 /**
  * 1 min threshold constant in ms
@@ -35,21 +37,18 @@ export type VertesiaClientProps = {
      * @default api.vertesia.io
      * @since 0.52.0
      */
-    site?:
-        | "api.vertesia.io"
-        | "api-preview.vertesia.io"
-        | "api-staging.vertesia.io";
+    site?: 'api.vertesia.io' | 'api-preview.vertesia.io' | 'api-staging.vertesia.io';
     serverUrl?: string;
     storeUrl?: string;
-    tokenServerUrl?: string;
     apikey?: string;
     projectId?: string;
     sessionTags?: string | string[];
     onRequest?: (request: Request) => void;
     onResponse?: (response: Response) => void;
-};
+}
 
 export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
+
     /**
      * The JWT token linked to the API KEY (sk or pk)
      */
@@ -65,15 +64,11 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
      */
     sessionTags?: string | string[];
 
-    /**
-     * tokenServerUrl
-     */
-    tokenServerUrl: string;
 
     /**
-     * Create a client from the given token.
+     * Create a client from the given token. 
      * If you already have the decoded token you can pass it as the second argument to avoid decodinf it again.
-     *
+     * 
      * @param token the raw JWT token
      * @param payload the decoded JWT token as an AuthTokenPayload - optional
      */
@@ -81,21 +76,21 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         if (!payload) {
             payload = decodeJWT(token);
         }
-
-        const endpoints = decodeEndpoints(payload.endpoints);
+        const endpoints = decodeEndpoints(payload!.endpoints);
         return await new VertesiaClient({
             serverUrl: endpoints.studio,
-            storeUrl: endpoints.store,
-            tokenServerUrl: payload.iss,
+            storeUrl: endpoints.store
         }).withApiKey(token);
     }
 
-    static decodeEndpoints() {}
+    static decodeEndpoints() {
+
+    }
 
     constructor(
         opts: VertesiaClientProps = {
-            site: "api.vertesia.io",
-        },
+            site: 'api.vertesia.io',
+        }
     ) {
         let studioServerUrl: string;
         let zenoServerUrl: string;
@@ -105,9 +100,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         } else if (opts.site) {
             studioServerUrl = `https://${opts.site}`;
         } else {
-            throw new Error(
-                "Parameter 'site' or 'serverUrl' is required for VertesiaClient",
-            );
+            throw new Error("Parameter 'site' or 'serverUrl' is required for VertesiaClient");
         }
 
         if (opts.storeUrl) {
@@ -115,72 +108,39 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         } else if (opts.site) {
             zenoServerUrl = `https://${opts.site}`;
         } else {
-            throw new Error(
-                "Parameter 'site' or 'storeUrl' is required for VertesiaClient",
-            );
+            throw new Error("Parameter 'site' or 'storeUrl' is required for VertesiaClient");
         }
 
         super(studioServerUrl);
 
-        if (opts.tokenServerUrl) {
-            this.tokenServerUrl = opts.tokenServerUrl;
-        } else if (opts.site) {
-            this.tokenServerUrl = `https://${opts.site.replace(/^api/, "sts")}`;
-        } else if (opts.serverUrl || opts.storeUrl) {
-            // Determine STS URL based on environment in serverUrl or storeUrl
-            const urlToCheck = opts.serverUrl || opts.storeUrl || "";
-            try {
-                const url = new URL(urlToCheck);
-                // Check for environment patterns
-                if (url.hostname.includes("-production.")) {
-                    // zeno-server-production.api.vertesia.io -> sts.vertesia.io
-                    this.tokenServerUrl = "https://sts.vertesia.io";
-                } else if (url.hostname.includes("-preview.")) {
-                    // zeno-server-preview.api.vertesia.io -> sts-preview.vertesia.io
-                    this.tokenServerUrl = "https://sts-preview.vertesia.io";
-                } else if (url.hostname === "api.vertesia.io") {
-                    // api.vertesia.io -> sts.vertesia.io
-                    this.tokenServerUrl = "https://sts.vertesia.io";
-                } else if (url.hostname === "api-preview.vertesia.io") {
-                    // api-preview.vertesia.io -> sts-preview.vertesia.io
-                    this.tokenServerUrl = "https://sts-preview.vertesia.io";
-                } else if (url.hostname === "api-staging.vertesia.io") {
-                    // api-staging.vertesia.io -> sts-staging.vertesia.io
-                    this.tokenServerUrl = "https://sts-staging.vertesia.io";
-                } else if (url.hostname.startsWith("api")) {
-                    // Generic api.* pattern replacement
-                    url.hostname = url.hostname.replace(/^api/, "sts");
-                    this.tokenServerUrl = url.toString();
-                } else {
-                    // Default to staging for everything else
-                    this.tokenServerUrl = "https://sts-staging.vertesia.io";
-                }
-            } catch (e) {
-                // Default to staging if URL parsing fails
-                this.tokenServerUrl = "https://sts-staging.vertesia.io";
-            }
-        } else {
-            // Default to staging if no URL provided
-            this.tokenServerUrl = "https://sts-staging.vertesia.io";
-        }
-
         this.store = new ZenoClient({
             serverUrl: zenoServerUrl,
-            tokenServerUrl: this.tokenServerUrl,
             apikey: opts.apikey,
             onRequest: opts.onRequest,
-            onResponse: opts.onResponse,
+            onResponse: opts.onResponse
         });
 
         if (opts.apikey) {
             this.withApiKey(opts.apikey);
         }
-
+        //TODO: this is no more used, remove in next major version
+        if (opts.projectId) {
+            this.headers["x-project-id"] = opts.projectId;
+        }
         this.onRequest = opts.onRequest;
         this.onResponse = opts.onResponse;
         this.sessionTags = opts.sessionTags;
     }
 
+    withApiVersion(version: string | number | null) {
+        if (!version) {
+            delete this.headers[VERSION_HEADER];
+        } else {
+            this.headers[VERSION_HEADER] = String(version);
+        }
+        return this;
+    }
+
     /**
      * Overwrite to keep store and composable clients synchronized on the auth callback
      * @param authCb
@@ -193,28 +153,25 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
 
     async withApiKey(apiKey: string | null) {
         return this.withAuthCallback(
-            apiKey
-                ? async () => {
-                      if (!isApiKey(apiKey)) {
-                          return `Bearer ${apiKey}`;
-                      }
-
-                      if (isTokenExpired(this._jwt)) {
-                          const jwt = await this.getAuthToken(apiKey);
-                          this._jwt = jwt.token;
-                      }
-                      return `Bearer ${this._jwt}`;
-                  }
-                : undefined,
+            apiKey ? async () => {
+                if (!isApiKey(apiKey)) {
+                    return `Bearer ${apiKey}`
+                }
+
+                if (isTokenExpired(this._jwt)) {
+                    const jwt = await this.getAuthToken(apiKey);
+                    this._jwt = jwt.token;
+                }
+                return `Bearer ${this._jwt}`
+            } : undefined
         );
     }
 
     async getRawJWT() {
         if (!this._jwt && this._auth) {
             const auth = await this._auth();
-            if (!this._jwt) {
-                // the _jwt may be set by the auth callback
-                this._jwt = auth.trim().split(" ")[1]; // remove Bearer prefix
+            if (!this._jwt) { // the _jwt may be set by the auth callback
+                this._jwt = auth.trim().split(' ')[1]; // remove Bearer prefix
             }
         }
         return this._jwt || null;
@@ -264,35 +221,27 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         return this.store.baseUrl;
     }
 
+
     /**
      *
-     * Generate a token for use with other Vertesia's services
+     * Generate a token for use with other Composable's services
      *
+     * @param accountId: selected account to generate the token for
      * @returns AuthTokenResponse
      */
-    async getAuthToken(token?: string): Promise<AuthTokenResponse> {
-        return fetch(`${this.tokenServerUrl}/token/issue`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-        })
-            .then((response) => response.json())
-            .then((data) => data as AuthTokenResponse)
-            .catch((error) => {
-                console.error(
-                    `Error fetching token from ${this.tokenServerUrl}:`,
-                    { error },
-                );
-                throw error;
-            });
+    async getAuthToken(token?: string, accountId?: string): Promise<AuthTokenResponse> {
+        const query = {
+            accountId,
+            token
+        };
+
+        return this.get('/auth/token', { query: query, headers: { "authorization": undefined } as any });
     }
 
     get initialHeaders() {
         return {
             ...super.initialHeaders,
-            'X-Api-Version': '20250925' // YYYYMMDD, client versioning for API endpoints. Increment manually for breaking changes
+            [VERSION_HEADER]: VERSION
         }
     }
 
@@ -314,7 +263,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
 }
 
 function isApiKey(apiKey: string) {
-    return apiKey.startsWith("pk-") || apiKey.startsWith("sk-");
+    return (apiKey.startsWith('pk-') || apiKey.startsWith('sk-'));
 }
 
 function isTokenExpired(token: string | null) {
@@ -325,45 +274,38 @@ function isTokenExpired(token: string | null) {
     const decoded = decodeJWT(token);
     const exp = decoded.exp;
     const currentTime = Date.now();
-    return currentTime <= exp * 1000 - EXPIRATION_THRESHOLD;
+    return (currentTime <= exp * 1000 - EXPIRATION_THRESHOLD);
 }
 
 export function decodeJWT(jwt: string): AuthTokenPayload {
-    const payloadBase64 = jwt.split(".")[1];
+    const payloadBase64 = jwt.split('.')[1];
     const decodedJson = base64UrlDecode(payloadBase64);
-    return JSON.parse(decodedJson);
+    return JSON.parse(decodedJson)
 }
 
 function base64UrlDecode(input: string): string {
     // Convert base64url to base64
-    const base64 = input
-        .replace(/-/g, "+")
-        .replace(/_/g, "/")
+    const base64 = input.replace(/-/g, '+').replace(/_/g, '/')
         // Pad with '=' to make length a multiple of 4
-        .padEnd(Math.ceil(input.length / 4) * 4, "=");
+        .padEnd(Math.ceil(input.length / 4) * 4, '=');
 
-    if (typeof Buffer !== "undefined") {
+    if (typeof Buffer !== 'undefined') {
         // Node.js
-        return Buffer.from(base64, "base64").toString("utf-8");
-    } else if (
-        typeof atob !== "undefined" &&
-        typeof TextDecoder !== "undefined"
-    ) {
+        return Buffer.from(base64, 'base64').toString('utf-8');
+    } else if (typeof atob !== 'undefined' && typeof TextDecoder !== 'undefined') {
         // Browser
         const binary = atob(base64);
-        const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+        const bytes = Uint8Array.from(binary, c => c.charCodeAt(0));
         // decode to utf8
         return new TextDecoder().decode(bytes);
     } else {
-        throw new Error("No base64 decoder available");
+        throw new Error('No base64 decoder available');
     }
 }
 
-export function decodeEndpoints(
-    endpoints: string | Record<string, string> | undefined,
-): Record<string, string> {
+export function decodeEndpoints(endpoints: string | Record<string, string> | undefined): Record<string, string> {
     if (!endpoints) {
-        return getEndpointsFromDomain("api.vertesia.io");
+        return getEndpointsFromDomain("api.vertesia.io")
     }
     if (typeof endpoints === "string") {
         return getEndpointsFromDomain(endpoints);
@@ -377,14 +319,12 @@ function getEndpointsFromDomain(domain: string) {
         return {
             studio: `http://localhost:8091`,
             store: `http://localhost:8092`,
-            token: process.env.STS_URL ?? "https://sts-staging.vertesia.io",
-        };
+        }
     } else {
         const url = `https://${domain}`;
         return {
             studio: url,
             store: url,
-            token: url.replace("api", "sts"),
-        };
+        }
     }
 }

package/src/store/FilesApi.ts

@@ -120,9 +120,9 @@ export class FilesApi extends ApiTopic {
                 if (res.ok) {
                     return res;
                 } else if (res.status === 404) {
-                    throw new Error(`File at ${url} not found`); //TODO: type fetch error better with a fetch error class
+                    throw new Error(`File ${location} not found`); //TODO: type fetch error better with a fetch error class
                 } else if (res.status === 403) {
-                    throw new Error(`File at ${url} is forbidden`);
+                    throw new Error(`File ${location} is forbidden`);
                 } else {
                     console.log(res);
                     throw new Error(

package/src/store/WorkflowsApi.ts

@@ -10,8 +10,6 @@ import {
     ListWorkflowInteractionsResponse,
     ListWorkflowRunsPayload,
     ListWorkflowRunsResponse,
-    WebSocketClientMessage,
-    WebSocketServerMessage,
     WorkflowDefinitionRef,
     WorkflowRule,
     WorkflowRuleItem,
@@ -250,170 +248,6 @@ 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

@@ -1,18 +1,18 @@
 import { AbstractFetchClient, RequestError } from "@vertesia/api-fetch-client";
 import { BulkOperationPayload, BulkOperationResult } from "@vertesia/common";
 import { AgentsApi } from "./AgentsApi.js";
+import { CollectionsApi } from "./CollectionsApi.js";
 import { CommandsApi } from "./CommandsApi.js";
 import { EmbeddingsApi } from "./EmbeddingsApi.js";
 import { ZenoClientNotFoundError } from "./errors.js";
 import { FilesApi } from "./FilesApi.js";
 import { ObjectsApi } from "./ObjectsApi.js";
 import { TypesApi } from "./TypesApi.js";
+import { VERSION, VERSION_HEADER } from "./version.js";
 import { WorkflowsApi } from "./WorkflowsApi.js";
-import { CollectionsApi } from "./CollectionsApi.js";
 
 export interface ZenoClientProps {
     serverUrl?: string;
-    tokenServerUrl?: string;
     apikey?: string;
     onRequest?: (request: Request) => void;
     onResponse?: (response: Response) => void;
@@ -45,6 +45,15 @@ export class ZenoClient extends AbstractFetchClient<ZenoClient> {
         }
     }
 
+    withApiVersion(version: string | number | null) {
+        if (!version) {
+            delete this.headers[VERSION_HEADER];
+        } else {
+            this.headers[VERSION_HEADER] = String(version);
+        }
+        return this;
+    }
+
     withApiKey(apiKey: string | null) {
         return this.withAuthCallback(
             apiKey ? () => Promise.resolve(`Bearer ${apiKey}`) : undefined
@@ -60,7 +69,7 @@ export class ZenoClient extends AbstractFetchClient<ZenoClient> {
     get initialHeaders() {
         return {
             ...super.initialHeaders,
-            'X-Api-Version': '20250925' // YYYYMMDD, client versioning for API endpoints. Increment manually for breaking changes
+            [VERSION_HEADER]: VERSION
         }
     }
 

package/src/store/version.ts

@@ -0,0 +1,2 @@
+export const VERSION = '20250925' // YYYYMMDD, client versioning for API endpoints. Increment manually for breaking changes
+export const VERSION_HEADER = 'x-api-version';