@vertesia/client 0.50.1 → 0.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/client",
-  "version": "0.50.1",
+  "version": "0.53.0",
   "type": "module",
   "types": "./lib/types/index.d.ts",
   "files": [
@@ -9,28 +9,43 @@
   ],
   "devDependencies": {
     "@types/eventsource": "^1.1.14",
-    "@types/node": "^20.8.9",
+    "@types/node": "^22.13.5",
     "ts-dual-module": "^0.6.3",
     "typescript": "^5.0.2",
-    "vitest": "^2.1.8"
+    "vitest": "^3.0.9"
   },
   "dependencies": {
     "eventsource": "^2.0.2",
-    "@vertesia/common": "0.50.1",
-    "@vertesia/api-fetch-client": "0.50.1",
-    "@llumiverse/core": "0.15.0"
+    "@vertesia/api-fetch-client": "0.52.0",
+    "@llumiverse/core": "0.17.0",
+    "@vertesia/common": "0.52.0"
   },
   "ts_dual_module": {
     "outDir": "lib"
   },
   "exports": {
-    "types": "./lib/types/index.d.ts",
-    "import": "./lib/esm/index.js",
-    "require": "./lib/cjs/index.js"
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    },
+    "./node": {
+      "types": "./lib/types/nodejs/index.d.ts",
+      "import": "./lib/esm/nodejs/index.js",
+      "require": "./lib/cjs/nodejs/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "node": [
+        "./lib/types/nodejs/index.d.ts"
+      ]
+    }
   },
   "scripts": {
     "eslint": "eslint './src/**/*.{jsx,js,tsx,ts}'",
     "build": "pnpm exec tsmod build",
-    "clean": "rimraf ./node_modules ./lib ./tsconfig.tsbuildinfo"
+    "clean": "rimraf ./node_modules ./lib ./tsconfig.tsbuildinfo",
+    "test": "vitest run"
   }
 }

package/src/AccountApi.ts

@@ -1,5 +1,5 @@
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
-import { Account, InviteUserRequestPayload, InviteUserResponsePayload, OnboardingProgress, ProjectRef, TransientToken, UpdateAccountPayload, User, UserInviteTokenData } from "@vertesia/common";
+import { Account, InviteUserRequestPayload, InviteUserResponsePayload, OnboardingProgress, ProjectRef, StripeBillingStatusResponse, TransientToken, UpdateAccountPayload, User, UserInviteTokenData } from "@vertesia/common";
 
 export default class AccountApi extends ApiTopic {
 
@@ -42,13 +42,21 @@ export default class AccountApi extends ApiTopic {
     }
 
     /**
-     * Fetch Invites for account
+     * Fetch Invites for Principal
      * @returns UserInviteTokenData[]
      * */
     listInvites(): Promise<TransientToken<UserInviteTokenData>[]> {
         return this.get('/invites');
     }
 
+    /**
+     * Fetch Invites for Account
+     * @returns UserInviteTokenData[]
+     * */
+    listAccountInvitation(id: string): Promise<TransientToken<UserInviteTokenData>[]> {
+        return this.get(`/invites/${id}`);
+    }
+
     /**
      * Accept Invite for account
      * @returns UserInviteTokenData
@@ -81,4 +89,8 @@ export default class AccountApi extends ApiTopic {
         return this.get('/google-token');
     }
 
+    getStripeBillingStatus(): Promise<StripeBillingStatusResponse> {
+        return this.get('/stripe-billing-status')
+    }
+
 }

package/src/AccountsApi.ts

@@ -11,6 +11,10 @@ export default class AccountsApi extends ApiTopic {
         return this.post('/', { payload: { name } });
     }
 
+    list(): Promise<Account[]> {
+        return this.get('/');
+    }
+
 
 
 

package/src/InteractionsApi.ts

@@ -1,7 +1,7 @@
-import { ComputeInteractionFacetPayload, ExecutionRun, GenerateInteractionPayload, GenerateTestDataPayload, ImprovePromptPayload, Interaction, InteractionCreatePayload, InteractionExecutionPayload, InteractionForkPayload, InteractionPublishPayload, InteractionRef, InteractionRefWithSchema, InteractionUpdatePayload, InteractionsExportPayload, InteractionSearchPayload, InteractionSearchQuery } from "@vertesia/common";
 import { ApiTopic, ClientBase, ServerError } from "@vertesia/api-fetch-client";
+import { AsyncExecutionPayload, ComputeInteractionFacetPayload, ExecutionRun, GenerateInteractionPayload, GenerateTestDataPayload, ImprovePromptPayload, Interaction, InteractionCreatePayload, InteractionEndpointQuery, InteractionExecutionPayload, InteractionExecutionResult, InteractionForkPayload, InteractionPublishPayload, InteractionRef, InteractionRefWithSchema, InteractionSearchPayload, InteractionSearchQuery, InteractionUpdatePayload, InteractionsExportPayload } from "@vertesia/common";
 import { VertesiaClient } from "./client.js";
-import { executeInteraction, executeInteractionByName } from "./execute.js";
+import { executeInteraction, executeInteractionAsync, executeInteractionByName } from "./execute.js";
 
 export interface ComputeInteractionFacetsResponse {
     tags?: { _id: string, count: number }[];
@@ -9,6 +9,10 @@ export interface ComputeInteractionFacetsResponse {
     total?: { count: number }[];
 }
 
+export interface AsyncExecutionResult {
+    runId: string, workflowId: string
+}
+
 export default class InteractionsApi extends ApiTopic {
     constructor(parent: ClientBase) {
         super(parent, "/api/v1/interactions");
@@ -27,6 +31,24 @@ export default class InteractionsApi extends ApiTopic {
             }
         });
     }
+    /**
+     * Find interractions given a mongo match query.
+     * You can also specify if prompts schemas are included in the result
+     */
+    listEndpoints(payload: InteractionEndpointQuery): Promise<InteractionRef[]> {
+        return this.post("/endpoints", {
+            payload
+        });
+    }
+
+    /**
+     * List all interaction versions in the project having the given endpoint name.
+     * This is useful to list orphaned versions
+     * @param name
+     */
+    listVersionsByName(name: string): Promise<InteractionRef[]> {
+        return this.get(`/versions/${name}`);
+    }
 
     /**
      * Get the list of all interactions facets
@@ -137,7 +159,7 @@ export default class InteractionsApi extends ApiTopic {
      * @returns
      */
     executeByName<P = any, R = any>(nameWithTag: string, payload: InteractionExecutionPayload = {},
-        onChunk?: (chunk: string) => void): Promise<ExecutionRun<P, R>> {
+        onChunk?: (chunk: string) => void): Promise<InteractionExecutionResult<P, R>> {
         return executeInteractionByName(this.client as VertesiaClient, nameWithTag, payload, onChunk).catch(err => {
             if (err instanceof ServerError && err.payload?.id) {
                 throw err.updateDetails({ run_id: err.payload.id });
@@ -147,6 +169,15 @@ export default class InteractionsApi extends ApiTopic {
         });
     }
 
+    /**
+     * Execute an interaction in an workflow
+     * @param payload
+     * @returns
+     */
+    executeAsync(payload: AsyncExecutionPayload): Promise<AsyncExecutionResult> {
+        return executeInteractionAsync(this.client as VertesiaClient, payload);
+    }
+
     publish(id: string, payload: InteractionPublishPayload): Promise<Interaction> {
         return this.post(`/${id}/publish`, {
             payload

package/src/ProjectsApi.ts

@@ -1,5 +1,5 @@
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
-import { AwsConfiguration, GithubConfiguration, GladiaConfiguration, ICreateProjectPayload, Project, ProjectIntegrationListEntry, ProjectRef, SupportedIntegrations } from "@vertesia/common";
+import { AwsConfiguration, GithubConfiguration, GladiaConfiguration, ICreateProjectPayload, MacgicPdfConfiguration, Project, ProjectIntegrationListEntry, ProjectRef, SupportedIntegrations } from "@vertesia/common";
 
 export default class ProjectsApi extends ApiTopic {
     constructor(parent: ClientBase) {
@@ -40,7 +40,7 @@ class IntegrationsConfigurationApi extends ApiTopic {
         return this.get(`/${projectId}/integrations`).then(res => res.integrations);
     }
 
-    retrieve(projectId: string, integrationId: SupportedIntegrations): Promise<GladiaConfiguration | GithubConfiguration | AwsConfiguration | undefined> {
+    retrieve(projectId: string, integrationId: SupportedIntegrations): Promise<GladiaConfiguration | GithubConfiguration | AwsConfiguration | MacgicPdfConfiguration | undefined> {
         return this.get(`/${projectId}/integrations/${integrationId}`).catch(err => {
             if (err.status === 404) {
                 return undefined;

package/src/RunsApi.ts

@@ -1,26 +1,38 @@
-import { ComputeRunFacetPayload, ExecutionRun, ExecutionRunRef, FindPayload, RunCreatePayload, RunListingFilters, RunListingQueryOptions, RunSearchPayload } from "@vertesia/common";
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import {
+    CheckpointConversationPayload,
+    ComputeRunFacetPayload,
+    ExecutionRun,
+    ExecutionRunRef,
+    FindPayload,
+    RunCreatePayload,
+    RunListingFilters,
+    RunListingQueryOptions,
+    RunSearchPayload,
+    ToolResultsPayload,
+    UserMessagePayload,
+} from "@vertesia/common";
 import { VertesiaClient } from "./client.js";
+import { ExecutionResponse } from "@llumiverse/core";
 
 export interface FilterOption {
-    id: string,
-    name: string,
-    count: number
+    id: string;
+    name: string;
+    count: number;
 }
 
 export interface ComputeRunFacetsResponse {
-    environments?: { _id: string, count: number }[];
-    interactions?: { _id: string, count: number }[];
-    models?: { _id: string, count: number }[];
-    tags?: { _id: string, count: number }[];
-    status?: { _id: string, count: number }[];
+    environments?: { _id: string; count: number }[];
+    interactions?: { _id: string; count: number }[];
+    models?: { _id: string; count: number }[];
+    tags?: { _id: string; count: number }[];
+    status?: { _id: string; count: number }[];
     total?: { count: number }[];
 }
 
 export class RunsApi extends ApiTopic {
-
     constructor(parent: ClientBase) {
-        super(parent, "/api/v1/runs")
+        super(parent, "/api/v1/runs");
     }
 
     /**
@@ -30,29 +42,29 @@ export class RunsApi extends ApiTopic {
      * @returns InteractionResult[]
      **/
     list({ limit, offset, filters }: RunListingQueryOptions): Promise<ExecutionRunRef[]> {
-
         const query = {
             limit,
             offset,
-            ...filters
-        }
+            ...filters,
+        };
 
-        return this.get('/', { query: query });
+        return this.get("/", { query: query });
     }
 
     find(payload: FindPayload): Promise<ExecutionRun[]> {
         return this.post("/find", {
-            payload
+            payload,
         });
     }
 
     /**
      * Get a run by id
+     *
      * @param id
      * @returns InteractionResult
      **/
-    retrieve(id: string): Promise<ExecutionRun> {
-        return this.get('/' + id);
+    retrieve<P = any, R = any>(id: string): Promise<ExecutionRun<P, R>> {
+        return this.get("/" + id);
     }
 
     /**
@@ -61,10 +73,9 @@ export class RunsApi extends ApiTopic {
      */
     filterOptions(field: string, filters: RunListingFilters): Promise<FilterOption[]> {
         const query = {
-            ...filters
-        }
+            ...filters,
+        };
         return this.get(`/filter-options/${field}`, { query });
-
     }
 
     create(payload: RunCreatePayload): Promise<ExecutionRun> {
@@ -72,14 +83,42 @@ export class RunsApi extends ApiTopic {
         if (sessionTags) {
             let tags = Array.isArray(sessionTags) ? sessionTags : [sessionTags];
             if (Array.isArray(payload.tags)) {
-                tags = tags.concat(payload.tags)
+                tags = tags.concat(payload.tags);
             } else if (payload.tags) {
-                tags = tags.concat([payload.tags])
+                tags = tags.concat([payload.tags]);
             }
-            payload = { ...payload, tags }
+            payload = { ...payload, tags };
         }
         return this.post("/", {
-            payload
+            payload,
+        });
+    }
+
+    /**
+     * Send tool results and continues the conversation
+     * @param payload
+     * @returns
+     */
+    sendToolResults(payload: ToolResultsPayload): Promise<ExecutionResponse> {
+        return this.post(`/tool-results`, {
+            payload,
+        });
+    }
+
+    /**
+     *
+     * @param payload
+     * @returns
+     */
+    sendUserMessage(payload: UserMessagePayload): Promise<ExecutionResponse> {
+        return this.post(`/user-message`, {
+            payload,
+        });
+    }
+
+    createCheckpoint(payload: CheckpointConversationPayload): Promise<ExecutionResponse> {
+        return this.post(`/checkpoint`, {
+            payload,
         });
     }
 
@@ -90,14 +129,13 @@ export class RunsApi extends ApiTopic {
      **/
     computeFacets(query: ComputeRunFacetPayload): Promise<ComputeRunFacetsResponse> {
         return this.post("/facets", {
-            payload: query
+            payload: query,
         });
     }
 
     search(payload: RunSearchPayload): Promise<ExecutionRunRef[]> {
         return this.post("/search", {
-            payload
+            payload,
         });
     }
-
-}
+}

package/src/client.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from "vitest";
+import { VertesiaClient } from "./client";
+
+describe('Test Vertesia Client', () => {
+    test('Initialization with studio and zeno URLs', () => {
+        const client = new VertesiaClient({
+            serverUrl: 'https://api.vertesia.io',
+            storeUrl: 'https://api.vertesia.io',
+            apikey: '1234',
+        });
+        expect(client).toBeDefined();
+    });
+
+    test('Initialization with studio URL only', () => {
+        expect(() => {
+            new VertesiaClient({
+                serverUrl: 'https://api.vertesia.io',
+                storeUrl: '',
+            });
+        }).toThrowError("Parameter 'site' or 'storeUrl' is required for VertesiaClient");
+    });
+
+    test('Initialization with zeno URL only', () => {
+        expect(() => {
+            new VertesiaClient({
+                serverUrl: '',
+                storeUrl: 'https://api.vertesia.io',
+            });
+        }).toThrowError("Parameter 'site' or 'serverUrl' is required for VertesiaClient");
+    });
+
+    test('Initialization with same site', () => {
+        const client = new VertesiaClient({
+            serverUrl: 'https://api.vertesia.io',
+            storeUrl: 'https://api.vertesia.io',
+            site: 'api.vertesia.io',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://api.vertesia.io');
+        expect(client.storeUrl).toBe('https://api.vertesia.io');
+    });
+
+    test('Initialization with default parameters', () => {
+        const client = new VertesiaClient();
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://api.vertesia.io');
+        expect(client.storeUrl).toBe('https://api.vertesia.io');
+    });
+
+    test('Initialization with site api-preview.vertesia.io', () => {
+        const client = new VertesiaClient({
+            site: 'api-preview.vertesia.io',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://api-preview.vertesia.io');
+        expect(client.storeUrl).toBe('https://api-preview.vertesia.io');
+    });
+
+    test('Initialization with site api-staging.vertesia.io', () => {
+        const client = new VertesiaClient({
+            site: 'api-staging.vertesia.io',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://api-staging.vertesia.io');
+        expect(client.storeUrl).toBe('https://api-staging.vertesia.io');
+    });
+
+    test('Initialization with site localhost', () => {
+        const client = new VertesiaClient({
+            serverUrl: 'http://localhost:8091',
+            storeUrl: 'http://localhost:8092',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('http://localhost:8091');
+        expect(client.storeUrl).toBe('http://localhost:8092');
+    });
+
+    test('Initialization with overrides', () => {
+        const client = new VertesiaClient({
+            serverUrl: 'https://studio-server-production.api.becomposable.com',
+            storeUrl: 'https://zeno-server-production.api.becomposable.com',
+            site: 'api.vertesia.io',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://studio-server-production.api.becomposable.com');
+        expect(client.storeUrl).toBe('https://zeno-server-production.api.becomposable.com');
+    });
+});

package/src/client.ts

@@ -21,9 +21,22 @@ import UsersApi from "./UsersApi.js";
  */
 const EXPIRATION_THRESHOLD = 60000;
 
-export interface VertesiaClientProps {
-    serverUrl: string;
-    storeUrl: string;
+export type VertesiaClientProps = {
+    /**
+     * The site name of Vertesia.
+     *
+     * This is used to determine the API backend. It should not include the protocol. For more
+     * advanced configurations, use `serverUrl` and `storeUrl` instead.
+     *
+     * @example api.vertesia.io
+     * @example api-preview.vertesia.io
+     * @example api-staging.vertesia.io
+     * @default api.vertesia.io
+     * @since 0.52.0
+     */
+    site?: 'api.vertesia.io' | 'api-preview.vertesia.io' | 'api-staging.vertesia.io';
+    serverUrl?: string;
+    storeUrl?: string;
     apikey?: string;
     projectId?: string;
     sessionTags?: string | string[];
@@ -49,17 +62,33 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
     sessionTags?: string | string[];
 
     constructor(
-        opts: VertesiaClientProps = {} as any
+        opts: VertesiaClientProps = {
+            site: 'api.vertesia.io',
+        }
     ) {
-        super(opts.serverUrl);
-        if (!opts.serverUrl) {
-            throw new Error("storeUrl is required for VertesiaClient");
+        let studioServerUrl: string;
+        let zenoServerUrl: string;
+
+        if (opts.serverUrl) {
+            studioServerUrl = opts.serverUrl;
+        } else if (opts.site) {
+            studioServerUrl = `https://${opts.site}`;
+        } else {
+            throw new Error("Parameter 'site' or 'serverUrl' is required for VertesiaClient");
         }
-        if (!opts.storeUrl) {
-            throw new Error("storeUrl is required for VertesiaClient");
+
+        if (opts.storeUrl) {
+            zenoServerUrl = opts.storeUrl;
+        } else if (opts.site) {
+            zenoServerUrl = `https://${opts.site}`;
+        } else {
+            throw new Error("Parameter 'site' or 'storeUrl' is required for VertesiaClient");
         }
+
+        super(studioServerUrl);
+
         this.store = new ZenoClient({
-            serverUrl: opts.storeUrl,
+            serverUrl: zenoServerUrl,
             apikey: opts.apikey,
             onRequest: opts.onRequest,
             onResponse: opts.onResponse
@@ -103,6 +132,21 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         );
     }
 
+    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
+            }
+        }
+        return this._jwt || null;
+    }
+
+    async getDecodedJWT() {
+        const jwt = await this.getRawJWT();
+        return jwt ? decodeJWT(jwt) : null;
+    }
+
     /**
      * Alias for store.workflows
      */
@@ -128,6 +172,9 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         return this.store.types;
     }
 
+    get storeUrl() {
+        return this.store.baseUrl;
+    }
 
     set project(projectId: string | null) {
         if (projectId) {
@@ -182,10 +229,34 @@ function isTokenExpired(token: string | null) {
         return true;
     }
 
-    const payloadBase64 = token.split('.')[1];
-    const decodedJson = Buffer.from(payloadBase64, 'base64').toString();
-    const decoded = JSON.parse(decodedJson)
+    const decoded = decodeJWT(token);
     const exp = decoded.exp;
     const currentTime = Date.now();
     return (currentTime <= exp * 1000 - EXPIRATION_THRESHOLD);
 }
+
+function decodeJWT(jwt: string) {
+    const payloadBase64 = jwt.split('.')[1];
+    const decodedJson = base64UrlDecode(payloadBase64);
+    return JSON.parse(decodedJson)
+}
+
+function base64UrlDecode(input: string): string {
+    // Convert base64url to base64
+    const base64 = input.replace(/-/g, '+').replace(/_/g, '/')
+        // Pad with '=' to make length a multiple of 4
+        .padEnd(Math.ceil(input.length / 4) * 4, '=');
+
+    if (typeof Buffer !== 'undefined') {
+        // Node.js
+        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));
+        // decode to utf8
+        return new TextDecoder().decode(bytes);
+    } else {
+        throw new Error('No base64 decoder available');
+    }
+}

package/src/execute.ts

@@ -1,4 +1,4 @@
-import { ExecutionRun, ExecutionRunStatus, InteractionExecutionPayload, NamedInteractionExecutionPayload } from '@vertesia/common';
+import { AsyncExecutionPayload, ExecutionRunStatus, InteractionExecutionPayload, InteractionExecutionResult, NamedInteractionExecutionPayload } from '@vertesia/common';
 import { VertesiaClient } from './client.js';
 
 export function EventSourceProvider(): Promise<typeof EventSource> {
@@ -22,7 +22,7 @@ export function EventSourceProvider(): Promise<typeof EventSource> {
 export async function executeInteraction<P = any, R = any>(client: VertesiaClient,
     interactionId: string,
     payload: InteractionExecutionPayload = {},
-    onChunk?: (chunk: string) => void): Promise<ExecutionRun<P, R>> {
+    onChunk?: (chunk: string) => void): Promise<InteractionExecutionResult<P, R>> {
     const stream = !!onChunk;
     const response = await client.runs.create({
         ...payload, interaction: interactionId, stream
@@ -55,7 +55,7 @@ export async function executeInteraction<P = any, R = any>(client: VertesiaClien
 export async function executeInteractionByName<P = any, R = any>(client: VertesiaClient,
     interaction: string,
     payload: InteractionExecutionPayload = {},
-    onChunk?: (chunk: string) => void): Promise<ExecutionRun<P, R>> {
+    onChunk?: (chunk: string) => void): Promise<InteractionExecutionResult<P, R>> {
     const stream = !!onChunk;
     const response = await client.post('/api/v1/execute', {
         payload: {
@@ -111,4 +111,10 @@ function handleStreaming(client: VertesiaClient, runId: string, onChunk: (chunk:
             reject(err);
         }
     });
+}
+
+export async function executeInteractionAsync(client: VertesiaClient, payload: AsyncExecutionPayload): Promise<{ runId: string, workflowId: string }> {
+    return await client.post('/api/v1/execute/async', {
+        payload,
+    });
 }

package/src/index.ts

@@ -1,8 +1,7 @@
+export * from './client.js';
 export * from './InteractionBase.js';
+export type { AsyncExecutionResult, ComputeInteractionFacetsResponse } from './InteractionsApi.js';
 export type { ComputePromptFacetsResponse, ListInteractionsResponse } from './PromptsApi.js';
-export type { ComputeInteractionFacetsResponse } from './InteractionsApi.js';
 export type { ComputeRunFacetsResponse, FilterOption } from './RunsApi.js';
-export * from './client.js';
-export * from './InteractionBase.js';
 export * from "./store/index.js";
 export * from "./StreamSource.js";