@vertesia/client 0.79.1 → 0.80.0-dev-20251118

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vertesia/client",
-    "version": "0.79.1",
+    "version": "0.80.0-dev-20251118",
     "type": "module",
     "types": "./lib/types/index.d.ts",
     "files": [
@@ -47,6 +47,11 @@
             "require": "./lib/cjs/nodejs/index.js"
         }
     },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/vertesia/composableai.git",
+        "directory": "packages/client"
+    },
     "typesVersions": {
         "*": {
             "node": [

package/src/InteractionCatalogApi.ts

@@ -0,0 +1,72 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import {
+    CatalogInteractionRef,
+    InCodeInteraction,
+    InteractionStatus
+} from "@vertesia/common";
+
+
+export class InteractionCatalogApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/interactions/catalog");
+    }
+
+    /**
+     * List all project interactions
+     */
+    list(query: { status?: InteractionStatus, tag?: string } = {}): Promise<CatalogInteractionRef[]> {
+        return this.get("/", {
+            query
+        });
+    }
+
+    /**
+     * List all stored interactions
+     */
+    listStoredInteractions(query: { status?: InteractionStatus, tag?: string } = {}): Promise<CatalogInteractionRef[]> {
+        return this.get("/stored", {
+            query
+        });
+    }
+
+    /**
+     * List sys interactions
+     */
+    listSysInteractions(tag?: string): Promise<CatalogInteractionRef[]> {
+        return this.get(`/sys`, {
+            query: {
+                tag
+            }
+        });
+    }
+
+    /**
+     * List sys interactions
+     */
+    listAppInteractions(appName: string, tag?: string): Promise<CatalogInteractionRef[]> {
+        return this.get(`/apps/${appName}`, {
+            query: {
+                tag
+            }
+        });
+    }
+
+    /**
+     * List all app interactions
+     */
+    listAllAppInteractions(tag?: string): Promise<CatalogInteractionRef[]> {
+        return this.get(`/apps`, {
+            query: {
+                tag
+            }
+        });
+    }
+
+    /**
+     * Resolve an interaction given its id to a InCodeInteraction
+     * @param id Interaction id
+     */
+    resolve(id: string): Promise<InCodeInteraction> {
+        return this.get(`/resolve/${id}`);
+    }
+}

package/src/InteractionsApi.ts

@@ -1,12 +1,16 @@
 import { ApiTopic, ClientBase, ServerError } from "@vertesia/api-fetch-client";
 import {
     AsyncExecutionPayload, ComputeInteractionFacetPayload, GenerateInteractionPayload, GenerateTestDataPayload, ImprovePromptPayload,
-    Interaction, InteractionCreatePayload, InteractionEndpoint, InteractionEndpointQuery, InteractionExecutionPayload, InteractionForkPayload,
+    ImprovePromptPayloadConfig,
+    Interaction, InteractionCreatePayload, InteractionEndpoint, InteractionEndpointQuery,
+    InteractionExecutionPayload, InteractionForkPayload,
     InteractionPublishPayload, InteractionRef, InteractionRefWithSchema, InteractionSearchPayload, InteractionSearchQuery,
-    InteractionsExportPayload, InteractionUpdatePayload, RateLimitRequestPayload, RateLimitRequestResponse
+    InteractionsExportPayload, InteractionUpdatePayload,
+    RateLimitRequestPayload, RateLimitRequestResponse
 } from "@vertesia/common";
 import { VertesiaClient } from "./client.js";
 import { checkRateLimit, executeInteraction, executeInteractionAsync, executeInteractionByName } from "./execute.js";
+import { InteractionCatalogApi } from "./InteractionCatalogApi.js";
 import { EnhancedExecutionRun, EnhancedInteractionExecutionResult, enhanceExecutionRun, enhanceInteractionExecutionResult } from "./InteractionOutput.js";
 
 export interface ComputeInteractionFacetsResponse {
@@ -20,8 +24,11 @@ export interface AsyncExecutionResult {
 }
 
 export default class InteractionsApi extends ApiTopic {
+    catalog: InteractionCatalogApi;
+
     constructor(parent: ClientBase) {
         super(parent, "/api/v1/interactions");
+        this.catalog = new InteractionCatalogApi(parent);
     }
 
     /**
@@ -221,14 +228,23 @@ export default class InteractionsApi extends ApiTopic {
 
     /**
      * Suggest Improvement for a prompt
+     * @deprecated use suggestPromptImprovements instead
      */
-    async suggestImprovements<ResultT = any, ParamsT = any>(id: string, payload: ImprovePromptPayload): Promise<EnhancedExecutionRun<ResultT, ParamsT>> {
+    async suggestImprovements<ResultT = any, ParamsT = any>(id: string, payload: ImprovePromptPayloadConfig): Promise<EnhancedExecutionRun<ResultT, ParamsT>> {
         const r = await this.post(`${id}/suggest-prompt-improvements`, {
             payload
         });
         return enhanceExecutionRun<ResultT, ParamsT>(r);
     }
 
+    async suggestPromptImprovements<ResultT = any, ParamsT = any>(payload: ImprovePromptPayload): Promise<EnhancedInteractionExecutionResult<ResultT, ParamsT>> {
+        const r = await this.post(`/improve`, {
+            payload
+        });
+        return enhanceInteractionExecutionResult<ResultT, ParamsT>(r);
+    }
+
+
     /**
      * List the versions of the interaction. Returns an empty array if no versions are found
      * @param id

package/src/ProjectsApi.ts

@@ -1,5 +1,5 @@
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
-import { AwsConfiguration, GithubConfiguration, GladiaConfiguration, ICreateProjectPayload, MagicPdfConfiguration, Project, ProjectIntegrationListEntry, ProjectRef, SupportedIntegrations } from "@vertesia/common";
+import { AwsConfiguration, GithubConfiguration, GladiaConfiguration, ICreateProjectPayload, MagicPdfConfiguration, Project, ProjectConfiguration, ProjectIntegrationListEntry, ProjectRef, SupportedIntegrations } from "@vertesia/common";
 
 export default class ProjectsApi extends ApiTopic {
     constructor(parent: ClientBase) {
@@ -26,6 +26,12 @@ export default class ProjectsApi extends ApiTopic {
         });
     }
 
+    updateConfiguration(projectId: string, payload: Partial<ProjectConfiguration>): Promise<ProjectConfiguration> {
+        return this.put(`/${projectId}/configuration`, {
+            payload
+        });
+    }
+
     integrations: IntegrationsConfigurationApi = new IntegrationsConfigurationApi(this);
 
 }

package/src/RunsApi.ts

@@ -1,3 +1,4 @@
+import type { ExecutionResponse } from "@llumiverse/common";
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
 import {
     CheckpointConversationPayload,
@@ -5,6 +6,7 @@ import {
     ExecutionRun,
     ExecutionRunRef,
     FindPayload,
+    PopulatedExecutionRun,
     RunCreatePayload,
     RunListingFilters,
     RunListingQueryOptions,
@@ -13,7 +15,6 @@ import {
     UserMessagePayload,
 } from "@vertesia/common";
 import { VertesiaClient } from "./client.js";
-import type { ExecutionResponse } from "@llumiverse/common";
 import { EnhancedExecutionRun, enhanceExecutionRun } from "./InteractionOutput.js";
 
 export interface FilterOption {
@@ -69,6 +70,12 @@ export class RunsApi extends ApiTopic {
         return enhanceExecutionRun<ResultT, ParamsT>(r);
     }
 
+    retrievePopulated<P = any>(id: string): Promise<PopulatedExecutionRun<P>> {
+        return this.get("/" + id, {
+            query: { populate: "true" },
+        });
+    }
+
     /**
      * Get filter options for a field
      * return FilterOption[]

package/src/client.test.ts

@@ -6,6 +6,7 @@ describe('Test Vertesia Client', () => {
         const client = new VertesiaClient({
             serverUrl: 'https://api.vertesia.io',
             storeUrl: 'https://api.vertesia.io',
+            tokenServerUrl: 'https://sts.vertesia.io',
             apikey: '1234',
         });
         expect(client).toBeDefined();
@@ -73,6 +74,7 @@ describe('Test Vertesia Client', () => {
         const client = new VertesiaClient({
             serverUrl: 'http://localhost:8091',
             storeUrl: 'http://localhost:8092',
+            tokenServerUrl: 'http://localhost:8093',
         });
 
         expect(client).toBeDefined();

package/src/client.ts

@@ -37,18 +37,21 @@ 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)
      */
@@ -64,11 +67,15 @@ 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
      */
@@ -76,21 +83,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
+            storeUrl: endpoints.store,
+            tokenServerUrl: payload.iss,
         }).withApiKey(token);
     }
 
-    static decodeEndpoints() {
-
-    }
+    static decodeEndpoints() {}
 
     constructor(
         opts: VertesiaClientProps = {
-            site: 'api.vertesia.io',
-        }
+            site: "api.vertesia.io",
+        },
     ) {
         let studioServerUrl: string;
         let zenoServerUrl: string;
@@ -100,7 +107,9 @@ 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) {
@@ -108,25 +117,67 @@ 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;
@@ -153,25 +204,28 @@ 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;
@@ -221,21 +275,29 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         return this.store.baseUrl;
     }
 
-
     /**
      *
-     * Generate a token for use with other Composable's services
+     * Generate a token for use with other Vertesia's services
      *
-     * @param accountId: selected account to generate the token for
      * @returns AuthTokenResponse
      */
-    async getAuthToken(token?: string, accountId?: string): Promise<AuthTokenResponse> {
-        const query = {
-            accountId,
-            token
-        };
-
-        return this.get('/auth/token', { query: query, headers: { "authorization": undefined } as any });
+    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;
+            });
     }
 
     get initialHeaders() {
@@ -263,7 +325,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) {
@@ -274,38 +336,45 @@ 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);
@@ -319,12 +388,14 @@ 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/index.ts

@@ -7,3 +7,4 @@ export type { ComputeRunFacetsResponse, FilterOption } from './RunsApi.js';
 export type { GroupsQueryOptions } from './GroupsApi.js';
 export * from "./store/index.js";
 export * from "./StreamSource.js";
+export type { OrphanedAppInstallation } from "./AppsApi.js";

package/src/store/CollectionsApi.ts

@@ -128,7 +128,6 @@ export class CollectionsApi extends ApiTopic {
     updatePermissions(collectionId: string, permissions: Record<string, string[]>): Promise<{
         id: string;
         security: Record<string, string[]>;
-        objectsUpdated: number;
     }> {
         return this.put(`/${collectionId}/permissions`, {
             payload: permissions
@@ -145,9 +144,23 @@ export class CollectionsApi extends ApiTopic {
         id: string;
         message: string;
         security?: Record<string, string[]>;
-        objectsUpdated: number;
     }> {
         return this.post(`/${collectionId}/propagate-permissions`);
     }
 
+    /**
+     * Manually trigger shared properties propagation from collection to member objects
+     * Useful for debugging and fixing shared properties issues
+     * @param collectionId - The collection ID
+     * @returns Object with collection id, message, and number of objects updated
+     */
+    propagateSharedProperties(collectionId: string): Promise<{
+        id: string;
+        message: string;
+        shared_properties: string[]
+    }> {
+        return this.post(`/${collectionId}/propagate-shared-props`);
+    }
+
+
 }

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/WorkflowsApi.ts

@@ -10,6 +10,8 @@ import {
     ListWorkflowInteractionsResponse,
     ListWorkflowRunsPayload,
     ListWorkflowRunsResponse,
+    WebSocketClientMessage,
+    WebSocketServerMessage,
     WorkflowActionPayload,
     WorkflowDefinitionRef,
     WorkflowRule,
@@ -251,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;