@vertesia/client 0.42.2

package/lib/types/store/errors.d.ts

@@ -0,0 +1,4 @@
+import { RequestError } from "@vertesia/api-fetch-client";
+export declare class ZenoClientNotFoundError extends RequestError {
+    constructor(req: Request, error: RequestError);
+}

package/lib/types/store/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/store/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D,qBAAa,uBAAwB,SAAQ,YAAY;gBACzC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY;CAGhD"}

package/lib/types/store/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./client.js";
+export * from "./CommandsApi.js";
+export * from "./ObjectsApi.js";
+export * from "./TypesApi.js";
+export * from "./WorkflowsApi.js";

package/lib/types/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/store/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@vertesia/client",
+  "version": "0.42.2",
+  "type": "module",
+  "types": "./lib/types/index.d.ts",
+  "files": [
+    "lib",
+    "src"
+  ],
+  "devDependencies": {
+    "@types/eventsource": "^1.1.14",
+    "@types/node": "^20.8.9",
+    "ts-dual-module": "^0.6.3",
+    "typescript": "^5.0.2",
+    "vitest": "^2.1.6"
+  },
+  "dependencies": {
+    "eventsource": "^2.0.2",
+    "@vertesia/common": "0.42.2",
+    "@vertesia/api-fetch-client": "0.42.2",
+    "@llumiverse/core": "0.15.0"
+  },
+  "ts_dual_module": {
+    "outDir": "lib"
+  },
+  "exports": {
+    "types": "./lib/types/index.d.ts",
+    "import": "./lib/esm/index.js",
+    "require": "./lib/cjs/index.js"
+  },
+  "scripts": {
+    "eslint": "eslint './src/**/*.{jsx,js,tsx,ts}'",
+    "build": "pnpm exec tsmod build",
+    "clean": "rimraf ./node_modules ./lib ./tsconfig.tsbuildinfo"
+  }
+}

package/src/AccountApi.ts

@@ -0,0 +1,75 @@
+import { Account, InviteUserRequestPayload, InviteUserResponsePayload, OnboardingProgress, ProjectRef, TransientToken, UpdateAccountPayload, User, UserInviteTokenData } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+export default class AccountApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/account")
+    }
+
+    /**
+     * Retrieve all account information for current account
+     * @returns Account[]
+     */
+    info(): Promise<Account> {
+        return this.get('/');
+    }
+
+    /**
+     * Update account information
+     * @returns Account
+     */
+    update(payload: UpdateAccountPayload): Promise<Account> {
+        return this.put('/', { payload });
+    }
+
+    /**
+     * Get all projects for account
+    */
+    projects(): Promise<ProjectRef[]> {
+        return this.get('/projects').then(res => res.data);
+    }
+
+    members(): Promise<User[]> {
+        return this.get('/members')
+    }
+
+    /**
+     * Invite User to account
+     */
+    inviteUser(payload: InviteUserRequestPayload): Promise<InviteUserResponsePayload> {
+        return this.post('/invites', { payload });
+    }
+
+    /**
+     * Fetch Invites for account
+     * @returns UserInviteTokenData[]
+     * */
+    listInvites(): Promise<TransientToken<UserInviteTokenData>[]> {
+        return this.get('/invites');
+    }
+
+    /**
+     * Accept Invite for account
+     * @returns UserInviteTokenData
+     * */
+    acceptInvite(id: string): Promise<UserInviteTokenData> {
+        return this.put(`/invites/${id}`);
+    }
+
+    /**
+     * Delete Invite for account
+     * @returns UserInviteTokenData
+     * */
+    rejectInvite(id: string): Promise<UserInviteTokenData> {
+        return this.delete(`/invites/${id}`);
+    }
+
+    /**
+     * Get Onboarding Progress for account
+     */
+    onboardingProgress(): Promise<OnboardingProgress> {
+        return this.get('/onboarding');
+    }
+
+}

package/src/AccountsApi.ts

@@ -0,0 +1,18 @@
+import { Account } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+export default class AccountsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/accounts")
+    }
+
+    create(name: string): Promise<Account> {
+        return this.post('/', { payload: { name } });
+    }
+
+
+
+
+
+}

package/src/AnalyticsApi.ts

@@ -0,0 +1,20 @@
+import { RunAnalyticsQuery, RunAnalyticsResult } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+
+
+
+export default class AnalyticsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/analytics")
+    }
+
+    runs(params: RunAnalyticsQuery): Promise<RunAnalyticsResult[]> {
+
+        return this.post('/runs', { payload: params });
+
+    }
+
+
+}

package/src/ApiKeysApi.ts

@@ -0,0 +1,67 @@
+import { ApiKey, ApiKeyWithValue, CreateOrUpdateApiKeyPayload, CreatePublicKeyPayload } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+export class ApiKeysApi extends ApiTopic {
+
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/apikeys")
+    }
+
+
+    /**
+     * List all keys for account without values
+     * @returns ApiKey[]
+     */
+    list(): Promise<ApiKey[]> {
+        return this.get('/');
+    }
+
+    /**
+     * Create an new ApiKey for account
+     * BE VERY CAREFUL USING THIS API
+     * ALL REQUESTS ARE LOGGED IN SECURITY AUDIT LOG
+     * @returns ApiKeyWithValue
+     */
+    create(payload: CreateOrUpdateApiKeyPayload): Promise<ApiKeyWithValue> {
+        return this.post('/', { payload });
+    }
+
+    /**
+     * Update an existing ApiKey for account
+     * @returns ApiKey
+     */
+    update(id: string, payload: CreateOrUpdateApiKeyPayload): Promise<ApiKey> {
+        return this.put(`/${id}`, { payload });
+    }
+
+    /**
+     * Retrieve an ApiKey and its value
+     * BE VERY CAREFUL USING THIS API AS IT EXPOSE THE API KEY VALUE
+     * ALL REQUESTS ARE LOGGED IN SECURITY AUDIT LOG
+     * @returns ApiKeyWithValue
+     * */
+    retrieve(id: string, withValue: boolean = false): Promise<ApiKey | ApiKeyWithValue> {
+        if (withValue) {
+            return this.get(`/${id}`, { query: { withValue: true } });
+        } else {
+            return this.get(`/${id}`);
+        }
+    }
+
+    /**
+     * get or create a temporary public key which can be used from browser to browse and execute itneractions.
+     * If a public key already exists for the given project (or for the current organization) then it is returned, otherwise a new one is created.
+     * The payload object can contain the following properties:
+     * - name: the name of the public key. If not specified a random name is generated.
+     * - projectId: the id of the project to which the public key will be associated.
+     * If not specified the key is associated with the current organization. (i.e. account).
+     * - ttl: the time to live of the public key in seconds.
+     * The ttl defaults to 1h.
+     * @param opts
+     * @returns
+     */
+    requestPublicKey(payload: CreatePublicKeyPayload = {}): Promise<string> {
+        return this.get('/pk', { query: payload as Record<string, string | number> });
+    }
+}

package/src/CommandsApi.ts

@@ -0,0 +1,23 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import { GenericCommandResponse } from "@vertesia/common";
+
+
+/**
+ * Various utility commands
+ */
+
+export default class CommandsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/commands")
+    }
+
+    async isNamespaceAvailable(name: string): Promise<boolean> {
+        return this.get(`/namespaces/${name}/is_available`).then((response) => response.available);
+    }
+
+    async initSamples(): Promise<GenericCommandResponse> {
+        return this.post("/onboarding/init-samples");
+    }
+
+}

package/src/EnvironmentsApi.ts

@@ -0,0 +1,70 @@
+import { ExecutionEnvironment, ExecutionEnvironmentCreatePayload, ExecutionEnvironmentRef, ExecutionEnvironmentUpdatePayload, LoadBalancingEnvConfig, MediatorEnvConfig } from "@vertesia/common";
+import { AIModel, EmbeddingsOptions, EmbeddingsResult, ModelSearchPayload } from "@llumiverse/core";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+export default class EnvironmentsApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/environments");
+    }
+
+    /**
+     * List all environments for the current project
+     * @param all if true, list all environments, otherwise only the ones for the current project
+     */
+    list(all: boolean = false): Promise<ExecutionEnvironmentRef[]> {
+        const query = all ? { all: true } : undefined;
+
+        return this.get('/', { query });
+    }
+
+    create(payload: ExecutionEnvironmentCreatePayload): Promise<ExecutionEnvironment> {
+        return this.post('/', {
+            payload
+        });
+    }
+
+    retrieve(id: string): Promise<ExecutionEnvironment> {
+        return this.get('/' + id);
+    }
+
+    update(id: string, payload: ExecutionEnvironmentUpdatePayload): Promise<ExecutionEnvironment> {
+        return this.put('/' + id, {
+            payload
+        });
+    }
+
+    /**
+     * udpate enabled models and / or config. If enabled_models is not provided, the existing enabled models will not change.
+     * Same, if config is not provioded the exiting config is not changed.
+     * If the config is provided then it will be updated without removing fields that are not provided.
+     *
+     * @param id
+     * @param payload
+     * @returns
+     */
+    updateConfig(id: string, payload: {
+        enabled_models?: AIModel[],
+        config?: MediatorEnvConfig | LoadBalancingEnvConfig
+    }): Promise<ExecutionEnvironment> {
+        return this.put('/' + id + '/config', {
+            payload
+        });
+    }
+
+    listModels(id: string, payload?: ModelSearchPayload): Promise<AIModel[]> {
+        return this.get('/' + id + '/models', {
+            query: payload ? { ...payload } : undefined
+        });
+    }
+
+    listTrainableModels(id: string): Promise<AIModel[]> {
+        return this.get(`/${id}/trainable-models`);
+    }
+
+    embeddings(id: string, payload?: EmbeddingsOptions): Promise<EmbeddingsResult> {
+        return this.post('/' + id + '/embeddings', {
+            payload
+        });
+    }
+
+}

package/src/IamApi.ts

@@ -0,0 +1,68 @@
+import { AccessControlEntry, ACECreatePayload, AcesQueryOptions, Permission, ProjectRoles } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+
+export interface FilterOption {
+    id: string,
+    name: string,
+    count: number
+}
+
+
+export class IamApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/iam")
+    }
+
+    aces = new AcesApi(this)
+    roles = new RolesApi(this)
+}
+
+export class RolesApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/roles")
+    }
+
+    list(): Promise<{ name: ProjectRoles, permissions: Permission[] }[]> {
+        return this.get('/');
+    }
+
+}
+
+
+export class AcesApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/aces")
+    }
+
+    /**
+     * Get the list of all runs
+     * @param project optional project id to filter by
+     * @param interaction optional interaction id to filter by
+     * @returns InteractionResult[]
+     **/
+    list(options: AcesQueryOptions): Promise<AccessControlEntry[]> {
+        return this.get('/', { query: { ...options } });
+    }
+
+    /**
+     * Get an ACE by its Id
+     * @param id
+     * @returns InteractionResult
+     **/
+    retrieve(id: string): Promise<AccessControlEntry> {
+        return this.get('/' + id);
+    }
+
+    create(payload: ACECreatePayload): Promise<AccessControlEntry> {
+        return this.post('/', { payload })
+    }
+
+    delete(id: string): Promise<{ id: string }> {
+        return this.del('/' + id)
+    }
+
+}

package/src/InteractionBase.ts

@@ -0,0 +1,44 @@
+import { ExecutionRun, InteractionUpdatePayload, InteractionExecutionPayload } from "@vertesia/common";
+import { ComposableClient, ComposableClientProps } from "./client.js";
+import { executeInteraction } from "./execute.js";
+
+export class InteractionBase<P = any, R = any> {
+    client: ComposableClient;
+
+    constructor(public id: string, clientOrOpts: ComposableClient | ComposableClientProps) {
+        if (clientOrOpts instanceof ComposableClient) {
+            this.client = clientOrOpts;
+        } else {
+            this.client = new ComposableClient(clientOrOpts);
+        }
+    }
+
+    retrieve() {
+        return this.client.interactions.retrieve(this.id);
+    }
+
+    update(payload: InteractionUpdatePayload) {
+        return this.client.interactions.update(this.id, payload);
+    }
+
+    render(data: P) {
+        data;
+        //TODO
+    }
+
+    /**
+     * 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
+     * @returns the resolved execution run as Promise<ExecutionRun>
+     */
+    async execute(payload: InteractionExecutionPayload = {},
+        onChunk?: (chunk: string) => void): Promise<ExecutionRun<P, R>> {
+        return executeInteraction<P, R>(this.client, this.id, payload, onChunk);
+    }
+}

package/src/InteractionsApi.ts

@@ -0,0 +1,210 @@
+import { ComputeInteractionFacetPayload, ExecutionRun, GenerateInteractionPayload, GenerateTestDataPayload, ImprovePromptPayload, Interaction, InteractionCreatePayload, InteractionExecutionPayload, InteractionForkPayload, InteractionPublishPayload, InteractionRef, InteractionRefWithSchema, InteractionUpdatePayload, InteractionsExportPayload, InteractionSearchPayload, InteractionSearchQuery } from "@vertesia/common";
+import { ApiTopic, ClientBase, ServerError } from "@vertesia/api-fetch-client";
+import { ComposableClient } from "./client.js";
+import { executeInteraction, executeInteractionByName } from "./execute.js";
+
+export interface ComputeInteractionFacetsResponse {
+    tags?: { _id: string, count: number }[];
+    status?: { _id: string, count: number }[];
+    total?: { count: number }[];
+}
+
+export default class InteractionsApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/interactions");
+    }
+
+    /**
+     * Get the list of all interactions in the current project
+     * @returns InteractionRef[]
+     **/
+    list(payload: InteractionSearchPayload = {}): Promise<InteractionRef[]> {
+        const query = payload.query || {} as InteractionSearchQuery;
+
+        return this.get("/", {
+            query: {
+                ...query
+            }
+        });
+    }
+
+    /**
+     * Get the list of all interactions facets
+     * @param payload query payload to filter facet search
+     * @returns ComputeInteractionFacetsResponse[]
+     **/
+    computeFacets(query: ComputeInteractionFacetPayload): Promise<ComputeInteractionFacetsResponse> {
+        return this.post("/facets", {
+            payload: query
+        });
+    }
+
+    /**
+     * List interaction names in the current project
+     * @returns
+     */
+    listNames(): Promise<{ id: string, name: string }[]> {
+        return this.get('/names');
+    }
+
+    /**
+     * Get the list of all interactions in the current project. Schemas will be returned too.
+     * @returns InteractionRefWithSchema[]
+     **/
+    export(payload: InteractionsExportPayload): Promise<InteractionRefWithSchema[]> {
+        return this.post('/export', { payload });
+    }
+
+    /**
+     * Create a new interaction
+     * @param payload InteractionCreatePayload
+     * @returns Interaction
+     * @throws ApiError
+     * @throws 400 if payload is invalid
+     * @throws 500 if interaction creation fails
+     **/
+    create(payload: InteractionCreatePayload): Promise<Interaction> {
+        return this.post('/', {
+            payload
+        });
+    }
+
+    /**
+     * Retrieve an existing interaction definiton
+     * @param id of the interaction to retrieve
+     * @returns Interaction
+     **/
+    retrieve(id: string): Promise<Interaction> {
+        return this.get(`/${id}`);
+    }
+
+    /**
+     * Update an existing interaction definiton
+     * @param id of the interaction to update
+     * @param payload InteractionUpdatePayload
+     * @returns Interaction
+     * @throws ApiError
+     * @throws 400 if payload is invalid
+     * @throws 500 if interaction update fails
+     * @throws 404 if interaction not found
+     **/
+    update(id: string, payload: InteractionUpdatePayload): Promise<Interaction> {
+        return this.put(`/${id}`, {
+            payload
+        });
+    }
+
+    /**
+     * 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
+     * @returns Promise<ExecutionRun>
+     * @throws ApiError
+     * @throws 404 if interaction not found
+     * @throws 400 if payload is invalid
+     * @throws 500 if interaction execution fails
+     * @throws 500 if interaction execution times out
+     **/
+    execute<P = any, R = any>(id: string, payload: InteractionExecutionPayload = {},
+        onChunk?: (chunk: string) => void): Promise<ExecutionRun<P, R>> {
+        return executeInteraction(this.client as ComposableClient, id, payload, onChunk).catch(err => {
+            if (err instanceof ServerError && err.payload?.id) {
+                throw err.updateDetails({ run_id: err.payload.id });
+            } else {
+                throw err;
+            }
+        });
+    }
+
+    /**
+     * Same as execute 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 nameWithTag
+     * @param payload
+     * @param onChunk
+     * @returns
+     */
+    executeByName<P = any, R = any>(nameWithTag: string, payload: InteractionExecutionPayload = {},
+        onChunk?: (chunk: string) => void): Promise<ExecutionRun<P, R>> {
+        return executeInteractionByName(this.client as ComposableClient, nameWithTag, payload, onChunk).catch(err => {
+            if (err instanceof ServerError && err.payload?.id) {
+                throw err.updateDetails({ run_id: err.payload.id });
+            } else {
+                throw err;
+            }
+        });
+    }
+
+    publish(id: string, payload: InteractionPublishPayload): Promise<Interaction> {
+        return this.post(`/${id}/publish`, {
+            payload
+        });
+    }
+
+    fork(id: string, payload: InteractionForkPayload): Promise<Interaction> {
+        return this.post(`/${id}/fork`, {
+            payload
+        });
+    }
+
+    /**
+     * Generate Composable definition of an interaction
+     **/
+    generateInteraction(id: string, payload: GenerateInteractionPayload): Promise<any[]> {
+
+        return this.post(`${id}/generate-interaction`, {
+            payload
+        });
+
+    }
+
+    /**
+     * Generate Test Data for an interaction
+     **/
+    generateTestData(id: string, payload: GenerateTestDataPayload): Promise<any[]> {
+
+        return this.post(`${id}/generate-test-data`, {
+            payload
+        });
+    }
+
+    /**
+     * Suggest Improvement for a prompt
+     */
+    suggestImprovements(id: string, payload: ImprovePromptPayload): Promise<{ result: string; }> {
+        return this.post(`${id}/suggest-prompt-improvements`, {
+            payload
+        });
+    }
+
+    /**
+     * List the versions of the interaction. Returns an empty array if no versions are found
+     * @param id
+     * @returns the versions list or an empty array if no versions are found
+     */
+    listVersions(id: string): Promise<InteractionRef[]> {
+        return this.get(`/${id}/versions`);
+    }
+
+    /**
+     * List the forks of the interaction. Returns an empty array if no forks are found
+     * @param id
+     * @returns the versions list or an empty array if no forks are found
+     */
+    listForks(id: string): Promise<InteractionRef[]> {
+        return this.get(`/${id}/forks`);
+    }
+
+}