@vertesia/client 0.51.0 → 0.54.0

package/src/store/ObjectsApi.ts

@@ -1,35 +1,54 @@
-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';
-import { AnalyzeDocApi } from './AnalyzeDocApi.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
-
-    }
+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";
+import { AnalyzeDocApi } from "./AnalyzeDocApi.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 }[];
+    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");
     }
@@ -39,64 +58,85 @@ export class ObjectsApi extends ApiTopic {
     }
 
     getUploadUrl(payload: GetUploadUrlPayload): Promise<GetFileUrlResponse> {
-        return this.post('/upload-url', {
-            payload
-        })
+        return this.post("/upload-url", {
+            payload,
+        });
     }
 
     getDownloadUrl(fileUri: string): Promise<{ url: string }> {
-        return this.post('/download-url', {
+        return this.post("/download-url", {
             payload: {
-                file: fileUri
-            } satisfies GetFileUrlPayload
-        })
+                file: fileUri,
+            } satisfies GetFileUrlPayload,
+        });
     }
 
     getContentSource(objectId: string): Promise<ContentSource> {
         return this.get(`/${objectId}/content-source`);
     }
 
-    list(payload: ObjectSearchPayload = {}): Promise<ContentObjectItem[]> {
+    /**
+     * List objects with revision filtering options
+     *
+     * @param payload Search/filter parameters
+     * @returns Matching content objects
+     */
+    list<T = any>(payload: ObjectSearchPayload = {}): Promise<ContentObjectItem<T>[]> {
         const limit = payload.limit || 100;
         const offset = payload.offset || 0;
-        const query = payload.query || {} as ObjectSearchQuery;
+        const query = payload.query || ({} as ObjectSearchQuery);
+
+        // Add revision filtering options
+        const showAllRevisions = payload.show_all_revisions === true;
+        const revisionRoot = payload.from_root;
 
         return this.get("/", {
             query: {
                 limit,
                 offset,
-                ...query
-            }
+                ...query,
+                show_all_revisions: showAllRevisions ? "true" : undefined,
+                from_root: revisionRoot,
+            },
         });
     }
 
     computeFacets(query: ComputeObjectFacetPayload): Promise<ComputeFacetsResponse> {
         return this.post("/facets", {
-            payload: query
+            payload: query,
         });
     }
 
-    listFolders(path: string = '/') {
-        path;//TODO
+    listFolders(path: string = "/") {
+        path; //TODO
     }
 
+    /** Find object based on query */
     find(payload: FindPayload): Promise<ContentObject[]> {
         return this.post("/find", {
-            payload
+            payload,
         });
     }
 
+    /** Count number of objects matching this query */
+    count(payload: FindPayload): Promise<{ count: number }> {
+        return this.post("/count", {
+            payload,
+        });
+    }
+
+    /** Search object — different from find because allow full text search */
     search(payload: ComplexSearchPayload): Promise<ContentObjectItem[]> {
         return this.post("/search", {
-            payload
+            payload,
         });
     }
 
     retrieve(id: string, select?: string): Promise<ContentObject> {
         return this.get(`/${id}`, {
             query: {
-                select
-            }
+                select,
+            },
         });
     }
 
@@ -110,10 +150,10 @@ export class ObjectsApi extends ApiTopic {
         const { url, id, mime_type } = await this.getUploadUrl({
             id: isStream ? source.id : undefined,
             name: source.name,
-            mime_type: source.type
+            mime_type: source.type,
         });
 
-        console.log(`Uploading file to ${url}`, { id, mime_type, isStream, source })
+        console.log(`Uploading content to ${url}`, { id, mime_type, isStream, source });
 
         // upload the file content to the signed URL
         /*const res = await this.fetch(url, {
@@ -134,44 +174,50 @@ export class ObjectsApi extends ApiTopic {
         });*/
 
         const res = await fetch(url, {
-            method: 'PUT',
+            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;
-        });
-
+                "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;
+            });
+
+        //Etag need to be unquoted
+        //When a server returns an ETag header, it includes the quotes around the actual hash value.
+        //This is part of the HTTP specification (RFC 7232), which states that ETags should be
+        //enclosed in double quotes.
+        const etag = res.headers.get("etag")?.replace(/^"(.*)"$/, "$1");
 
         return {
             source: id,
             name: source.name,
             type: mime_type,
-            etag: res.headers.get('etag') ?? undefined
-        }
+            etag,
+        };
     }
 
     async create(payload: UploadContentObjectPayload): Promise<ContentObject> {
-
         const createPayload: CreateContentObjectPayload = {
-            ...payload
+            ...payload,
         };
         if (payload.content instanceof StreamSource || payload.content instanceof File) {
             createPayload.content = await this.upload(payload.content);
         }
-        return await this.post('/', {
-            payload: createPayload
+        return await this.post("/", {
+            payload: createPayload,
         });
     }
 
@@ -184,25 +230,72 @@ export class ObjectsApi extends ApiTopic {
      * @returns
      */
     async createFromExternalSource(uri: string, payload: CreateContentObjectPayload = {}): Promise<ContentObject> {
-        const metadata = await ((this.client as ZenoClient).files.getMetadata(uri));
+        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
-            }
+                etag: metadata.etag,
+            },
         };
-        return await this.post('/', {
-            payload: createPayload
+        return await this.post("/", {
+            payload: createPayload,
         });
     }
 
-    update(id: string, payload: Partial<CreateContentObjectPayload>): Promise<ContentObject> {
-        return this.put(`/${id}`, {
-            payload
-        });
+    /**
+     * Updates an existing object or creates a new revision
+     * Handles file uploads similar to the create method
+     *
+     * @param id The ID of the object to update
+     * @param payload The changes to apply
+     * @param options Additional options
+     * @param options.createRevision Whether to create a new revision instead of updating in place
+     * @param options.revisionLabel Optional label for the revision (e.g., "v1.2")
+     * @returns The updated object or newly created revision
+     */
+    async update(
+        id: string,
+        payload: Partial<CreateContentObjectPayload>,
+        options?: {
+            createRevision?: boolean;
+            revisionLabel?: string;
+        },
+    ): Promise<ContentObject> {
+        const updatePayload: Partial<CreateContentObjectPayload> = {
+            ...payload,
+        };
+
+        // Handle file upload if content is provided as File or StreamSource
+        if (payload.content instanceof StreamSource || payload.content instanceof File) {
+            updatePayload.content = await this.upload(payload.content);
+        }
+
+        if (options?.createRevision) {
+            return this.put(`/${id}`, {
+                payload: updatePayload,
+                headers: {
+                    "x-create-revision": "true",
+                    "x-revision-label": options.revisionLabel || "",
+                },
+            });
+        } else {
+            return this.put(`/${id}`, {
+                payload: updatePayload,
+            });
+        }
+    }
+
+    /**
+     * Retrieves all revisions of a content object
+     *
+     * @param id The ID of any revision in the object's history
+     * @returns Array of all revisions sharing the same root
+     */
+    getRevisions(id: string): Promise<ContentObjectItem[]> {
+        return this.get(`/${id}/revisions`);
     }
 
     delete(id: string): Promise<{ id: string }> {
@@ -210,9 +303,7 @@ export class ObjectsApi extends ApiTopic {
     }
 
     listWorkflowRuns(documentId: string): Promise<ListWorkflowRunsResponse> {
-
-        return this.get(`/${documentId}/workflow-runs`)
-
+        return this.get(`/${documentId}/workflow-runs`);
     }
 
     listRenditions(documentId: string): Promise<ContentObjectItem[]> {
@@ -220,31 +311,33 @@ export class ObjectsApi extends ApiTopic {
     }
 
     getRendition(documentId: string, options: GetRenditionParams): Promise<GetRenditionResponse> {
-
         const query = {
             max_hw: options.max_hw,
-            generate_if_missing: options.generate_if_missing
-        }
+            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
+            payload,
         });
     }
 
-    setEmbedding(id: string, type: SupportedEmbeddingTypes, payload: Embedding): Promise<Record<SupportedEmbeddingTypes, Embedding>> {
+    setEmbedding(
+        id: string,
+        type: SupportedEmbeddingTypes,
+        payload: Embedding,
+    ): Promise<Record<SupportedEmbeddingTypes, Embedding>> {
         return this.put(`/${id}/embeddings/${type}`, {
-            payload
+            payload,
         });
     }
-
 }
 
 interface GetRenditionParams {
     format: string;
     max_hw?: number;
     generate_if_missing?: boolean;
-}
+}

package/src/store/TypesApi.ts

@@ -16,7 +16,7 @@ export class TypesApi extends ApiTopic {
      * @param options
      * @returns
      */
-    list(payload: ObjectTypeSearchPayload = {}, options?: { layout: boolean }): Promise<ContentObjectTypeItem[]> {
+    list(payload: ObjectTypeSearchPayload = {}, options?: { layout?: boolean, schema?: boolean }): Promise<ContentObjectTypeItem[]> {
         const limit = payload.limit || 100;
         const offset = payload.offset || 0;
         const query = payload.query || {} as ObjectTypeSearchQuery;
@@ -26,6 +26,7 @@ export class TypesApi extends ApiTopic {
                 limit,
                 offset,
                 layout: options?.layout ? true : false,
+                schema: options?.schema ? true : false,
                 ...query
             }
         });

package/src/store/WorkflowsApi.ts

@@ -1,8 +1,23 @@
-import { ApiTopic, ClientBase } from '@vertesia/api-fetch-client';
-import { ActivityCatalog, CreateWorkflowRulePayload, DSLWorkflowDefinition, DSLWorkflowSpec, ExecuteWorkflowPayload, ListWorkflowRunsPayload, ListWorkflowRunsResponse, WorkflowDefinitionRef, WorkflowRule, WorkflowRuleItem, WorkflowRunWithDetails } from '@vertesia/common';
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import {
+    ActivityCatalog,
+    AgentMessage,
+    AgentMessageType,
+    CreateWorkflowRulePayload,
+    DSLWorkflowDefinition,
+    DSLWorkflowSpec,
+    ExecuteWorkflowPayload,
+    ListWorkflowRunsPayload,
+    ListWorkflowRunsResponse,
+    WorkflowDefinitionRef,
+    WorkflowRule,
+    WorkflowRuleItem,
+    WorkflowRunWithDetails,
+} from "@vertesia/common";
+import { VertesiaClient } from "../client.js";
+import { EventSourceProvider } from "../execute.js";
 
 export class WorkflowsApi extends ApiTopic {
-
     constructor(parent: ClientBase) {
         super(parent, "/api/v1/workflows");
     }
@@ -19,53 +34,142 @@ export class WorkflowsApi extends ApiTopic {
         return this.post(`/runs`, { payload: payload });
     }
 
+    sendSignal(workflowId: string, runId: string, signal: string, payload?: any): Promise<{ message: string }> {
+        return this.post(`/runs/${workflowId}/${runId}/signal/${signal}`, { payload });
+    }
+
     getRunDetails(runId: string, workflowId: string): Promise<WorkflowRunWithDetails> {
-        return this.get(`/runs/${workflowId}/${runId}`, { query: { workflowId } });
+        return this.get(`/runs/${workflowId}/${runId}`);
     }
 
     terminate(workflowId: string, runId: string, reason?: string): Promise<{ message: string }> {
-        return this.post(`/runs/${workflowId}/${runId}/terminate`, { payload: { reason } });
+        return this.post(`/runs/${workflowId}/${runId}/actions/terminate`, { payload: { reason } });
     }
 
     cancel(workflowId: string, runId: string, reason?: string): Promise<{ message: string }> {
-        return this.post(`/runs/${workflowId}/${runId}/cancel`, { payload: { reason } });
+        return this.post(`/runs/${workflowId}/${runId}/actions/cancel`, { payload: { reason } });
     }
 
-    execute(name: string, payload: ExecuteWorkflowPayload = {}): Promise<{ runIds: string[] }> {
+    execute(
+        name: string,
+        payload: ExecuteWorkflowPayload = {},
+    ): Promise<({ run_id: string; workflow_id: string } | undefined)[]> {
         return this.post(`/execute/${name}`, { payload });
     }
 
+    postMessage(runId: string, message: string, type?: AgentMessageType, details?: any): Promise<void> {
+        if (!runId) {
+            throw new Error("runId is required");
+        }
+        const payload = {
+            message,
+            type,
+            details,
+        };
+        return this.post(`/runs/${runId}/updates`, { payload });
+    }
+
+    retrieveMessages(runId: string, since?: number): Promise<AgentMessage[]> {
+        const query = {
+            since,
+        };
+        return this.get(`/runs/${runId}/updates`, { query });
+    }
+
+    streamMessages(runId: string, onMessage?: (message: AgentMessage) => void, since?: number): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const EventSourceImpl = await EventSourceProvider();
+                const client = this.client as VertesiaClient;
+                const streamUrl = new URL(client.workflows.baseUrl + "/runs/" + runId + "/stream");
+
+                if (since) {
+                    streamUrl.searchParams.set("since", since.toString());
+                }
+
+                const bearerToken = client._auth ? await client._auth() : undefined;
+                if (!bearerToken) return reject(new Error("No auth token available"));
+
+                const token = bearerToken.split(" ")[1];
+                streamUrl.searchParams.set("access_token", token);
+
+                const sse = new EventSourceImpl(streamUrl.href);
+                let isClosed = false;
+
+                sse.onmessage = (ev: MessageEvent) => {
+                    if (!ev.data || ev.data.startsWith(":")) {
+                        console.log("Received comment or heartbeat; ignoring it.: ", ev.data);
+                        return;
+                    }
+
+                    try {
+                        const message = JSON.parse(ev.data) as AgentMessage;
+                        if (onMessage) onMessage(message);
+
+                        if (message.type === AgentMessageType.COMPLETE) {
+                            sse.close();
+                            isClosed = true;
+                            resolve();
+                        }
+                    } catch (err) {
+                        console.error("Failed to parse SSE message:", err, ev.data);
+                    }
+                };
+
+                sse.onerror = (err: any) => {
+                    if (!isClosed) {
+                        console.error("SSE stream error:", err);
+                        sse.close();
+                        reject(err);
+                    }
+                };
+
+                // Prevent Node from exiting prematurely
+                const interval = setInterval(() => { }, 1000);
+
+                // Cleanup when stream resolves
+                const cleanup = () => {
+                    clearInterval(interval);
+                };
+
+                // Attach cleanup
+                sse.addEventListener("close", () => {
+                    isClosed = true;
+                    cleanup();
+                    resolve();
+                });
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+
     rules = new WorkflowsRulesApi(this);
     definitions = new WorkflowsDefinitionApi(this);
-
 }
 
-
 export class WorkflowsRulesApi extends ApiTopic {
-
     constructor(parent: WorkflowsApi) {
         super(parent, "/rules");
     }
 
-
     list(): Promise<WorkflowRuleItem[]> {
         return this.get("/");
     }
 
-
     retrieve(id: string): Promise<WorkflowRule> {
         return this.get(`/${id}`);
     }
 
     update(id: string, payload: any): Promise<WorkflowRule> {
         return this.put(`/${id}`, {
-            payload
+            payload,
         });
     }
 
     create(payload: CreateWorkflowRulePayload): Promise<WorkflowRule> {
         return this.post("/", {
-            payload
+            payload,
         });
     }
 
@@ -73,19 +177,20 @@ export class WorkflowsRulesApi extends ApiTopic {
         return this.del(`/${id}`);
     }
 
-
-    execute(id: string, objectIds?: string[], vars?: Record<string, any>): Promise<{ runIds: string[] }> {
+    execute(
+        id: string,
+        objectIds?: string[],
+        vars?: Record<string, any>,
+    ): Promise<({ run_id: string; workflow_id: string } | undefined)[]> {
         const payload: ExecuteWorkflowPayload = {
             objectIds,
-            vars
+            vars,
         };
         return this.post(`/${id}/execute`, { payload });
     }
-
 }
 
 export class WorkflowsDefinitionApi extends ApiTopic {
-
     //model: DSLWorkflowDefinition;
 
     constructor(parent: WorkflowsApi) {
@@ -96,26 +201,23 @@ export class WorkflowsDefinitionApi extends ApiTopic {
         return this.get("/");
     }
 
-
     retrieve(id: string): Promise<DSLWorkflowDefinition> {
         return this.get(`/${id}`);
     }
 
     update(id: string, payload: any): Promise<DSLWorkflowDefinition> {
         return this.put(`/${id}`, {
-            payload
+            payload,
         });
     }
 
     create(payload: DSLWorkflowSpec): Promise<DSLWorkflowDefinition> {
         return this.post("/", {
-            payload
+            payload,
         });
     }
 
     delete(id: string) {
         return this.del(`/${id}`);
     }
-
-
-}
+}

package/src/store/client.ts

@@ -2,6 +2,7 @@ import { AbstractFetchClient, RequestError } from "@vertesia/api-fetch-client";
 import { BulkOperationPayload, BulkOperationResult } from "@vertesia/common";
 import { AgentsApi } from "./AgentsApi.js";
 import { CommandsApi } from "./CommandsApi.js";
+import { EmbeddingsApi } from "./EmbeddingsApi.js";
 import { ZenoClientNotFoundError } from "./errors.js";
 import { FilesApi } from "./FilesApi.js";
 import { ObjectsApi } from "./ObjectsApi.js";
@@ -62,4 +63,5 @@ export class ZenoClient extends AbstractFetchClient<ZenoClient> {
     commands = new CommandsApi(this);
     agents = new AgentsApi(this);
     collections = new CollectionsApi(this);
+    embeddings = new EmbeddingsApi(this);
 }