@vertesia/client 0.51.0 → 0.54.0

package/src/client.ts

@@ -15,15 +15,29 @@ import { RunsApi } from "./RunsApi.js";
 import { ZenoClient } from "./store/client.js";
 import TrainingApi from "./TrainingApi.js";
 import UsersApi from "./UsersApi.js";
+import PluginsApi from "./PluginsApi.js";
 
 /**
  * 1 min threshold constant in ms
  */
 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 +63,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 +133,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 +173,9 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         return this.store.types;
     }
 
+    get storeUrl() {
+        return this.store.baseUrl;
+    }
 
     set project(projectId: string | null) {
         if (projectId) {
@@ -171,6 +219,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
     iam = new IamApi(this);
     refs = new RefsApi(this);
     commands = new CommandsApi(this);
+    plugins = new PluginsApi(this);
 }
 
 function isApiKey(apiKey: string) {
@@ -182,10 +231,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,11 +1,11 @@
-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> {
+export async function EventSourceProvider(): Promise<typeof EventSource> {
     if (typeof globalThis.EventSource === 'function') {
-        return Promise.resolve(globalThis.EventSource)
+        return globalThis.EventSource;
     } else {
-        return import('eventsource').then(module => module.default as unknown as typeof EventSource);
+        return (await import('eventsource')).EventSource;
     }
 }
 /**
@@ -14,7 +14,7 @@ export function EventSourceProvider(): Promise<typeof EventSource> {
  * the run completes or fails.
  * If the onChunk callback is passed then the streaming of the result is enabled.
  * The onChunk callback with be called with the next chunk of the result as soon as it is available.
- * When all chunks are received the fucntion will return the resolved promise
+ * When all chunks are received the function will return the resolved promise
  * @param id of the interaction to execute
  * @param payload InteractionExecutionPayload
  * @param onChunk callback to be called when the next chunk of the response is available
@@ -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
@@ -38,7 +38,7 @@ export async function executeInteraction<P = any, R = any>(client: VertesiaClien
 
 /**
  * Same as executeInteraction but uses the interaction name selector instead of the id.
- * A name selector is the interaction endpoint name suffuxed with an optional tag or version wich is starting with a `@` character.
+ * A name selector is the interaction endpoint name suffixed with an optional tag or version which is starting with a `@` character.
  * The special `draft` tag is used to select the draft version of the interaction. If no tag or version is specified then the latest version is selected.
  * Examples of selectors:
  * - `ReviewContract` - select the latest version of the ReviewContract interaction
@@ -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";

package/src/nodejs/NodeStreamSource.ts

@@ -0,0 +1,43 @@
+import type { Readable } from "node:stream";
+import { ReadableStream as NodeReadableStream } from "node:stream/web";
+import { StreamSource } from "../StreamSource.js";
+
+
+/**
+ * A stream source that wraps a Node.js Readable stream.
+ * This class is only works in Node.js environments.
+ */
+export class NodeStreamSource extends StreamSource {
+    constructor(stream: Readable, name: string, type?: string, id?: string) {
+        super(readableToWebStream(stream) as ReadableStream, name, type, id);
+    }
+}
+
+function readableToWebStream<T = string | Buffer>(stream: Readable): ReadableStream<T> {
+    if (NodeReadableStream.from) {
+        return NodeReadableStream.from(stream) as ReadableStream<T>;
+    } else {
+        return readableToWebStream_BUN(stream);
+    }
+}
+
+/**
+ * Bun implementation since bun is not yet supporting NodeReadableStream.from
+ * @returns
+ */
+function readableToWebStream_BUN<T = string | Buffer>(stream: Readable): ReadableStream<T> {
+    const it = stream[Symbol.asyncIterator]();
+    return new ReadableStream<T>({
+        async pull(controller) {
+            const { value, done } = await it.next();
+            if (done) {
+                controller.close();
+            } else {
+                controller.enqueue(value);
+            }
+        },
+        cancel() {
+            it.return?.();
+        }
+    });
+}

package/src/nodejs/index.ts

@@ -0,0 +1 @@
+export * from "./NodeStreamSource.js";

package/src/store/AnalyzeDocApi.ts

@@ -1,5 +1,5 @@
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
-import { ContentObject, DocAnalyzerResultResponse, DocAnalyzeRunStatusResponse, DocImage, DocTableCsv, DocTableJson, PdfToRichtextOptions } from "@vertesia/common";
+import { AdaptedTable, AdaptTablesRequest, DocAnalyzerResultResponse, DocAnalyzeRunStatusResponse, DocImage, DocTableCsv, DocTableJson, ExportTableFormats, GetAdaptedTablesRequestQuery, PdfToRichtextOptions, WorkflowRunStatus } from "@vertesia/common";
 
 export class AnalyzeDocApi extends ApiTopic {
     constructor(parent: ClientBase, public objectId: string) {
@@ -18,24 +18,44 @@ export class AnalyzeDocApi extends ApiTopic {
         return this.get("/results");
     }
 
+    async adaptTables(payload: AdaptTablesRequest): Promise<WorkflowRunStatus> {
+        return this.post("/adapt_tables", { payload });
+    }
+
+    async getAdaptedTables(runId?: string, query?: GetAdaptedTablesRequestQuery): Promise<Record<number, AdaptedTable>> {
+        const path = runId ? `/adapt_tables/${runId}` : "/adapt_tables";
+        
+        // Build query parameters
+        const queryParams: any = {};
+        if (query?.format) queryParams.format = query.format;
+        if (query?.raw !== undefined) queryParams.raw = query.raw;
+        
+        // If format is CSV, set response type to text to avoid automatic JSON parsing
+        const options: any = { query: queryParams };
+        if (query?.format === 'csv') {
+            options.responseType = 'text';
+        }
+        
+        return this.get(path, options);
+    }
+
     async getXml(): Promise<string> {
         return this.get("/xml");
     }
 
-    async getTables(): Promise<DocTableCsv[] | DocTableJson[]> {
-        return this.get("/tables");
+    async getTables(format?: ExportTableFormats): Promise<DocTableCsv[] | DocTableJson[]> {
+        const options: any = {};
+        if (format) {
+            options.query = {format: format}
+        }
+        return this.get("/tables", options);
     }
 
     async getImages(): Promise<DocImage[]> {
-        return this.get("/tables");
-    }
-
-    async getParts(): Promise<ContentObject[]> {
-        return this.get("/parts");
+        return this.get("/images");
     }
 
     async getAnnotated(): Promise<{ url: string }> {
         return this.get("/annotated");
     }
-
 }

package/src/store/CommandsApi.ts

@@ -1,42 +1,15 @@
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
-import { EmbeddingsStatusResponse, GenericCommandResponse, ProjectConfigurationEmbeddings, SupportedEmbeddingTypes } from "@vertesia/common";
-
+import { EmbeddingsApi } from "./EmbeddingsApi.js";
 
+/**
+ * @deprecated use EmbeddingsApi instead
+ * @see EmbeddingsApi
+ */
 export class CommandsApi extends ApiTopic {
 
     constructor(parent: ClientBase) {
         super(parent, "/api/v1/commands");
     }
 
-    embeddings = new EmbeddingsApi(this);
-
+    embeddings = new EmbeddingsApi(this, "/embeddings");
 }
-
-export class EmbeddingsApi extends ApiTopic {
-
-    constructor(parent: ClientBase) {
-        super(parent, "/embeddings");
-    }
-
-    async status(type: SupportedEmbeddingTypes): Promise<EmbeddingsStatusResponse> {
-        return this.get(type + "/status");
-    }
-
-    async activate(type: SupportedEmbeddingTypes, config: Partial<ProjectConfigurationEmbeddings>): Promise<GenericCommandResponse> {
-
-        if (!config.environment) {
-            throw new Error("Invalid configuration: select environment");
-        }
-
-        return this.post(type + "/enable", { payload: config });
-    }
-
-    async disable(type: SupportedEmbeddingTypes): Promise<GenericCommandResponse> {
-        return this.post(type + "/disable");
-    }
-
-    async recalculate(type: SupportedEmbeddingTypes): Promise<GenericCommandResponse> {
-        return this.post(type + "/recalculate");
-    }
-
-}

package/src/store/EmbeddingsApi.ts

@@ -0,0 +1,39 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import {
+    EmbeddingsStatusResponse,
+    GenericCommandResponse,
+    ProjectConfigurationEmbeddings,
+    SupportedEmbeddingTypes,
+} from "@vertesia/common";
+
+/**
+ * @since 0.52.0
+ */
+export class EmbeddingsApi extends ApiTopic {
+
+    constructor(parent: ClientBase, basePath: string = "/api/v1/embeddings") {
+        super(parent, basePath);
+    }
+
+    async status(type: SupportedEmbeddingTypes): Promise<EmbeddingsStatusResponse> {
+        return this.get(type + "/status");
+    }
+
+    async activate(type: SupportedEmbeddingTypes, config: Partial<ProjectConfigurationEmbeddings>): Promise<GenericCommandResponse> {
+
+        if (!config.environment) {
+            throw new Error("Invalid configuration: select environment");
+        }
+
+        return this.post(type + "/enable", { payload: config });
+    }
+
+    async disable(type: SupportedEmbeddingTypes): Promise<GenericCommandResponse> {
+        return this.post(type + "/disable");
+    }
+
+    async recalculate(type: SupportedEmbeddingTypes): Promise<GenericCommandResponse> {
+        return this.post(type + "/recalculate");
+    }
+
+}

package/src/store/FilesApi.ts

@@ -101,6 +101,10 @@ export class FilesApi extends ApiTopic {
         }).then((res: Response) => {
             if (res.ok) {
                 return res;
+            } else if (res.status === 404) {
+                throw new Error(`File ${name} not found`); //TODO: type fetch error better with a fetch error class
+            } else if (res.status === 403) {
+                throw new Error(`File ${name} is forbidden`);
             } else {
                 console.log(res);
                 throw new Error(`Failed to download file ${name}: ${res.statusText}`);