@vertesia/client 0.50.1 → 0.53.0

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

@@ -0,0 +1,61 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+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) {
+        super(parent, `/${objectId}/analyze`);
+    }
+
+    async start(payload: PdfToRichtextOptions): Promise<DocAnalyzeRunStatusResponse> {
+        return this.post("/", { payload });
+    }
+
+    async getStatus(): Promise<DocAnalyzeRunStatusResponse> {
+        return this.get("/status");
+    }
+
+    async getResults(): Promise<DocAnalyzerResultResponse> {
+        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(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("/images");
+    }
+
+    async getAnnotated(): Promise<{ url: string }> {
+        return this.get("/annotated");
+    }
+}

package/src/store/CollectionsApi.ts

@@ -0,0 +1,93 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import { Collection, CollectionItem, CollectionSearchPayload, ComplexSearchPayload, ComputeObjectFacetPayload, ContentObjectItem, ContentObjectStatus, CreateCollectionPayload, DynamicCollection } from "@vertesia/common";
+import { ComputeFacetsResponse } from "./ObjectsApi.js";
+
+
+export class CollectionsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/collections");
+    }
+
+    /**
+     * List collections
+     * @param payload
+     * @returns
+     */
+    list(payload: CollectionSearchPayload = {}): Promise<CollectionItem[]> {
+        return this.get("/", {
+            query: {
+                limit: 100,
+                offset: 0,
+                ...payload
+            }
+        });
+    }
+
+    /**
+     * Get the collection data without members
+     * @param collectionId
+     * @returns
+     */
+    retrieve(collectionId: string): Promise<Collection | DynamicCollection> {
+        return this.get(`/${collectionId}`);
+    }
+
+    create(payload: CreateCollectionPayload): Promise<Collection> {
+        return this.post(`/`, {
+            payload
+        });
+    }
+
+    update(collectionId: string, payload: Partial<CreateCollectionPayload>): Promise<{ id: string }> {
+        return this.put(`/${collectionId}`, {
+            payload
+        });
+    }
+
+    addMembers(collectionId: string, members: string[]): Promise<{ id: string }> {
+        return this.post(`/${collectionId}/members`, {
+            payload: {
+                action: 'add',
+                members
+            }
+        });
+    }
+
+    listMembers(collectionId: string, payload: {
+        limit?: number,
+        offset?: number,
+        status?: ContentObjectStatus,
+        type?: string,
+    }): Promise<ContentObjectItem[]> {
+        return this.get(`/${collectionId}/members`, {
+            query: {
+                ...payload
+            }
+        });
+    }
+
+    computeFacets(collectionId: string, query: ComputeObjectFacetPayload): Promise<ComputeFacetsResponse> {
+        return this.post(`/${collectionId}/facets`, {
+            payload: query
+        });
+    }
+
+    searchMembers(collectionId: string, payload: ComplexSearchPayload): Promise<ContentObjectItem[]> {
+        return this.post(`/${collectionId}/search`, { payload });
+    }
+
+    deleteMembers(collectionId: string, members: string[]): Promise<{ id: string }> {
+        return this.post(`/${collectionId}/members`, {
+            payload: {
+                action: 'delete',
+                members
+            }
+        });
+    }
+
+    delete(id: string) {
+        return this.del(`/${id}`);
+    }
+
+}

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}`);

package/src/store/ObjectsApi.ts

@@ -3,6 +3,7 @@ import { ComplexSearchPayload, ComputeObjectFacetPayload, ContentObject, Content
 
 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 | {
@@ -33,6 +34,10 @@ export class ObjectsApi extends ApiTopic {
         super(parent, "/api/v1/objects");
     }
 
+    analyze(objectId: string) {
+        return new AnalyzeDocApi(this, objectId);
+    }
+
     getUploadUrl(payload: GetUploadUrlPayload): Promise<GetFileUrlResponse> {
         return this.post('/upload-url', {
             payload

package/src/store/TypesApi.ts

@@ -1,4 +1,4 @@
-import { ContentObjectType, ContentObjectTypeItem, ContentObjectTypeLayout, CreateContentObjectTypePayload, FindPayload, ObjectTypeSearchQuery, ObjectTypeSearchPayload } from "@vertesia/common";
+import { ContentObjectType, ContentObjectTypeItem, CreateContentObjectTypePayload, FindPayload, ObjectTypeSearchQuery, ObjectTypeSearchPayload } from "@vertesia/common";
 import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
 
 
@@ -8,7 +8,15 @@ export class TypesApi extends ApiTopic {
         super(parent, "/api/v1/types");
     }
 
-    list(payload: ObjectTypeSearchPayload = {}): Promise<ContentObjectTypeItem[]> {
+    /**
+     * The options can be used to include more information in the return objects.
+     * You can specify to also include layout information using `layout: true`.
+     * By default the layout information is not included.
+     * @param payload
+     * @param options
+     * @returns
+     */
+    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;
@@ -17,6 +25,8 @@ export class TypesApi extends ApiTopic {
             query: {
                 limit,
                 offset,
+                layout: options?.layout ? true : false,
+                schema: options?.schema ? true : false,
                 ...query
             }
         });
@@ -28,12 +38,6 @@ export class TypesApi extends ApiTopic {
         });
     }
 
-    layouts(): Promise<ContentObjectTypeLayout[]> {
-        return this.get('/', {
-            query: { layout: true }
-        });
-    }
-
     retrieve(typeId: string): Promise<ContentObjectType> {
         return this.get(`/${typeId}`);
     }

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,11 +2,13 @@ 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";
 import { TypesApi } from "./TypesApi.js";
 import { WorkflowsApi } from "./WorkflowsApi.js";
+import { CollectionsApi } from "./CollectionsApi.js";
 
 export interface ZenoClientProps {
     serverUrl?: string;
@@ -60,4 +62,6 @@ export class ZenoClient extends AbstractFetchClient<ZenoClient> {
     files = new FilesApi(this);
     commands = new CommandsApi(this);
     agents = new AgentsApi(this);
+    collections = new CollectionsApi(this);
+    embeddings = new EmbeddingsApi(this);
 }