@vertesia/workflow 0.45.2 → 0.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/workflow",
-  "version": "0.45.2",
+  "version": "0.46.0",
   "type": "module",
   "description": "Composable prompts workflow dsl",
   "main": "./lib/esm/index.js",
@@ -49,9 +49,9 @@
     "tiktoken": "^1.0.15",
     "tmp": "^0.2.3",
     "yaml": "^2.6.0",
-    "@vertesia/common": "0.45.2",
+    "@vertesia/common": "0.46.0",
     "@llumiverse/core": "0.15.0",
-    "@vertesia/client": "0.45.2"
+    "@vertesia/client": "0.46.0"
   },
   "ts_dual_module": {
     "outDir": "lib",

package/src/activities/executeInteraction.ts

@@ -1,4 +1,4 @@
-import { ComposableClient } from "@vertesia/client";
+import { VertesiaClient } from "@vertesia/client";
 import { DSLActivityExecutionPayload, DSLActivitySpec, ExecutionRun, ExecutionRunStatus, InteractionExecutionConfiguration, RunSearchPayload } from "@vertesia/common";
 import { activityInfo, log } from "@temporalio/activity";
 import { projectResult } from "../dsl/projections.js";
@@ -53,7 +53,7 @@ const JSON: DSLActivitySpec = {
     }
 }
 
-export interface InteractionExecutionParams extends ModelOptions{
+export interface InteractionExecutionParams extends ModelOptions {
     /**
      * The environment to use. If not specified the project default environment will be used.
      * If the latter is not specified an exeption will be thrown.
@@ -117,7 +117,7 @@ export async function executeInteraction(payload: DSLActivityExecutionPayload) {
 
 }
 
-export async function executeInteractionFromActivity(client: ComposableClient, interactionName: string, params: InteractionExecutionParams, prompt_data: any, debug?: boolean) {
+export async function executeInteractionFromActivity(client: VertesiaClient, interactionName: string, params: InteractionExecutionParams, prompt_data: any, debug?: boolean) {
     const userTags = params.tags;
     const info = activityInfo();
     const runId = info.workflowExecution.runId;

package/src/activities/generateEmbeddings.ts

@@ -1,4 +1,4 @@
-import { ComposableClient } from "@vertesia/client";
+import { VertesiaClient } from "@vertesia/client";
 import { ContentObject, DSLActivityExecutionPayload, DSLActivitySpec, ProjectConfigurationEmbeddings, SupportedEmbeddingTypes } from "@vertesia/common";
 import { EmbeddingsResult } from "@llumiverse/core";
 import { log } from "@temporalio/activity";
@@ -96,7 +96,7 @@ export async function generateEmbeddings(payload: DSLActivityExecutionPayload) {
 
 interface ExecuteGenerateEmbeddingsParams {
     document: ContentObject;
-    client: ComposableClient;
+    client: VertesiaClient;
     type: SupportedEmbeddingTypes;
     config: ProjectConfigurationEmbeddings;
     property?: string;
@@ -297,7 +297,7 @@ async function generateImageEmbeddings({ document, client, type, config }: Execu
 
 }
 
-async function generateEmbeddingsFromStudio(text: string, env: string, client: ComposableClient, model?: string): Promise<EmbeddingsResult> {
+async function generateEmbeddingsFromStudio(text: string, env: string, client: VertesiaClient, model?: string): Promise<EmbeddingsResult> {
 
     log.info(`Generating embeddings for text of ${text.length} chars with environment ${env}`);
 

package/src/dsl/setup/ActivityContext.ts

@@ -1,4 +1,4 @@
-import { ComposableClient } from "@vertesia/client";
+import { VertesiaClient } from "@vertesia/client";
 import { DSLActivityExecutionPayload, DSLWorkflowExecutionPayload, Project, WorkflowExecutionPayload } from "@vertesia/common";
 import { log } from "@temporalio/activity";
 import { NoDocumentFound, WorkflowParamNotFound } from "../../errors.js";
@@ -14,10 +14,10 @@ registerFetchProviderFactory(DocumentTypeProvider.ID, DocumentTypeProvider.facto
 registerFetchProviderFactory(InteractionRunProvider.ID, InteractionRunProvider.factory);
 
 export class ActivityContext<T extends Record<string, any> = Record<string, any>> {
-    client: ComposableClient;
+    client: VertesiaClient;
     _project?: Promise<Project | undefined>;
 
-    constructor(public payload: DSLActivityExecutionPayload, client: ComposableClient, public params: T) {
+    constructor(public payload: DSLActivityExecutionPayload, client: VertesiaClient, public params: T) {
         this.client = client;
         this.fetchProject = this.fetchProject.bind(this);
     }
@@ -100,7 +100,7 @@ export async function setupActivity<T extends Record<string, any> = Record<strin
 }
 
 
-async function _fetchProject(client: ComposableClient, payload: WorkflowExecutionPayload) {
+async function _fetchProject(client: VertesiaClient, payload: WorkflowExecutionPayload) {
     const project = await getProjectFromToken(payload.auth_token);
     return project ? await client.projects.retrieve(project.id) : undefined;
 }

package/src/dsl/setup/fetch/index.ts

@@ -1,16 +1,16 @@
 import { ActivityFetchSpec } from "@vertesia/common";
-import { ComposableClient } from "@vertesia/client";
+import { VertesiaClient } from "@vertesia/client";
 import { DataProvider } from "./DataProvider.js";
 
 
-const factories: Record<string, ((client: ComposableClient, source?: string) => DataProvider)> = {};
+const factories: Record<string, ((client: VertesiaClient, source?: string) => DataProvider)> = {};
 
 
-export function registerFetchProviderFactory(name: string, factory: ((client: ComposableClient) => DataProvider)) {
+export function registerFetchProviderFactory(name: string, factory: ((client: VertesiaClient) => DataProvider)) {
     factories[name] = factory;
 }
 
-export function getFetchProvider(client: ComposableClient, fetchSpec: ActivityFetchSpec) {
+export function getFetchProvider(client: VertesiaClient, fetchSpec: ActivityFetchSpec) {
     const factory = factories[fetchSpec.type];
     if (!factory) {
         throw new Error("Unknown data provider: " + fetchSpec.source);

package/src/dsl/setup/fetch/providers.ts

@@ -1,5 +1,5 @@
 import { FindPayload } from "@vertesia/common";
-import { ComposableClient } from "@vertesia/client";
+import { VertesiaClient } from "@vertesia/client";
 import { DataProvider } from "./DataProvider.js";
 
 function useMongoId(query: Record<string, any>) {
@@ -13,7 +13,7 @@ function useMongoId(query: Record<string, any>) {
 
 export class DocumentProvider extends DataProvider {
     static ID = "document";
-    constructor(public client: ComposableClient) {
+    constructor(public client: VertesiaClient) {
         super(DocumentProvider.ID, true);
     }
 
@@ -24,14 +24,14 @@ export class DocumentProvider extends DataProvider {
         });
     }
 
-    static factory(client: ComposableClient) {
+    static factory(client: VertesiaClient) {
         return new DocumentProvider(client);
     }
 }
 
 export class DocumentTypeProvider extends DataProvider {
     static ID = "document_type";
-    constructor(public client: ComposableClient) {
+    constructor(public client: VertesiaClient) {
         super(DocumentTypeProvider.ID, true);
     }
 
@@ -42,14 +42,14 @@ export class DocumentTypeProvider extends DataProvider {
         });
     }
 
-    static factory(client: ComposableClient) {
+    static factory(client: VertesiaClient) {
         return new DocumentTypeProvider(client);
     }
 }
 
 export class InteractionRunProvider extends DataProvider {
     static ID = "interaction_run";
-    constructor(public client: ComposableClient) {
+    constructor(public client: VertesiaClient) {
         super(DocumentProvider.ID, true);
     }
 
@@ -60,7 +60,7 @@ export class InteractionRunProvider extends DataProvider {
         });
     }
 
-    static factory(client: ComposableClient) {
+    static factory(client: VertesiaClient) {
         return new InteractionRunProvider(client);
     }
 

package/src/dsl/workflow-fetch.test.ts

@@ -1,4 +1,4 @@
-import { ComposableClient } from '@vertesia/client';
+import { VertesiaClient } from '@vertesia/client';
 import { ContentEventName, DSLActivityExecutionPayload, DSLActivitySpec, DSLWorkflowExecutionPayload, FindPayload } from '@vertesia/common';
 import { TestWorkflowEnvironment } from '@temporalio/testing';
 import { Worker } from '@temporalio/worker';
@@ -27,7 +27,7 @@ class DocumentTestProvider extends DataProvider {
         }
     }
 
-    static factory(_context: ComposableClient) {
+    static factory(_context: VertesiaClient) {
         return new DocumentTestProvider();
     }
 }

package/src/iterative-generation/utils.ts

@@ -1,4 +1,4 @@
-import { ComposableClient } from "@vertesia/client";
+import { VertesiaClient } from "@vertesia/client";
 import { ExecutionRun } from "@vertesia/common";
 import { ApplicationFailure } from "@temporalio/workflow";
 import { OutputMemoryMeta, PartIndex, Toc, TocIndex, TocSection } from "./types.js";
@@ -14,7 +14,7 @@ export interface ExecuteOptions {
     result_schema?: Record<string, any>;
 }
 
-export async function execute<T = any>(client: ComposableClient, options: ExecuteOptions): Promise<ExecutionRun<any, T>> {
+export async function execute<T = any>(client: VertesiaClient, options: ExecuteOptions): Promise<ExecutionRun<any, T>> {
     return client.interactions.executeByName(options.interaction, {
         data: {
             ...options.memory_mapping,
@@ -30,7 +30,7 @@ export async function execute<T = any>(client: ComposableClient, options: Execut
     });
 }
 
-export function executeWithVars<T = any>(client: ComposableClient, interaction: string, vars: Record<string, any>, mapping?: Record<string, any>, result_schema?: Record<string, any>): Promise<ExecutionRun<any, T>> {
+export function executeWithVars<T = any>(client: VertesiaClient, interaction: string, vars: Record<string, any>, mapping?: Record<string, any>, result_schema?: Record<string, any>): Promise<ExecutionRun<any, T>> {
     if (mapping) {
         mapping = { ...vars.input_mapping, ...mapping };
     } else {

package/src/utils/blobs.ts

@@ -1,4 +1,4 @@
-import { ComposableClient } from "@vertesia/client";
+import { VertesiaClient } from "@vertesia/client";
 import crypto from "crypto";
 import { createWriteStream } from "fs";
 import tmp from "tmp";
@@ -6,14 +6,14 @@ import { NoDocumentFound } from "../errors.js";
 
 tmp.setGracefulCleanup();
 
-export async function fetchBlobAsStream(client: ComposableClient, blobUri: string): Promise<ReadableStream<Uint8Array>> {
+export async function fetchBlobAsStream(client: VertesiaClient, blobUri: string): Promise<ReadableStream<Uint8Array>> {
     try {
         return await client.files.downloadFile(blobUri);
     } catch (err: any) {
         throw new NoDocumentFound(`Blob ${blobUri} not found`, []);
     }
 }
-export async function fetchBlobAsBuffer(client: ComposableClient, blobUri: string): Promise<Buffer> {
+export async function fetchBlobAsBuffer(client: VertesiaClient, blobUri: string): Promise<Buffer> {
     let stream = await fetchBlobAsStream(client, blobUri);
     const buffers: Uint8Array[] = [];
     for await (const data of stream) {
@@ -22,18 +22,18 @@ export async function fetchBlobAsBuffer(client: ComposableClient, blobUri: strin
     return Buffer.concat(buffers);
 }
 
-export async function fetchBlobAsBase64(client: ComposableClient, blobUri: string): Promise<string> {
+export async function fetchBlobAsBase64(client: VertesiaClient, blobUri: string): Promise<string> {
     const buffer = await fetchBlobAsBuffer(client, blobUri);
     return buffer.toString('base64');
 }
 
-export async function saveBlobToFile(client: ComposableClient, blobUri: string, toFile: string): Promise<void> {
+export async function saveBlobToFile(client: VertesiaClient, blobUri: string, toFile: string): Promise<void> {
     let stream = await fetchBlobAsStream(client, blobUri);
     const out = createWriteStream(toFile);
     await writeChunksToStream(stream, out);
 }
 
-export async function saveBlobToTempFile(client: ComposableClient, blobUri: string, fileExt?: string): Promise<string> {
+export async function saveBlobToTempFile(client: VertesiaClient, blobUri: string, fileExt?: string): Promise<string> {
     const tmpFile = tmp.fileSync({
         prefix: "composable-activity-",
         postfix: fileExt,

package/src/utils/client.ts

@@ -2,7 +2,7 @@
  * get a zeno client for a given token
  */
 
-import { ComposableClient } from "@vertesia/client";
+import { VertesiaClient } from "@vertesia/client";
 import { WorkflowExecutionPayload } from "@vertesia/common";
 
 
@@ -20,7 +20,7 @@ export function getClient(payload: WorkflowExecutionPayload) {
         throw new Error("Content Store URL is missing from WorkflowExecutionPayload.servers.storeUrl");
     }
 
-    const client = new ComposableClient({
+    const client = new VertesiaClient({
         serverUrl: payload.config.studio_url,
         storeUrl: payload.config.store_url,
         apikey: payload.auth_token

package/src/utils/memory.ts

@@ -1,4 +1,4 @@
-import { ComposableClient, StreamSource } from "@vertesia/client";
+import { VertesiaClient, StreamSource } from "@vertesia/client";
 import { Commands, MemoryPack, buildMemoryPack as _buildMemoryPack, loadMemoryPack as _loadMemoryPack } from "@vertesia/memory";
 import { createReadStream, createWriteStream } from "fs";
 import { rm } from "fs/promises";
@@ -17,7 +17,7 @@ export class NodeStreamSource extends StreamSource {
     }
 }
 
-export async function publishMemoryPack(client: ComposableClient, file: string, name: string): Promise<void> {
+export async function publishMemoryPack(client: VertesiaClient, file: string, name: string): Promise<void> {
     const stream = createReadStream(file);
     try {
         const source = new NodeStreamSource(stream, name);
@@ -39,7 +39,7 @@ export async function buildMemoryPack(recipeFn: (commands: Commands) => Promise<
     });
 }
 
-export async function buildAndPublishMemoryPack(client: ComposableClient, name: string, recipeFn: (commands: Commands) => Promise<Record<string, any>>): Promise<void> {
+export async function buildAndPublishMemoryPack(client: VertesiaClient, name: string, recipeFn: (commands: Commands) => Promise<Record<string, any>>): Promise<void> {
     const tarFile = await buildMemoryPack(recipeFn);
     try {
         await publishMemoryPack(client, tarFile, name);
@@ -48,7 +48,7 @@ export async function buildAndPublishMemoryPack(client: ComposableClient, name:
     }
 }
 
-export async function fetchMemoryPack(client: ComposableClient, name: string): Promise<string> {
+export async function fetchMemoryPack(client: VertesiaClient, name: string): Promise<string> {
     const webStream = await client.files.downloadMemoryPack(name);
     const tarFile = tmp.fileSync({
         prefix: "composable-memory-pack-",
@@ -61,6 +61,6 @@ export async function fetchMemoryPack(client: ComposableClient, name: string): P
     return tarFile.name;
 }
 
-export function loadMemoryPack(client: ComposableClient, name: string): Promise<MemoryPack> {
+export function loadMemoryPack(client: VertesiaClient, name: string): Promise<MemoryPack> {
     return fetchMemoryPack(client, name).then(file => _loadMemoryPack(file));
 }