@vertesia/client 0.24.0-dev.202601221707

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,151 @@
+import type { ExecutionResponse } from "@llumiverse/common";
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import {
+    CheckpointConversationPayload,
+    ComputeRunFacetPayload,
+    ExecutionRun,
+    ExecutionRunRef,
+    FindPayload,
+    PopulatedExecutionRun,
+    RunCreatePayload,
+    RunListingFilters,
+    RunListingQueryOptions,
+    RunSearchPayload,
+    ToolResultsPayload,
+    UserMessagePayload,
+} from "@vertesia/common";
+import { VertesiaClient } from "./client.js";
+import { EnhancedExecutionRun, enhanceExecutionRun } from "./InteractionOutput.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
+     **/
+    async retrieve<ResultT = any, ParamsT = any>(id: string): Promise<EnhancedExecutionRun<ResultT, ParamsT>> {
+        const r = await this.get("/" + id);
+        return enhanceExecutionRun<ResultT, ParamsT>(r);
+    }
+
+    retrievePopulated<P = any>(id: string): Promise<PopulatedExecutionRun<P>> {
+        return this.get("/" + id, {
+            query: { populate: "true" },
+        });
+    }
+
+    /**
+     * 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 });
+    }
+
+    async create<ResultT = any, ParamsT = any>(payload: RunCreatePayload): Promise<EnhancedExecutionRun<ResultT, ParamsT>> {
+        const sessionTags = (this.client as VertesiaClient).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 };
+        }
+        const r = await this.post("/", {
+            payload,
+        });
+        return enhanceExecutionRun<ResultT, ParamsT>(r);
+    }
+
+    /**
+     * Send tool results and continues the conversation
+     * @param payload
+     * @returns
+     */
+    sendToolResults(payload: ToolResultsPayload): Promise<ExecutionResponse> {
+        return this.post(`/tool-results`, {
+            payload,
+        });
+    }
+
+    /**
+     *
+     * @param payload
+     * @returns
+     */
+    sendUserMessage(payload: UserMessagePayload): Promise<ExecutionResponse> {
+        return this.post(`/user-message`, {
+            payload,
+        });
+    }
+
+    createCheckpoint(payload: CheckpointConversationPayload): Promise<ExecutionResponse> {
+        return this.post(`/checkpoint`, {
+            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/SkillsApi.ts

@@ -0,0 +1,46 @@
+import { ApiTopic, ClientBase } from "@vertesia/api-fetch-client";
+import {
+    FindRelevantSkillsPayload,
+    InjectedSkill,
+    SkillContext,
+} from "@vertesia/common";
+
+/**
+ * API client for skill operations.
+ * Skills are interactions with agent_runner_options.is_skill = true.
+ * They provide contextual instructions to agents by executing/rendering
+ * the interaction and returning the result.
+ */
+export default class SkillsApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, "/api/v1/skills");
+    }
+
+    /**
+     * Find skills relevant to a given context.
+     * This is the core skill matching API for auto-injection.
+     * @param context The context to match against
+     * @param limit Maximum number of skills to return (default: 5)
+     * @returns Array of injected skills with match scores
+     */
+    findRelevant(context: SkillContext, limit?: number): Promise<InjectedSkill[]> {
+        const payload: FindRelevantSkillsPayload = { context, limit };
+        return this.post("/find-relevant", { payload });
+    }
+
+    /**
+     * Convenience method to find relevant skills by task description
+     * @param taskDescription The task or prompt to match
+     * @param toolNames Optional list of tools being used
+     * @returns Array of injected skills
+     */
+    findRelevantForTask(
+        taskDescription: string,
+        toolNames?: string[]
+    ): Promise<InjectedSkill[]> {
+        return this.findRelevant({
+            task_description: taskDescription,
+            tool_names: toolNames,
+        });
+    }
+}

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 type { TrainingJob } from "@llumiverse/common";
+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.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "vitest";
+import { VertesiaClient } from "./client";
+
+describe('Test Vertesia Client', () => {
+    test('Initialization with studio and zeno URLs', () => {
+        const client = new VertesiaClient({
+            serverUrl: 'https://api.vertesia.io',
+            storeUrl: 'https://api.vertesia.io',
+            tokenServerUrl: 'https://sts.vertesia.io',
+            apikey: '1234',
+        });
+        expect(client).toBeDefined();
+    });
+
+    test('Initialization with studio URL only', () => {
+        expect(() => {
+            new VertesiaClient({
+                serverUrl: 'https://api.vertesia.io',
+                storeUrl: '',
+            });
+        }).toThrowError("Parameter 'site' or 'storeUrl' is required for VertesiaClient");
+    });
+
+    test('Initialization with zeno URL only', () => {
+        expect(() => {
+            new VertesiaClient({
+                serverUrl: '',
+                storeUrl: 'https://api.vertesia.io',
+            });
+        }).toThrowError("Parameter 'site' or 'serverUrl' is required for VertesiaClient");
+    });
+
+    test('Initialization with same site', () => {
+        const client = new VertesiaClient({
+            serverUrl: 'https://api.vertesia.io',
+            storeUrl: 'https://api.vertesia.io',
+            site: 'api.vertesia.io',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://api.vertesia.io');
+        expect(client.storeUrl).toBe('https://api.vertesia.io');
+    });
+
+    test('Initialization with default parameters', () => {
+        const client = new VertesiaClient();
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://api.vertesia.io');
+        expect(client.storeUrl).toBe('https://api.vertesia.io');
+        expect(client.tokenServerUrl).toBe('https://sts.vertesia.io');
+    });
+
+    test('Initialization with site api-preview.vertesia.io', () => {
+        const client = new VertesiaClient({
+            site: 'api-preview.vertesia.io',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://api-preview.vertesia.io');
+        expect(client.storeUrl).toBe('https://api-preview.vertesia.io');
+        expect(client.tokenServerUrl).toBe('https://sts.vertesia.io');
+    });
+
+    test('Initialization with site api-staging.vertesia.io', () => {
+        const client = new VertesiaClient({
+            site: 'api-staging.vertesia.io',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://api-staging.vertesia.io');
+        expect(client.storeUrl).toBe('https://api-staging.vertesia.io');
+        expect(client.tokenServerUrl).toBe('https://sts-staging.vertesia.io');
+    });
+
+    test('Initialization with site localhost', () => {
+        const client = new VertesiaClient({
+            serverUrl: 'http://localhost:8091',
+            storeUrl: 'http://localhost:8092',
+            tokenServerUrl: 'http://localhost:8093',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('http://localhost:8091');
+        expect(client.storeUrl).toBe('http://localhost:8092');
+    });
+
+    test('Initialization with overrides', () => {
+        const client = new VertesiaClient({
+            serverUrl: 'https://studio-server-production.api.becomposable.com',
+            storeUrl: 'https://zeno-server-production.api.becomposable.com',
+            site: 'api.vertesia.io',
+        });
+
+        expect(client).toBeDefined();
+        expect(client.baseUrl).toBe('https://studio-server-production.api.becomposable.com');
+        expect(client.storeUrl).toBe('https://zeno-server-production.api.becomposable.com');
+    });
+});