@vertesia/client 0.42.2

package/src/ProjectsApi.ts

@@ -0,0 +1,58 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import { AwsConfiguration, GithubConfiguration, GladiaConfiguration, ICreateProjectPayload, Project, ProjectIntegrationListEntry, ProjectRef, SupportedIntegrations } from "@vertesia/common";
+
+export default class ProjectsApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/projects");
+    }
+
+    list(account?: string[]): Promise<ProjectRef[]> {
+        return this.get('/', { query: { account } });
+    }
+
+    retrieve(projectId: string): Promise<Project> {
+        return this.get(`/${projectId}`);
+    }
+
+    create(payload: ICreateProjectPayload): Promise<Project> {
+        return this.post('/', {
+            payload
+        });
+    }
+
+    update(projectId: string, payload: Partial<Project>): Promise<Project> {
+        return this.put(`/${projectId}`, {
+            payload
+        });
+    }
+
+    integrations: IntegrationsConfigurationApi = new IntegrationsConfigurationApi(this);
+
+}
+
+class IntegrationsConfigurationApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/");
+    }
+
+    list(projectId: string): Promise<ProjectIntegrationListEntry[]> {
+        return this.get(`/${projectId}/integrations`).then(res => res.integrations);
+    }
+
+    retrieve(projectId: string, integrationId: SupportedIntegrations): Promise<GladiaConfiguration | GithubConfiguration | AwsConfiguration | undefined> {
+        return this.get(`/${projectId}/integrations/${integrationId}`).catch(err => {
+            if (err.status === 404) {
+                return undefined;
+            }
+            throw err;
+        });
+    }
+
+    update(projectId: string, integrationId: string, payload: any): Promise<GladiaConfiguration | GithubConfiguration> {
+        return this.put(`/${projectId}/integrations/${integrationId}`, {
+            payload
+        });
+    }
+
+}

package/src/PromptsApi.ts

@@ -0,0 +1,160 @@
+import { ComputePromptFacetPayload, PromptSearchPayload, PromptSearchQuery, PromptTemplate, PromptTemplateForkPayload, PromptTemplateCreatePayload, PromptTemplateRef, PromptTemplateUpdatePayload } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+export interface ComputePromptFacetsResponse {
+    role?: { _id: string, count: number }[];
+    total?: { count: number }[];
+}
+
+export default class PromptsApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/prompts")
+    }
+
+    /**
+     * Get the list of all prompt templates
+     * @param payload query payload to filter search
+     * @returns PromptTemplateRef[]
+     **/
+    list(payload: PromptSearchPayload = {}): Promise<PromptTemplateRef[]> {
+        const query = payload.query || {} as PromptSearchQuery;
+
+        return this.get("/", {
+            query: {
+                ...query
+            }
+        });
+    }
+
+    /**
+     * Get the list of all prompt facets
+     * @param payload query payload to filter facet search
+     * @returns ComputePromptFacetsResponse[]
+     **/
+    computeFacets(query: ComputePromptFacetPayload): Promise<ComputePromptFacetsResponse> {
+        return this.post("/facets", {
+            payload: query
+        });
+    }
+
+    /**
+     * Create a new prompt template
+     * @param payload PromptTemplateCreatePayload
+     * @returns PromptTemplate
+     * @throws ApiError
+     * @throws 400 if payload is invalid
+     * @throws 500 if creation fails
+     **/
+    create(payload: PromptTemplateCreatePayload): Promise<PromptTemplate> {
+        return this.post('/', {
+            payload
+        });
+    }
+
+    /**
+     * Retrieve an existing prompt template
+     * @param id of the prompt template to retrieve
+     * @returns PromptTemplate
+     **/
+    retrieve(id: string): Promise<PromptTemplate> {
+        return this.get(`/${id}`);
+    }
+
+    /**
+     * Update an existing prompt template
+     * @param id of the prompt template to update
+     * @param payload PromptTemplateCreatePayload
+     * @returns PromptTemplate
+     * @throws ApiError
+     * @throws 400 if payload is invalid
+     * @throws 500 if update fails
+     * @throws 404 if not found
+     **/
+    update(id: string, payload: PromptTemplateUpdatePayload): Promise<PromptTemplate> {
+        return this.put(`/${id}`, {
+            payload
+        });
+    }
+
+    /**
+     * Delete an existing prompt template
+     * @param id of the prompt template to delete
+     * @returns void
+     */
+    delete(id: string): Promise<void> {
+        return this.del(`/${id}`);
+    }
+
+    /**
+     * Fork an existing prompt template
+     * @param id of the prompt template to fork
+     * @param payload PromptTemplateForkPayload
+     * @returns Forked PromptTemplate
+     */
+    fork(id: string, payload: PromptTemplateForkPayload): Promise<PromptTemplate> {
+        return this.post(`/${id}/fork`, {
+            payload
+        });
+    }
+
+    /**
+     * Render a prompt template
+     * @param id of the prompt template to render
+     * @param payload that will be passed to the prompt template to generate the prompts
+     * @returns PromptTemplate
+     * @throws ApiError
+     * @throws 404 if not found
+     * @throws 400 if payload is invalid
+     * @throws 500 if render fails
+     **/
+    render(id: string, payload: {}): Promise<PromptTemplate> {
+        return this.post(`/${id}/render`, {
+            payload
+        });
+    }
+
+    /**
+     * Get options for a field
+     * @param field name to get options for
+     * @returns string[]
+     */
+    options(field: string): Promise<string[]> {
+        return this.get(`/options/${field}`);
+    }
+
+    /**
+     * List the versions of the prompt template. Returens 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<PromptTemplateRef[]> {
+        return this.get(`/${id}/versions`);
+    }
+
+
+    /**
+     * Retrieve list of interactions that use the prompt template
+     */
+    listInteractions(id: string): Promise<ListInteractionsResponse> {
+        return this.get(`/${id}/interactions`);
+    }
+
+    /**
+     * List the forks of the prompt. Returns an empty array if no forks are found
+     * @param id of the prompt to search forks
+     * @returns the versions list or an empty array if no forks are found
+     */
+    listForks(id: string): Promise<PromptTemplateRef[]> {
+        return this.get(`/${id}/forks`);
+    }
+
+}
+
+export interface ListInteractionsResponse {
+    prompt: string,
+    interactions: {
+        id: string,
+        name: string,
+        versions: string[],
+    }[]
+}

package/src/RefsApi.ts

@@ -0,0 +1,18 @@
+import { ResolvableRef, ResourceRef } from "@vertesia/common"
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client"
+
+
+export class RefsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/refs")
+    }
+
+
+    resolve(refs: ResolvableRef[]): Promise<ResourceRef[]> {
+
+        return this.post('/resolve', { payload: { refs } })
+
+    }
+
+}

package/src/RunsApi.ts

@@ -0,0 +1,103 @@
+import { ComputeRunFacetPayload, ExecutionRun, ExecutionRunRef, FindPayload, RunCreatePayload, RunListingFilters, RunListingQueryOptions, RunSearchPayload } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import { ComposableClient } from "./client.js";
+
+export interface FilterOption {
+    id: string,
+    name: string,
+    count: number
+}
+
+export interface ComputeRunFacetsResponse {
+    environments?: { _id: string, count: number }[];
+    interactions?: { _id: string, count: number }[];
+    models?: { _id: string, count: number }[];
+    tags?: { _id: string, count: number }[];
+    status?: { _id: string, count: number }[];
+    total?: { count: number }[];
+}
+
+export class RunsApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/runs")
+    }
+
+    /**
+     * 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({ limit, offset, filters }: RunListingQueryOptions): Promise<ExecutionRunRef[]> {
+
+        const query = {
+            limit,
+            offset,
+            ...filters
+        }
+
+        return this.get('/', { query: query });
+    }
+
+    find(payload: FindPayload): Promise<ExecutionRun[]> {
+        return this.post("/find", {
+            payload
+        });
+    }
+
+    /**
+     * Get a run by id
+     * @param id
+     * @returns InteractionResult
+     **/
+    retrieve(id: string): Promise<ExecutionRun> {
+        return this.get('/' + id);
+    }
+
+    /**
+     * Get filter options for a field
+     * return FilterOption[]
+     */
+    filterOptions(field: string, filters: RunListingFilters): Promise<FilterOption[]> {
+        const query = {
+            ...filters
+        }
+        return this.get(`/filter-options/${field}`, { query });
+
+    }
+
+    create(payload: RunCreatePayload): Promise<ExecutionRun> {
+        const sessionTags = (this.client as ComposableClient).sessionTags;
+        if (sessionTags) {
+            let tags = Array.isArray(sessionTags) ? sessionTags : [sessionTags];
+            if (Array.isArray(payload.tags)) {
+                tags = tags.concat(payload.tags)
+            } else if (payload.tags) {
+                tags = tags.concat([payload.tags])
+            }
+            payload = { ...payload, tags }
+        }
+        return this.post("/", {
+            payload
+        });
+    }
+
+    /**
+     * Get the list of all runs facets
+     * @param payload query payload to filter facet search
+     * @returns ComputeRunFacetsResponse[]
+     **/
+    computeFacets(query: ComputeRunFacetPayload): Promise<ComputeRunFacetsResponse> {
+        return this.post("/facets", {
+            payload: query
+        });
+    }
+
+    search(payload: RunSearchPayload): Promise<ExecutionRunRef[]> {
+        return this.post("/search", {
+            payload
+        });
+    }
+
+}

package/src/StreamSource.ts

@@ -0,0 +1,3 @@
+export class StreamSource {
+    constructor(public stream: ReadableStream, public name: string, public type?: string, public id?: string) { }
+}

package/src/TrainingApi.ts

@@ -0,0 +1,71 @@
+import { TrainingJob } from "@llumiverse/core";
+import { ExecutionRunRef, ListTrainingSessionsQuery, TrainingSession, TrainingSessionCreatePayload, TrainingSessionRef } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+
+export default class TrainingApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/training")
+    }
+
+    listSessions(query: ListTrainingSessionsQuery = {}): Promise<TrainingSessionRef[]> {
+        return this.get('/', { query: query as any });
+    }
+
+    listSessionNames(query: ListTrainingSessionsQuery = {}): Promise<{ id: string, name: string }[]> {
+        return this.get('/names', { query: query as any });
+    }
+
+    createSession(payload: TrainingSessionCreatePayload): Promise<TrainingSession> {
+        return this.post('/', { payload })
+    }
+
+    getSession(sessionId: string): Promise<TrainingSession> {
+        return this.get('/' + sessionId)
+    }
+
+    addToSession(sessionId: string, runs: string[]): Promise<any> {
+        return this.post('/' + sessionId + '/add', { payload: { runs } })
+    }
+
+    listSessionRuns(sessionId: string, limit = 100, offset = 0): Promise<ExecutionRunRef[]> {
+        return this.get('/' + sessionId + '/runs', { query: { limit, offset } });
+    }
+
+    buildSession(sessionId: string) {
+        return this.post('/' + sessionId + '/build');
+    }
+
+    getDataUrl(sessionId: string): Promise<{ url: string }> {
+        return this.get('/' + sessionId + '/url')
+    }
+
+    getDataUploadUrl(sessionId: string, isResumable = false): Promise<{ url: string }> {
+        return this.get('/' + sessionId + '/upload-url',
+            isResumable ? { query: { resumable: 'true' } } : {})
+    }
+
+    startTraining(sessionId: string): Promise<TrainingJob> {
+        return this.post('/' + sessionId + '/start');
+    }
+
+    cancelTraining(sessionId: string): Promise<TrainingJob> {
+        return this.post('/' + sessionId + '/cancel');
+    }
+
+    getTrainingJob(jobId: string): Promise<TrainingJob> {
+        return this.get(`/job/${jobId}`);
+    }
+
+    getAndSyncTrainingJob(jobId: string): Promise<TrainingJob> {
+        return this.get(`/job/${jobId}`, {
+            query: { sync: 'true' }
+        });
+    }
+
+    setDataset(sessionId: string, name: string = "default"): Promise<any> {
+        return this.post('/' + sessionId + '/dataset', { payload: { dataset: name } })
+    }
+
+}

package/src/UsersApi.ts

@@ -0,0 +1,18 @@
+import { User } from "@vertesia/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+
+
+
+
+export default class UsersApi extends ApiTopic {
+
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/users")
+    }
+
+    retrieve(userId: string): Promise<User> {
+        return this.get('/' + userId);
+    }
+
+
+}

package/src/client.ts

@@ -0,0 +1,191 @@
+import { AbstractFetchClient } from "@vertesia/api-fetch-client";
+import { AuthTokenResponse } from "@vertesia/common";
+import AccountApi from "./AccountApi.js";
+import AccountsApi from "./AccountsApi.js";
+import AnalyticsApi from "./AnalyticsApi.js";
+import { ApiKeysApi } from "./ApiKeysApi.js";
+import CommandsApi from "./CommandsApi.js";
+import EnvironmentsApi from "./EnvironmentsApi.js";
+import { IamApi } from "./IamApi.js";
+import InteractionsApi from "./InteractionsApi.js";
+import ProjectsApi from "./ProjectsApi.js";
+import PromptsApi from "./PromptsApi.js";
+import { RefsApi } from "./RefsApi.js";
+import { RunsApi } from "./RunsApi.js";
+import { ZenoClient } from "./store/client.js";
+import TrainingApi from "./TrainingApi.js";
+import UsersApi from "./UsersApi.js";
+
+/**
+ * 1 min threshold constant in ms
+ */
+const EXPIRATION_THRESHOLD = 60000;
+
+export interface ComposableClientProps {
+    serverUrl: string;
+    storeUrl: string;
+    apikey?: string;
+    projectId?: string;
+    sessionTags?: string | string[];
+    onRequest?: (request: Request) => void;
+    onResponse?: (response: Response) => void;
+}
+
+export class ComposableClient extends AbstractFetchClient<ComposableClient> {
+
+    /**
+     * The JWT token linked to the API KEY (sk or pk)
+     */
+    _jwt: string | null = null;
+
+    /**
+     * The store client
+     */
+    store: ZenoClient;
+
+    /**
+     * The session name will be sent when executing an interaction as a tag
+     */
+    sessionTags?: string | string[];
+
+    constructor(
+        opts: ComposableClientProps = {} as any
+    ) {
+        super(opts.serverUrl);
+        if (!opts.serverUrl) {
+            throw new Error("storeUrl is required for ComposableClient");
+        }
+        if (!opts.storeUrl) {
+            throw new Error("storeUrl is required for ComposableClient");
+        }
+        this.store = new ZenoClient({
+            serverUrl: opts.storeUrl,
+            apikey: opts.apikey,
+            onRequest: opts.onRequest,
+            onResponse: opts.onResponse
+        });
+
+        if (opts.apikey) {
+            this.withApiKey(opts.apikey);
+        }
+        if (opts.projectId) {
+            this.headers["x-project-id"] = opts.projectId;
+        }
+        this.onRequest = opts.onRequest;
+        this.onResponse = opts.onResponse;
+        this.sessionTags = opts.sessionTags;
+    }
+
+
+    /**
+     * Overwrite to keep store and composable clients synchronized on the auth callback
+     * @param authCb
+     * @returns
+     */
+    withAuthCallback(authCb?: (() => Promise<string>) | null) {
+        this.store.withAuthCallback(authCb);
+        return super.withAuthCallback(authCb);
+    }
+
+    async withApiKey(apiKey: string | null) {
+        return this.withAuthCallback(
+            apiKey ? async () => {
+                if (!isApiKey(apiKey)) {
+                    return `Bearer ${apiKey}`
+                }
+
+                if (isTokenExpired(this._jwt)) {
+                    const jwt = await this.getAuthToken(apiKey);
+                    this._jwt = jwt.token;
+                }
+                return `Bearer ${this._jwt}`
+            } : undefined
+        );
+    }
+
+    /**
+     * Alias for store.workflows
+     */
+    get workflows() {
+        return this.store.workflows;
+    }
+
+    /**
+     * Alias for store.objects
+     */
+    get objects() {
+        return this.store.objects;
+    }
+
+    get files() {
+        return this.store.files;
+    }
+
+    /**
+     * Alias for store.types
+     */
+    get types() {
+        return this.store.types;
+    }
+
+
+    set project(projectId: string | null) {
+        if (projectId) {
+            this.headers["x-project-id"] = projectId;
+        } else {
+            delete this.headers["x-project-id"];
+        }
+    }
+
+    get project() {
+        return this.headers["x-project-id"] || null;
+    }
+
+    /**
+     *
+     * Generate a token for use with other Composable's services
+     *
+     * @param accountId: selected account to generate the token for
+     * @returns AuthTokenResponse
+     */
+    async getAuthToken(token?: string, accountId?: string): Promise<AuthTokenResponse> {
+        const query = {
+            accountId,
+            token
+        };
+
+        return this.get('/auth/token', { query: query, headers: { "authorization": undefined } as any });
+    }
+
+    projects = new ProjectsApi(this);
+    environments = new EnvironmentsApi(this);
+    interactions = new InteractionsApi(this);
+    prompts = new PromptsApi(this);
+    runs = new RunsApi(this);
+    account = new AccountApi(this);
+    accounts = new AccountsApi(this);
+    apikeys = new ApiKeysApi(this);
+    analytics = new AnalyticsApi(this);
+    training = new TrainingApi(this);
+    users = new UsersApi(this);
+    iam = new IamApi(this);
+    refs = new RefsApi(this);
+    commands = new CommandsApi(this);
+}
+
+function isApiKey(apiKey: string) {
+    return (apiKey.startsWith('pk-') || apiKey.startsWith('sk-'));
+}
+
+function isTokenExpired(token: string | null) {
+    if (!token) {
+        return true;
+    }
+
+    const payloadBase64 = token.split('.')[1];
+    const decodedJson = Buffer.from(payloadBase64, 'base64').toString();
+    const decoded = JSON.parse(decodedJson)
+    const exp = decoded.exp;
+    const currentTime = Date.now();
+    return (currentTime <= exp * 1000 - EXPIRATION_THRESHOLD);
+}