@vertesia/client 1.2.0 → 1.3.0-dev.20260620.091720Z

package/src/client.ts

@@ -1,30 +1,31 @@
-import { AbstractFetchClient } from "@vertesia/api-fetch-client";
-import { AuthTokenPayload, 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 AppsApi from "./AppsApi.js";
-import AuditTrailApi from "./AuditTrailApi.js";
-import CommandsApi from "./CommandsApi.js";
-import EnvironmentsApi from "./EnvironmentsApi.js";
-import { IamApi } from "./IamApi.js";
-import InteractionsApi from "./InteractionsApi.js";
-import OAuthClientsApi from "./OAuthClientsApi.js";
-import OAuthGrantsApi from "./OAuthGrantsApi.js";
-import OAuthProvidersApi from "./OAuthProvidersApi.js";
-import OAuthServerApi from "./OAuthServerApi.js";
-import ProjectsApi from "./ProjectsApi.js";
-import PromptsApi from "./PromptsApi.js";
-import { RefsApi } from "./RefsApi.js";
-import RemoteMcpConnectionsApi from "./RemoteMcpConnectionsApi.js";
-import { RunsApi } from "./RunsApi.js";
-import SkillsApi from "./SkillsApi.js";
-import { ZenoClient } from "./store/client.js";
-import { VERSION, VERSION_HEADER } from "./store/version.js";
-import TrainingApi from "./TrainingApi.js";
-import UsersApi from "./UsersApi.js";
-
+import { AbstractFetchClient, type FETCH_FN, type IRequestRetryPolicy } from '@vertesia/api-fetch-client';
+import { APP_VERSION_HEADER, type AuthTokenPayload, type 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 AppsApi from './AppsApi.js';
+import AuditTrailApi from './AuditTrailApi.js';
+import CommandsApi from './CommandsApi.js';
+import EnvironmentsApi from './EnvironmentsApi.js';
+import { IamApi } from './IamApi.js';
+import InteractionsApi from './InteractionsApi.js';
+import OAuthClientsApi from './OAuthClientsApi.js';
+import OAuthGrantsApi from './OAuthGrantsApi.js';
+import OAuthProvidersApi from './OAuthProvidersApi.js';
+import OAuthServerApi from './OAuthServerApi.js';
+import ProjectsApi from './ProjectsApi.js';
+import PromptsApi from './PromptsApi.js';
+import { RefsApi } from './RefsApi.js';
+import RemoteMcpConnectionsApi from './RemoteMcpConnectionsApi.js';
+import { RunsApi } from './RunsApi.js';
+import SecretsApi from './SecretsApi.js';
+import SkillsApi from './SkillsApi.js';
+import { ZenoClient } from './store/client.js';
+import { VERSION, VERSION_HEADER } from './store/version.js';
+import ToolsApi from './ToolsApi.js';
+import TrainingApi from './TrainingApi.js';
+import UsersApi from './UsersApi.js';
 
 /**
  * 1 min threshold constant in ms
@@ -45,15 +46,16 @@ export type VertesiaClientProps = {
      * @since 0.52.0
      */
     site?:
-    | "api.vertesia.io"
-    | "api-preview.vertesia.io"
-    | "api.us1.vertesia.io"
-    | "api-preview.us1.vertesia.io"
-    | "api.eu1.vertesia.io"
-    | "api-preview.eu1.vertesia.io"
-    | "api.jp1.vertesia.io"
-    | "api-preview.jp1.vertesia.io"
-    | "api.dev1.vertesia.io";
+        | 'api.vertesia.io'
+        | 'api-preview.vertesia.io'
+        | 'api.us1.vertesia.io'
+        | 'api-preview.us1.vertesia.io'
+        | 'api.eu1.vertesia.io'
+        | 'api-preview.eu1.vertesia.io'
+        | 'api.jp1.vertesia.io'
+        | 'api-preview.jp1.vertesia.io'
+        | 'api.dev1.vertesia.io'
+        | 'api-preview.dev1.vertesia.io';
     serverUrl?: string;
     storeUrl?: string;
     tokenServerUrl?: string;
@@ -62,6 +64,14 @@ export type VertesiaClientProps = {
     sessionTags?: string | string[];
     onRequest?: (request: Request) => void;
     onResponse?: (response: Response) => void;
+    retryPolicy?: IRequestRetryPolicy;
+    /**
+     * Default request timeout in ms applied to every request (studio + store) unless overridden
+     * per-request via `timeoutMs`. `false`/`null`/`0` disables it. Aborts the whole request
+     * (connection + headers + body) via AbortSignal — browser + Node safe.
+     */
+    timeout?: number | false | null;
+    fetch?: FETCH_FN | Promise<FETCH_FN>;
 };
 
 export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
@@ -90,6 +100,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
     oauthServer: OAuthServerApi;
     oauthProviders: OAuthProvidersApi;
     remoteMcpConnections: RemoteMcpConnectionsApi;
+    secrets: SecretsApi;
 
     /**
      * Create a client from the given token.
@@ -102,7 +113,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
     static async fromAuthToken(
         token: string,
         payload?: AuthTokenPayload,
-        endpoints?: { studio: string; store: string; token?: string }
+        endpoints?: { studio: string; store: string; token?: string; git?: string },
     ) {
         if (!payload) {
             payload = decodeJWT(token);
@@ -116,11 +127,11 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         }).withApiKey(token);
     }
 
-    static decodeEndpoints() { }
+    static decodeEndpoints() {}
 
     constructor(
         opts: VertesiaClientProps = {
-            site: "api.vertesia.io",
+            site: 'api.vertesia.io',
         },
     ) {
         let studioServerUrl: string;
@@ -131,9 +142,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         } else if (opts.site) {
             studioServerUrl = `https://${opts.site}`;
         } else {
-            throw new Error(
-                "Parameter 'site' or 'serverUrl' is required for VertesiaClient",
-            );
+            throw new Error("Parameter 'site' or 'serverUrl' is required for VertesiaClient");
         }
 
         if (opts.storeUrl) {
@@ -141,12 +150,10 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         } else if (opts.site) {
             zenoServerUrl = `https://${opts.site}`;
         } else {
-            throw new Error(
-                "Parameter 'site' or 'storeUrl' is required for VertesiaClient",
-            );
+            throw new Error("Parameter 'site' or 'storeUrl' is required for VertesiaClient");
         }
 
-        super(studioServerUrl);
+        super(studioServerUrl, opts.fetch);
 
         if (opts.tokenServerUrl) {
             this.tokenServerUrl = opts.tokenServerUrl;
@@ -162,10 +169,10 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
             this.tokenServerUrl = `https://${stsHost}`;
         } else if (opts.serverUrl || opts.storeUrl) {
             // Determine STS URL based on environment in serverUrl or storeUrl
-            const urlToCheck = opts.serverUrl || opts.storeUrl || "";
+            const urlToCheck = opts.serverUrl || opts.storeUrl || '';
             try {
                 const url = new URL(urlToCheck);
-                if (url.hostname.startsWith("api")) {
+                if (url.hostname.startsWith('api')) {
                     // Strip -preview and replace api with sts.
                     // api.us1.vertesia.io         -> sts.us1.vertesia.io
                     // api-preview.us1.vertesia.io -> sts.us1.vertesia.io
@@ -173,13 +180,13 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
                     const stsHost = url.hostname.replace('api-preview.', 'api.').replace(/^api/, 'sts');
                     this.tokenServerUrl = `https://${stsHost}`;
                 } else {
-                    this.tokenServerUrl = "https://sts.dev1.vertesia.io";
+                    this.tokenServerUrl = 'https://sts.dev1.vertesia.io';
                 }
-            } catch (e) {
-                this.tokenServerUrl = "https://sts.dev1.vertesia.io";
+            } catch {
+                this.tokenServerUrl = 'https://sts.dev1.vertesia.io';
             }
         } else {
-            this.tokenServerUrl = "https://sts.dev1.vertesia.io";
+            this.tokenServerUrl = 'https://sts.dev1.vertesia.io';
         }
 
         this.store = new ZenoClient({
@@ -188,10 +195,21 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
             apikey: opts.apikey,
             onRequest: opts.onRequest,
             onResponse: opts.onResponse,
+            retryPolicy: opts.retryPolicy,
+            timeout: opts.timeout,
+            fetch: opts.fetch,
         });
 
+        if (opts.retryPolicy) {
+            this.withRetryPolicy(opts.retryPolicy);
+        }
+
+        if (opts.timeout !== undefined) {
+            this.withTimeout(opts.timeout);
+        }
+
         if (opts.apikey) {
-            this.withApiKey(opts.apikey);
+            void this.withApiKey(opts.apikey);
         }
 
         this.onRequest = opts.onRequest;
@@ -199,9 +217,10 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         this.sessionTags = opts.sessionTags;
         this.oauthClients = new OAuthClientsApi(this);
         this.oauthGrants = new OAuthGrantsApi(this);
-        this.oauthServer = new OAuthServerApi(this);
+        this.oauthServer = new OAuthServerApi(this, this.tokenServerUrl);
         this.oauthProviders = new OAuthProvidersApi(this);
         this.remoteMcpConnections = new RemoteMcpConnectionsApi(this);
+        this.secrets = new SecretsApi(this);
     }
 
     withApiVersion(version: string | number | null) {
@@ -213,6 +232,20 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         return this;
     }
 
+    /**
+     * Pin the app version this client's requests resolve against. A generated app's UI sets this from
+     * its build-time `VITE_APP_VERSION` so studio/zeno resolve its `app:<app>:…` refs against that
+     * published version (candidate testing) instead of current. Pass null/empty to clear (→ current).
+     */
+    withAppVersion(version: string | null | undefined) {
+        if (!version) {
+            delete this.headers[APP_VERSION_HEADER];
+        } else {
+            this.headers[APP_VERSION_HEADER] = String(version);
+        }
+        return this;
+    }
+
     /**
      * Overwrite to keep store and composable clients synchronized on the auth callback
      * @param authCb
@@ -223,20 +256,30 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         return super.withAuthCallback(authCb);
     }
 
+    withRetryPolicy(policy?: IRequestRetryPolicy | null) {
+        this.store.withRetryPolicy(policy);
+        return super.withRetryPolicy(policy);
+    }
+
+    withTimeout(timeoutMs?: number | false | null) {
+        this.store.withTimeout(timeoutMs);
+        return super.withTimeout(timeoutMs);
+    }
+
     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}`;
-                }
+                      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,
         );
     }
@@ -246,7 +289,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
             const auth = await this._auth();
             if (!this._jwt) {
                 // the _jwt may be set by the auth callback
-                this._jwt = auth.trim().split(" ")[1]; // remove Bearer prefix
+                this._jwt = auth.trim().split(' ')[1]; // remove Bearer prefix
             }
         }
         return this._jwt || null;
@@ -292,6 +335,14 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         return this.store.files;
     }
 
+    get processes() {
+        return this.store.processes;
+    }
+
+    get tasks() {
+        return this.store.tasks;
+    }
+
     /**
      * Alias for store.types
      */
@@ -317,29 +368,30 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
      * @returns AuthTokenResponse
      */
     async getAuthToken(token?: string): Promise<AuthTokenResponse> {
-        return fetch(`${this.tokenServerUrl}/token/issue`, {
-            method: "POST",
+        // Route through the base client (absolute URL) so the call benefits from the
+        // retry policy. The default retry methods exclude POST as non-idempotent, but
+        // /token/issue is safe to retry, so we opt POST in explicitly for this request.
+        return this.post<AuthTokenResponse>(`${this.tokenServerUrl}/token/issue`, {
             headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${token}`,
+                'content-type': 'application/json',
+                authorization: `Bearer ${token}`,
             },
-        })
-            .then((response) => response.json())
-            .then((data) => data as AuthTokenResponse)
-            .catch((error) => {
-                console.error(
-                    `Error fetching token from ${this.tokenServerUrl}:`,
-                    { error },
-                );
-                throw error;
-            });
+            retryPolicy: {
+                attempts: 4,
+                methods: ['POST'],
+                statuses: [429, 500, 502, 503, 504],
+            },
+        }).catch((error) => {
+            console.error(`Error fetching token from ${this.tokenServerUrl}:`, { error });
+            throw error;
+        });
     }
 
     get initialHeaders() {
         return {
             ...super.initialHeaders,
-            [VERSION_HEADER]: VERSION
-        }
+            [VERSION_HEADER]: VERSION,
+        };
     }
 
     projects = new ProjectsApi(this);
@@ -359,13 +411,18 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
     refs = new RefsApi(this);
     commands = new CommandsApi(this);
     apps = new AppsApi(this);
+    tools = new ToolsApi(this);
 }
 
 function isApiKey(apiKey: string) {
-    return apiKey.startsWith("pk-") || apiKey.startsWith("sk-");
+    return apiKey.startsWith('pk-') || apiKey.startsWith('sk-');
 }
 
-function isTokenExpired(token: string | null) {
+/**
+ * Returns true when the token should be refreshed: either missing, or within
+ * EXPIRATION_THRESHOLD of its `exp` claim, or already expired. Exported for tests.
+ */
+export function isTokenExpired(token: string | null) {
     if (!token) {
         return true;
     }
@@ -373,11 +430,11 @@ function isTokenExpired(token: string | null) {
     const decoded = decodeJWT(token);
     const exp = decoded.exp;
     const currentTime = Date.now();
-    return currentTime <= exp * 1000 - EXPIRATION_THRESHOLD;
+    return currentTime >= exp * 1000 - EXPIRATION_THRESHOLD;
 }
 
 export function decodeJWT(jwt: string): AuthTokenPayload {
-    const payloadBase64 = jwt.split(".")[1];
+    const payloadBase64 = jwt.split('.')[1];
     const decodedJson = base64UrlDecode(payloadBase64);
     return JSON.parse(decodedJson);
 }
@@ -387,7 +444,10 @@ type RuntimeProcess = {
 };
 
 type RuntimeBuffer = {
-    from(input: string, encoding: string): {
+    from(
+        input: string,
+        encoding: string,
+    ): {
         toString(encoding: string): string;
     };
 };
@@ -404,36 +464,31 @@ function getRuntimeStsUrl() {
 function base64UrlDecode(input: string): string {
     // Convert base64url to base64
     const base64 = input
-        .replace(/-/g, "+")
-        .replace(/_/g, "/")
+        .replace(/-/g, '+')
+        .replace(/_/g, '/')
         // Pad with '=' to make length a multiple of 4
-        .padEnd(Math.ceil(input.length / 4) * 4, "=");
+        .padEnd(Math.ceil(input.length / 4) * 4, '=');
 
     const runtimeBuffer = getRuntimeBuffer();
     if (runtimeBuffer) {
         // Node.js
-        return runtimeBuffer.from(base64, "base64").toString("utf-8");
-    } else if (
-        typeof atob !== "undefined" &&
-        typeof TextDecoder !== "undefined"
-    ) {
+        return runtimeBuffer.from(base64, 'base64').toString('utf-8');
+    } else if (typeof atob !== 'undefined' && typeof TextDecoder !== 'undefined') {
         // Browser
         const binary = atob(base64);
         const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
         // decode to utf8
         return new TextDecoder().decode(bytes);
     } else {
-        throw new Error("No base64 decoder available");
+        throw new Error('No base64 decoder available');
     }
 }
 
-export function decodeEndpoints(
-    endpoints: string | Record<string, string> | undefined,
-): Record<string, string> {
+export function decodeEndpoints(endpoints: string | Record<string, string> | undefined): Record<string, string> {
     if (!endpoints) {
-        return getEndpointsFromDomain("api.vertesia.io");
+        return getEndpointsFromDomain('api.vertesia.io');
     }
-    if (typeof endpoints === "string") {
+    if (typeof endpoints === 'string') {
         return getEndpointsFromDomain(endpoints);
     } else {
         return endpoints;
@@ -441,11 +496,12 @@ export function decodeEndpoints(
 }
 
 function getEndpointsFromDomain(domain: string) {
-    if (domain === "local") {
+    if (domain === 'local') {
         return {
             studio: `http://localhost:8091`,
             store: `http://localhost:8092`,
-            token: getRuntimeStsUrl() ?? "https://sts.dev1.vertesia.io",
+            token: getRuntimeStsUrl() ?? 'https://sts.dev1.vertesia.io',
+            git: 'https://git.dev1.vertesia.io',
         };
     } else {
         const url = `https://${domain}`;
@@ -454,7 +510,8 @@ function getEndpointsFromDomain(domain: string) {
         return {
             studio: url,
             store: url,
-            token: url.replace("api", "sts"),
+            token: url.replace('api', 'sts'),
+            git: url.replace('api', 'git'),
         };
     }
 }

package/src/execute.ts

@@ -1,5 +1,26 @@
-import { AsyncExecutionPayload, AsyncExecutionResult, ExecutionRunStatus, InteractionExecutionPayload, InteractionExecutionResult, NamedInteractionExecutionPayload, RateLimitRequestPayload, RateLimitRequestResponse } from '@vertesia/common';
-import { VertesiaClient } from './client.js';
+import {
+    type AsyncExecutionPayload,
+    type AsyncExecutionResult,
+    ExecutionRunStatus,
+    type InteractionExecutionPayload,
+    type InteractionExecutionResult,
+    type NamedInteractionExecutionPayload,
+    type RateLimitRequestPayload,
+    type RateLimitRequestResponse,
+} from '@vertesia/common';
+import type { VertesiaClient } from './client.js';
+
+/**
+ * Client-side timeout for a synchronous (non-streaming) interaction execution. The request blocks on
+ * studio-server until the model finishes — and the LLM (e.g. image generation) can legitimately take
+ * minutes — so the per-request timeout here is long, overriding any short client default. Override
+ * via the VERTESIA_INTERACTION_TIMEOUT_MS env var.
+ */
+const INTERACTION_EXECUTION_TIMEOUT_MS = (() => {
+    const raw = typeof process !== 'undefined' ? process.env?.VERTESIA_INTERACTION_TIMEOUT_MS : undefined;
+    const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 30 * 60 * 1000; // 30 minutes
+})();
 
 export async function EventSourceProvider(): Promise<typeof EventSource> {
     if (typeof globalThis.EventSource === 'function') {
@@ -19,14 +40,23 @@ export async function EventSourceProvider(): Promise<typeof EventSource> {
  * @param payload InteractionExecutionPayload
  * @param onChunk callback to be called when the next chunk of the response is available
  */
-export async function executeInteraction<P = any>(client: VertesiaClient,
+export async function executeInteraction<P = unknown>(
+    client: VertesiaClient,
     interactionId: string,
     payload: InteractionExecutionPayload = {},
-    onChunk?: (chunk: string) => void): Promise<InteractionExecutionResult<P>> {
+    onChunk?: (chunk: string) => void,
+): Promise<InteractionExecutionResult<P>> {
     const stream = !!onChunk;
-    const response = await client.runs.create({
-        ...payload, interaction: interactionId, stream
-    });
+    const response = (await client.runs.create(
+        {
+            ...payload,
+            interaction: interactionId,
+            stream,
+        },
+        // Synchronous interaction execution blocks on the model; keep a long client timeout.
+        // (Streaming returns the run immediately, then streams over a separate channel — see below.)
+        { timeoutMs: stream ? undefined : INTERACTION_EXECUTION_TIMEOUT_MS },
+    )) as unknown as InteractionExecutionResult<P>;
     if (stream) {
         if (response.status === ExecutionRunStatus.failed) {
             return response;
@@ -52,17 +82,21 @@ export async function executeInteraction<P = any>(client: VertesiaClient,
  * @param onChunk
  * @returns
  */
-export async function executeInteractionByName<P = any>(client: VertesiaClient,
+export async function executeInteractionByName<P = unknown>(
+    client: VertesiaClient,
     interaction: string,
     payload: InteractionExecutionPayload = {},
-    onChunk?: (chunk: string) => void): Promise<InteractionExecutionResult<P>> {
+    onChunk?: (chunk: string) => void,
+): Promise<InteractionExecutionResult<P>> {
     const stream = !!onChunk;
-    const response = await client.post('/api/v1/execute', {
+    const response = await client.post<InteractionExecutionResult<P>>('/api/v1/execute', {
         payload: {
             ...payload,
             interaction,
-            stream
+            stream,
         } as NamedInteractionExecutionPayload,
+        // Synchronous interaction execution blocks on the model; keep a long client timeout.
+        timeoutMs: stream ? undefined : INTERACTION_EXECUTION_TIMEOUT_MS,
     });
     if (stream) {
         if (response.status === ExecutionRunStatus.failed) {
@@ -75,10 +109,10 @@ export async function executeInteractionByName<P = any>(client: VertesiaClient,
 
 function handleStreaming(client: VertesiaClient, runId: string, onChunk: (chunk: string) => void) {
     return new Promise((resolve, reject) => {
-        (async () => {
+        void (async () => {
             try {
                 const EventSourceImpl = await EventSourceProvider();
-                const streamUrl = new URL(client.runs.baseUrl + '/' + runId + '/stream');
+                const streamUrl = new URL(`${client.runs.baseUrl}/${runId}/stream`);
                 const bearerToken = client._auth ? await client._auth() : undefined;
 
                 if (bearerToken) {
@@ -89,20 +123,20 @@ function handleStreaming(client: VertesiaClient, runId: string, onChunk: (chunk:
                 }
 
                 const sse = new EventSourceImpl(streamUrl.href);
-                sse.addEventListener("message", ev => {
+                sse.addEventListener('message', (ev) => {
                     try {
                         const data = JSON.parse(ev.data);
                         if (data) {
-                            onChunk && onChunk(data);
+                            onChunk?.(data);
                         }
                     } catch (err) {
                         reject(err);
                     }
                 });
-                sse.addEventListener("close", (ev) => {
+                sse.addEventListener('close', (ev) => {
                     try {
                         sse.close();
-                        const msg = JSON.parse(ev.data)
+                        const msg = JSON.parse(ev.data);
                         resolve(msg);
                     } catch (err) {
                         reject(err);
@@ -115,14 +149,20 @@ function handleStreaming(client: VertesiaClient, runId: string, onChunk: (chunk:
     });
 }
 
-export async function executeInteractionAsync(client: VertesiaClient, payload: AsyncExecutionPayload): Promise<AsyncExecutionResult> {
+export async function executeInteractionAsync(
+    client: VertesiaClient,
+    payload: AsyncExecutionPayload,
+): Promise<AsyncExecutionResult> {
     return await client.post('/api/v1/execute/async', {
         payload,
     });
 }
 
-export async function checkRateLimit(client: VertesiaClient, payload: RateLimitRequestPayload): Promise<RateLimitRequestResponse> {
+export async function checkRateLimit(
+    client: VertesiaClient,
+    payload: RateLimitRequestPayload,
+): Promise<RateLimitRequestResponse> {
     return await client.post('/api/v1/execute/rate-limit/request', {
-        payload
+        payload,
     });
 }

package/src/index.ts

@@ -1,6 +1,7 @@
-import type { AsyncExecutionResult, ComputedFacetResponse } from '@vertesia/common';
+import type { AsyncExecutionResult } from '@vertesia/common';
 
-export type { OrphanedAppInstallation } from "@vertesia/common";
+export type { OrphanedAppInstallation } from '@vertesia/common';
+export { getOAuthPermissionScopes, Permission } from '@vertesia/common';
 export * from './client.js';
 export type { GroupsQueryOptions } from './GroupsApi.js';
 export * from './InteractionBase.js';
@@ -9,11 +10,10 @@ export { default as OAuthClientsApi } from './OAuthClientsApi.js';
 export { default as OAuthGrantsApi } from './OAuthGrantsApi.js';
 export { default as OAuthProvidersApi } from './OAuthProvidersApi.js';
 export { default as OAuthServerApi } from './OAuthServerApi.js';
-export { default as RemoteMcpConnectionsApi } from './RemoteMcpConnectionsApi.js';
-export type { AsyncExecutionResult };
-/** @deprecated Use `ComputedFacetResponse` from `@vertesia/common`. */
-export type ComputeInteractionFacetsResponse = ComputedFacetResponse;
 export type { ComputePromptFacetsResponse, ListInteractionsResponse } from './PromptsApi.js';
+export { default as RemoteMcpConnectionsApi } from './RemoteMcpConnectionsApi.js';
 export type { ComputeRunFacetsResponse, FilterOption } from './RunsApi.js';
-export * from "./store/index.js";
-export * from "./StreamSource.js";
+export { default as SecretsApi } from './SecretsApi.js';
+export * from './StreamSource.js';
+export * from './store/index.js';
+export type { AsyncExecutionResult };

package/src/nodejs/NodeStreamSource.ts

@@ -1,7 +1,6 @@
-import type { Readable } from "node:stream";
-import { ReadableStream as NodeReadableStream } from "node:stream/web";
-import { StreamSource } from "../StreamSource.js";
-
+import type { Readable } from 'node:stream';
+import { ReadableStream as NodeReadableStream } from 'node:stream/web';
+import { StreamSource } from '../StreamSource.js';
 
 /**
  * A stream source that wraps a Node.js Readable stream.
@@ -38,6 +37,6 @@ function readableToWebStream_BUN<T = string | Buffer>(stream: Readable): Readabl
         },
         cancel() {
             it.return?.();
-        }
+        },
     });
 }

package/src/nodejs/index.ts

@@ -1 +1 @@
-export * from "./NodeStreamSource.js";
+export * from './NodeStreamSource.js';