@vertesia/client 0.24.0-dev.202601221707

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,94 @@
+import type { AIModel, EmbeddingsOptions, EmbeddingsResult, ModelSearchPayload } from "@llumiverse/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import {
+    ExecutionEnvironment,
+    ExecutionEnvironmentCreatePayload,
+    ExecutionEnvironmentRef,
+    ExecutionEnvironmentUpdatePayload,
+    LoadBalancingEnvConfig,
+    MediatorEnvConfig,
+    MigrateInteractionsPayload,
+    MigrateInteractionsResult
+} from "@vertesia/common";
+
+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
+        });
+    }
+
+    /**
+     * Update enabled models and / or config. If enabled_models is not provided, the existing enabled models will not change.
+     * Same, if config is not provided 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
+        });
+    }
+
+    /**
+     * Batch update the LLM Environment for multiple Interactions, including the model used and the
+     * Environment that they belong to.
+     *
+     * It only updates Interactions that are in draft status.
+     *
+     * @param payload - The migration payload containing modelId and interactionIds
+     * @returns The count of matched and modified interactions
+     */
+    migrateInteractions(payload: MigrateInteractionsPayload): Promise<MigrateInteractionsResult> {
+        return this.post(`/migrate-interactions`, {
+            payload
+        });
+    }
+
+}

package/src/GroupsApi.ts

@@ -0,0 +1,92 @@
+import { UserGroup, UserRef } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+export interface GroupsQueryOptions {
+    search?: string;
+    tags?: string[];
+    limit?: number;
+    offset?: number;
+    [key: string]: string | string[] | number | undefined;
+}
+
+export class GroupsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/groups");
+    }
+
+    /**
+     * List all groups in the current account
+     * @param options Query options for filtering and pagination
+     * @returns Array of UserGroup objects
+     */
+    list(options?: GroupsQueryOptions): Promise<UserGroup[]> {
+        return this.get('/', { query: options });
+    }
+
+    /**
+     * Create a new group
+     * @param payload The group data to create
+     * @returns The created UserGroup object
+     */
+    create(payload: Partial<UserGroup>): Promise<UserGroup> {
+        return this.post('/', { payload });
+    }
+
+    /**
+     * Retrieve a specific group by ID
+     * @param groupId The ID of the group to retrieve
+     * @returns The UserGroup object
+     */
+    retrieve(groupId: string): Promise<UserGroup> {
+        return this.get('/' + groupId);
+    }
+
+    /**
+     * Update a group
+     * @param groupId The ID of the group to update
+     * @param payload The group data to update
+     * @returns The updated UserGroup object
+     */
+    update(groupId: string, payload: Partial<UserGroup>): Promise<UserGroup> {
+        return this.put('/' + groupId, { payload });
+    }
+
+    /**
+     * Delete a group
+     * @param groupId The ID of the group to delete
+     * @returns Object with the deleted group ID
+     */
+    delete(groupId: string): Promise<{ id: string }> {
+        return this.del('/' + groupId);
+    }
+
+    /**
+     * List members of a group
+     * @param groupId The ID of the group
+     * @returns Array of UserRef objects representing group members
+     */
+    listMembers(groupId: string): Promise<UserRef[]> {
+        return this.get('/' + groupId + '/members');
+    }
+
+    /**
+     * Add a member to a group
+     * @param groupId The ID of the group
+     * @param userId The ID of the user to add
+     * @returns The updated UserGroup object
+     */
+    addMember(groupId: string, userId: string): Promise<UserGroup> {
+        return this.post('/' + groupId + '/members/' + userId);
+    }
+
+    /**
+     * Remove a member from a group
+     * @param groupId The ID of the group
+     * @param userId The ID of the user to remove
+     * @returns The updated UserGroup object
+     */
+    removeMember(groupId: string, userId: string): Promise<UserGroup> {
+        return this.del('/' + groupId + '/members/' + userId);
+    }
+}

package/src/IamApi.ts

@@ -0,0 +1,70 @@
+import { AccessControlEntry, ACECreatePayload, AcesQueryOptions, Permission, ProjectRoles } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import { GroupsApi } from "./GroupsApi.js";
+
+
+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)
+    groups = new GroupsApi(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 { VertesiaClient, VertesiaClientProps } from "./client.js";
+import { executeInteraction } from "./execute.js";
+
+export class InteractionBase<P = any> {
+    client: VertesiaClient;
+
+    constructor(public id: string, clientOrOpts: VertesiaClient | VertesiaClientProps) {
+        if (clientOrOpts instanceof VertesiaClient) {
+            this.client = clientOrOpts;
+        } else {
+            this.client = new VertesiaClient(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 function 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>> {
+        return executeInteraction<P>(this.client, this.id, payload, onChunk);
+    }
+}

package/src/InteractionCatalogApi.ts

@@ -0,0 +1,72 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import {
+    CatalogInteractionRef,
+    InCodeInteraction,
+    InteractionStatus
+} from "@vertesia/common";
+
+
+export class InteractionCatalogApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/interactions/catalog");
+    }
+
+    /**
+     * List all project interactions
+     */
+    list(query: { status?: InteractionStatus, tag?: string } = {}): Promise<CatalogInteractionRef[]> {
+        return this.get("/", {
+            query
+        });
+    }
+
+    /**
+     * List all stored interactions
+     */
+    listStoredInteractions(query: { status?: InteractionStatus, tag?: string } = {}): Promise<CatalogInteractionRef[]> {
+        return this.get("/stored", {
+            query
+        });
+    }
+
+    /**
+     * List sys interactions
+     */
+    listSysInteractions(tag?: string): Promise<CatalogInteractionRef[]> {
+        return this.get(`/sys`, {
+            query: {
+                tag
+            }
+        });
+    }
+
+    /**
+     * List sys interactions
+     */
+    listAppInteractions(appName: string, tag?: string): Promise<CatalogInteractionRef[]> {
+        return this.get(`/apps/${appName}`, {
+            query: {
+                tag
+            }
+        });
+    }
+
+    /**
+     * List all app interactions
+     */
+    listAllAppInteractions(tag?: string): Promise<CatalogInteractionRef[]> {
+        return this.get(`/apps`, {
+            query: {
+                tag
+            }
+        });
+    }
+
+    /**
+     * Resolve an interaction given its id to a InCodeInteraction
+     * @param id Interaction id
+     */
+    resolve(id: string): Promise<InCodeInteraction> {
+        return this.get(`/resolve/${id}`);
+    }
+}