@vertesia/client 0.42.2

package/src/execute.ts

@@ -0,0 +1,114 @@
+import { ExecutionRun, ExecutionRunStatus, InteractionExecutionPayload, NamedInteractionExecutionPayload } from '@vertesia/common';
+import { ComposableClient } from './client.js';
+
+export function EventSourceProvider(): Promise<typeof EventSource> {
+    if (typeof globalThis.EventSource === 'function') {
+        return Promise.resolve(globalThis.EventSource)
+    } else {
+        return import('eventsource').then(module => module.default as unknown as typeof EventSource);
+    }
+}
+/**
+ *
+ * Execute an interaction and return a promise which will be resolved with the executed run when
+ * 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
+ * @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
+ */
+export async function executeInteraction<P = any, R = any>(client: ComposableClient,
+    interactionId: string,
+    payload: InteractionExecutionPayload = {},
+    onChunk?: (chunk: string) => void): Promise<ExecutionRun<P, R>> {
+    const stream = !!onChunk;
+    const response = await client.runs.create({
+        ...payload, interaction: interactionId, stream
+    });
+    if (stream) {
+        if (response.status === ExecutionRunStatus.failed) {
+            return response;
+        }
+        await handleStreaming(client, response.id, onChunk);
+    }
+    return response;
+}
+
+/**
+ * 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.
+ * 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
+ * - `ReviewContract@1` - select the version 1 of the ReviewContract interaction
+ * - `ReviewContract@draft` - select the draft version of the ReviewContract interaction
+ * - `ReviewContract@fixed` - select the ReviewContract interaction which is tagged with 'fixed' tag.
+ *
+ * @param client
+ * @param interaction
+ * @param payload
+ * @param onChunk
+ * @returns
+ */
+export async function executeInteractionByName<P = any, R = any>(client: ComposableClient,
+    interaction: string,
+    payload: InteractionExecutionPayload = {},
+    onChunk?: (chunk: string) => void): Promise<ExecutionRun<P, R>> {
+    const stream = !!onChunk;
+    const response = await client.post('/api/v1/execute', {
+        payload: {
+            ...payload,
+            interaction,
+            stream
+        } as NamedInteractionExecutionPayload,
+    });
+    if (stream) {
+        if (response.status === ExecutionRunStatus.failed) {
+            return response;
+        }
+        await handleStreaming(client, response.id, onChunk);
+    }
+    return response;
+}
+
+function handleStreaming(client: ComposableClient, runId: string, onChunk: (chunk: string) => void) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const EventSourceImpl = await EventSourceProvider();
+            const streamUrl = new URL(client.runs.baseUrl + '/' + runId + '/stream');
+            const bearerToken = client._auth ? await client._auth() : undefined;
+
+            if (bearerToken) {
+                const token = bearerToken.split(' ')[1];
+                streamUrl.searchParams.set('access_token', token);
+            } else {
+                throw new Error('No auth token available');
+            }
+
+            const sse = new EventSourceImpl(streamUrl.href);
+            sse.addEventListener("message", ev => {
+                try {
+                    const data = JSON.parse(ev.data);
+                    if (data) {
+                        onChunk && onChunk(data);
+                    }
+                } catch (err) {
+                    reject(err);
+                }
+            });
+            sse.addEventListener("close", (ev) => {
+                try {
+                    sse.close();
+                    const msg = JSON.parse(ev.data)
+                    resolve(msg);
+                } catch (err) {
+                    reject(err);
+                }
+            });
+        } catch (err) {
+            reject(err);
+        }
+    });
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './InteractionBase.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/store/CommandsApi.ts

@@ -0,0 +1,42 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import { EmbeddingsStatusResponse, GenericCommandResponse, ProjectConfigurationEmbeddings, SupportedEmbeddingTypes } from "@vertesia/common";
+
+
+export class CommandsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/commands");
+    }
+
+    embeddings = new EmbeddingsApi(this);
+
+}
+
+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/FilesApi.ts

@@ -0,0 +1,139 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import { GetFileUrlPayload, GetFileUrlResponse, GetUploadUrlPayload } from "@vertesia/common";
+import { StreamSource } from "../StreamSource.js";
+
+export const MEMORIES_PREFIX = 'memories';
+
+export function getMemoryFilePath(name: string) {
+    const nameWithExt = name.endsWith(".tar.gz") ? name : name + ".tar.gz";
+    return `${MEMORIES_PREFIX}/${nameWithExt}`;
+}
+
+
+export class FilesApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/files");
+    }
+
+    /**
+     * get the metadata of a blob given its URI. Supported URI are:
+     * starting with s3:// and gs://.
+     * For s3 blobs use #region to specify the region. Ex: s3://bucket/key#us-west-2
+     * @param uri
+     * @returns
+     */
+    getMetadata(uri: string): Promise<{
+        name: string,
+        size: number,
+        contentType: string,
+        contentDisposition?:
+        string,
+        etag?: string
+    }> {
+        return this.get("/metadata", {
+            query: {
+                file: uri
+            }
+        });
+    }
+
+    /**
+     * Get or create a bucket for the project. If the bucket already exists, it does nothing.
+     * The bucket URI is returned.
+     * @returns
+     */
+    getOrCreateBucket(): Promise<{ bucket: string }> {
+        return this.post('/bucket');
+    }
+
+    getUploadUrl(payload: GetUploadUrlPayload): Promise<GetFileUrlResponse> {
+        return this.post('/upload-url', {
+            payload
+        })
+    }
+
+    getDownloadUrl(file: string): Promise<GetFileUrlResponse> {
+        return this.post('/download-url', {
+            payload: {
+                file
+            } satisfies GetFileUrlPayload
+        })
+    }
+
+    /**
+     * Upload content to a file and return the full path (including bucket name) of the uploaded file
+     * @param source
+     * @returns
+     */
+    async uploadFile(source: StreamSource | File): Promise<string> {
+        const isStream = source instanceof StreamSource;
+        const { url, path } = await this.getUploadUrl(source);
+
+        await fetch(url, {
+            method: 'PUT',
+            body: isStream ? source.stream : source,
+            //@ts-ignore: duplex is not in the types. See https://github.com/node-fetch/node-fetch/issues/1769
+            duplex: isStream ? "half" : undefined,
+            headers: {
+                'Content-Type': source.type || 'application/gzip'
+            }
+        }).then((res: Response) => {
+            if (res.ok) {
+                return res;
+            } else {
+                console.log(res);
+                throw new Error(`Failed to upload file: ${res.statusText}`);
+            }
+        }).catch(err => {
+            console.error('Failed to upload file', err);
+            throw err;
+        });
+
+        return path;
+    }
+
+    async downloadFile(name: string): Promise<ReadableStream<Uint8Array>> {
+        const { url } = await this.getDownloadUrl(name);
+
+        const res = await fetch(url, {
+            method: 'GET',
+        }).then((res: Response) => {
+            if (res.ok) {
+                return res;
+            } else {
+                console.log(res);
+                throw new Error(`Failed to download file ${name}: ${res.statusText}`);
+            }
+        }).catch(err => {
+            console.error(`Failed to download file ${name}.`, err);
+            throw err;
+        });
+
+        if (!res.body) {
+            throw new Error(`No body in response while downloading memory pack ${name}`);
+        }
+
+        return res.body;
+    }
+
+    async uploadMemoryPack(source: StreamSource | File): Promise<string> {
+        const fileId = getMemoryFilePath(source.name);
+        const nameWithExt = source.name.endsWith(".tar.gz") ? source.name : source.name + ".tar.gz";
+        if (source instanceof File) {
+            let file = source as File;
+            return this.uploadFile(new StreamSource(file.stream(), nameWithExt, file.type, fileId));
+        } else {
+            return this.uploadFile(new StreamSource(source.stream, nameWithExt, source.type, fileId));
+        }
+    }
+
+    async downloadMemoryPack(name: string, gunzip: boolean = false): Promise<ReadableStream<Uint8Array>> {
+        let stream = await this.downloadFile(getMemoryFilePath(name));
+        if (gunzip) {
+            const ds = new DecompressionStream("gzip");
+            stream = stream.pipeThrough(ds);
+        }
+        return stream;
+    }
+}

package/src/store/ObjectsApi.ts

@@ -0,0 +1,245 @@
+import { ApiTopic, ClientBase } from '@vertesia/api-fetch-client';
+import { ComplexSearchPayload, ComputeObjectFacetPayload, ContentObject, ContentObjectItem, ContentSource, CreateContentObjectPayload, Embedding, ExportPropertiesPayload, ExportPropertiesResponse, FindPayload, GetFileUrlPayload, GetFileUrlResponse, GetRenditionResponse, GetUploadUrlPayload, ListWorkflowRunsResponse, ObjectSearchPayload, ObjectSearchQuery, SupportedEmbeddingTypes } from '@vertesia/common';
+
+import { StreamSource } from '../StreamSource.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 }[];
+    status?: { _id: string, count: number }[];
+    total?: { count: number }[];
+}
+
+export class ObjectsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/objects");
+    }
+
+    getUploadUrl(payload: GetUploadUrlPayload): Promise<GetFileUrlResponse> {
+        return this.post('/upload-url', {
+            payload
+        })
+    }
+
+    getDownloadUrl(fileUri: string): Promise<{ url: string }> {
+        return this.post('/download-url', {
+            payload: {
+                file: fileUri
+            } satisfies GetFileUrlPayload
+        })
+    }
+
+    getContentSource(objectId: string): Promise<ContentSource> {
+        return this.get(`/${objectId}/content-source`);
+    }
+
+    list(payload: ObjectSearchPayload = {}): Promise<ContentObjectItem[]> {
+        const limit = payload.limit || 100;
+        const offset = payload.offset || 0;
+        const query = payload.query || {} as ObjectSearchQuery;
+
+        return this.get("/", {
+            query: {
+                limit,
+                offset,
+                ...query
+            }
+        });
+    }
+
+    computeFacets(query: ComputeObjectFacetPayload): Promise<ComputeFacetsResponse> {
+        return this.post("/facets", {
+            payload: query
+        });
+    }
+
+    listFolders(path: string = '/') {
+        path;//TODO
+    }
+
+    find(payload: FindPayload): Promise<ContentObject[]> {
+        return this.post("/find", {
+            payload
+        });
+    }
+
+    search(payload: ComplexSearchPayload): Promise<ContentObjectItem[]> {
+        return this.post("/search", {
+            payload
+        });
+    }
+
+    retrieve(id: string, select?: string): Promise<ContentObject> {
+        return this.get(`/${id}`, {
+            query: {
+                select
+            }
+        });
+    }
+
+    getObjectText(id: string): Promise<{ text: string }> {
+        return this.get(`/${id}/text`);
+    }
+
+    async upload(source: StreamSource | File) {
+        const isStream = source instanceof StreamSource;
+        // get a signed URL to upload the file a computed mimeType and the file object id.
+        const { url, id, mime_type } = await this.getUploadUrl({
+            id: isStream ? source.id : undefined,
+            name: source.name,
+            mime_type: source.type
+        });
+
+        console.log(`Uploading file to ${url}`, { id, mime_type, isStream, source })
+
+        // upload the file content to the signed URL
+        /*const res = await this.fetch(url, {
+            method: 'PUT',
+            //@ts-ignore: duplex is not in the types. See https://github.com/node-fetch/node-fetch/issues/1769
+            duplex: isStream ? "half" : undefined,
+            body: isStream ? source.stream : source,
+            headers: {
+                'Content-Type': mime_type || 'application/octet-stream'
+            }
+        }).then((res: Response) => {
+            if (res.ok) {
+                return res;
+            } else {
+                console.log(res);
+                throw new Error(`Failed to upload file: ${res.statusText}`);
+            }
+        });*/
+
+        const res = await fetch(url, {
+            method: 'PUT',
+            body: isStream ? source.stream : source,
+            //@ts-ignore: duplex is not in the types. See https://github.com/node-fetch/node-fetch/issues/1769
+            duplex: isStream ? "half" : undefined,
+            headers: {
+                'Content-Type': mime_type || 'application/octet-stream'
+            }
+        }).then((res: Response) => {
+            if (res.ok) {
+                return res;
+            } else {
+                console.log(res);
+                throw new Error(`Failed to upload file: ${res.statusText}`);
+            }
+        }).catch(err => {
+            console.error('Failed to upload file', err);
+            throw err;
+        });
+
+
+        return {
+            source: id,
+            name: source.name,
+            type: mime_type,
+            etag: res.headers.get('etag') ?? undefined
+        }
+    }
+
+    async create(payload: UploadContentObjectPayload): Promise<ContentObject> {
+
+        const createPayload: CreateContentObjectPayload = {
+            ...payload
+        };
+        if (payload.content instanceof StreamSource || payload.content instanceof File) {
+            createPayload.content = await this.upload(payload.content);
+        }
+        return await this.post('/', {
+            payload: createPayload
+        });
+    }
+
+    /**
+     * Create an object which holds a reference to an external blob (i.e. not in the project bucket)
+     * The uri should starts either with gs:// or s3://. Not other protocols are supported yet.
+     * For the s3 blobs you must use a hash with the blob #region. Ex: s3://bucket/path/to/file#us-east-1
+     * @param uri
+     * @param payload
+     * @returns
+     */
+    async createFromExternalSource(uri: string, payload: CreateContentObjectPayload = {}): Promise<ContentObject> {
+        const metadata = await ((this.client as ZenoClient).files.getMetadata(uri));
+        const createPayload: CreateContentObjectPayload = {
+            ...payload,
+            content: {
+                source: uri,
+                name: metadata.name,
+                type: metadata.contentType,
+                etag: metadata.etag
+            }
+        };
+        return await this.post('/', {
+            payload: createPayload
+        });
+    }
+
+    update(id: string, payload: Partial<CreateContentObjectPayload>): Promise<ContentObject> {
+        return this.put(`/${id}`, {
+            payload
+        });
+    }
+
+    delete(id: string): Promise<{ id: string }> {
+        return this.del(`/${id}`);
+    }
+
+    listWorkflowRuns(documentId: string): Promise<ListWorkflowRunsResponse> {
+
+        return this.get(`/${documentId}/workflow-runs`)
+
+    }
+
+    listRenditions(documentId: string): Promise<ContentObjectItem[]> {
+        return this.get(`/${documentId}/renditions`);
+    }
+
+    getRendition(documentId: string, options: GetRenditionParams): Promise<GetRenditionResponse> {
+
+        const query = {
+            max_hw: options.max_hw,
+            generate_if_missing: options.generate_if_missing
+        }
+
+        return this.get(`/${documentId}/renditions/${options.format}`, { query });
+    }
+
+    exportProperties(payload: ExportPropertiesPayload): Promise<ExportPropertiesResponse> {
+        return this.post("/export", {
+            payload
+        });
+    }
+
+    setEmbedding(id: string, type: SupportedEmbeddingTypes, payload: Embedding): Promise<Record<SupportedEmbeddingTypes, Embedding>> {
+        return this.put(`/${id}/embeddings/${type}`, {
+            payload
+        });
+    }
+
+}
+
+interface GetRenditionParams {
+    format: string;
+    max_hw?: number;
+    generate_if_missing?: boolean;
+}

package/src/store/TypesApi.ts

@@ -0,0 +1,61 @@
+import { ContentObjectType, ContentObjectTypeItem, ContentObjectTypeLayout, CreateContentObjectTypePayload, FindPayload, ObjectTypeSearchQuery, ObjectTypeSearchPayload } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+
+export class TypesApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/types");
+    }
+
+    list(payload: ObjectTypeSearchPayload = {}): Promise<ContentObjectTypeItem[]> {
+        const limit = payload.limit || 100;
+        const offset = payload.offset || 0;
+        const query = payload.query || {} as ObjectTypeSearchQuery;
+
+        return this.get("/", {
+            query: {
+                limit,
+                offset,
+                ...query
+            }
+        });
+    }
+
+    find(payload: FindPayload): Promise<ContentObjectType[]> {
+        return this.post("/find", {
+            payload
+        });
+    }
+
+    layouts(): Promise<ContentObjectTypeLayout[]> {
+        return this.get('/', {
+            query: { layout: true }
+        });
+    }
+
+    retrieve(typeId: string): Promise<ContentObjectType> {
+        return this.get(`/${typeId}`);
+    }
+
+    getTypeByName(typeName: string): Promise<ContentObjectType> {
+        return this.get(`/name/${typeName}`);
+    }
+
+    update(typeId: string, payload: Partial<CreateContentObjectTypePayload>): Promise<ContentObjectType> {
+        return this.put(`/${typeId}`, {
+            payload
+        });
+    }
+
+    create(payload: CreateContentObjectTypePayload): Promise<ContentObjectType> {
+        return this.post(`/`, {
+            payload
+        });
+    }
+
+    delete(id: string) {
+        return this.del(`/${id}`);
+    }
+
+}