@vertesia/client 1.6.0-dev.20260918.115658Z → 1.6.0-dev.20261004.085740Z

package/package.json

@@ -1,27 +1,28 @@
 {
   "name": "@vertesia/client",
-  "version": "1.6.0-dev.20260918.115658Z",
+  "version": "1.6.0-dev.20261004.085740Z",
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "files": [
     "lib",
     "src",
+    "!src/**/*.test.*",
     "tsconfig.dist.json"
   ],
   "license": "Apache-2.0",
   "devDependencies": {
-    "@types/node": "^24.13.3",
+    "@types/node": "^24.13.6",
     "@vertesia/tsconfig": "0.1.0",
-    "rolldown": "1.2.8",
+    "rolldown": "1.2.9",
     "typescript": "7.0.2",
-    "vitest": "5.0.0"
+    "vitest": "5.0.1"
   },
   "dependencies": {
-    "@llumiverse/common": "1.6.0-dev.20260918.055633Z",
-    "@vertesia/api-fetch-client": "1.6.0-dev.20260918.115658Z",
-    "@vertesia/common": "1.6.0-dev.20260918.115658Z",
-    "eventsource": "^5.1.1"
+    "@llumiverse/common": "1.6.0-dev.20261004.083934Z",
+    "@vertesia/api-fetch-client": "1.6.0-dev.20261004.085740Z",
+    "@vertesia/common": "1.6.0-dev.20261004.085740Z",
+    "eventsource": "^5.1.2"
   },
   "exports": {
     ".": {
@@ -48,13 +49,13 @@
     "ai",
     "typescript"
   ],
-  "gitHead": "5961811f0fdaee3b4902a2230875a3325e64ad80",
+  "gitHead": "b51b6dc9262f81f55e2424d1e57190060f6068d7",
   "scripts": {
     "lint": "biome lint src",
     "clean:lib": "rimraf ./lib ./tsconfig.tsbuildinfo",
-    "build": "pnpm run clean:lib && tsc -p tsconfig.json && pnpm exec rolldown -c rolldown.config.js",
+    "build": "pnpm run clean:lib && tsc --checkers 1 -p tsconfig.json && pnpm exec rolldown -c rolldown.config.js",
     "clean": "rimraf ./node_modules ./lib ./tsconfig.tsbuildinfo",
     "test": "vitest run",
-    "typecheck:test": "tsc -p tsconfig.test.json --noEmit"
+    "typecheck:test": "tsc --checkers 1 -p tsconfig.test.json --noEmit"
   }
 }

package/src/AppsApi.ts

@@ -39,6 +39,7 @@ import type {
     StartAppDevelopmentTaskRequest,
     StartAppScaffoldRequest,
     StartAppScaffoldResponse,
+    UpdateAppInstallationOAuthApprovalPayload,
     UpdateAppInstallationToolAllowlistPayload,
     UpdateAppPayload,
     UpsertAppVersionRequest,
@@ -429,6 +430,16 @@ export default class AppsApi extends ApiTopic {
         });
     }
 
+    /**
+     * Set project-admin approval for an installation's OAuth scopes.
+     * Pass an empty list to revoke approval.
+     */
+    updateOAuthApproval(installId: string, approved_scopes: string[]): Promise<AppInstallationWithManifest> {
+        return this.put(`/installations/${installId}/oauth-approval`, {
+            payload: { approved_scopes } satisfies UpdateAppInstallationOAuthApprovalPayload,
+        });
+    }
+
     /**
      * Update the tool allowlist for an app installation.
      * Pass null to remove all restrictions (all tools permitted).

package/src/EnvironmentsApi.ts

@@ -15,6 +15,8 @@ import type {
     ExecutionEnvironmentUpdatePayload,
     MigrateInteractionsPayload,
     MigrateInteractionsResult,
+    RunBudgetCapability,
+    RunBudgetCapabilityQuery,
 } from '@vertesia/common';
 
 export default class EnvironmentsApi extends ApiTopic {
@@ -38,6 +40,10 @@ export default class EnvironmentsApi extends ApiTopic {
         });
     }
 
+    runBudgetCapability(id: string, query: RunBudgetCapabilityQuery): Promise<RunBudgetCapability> {
+        return this.get(`/${id}/run-budget-capability`, { query });
+    }
+
     retrieve(id: string): Promise<ExecutionEnvironment> {
         return this.get(`/${id}`);
     }

package/src/InferenceProfilesApi.ts

@@ -0,0 +1,47 @@
+import { ApiTopic, type ClientBase } from '@vertesia/api-fetch-client';
+import type {
+    CreateInferenceProfilePayload,
+    DeleteByIdResult,
+    InferenceProfile,
+    InferenceProfileRecord,
+    InferenceProfileUsage,
+    InferenceProfileUsageQuery,
+    ProjectConfiguration,
+    ProjectInferenceProfiles,
+    UpdateInferenceProfilePayload,
+} from '@vertesia/common';
+
+export default class InferenceProfilesApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, '/api/v1/inference-profiles');
+    }
+    /** Read a category or base default, including projects awaiting the defaults migration. */
+    async getDefault(
+        configuration: Pick<ProjectConfiguration, 'inference' | 'defaults'>,
+        category?: keyof NonNullable<ProjectInferenceProfiles['system']>,
+    ): Promise<InferenceProfileRecord | InferenceProfile | undefined> {
+        const settings = configuration.inference;
+        const id = (category ? settings?.system?.[category] : undefined) ?? settings?.default_profile;
+        if (id) return this.retrieve(id);
+        return (category ? configuration.defaults?.system?.[category] : undefined) ?? configuration.defaults?.base;
+    }
+
+    list(): Promise<InferenceProfileRecord[]> {
+        return this.get('/');
+    }
+    retrieve(id: string): Promise<InferenceProfileRecord> {
+        return this.get(`/${encodeURIComponent(id)}`);
+    }
+    usage(id: string, query: InferenceProfileUsageQuery = {}): Promise<InferenceProfileUsage> {
+        return this.get(`/${encodeURIComponent(id)}/usage`, { query });
+    }
+    create(payload: CreateInferenceProfilePayload): Promise<InferenceProfileRecord> {
+        return this.post('/', { payload });
+    }
+    update(id: string, payload: UpdateInferenceProfilePayload): Promise<InferenceProfileRecord> {
+        return this.put(`/${encodeURIComponent(id)}`, { payload });
+    }
+    delete(id: string): Promise<DeleteByIdResult> {
+        return this.del(`/${encodeURIComponent(id)}`);
+    }
+}

package/src/InteractionConfigurationsApi.ts

@@ -0,0 +1,20 @@
+import { ApiTopic, type ClientBase } from '@vertesia/api-fetch-client';
+import type { InteractionConfigurationResult, UpdateInteractionConfigurationPayload } from '@vertesia/common';
+
+export default class InteractionConfigurationsApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, '/api/v1/interaction-configurations');
+    }
+    retrieve(interactionId: string): Promise<InteractionConfigurationResult> {
+        return this.get(`/${encodeURIComponent(interactionId)}`);
+    }
+    update(
+        interactionId: string,
+        payload: UpdateInteractionConfigurationPayload,
+    ): Promise<InteractionConfigurationResult> {
+        return this.put(`/${encodeURIComponent(interactionId)}`, { payload });
+    }
+    delete(interactionId: string): Promise<InteractionConfigurationResult> {
+        return this.del(`/${encodeURIComponent(interactionId)}`);
+    }
+}

package/src/InteractionOutput.ts

@@ -217,6 +217,21 @@ export class InteractionOutput<T = unknown> {
         return this.results.filter((r) => r.type === 'image').map((r) => r.value);
     }
 
+    hasAudio(): boolean {
+        return this.results.some((r) => r.type === 'audio');
+    }
+
+    /** Get complete audio metadata and its durable file reference. */
+    audios() {
+        return this.results.filter((r) => r.type === 'audio');
+    }
+
+    audio() {
+        const result = this.audios()[0];
+        if (!result) throw new Error('No audio result found');
+        return result;
+    }
+
     /** Get the first video result URI. */
     video(): string {
         const videoResult = this.results.find((r) => r.type === 'video');

package/src/InteractionsApi.ts

@@ -30,6 +30,7 @@ import type {
     RateLimitRequestPayload,
     RateLimitRequestResponse,
     ResolvedInteractionExecutionInfo,
+    ResolveInteractionQuery,
 } from '@vertesia/common';
 import type { VertesiaClient } from './client.js';
 import { checkRateLimit, executeInteraction, executeInteractionAsync, executeInteractionByName } from './execute.js';
@@ -341,15 +342,7 @@ export default class InteractionsApi extends ApiTopic {
      * @param options Optional environment and/or model to resolve with
      * @returns ResolvedInteractionExecutionInfo with the resolved environment and model
      */
-    resolve(
-        nameOrId: string,
-        options?: {
-            environment?: string;
-            model?: string;
-            hasImage?: boolean;
-            hasVideo?: boolean;
-        },
-    ): Promise<ResolvedInteractionExecutionInfo> {
+    resolve(nameOrId: string, options?: ResolveInteractionQuery): Promise<ResolvedInteractionExecutionInfo> {
         return this.get(`/resolve/${encodeURIComponent(nameOrId)}`, {
             query: options,
         });

package/src/InternalAccountsApi.ts

@@ -0,0 +1,12 @@
+import { ApiTopic, type ClientBase } from '@vertesia/api-fetch-client';
+import type { AccountApiVersionPolicy } from '@vertesia/common';
+
+export default class InternalAccountsApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, '/internal/accounts');
+    }
+
+    getApiVersionPolicy(accountId: string): Promise<AccountApiVersionPolicy> {
+        return this.get(`/${encodeURIComponent(accountId)}/api-version-policy`);
+    }
+}

package/src/InternalRunBudgetsApi.ts

@@ -0,0 +1,13 @@
+import { ApiTopic, type ClientBase } from '@vertesia/api-fetch-client';
+import type { ReadRunBudgetUsagePayload, RunBudgetTotals } from '@vertesia/common';
+
+/** Workload-authenticated accounting operations. Ordinary user tokens are not accepted. */
+export default class InternalRunBudgetsApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, '/internal/run-budget');
+    }
+
+    usage(payload: ReadRunBudgetUsagePayload): Promise<RunBudgetTotals> {
+        return this.post('/usage', { payload });
+    }
+}

package/src/OAuthServerApi.ts

@@ -7,6 +7,8 @@ import type {
     OAuthDeviceAuthorizationRequest,
     OAuthDeviceAuthorizationResponse,
     OAuthGrantableScopesResponse,
+    OAuthLoginDecisionResponse,
+    OAuthLoginPayload,
 } from '@vertesia/common';
 
 export default class OAuthServerApi extends ClientBase {
@@ -20,6 +22,10 @@ export default class OAuthServerApi extends ClientBase {
         this.verboseErrors = parent.verboseErrors;
     }
 
+    login(requestId: string, payload: OAuthLoginPayload): Promise<OAuthLoginDecisionResponse> {
+        return this.post(`/requests/${encodeURIComponent(requestId)}/login`, { payload });
+    }
+
     get headers() {
         return this.parent.headers;
     }

package/src/client.ts

@@ -1,4 +1,5 @@
 import { AbstractFetchClient, type FETCH_FN, type IRequestRetryPolicy } from '@vertesia/api-fetch-client';
+import type { AppSessionTokenRequest, AppSessionTokenResponse } from '@vertesia/common';
 import { APP_VERSION_HEADER, type AuthTokenPayload, type AuthTokenResponse } from '@vertesia/common';
 import AccountApi from './AccountApi.js';
 import AccountsApi from './AccountsApi.js';
@@ -10,7 +11,10 @@ import CommandsApi from './CommandsApi.js';
 import DelegationGrantsApi from './DelegationGrantsApi.js';
 import EnvironmentsApi from './EnvironmentsApi.js';
 import { IamApi } from './IamApi.js';
+import InferenceProfilesApi from './InferenceProfilesApi.js';
+import InteractionConfigurationsApi from './InteractionConfigurationsApi.js';
 import InteractionsApi from './InteractionsApi.js';
+import InternalRunBudgetsApi from './InternalRunBudgetsApi.js';
 import InternalSecretsApi from './InternalSecretsApi.js';
 import OAuthClientsApi from './OAuthClientsApi.js';
 import OAuthGrantsApi from './OAuthGrantsApi.js';
@@ -125,6 +129,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
     remoteMcpConnections: RemoteMcpConnectionsApi;
     secrets: SecretsApi;
     internalSecrets: InternalSecretsApi;
+    internalRunBudgets: InternalRunBudgetsApi;
 
     /**
      * Create a client from the given token.
@@ -257,6 +262,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         this.remoteMcpConnections = new RemoteMcpConnectionsApi(this);
         this.secrets = new SecretsApi(this);
         this.internalSecrets = new InternalSecretsApi(this);
+        this.internalRunBudgets = new InternalRunBudgetsApi(this);
     }
 
     withApiVersion(version: string | number | null) {
@@ -412,6 +418,10 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
      *
      * @returns AuthTokenResponse
      */
+    async mintAppSessionToken(request: AppSessionTokenRequest): Promise<AppSessionTokenResponse> {
+        return this.post<AppSessionTokenResponse>(`${this.tokenServerUrl}/token/app-session`, { payload: request });
+    }
+
     async getAuthToken(token?: string): Promise<AuthTokenResponse> {
         // 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
@@ -440,6 +450,8 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
     }
 
     projects = new ProjectsApi(this);
+    interactionConfigurations = new InteractionConfigurationsApi(this);
+    inferenceProfiles = new InferenceProfilesApi(this);
     environments = new EnvironmentsApi(this);
     interactions = new InteractionsApi(this);
     skills = new SkillsApi(this);

package/src/index.ts

@@ -7,6 +7,8 @@ export { default as DelegationGrantsApi } from './DelegationGrantsApi.js';
 export type { GroupsQueryOptions } from './GroupsApi.js';
 export * from './InteractionBase.js';
 export * from './InteractionOutput.js';
+export { default as InternalAccountsApi } from './InternalAccountsApi.js';
+export { default as InternalRunBudgetsApi } from './InternalRunBudgetsApi.js';
 export { default as InternalSecretsApi } from './InternalSecretsApi.js';
 export * from './managed-sse.js';
 export { default as OAuthClientsApi } from './OAuthClientsApi.js';

package/src/store/AgentsApi.ts

@@ -12,6 +12,7 @@ import {
     type AgentRunInternals,
     type AgentRunResponse,
     type AgentRunUpdatesResponse,
+    type AllocateAgentRunBudgetPayload,
     type BindRunWorkflowPayload,
     type CreateAgentRunPayload,
     type CreateProcessRunPayload,
@@ -226,6 +227,14 @@ export class AgentsApi extends ApiTopic {
         return this.post(`/${id}/restart`, {});
     }
 
+    /**
+     * Add token budget to a run paused because its budget ran out; the run resumes from where it
+     * stopped. The amount is added to the limit the run was granted, so usage past it is paid first.
+     */
+    allocateBudget(id: string, payload: AllocateAgentRunBudgetPayload): Promise<SignalAgentResponse> {
+        return this.post(`/${id}/budget`, { payload });
+    }
+
     /**
      * Fork a conversation into a new agent run.
      */
@@ -435,6 +444,15 @@ export class AgentsApi extends ApiTopic {
             );
         };
 
+        // A 404 while polling means the run itself is gone (deleted, or never persisted): nothing
+        // will ever arrive, so stop instead of polling the missing resource every 5s forever.
+        const isRunGone = (error: unknown): boolean =>
+            typeof error === 'object' && error !== null && (error as { status?: unknown }).status === 404;
+        const exitBecauseRunGone = () => {
+            console.warn(`Agent stream ${id}: the run no longer exists (404); stopping the polling fallback.`);
+            exit(null);
+        };
+
         const pollTick = async () => {
             if (isClosed || !isPolling) return;
             let polledMessages = false;
@@ -456,6 +474,10 @@ export class AgentsApi extends ApiTopic {
                     }
                 }
             } catch (err) {
+                if (isRunGone(err)) {
+                    exitBecauseRunGone();
+                    return;
+                }
                 warnPollFailure('GET /updates', err);
             }
             if (isClosed || !isPolling) return;
@@ -468,6 +490,10 @@ export class AgentsApi extends ApiTopic {
                 }
                 if (polledMessages) consecutivePollFailures = 0;
             } catch (err) {
+                if (isRunGone(err)) {
+                    exitBecauseRunGone();
+                    return;
+                }
                 warnPollFailure('run status check', err);
             }
             if (isClosed || !isPolling) return;

package/src/store/ContentApi.ts

@@ -0,0 +1,158 @@
+import { ApiTopic, type ClientBase } from '@vertesia/api-fetch-client';
+import type {
+    Collection,
+    ComplexSearchPayload,
+    ComputedFacetResponse,
+    ContentObject,
+    ContentObjectItem,
+    GetFileUrlResponse,
+    GetRenditionResponse,
+} from '@vertesia/common';
+
+/** A project sharing content with the caller. */
+export interface SharedProjectRef {
+    id: string;
+    name: string;
+}
+
+/** A lightweight entry in a shared browse listing (root list or collection members). */
+export interface SharedContentEntry {
+    type: 'object' | 'collection';
+    id: string;
+    title: string;
+    modified_at: string;
+}
+
+/** Result of resolving a bare content id: the entity, its type, and the project it lives in. */
+export type ResolvedContent =
+    | { type: 'object'; projectId: string; entity: ContentObject }
+    | { type: 'collection'; projectId: string; entity: Collection };
+
+/** A cross-project search hit, stamped with its owner project and relevance score. */
+export type ContentSearchHit = ContentObjectItem & { projectId: string; score: number };
+
+/** Which projects a cross-project content search covered. */
+export interface SharedSearchCoverage {
+    /** 'hybrid' when vector search ran on at least one field, otherwise 'text'. */
+    mode: 'text' | 'hybrid';
+    /** Project ids actually searched — full-text spans every reachable project. */
+    searched: string[];
+    /** Reachable project ids excluded from the vector pass as embedding-incompatible (hybrid only). */
+    vectorIncompatible: string[];
+}
+
+/**
+ * Response of the cross-project content search: the hits plus `coverage`. This is an object envelope —
+ * distinct from the plain array returned by the single-project object search — so callers can tell the
+ * two apart (array = project search, `{ results, coverage }` = cross-project search).
+ */
+export interface ContentSearchResponse {
+    results: ContentSearchHit[];
+    /** Facets computed across every reachable project. */
+    facets: ComputedFacetResponse;
+    coverage: SharedSearchCoverage;
+}
+
+/**
+ * Read-only client for the `/api/content` namespace: browse and read content shared by other
+ * projects in the account, resolve a bare content id, and search across the caller's reachable
+ * content (current project + shared projects). There are no write operations.
+ */
+export class ContentApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, '/api/v1/content');
+    }
+
+    /** The projects sharing content with the caller (`{ id, name }`). */
+    listSharedProjects(): Promise<SharedProjectRef[]> {
+        return this.get('/shared');
+    }
+
+    /**
+     * Shared COLLECTIONS at a browse level — the root collections of a shared project (no `parentId`),
+     * or the sub-collections of `parentId` within it. Bounded set, returned in full, newest first.
+     */
+    sharedCollections(projectId: string, parentId?: string): Promise<SharedContentEntry[]> {
+        const path = parentId ? `/shared/${projectId}/${parentId}` : `/shared/${projectId}`;
+        return this.get(path, { query: { list: 'collections' } });
+    }
+
+    /**
+     * A page of shared OBJECTS at a browse level — the root objects of a shared project (no `parentId`),
+     * or the member objects of `parentId` within it. Paginated via `from`/`limit`, newest first.
+     */
+    sharedObjects(
+        projectId: string,
+        parentId?: string,
+        options?: { from?: number; limit?: number },
+    ): Promise<SharedContentEntry[]> {
+        const path = parentId ? `/shared/${projectId}/${parentId}` : `/shared/${projectId}`;
+        return this.get(path, { query: { list: 'objects', from: options?.from, limit: options?.limit } });
+    }
+
+    /** Read a shared entity's detail: an object id → the full object; a collection id → its meta. */
+    getShared(projectId: string, id: string): Promise<ContentObject | Collection> {
+        return this.get(`/shared/${projectId}/${id}`);
+    }
+
+    /**
+     * A rendition (visual content) of a shared object — the rendered file (image / PDF) from the owner
+     * project's storage. `format`: 'jpeg' | 'png' | 'webp' | 'pdf' | 'docx'. Returns `{ status, renditions:
+     * url[] }`; rejects with 404 if no rendition of that format has been generated yet by the owner project.
+     */
+    getSharedRendition(
+        projectId: string,
+        id: string,
+        format: string,
+        options?: { max_hw?: number },
+    ): Promise<GetRenditionResponse> {
+        return this.get(`/shared/${projectId}/${id}/renditions/${format}`, {
+            query: { max_hw: options?.max_hw },
+        });
+    }
+
+    /**
+     * Signed download URL for a shared object's OWN file (its content source) from the owner project's
+     * storage — used to preview a native PDF/image or download the existing file cross-project.
+     * `disposition` 'attachment' forces a download (default 'inline'). Rejects with 404 if the object
+     * isn't shared/authorized or has no content source. Read-only: never generates anything.
+     */
+    getSharedFileUrl(
+        projectId: string,
+        id: string,
+        disposition?: 'inline' | 'attachment',
+    ): Promise<GetFileUrlResponse> {
+        return this.get(`/shared/${projectId}/${id}/file`, { query: { disposition } });
+    }
+
+    /**
+     * Resolve a bare content id when the project is unknown — the current project is checked first,
+     * then the shared projects. Returns the entity, its type, and the resolved projectId.
+     */
+    resolve(objectId: string): Promise<ResolvedContent> {
+        return this.get(`/resolve/${objectId}`);
+    }
+
+    /**
+     * Search content reachable by the caller (current project + shared projects). Takes the same
+     * `ComplexSearchPayload` as `objects.search` — full-text, vector/hybrid, filters and facets — applied
+     * across every reachable project (vector runs only over embedding-compatible ones). `onlyShared` drops
+     * the current project. Pagination (`payload.limit`/`offset`) is text-only; a vector/hybrid run returns
+     * a top-N window. Returns `{ results, facets, coverage }` — each hit stamped with its owner projectId,
+     * plus which projects were searched vs. excluded from the vector pass.
+     */
+    search(payload: ComplexSearchPayload, options?: { onlyShared?: boolean }): Promise<ContentSearchResponse> {
+        return this.post('/search', {
+            payload,
+            query: { onlyShared: options?.onlyShared ? 'true' : undefined },
+        });
+    }
+
+    /**
+     * The CURRENT project's shared roots (collections + documents) — the Manage view. Requires
+     * content-admin. Unshare an entry via the regular collection/object update with `shared_root: false`.
+     */
+    managed(): Promise<SharedContentEntry[]> {
+        return this.get('/managed');
+    }
+}

package/src/store/DataApi.ts

@@ -463,7 +463,7 @@ export class DataApi extends ApiTopic {
      * const info = await client.data.getDownloadInfo(storeId);
      * // Download if gcs_generation changed
      * if (info.gcs_generation !== localGeneration) {
-     *   await downloadFile(info.url, '/home/daytona/databases/store.duckdb');
+     *   await downloadFile(info.url, 'databases/store.duckdb');
      * }
      * ```
      */

package/src/store/IndexingApi.ts

@@ -335,12 +335,14 @@ export class IndexingApi extends ApiTopic {
         targetIndex: string,
         alias?: string,
         backend?: ElasticsearchBackend,
+        cleanup?: boolean,
     ): Promise<SwapAliasResult> {
         return this.zenoBulkPost('/reindex/swap-alias', {
             tenant_id: tenantId,
             target_index: targetIndex,
             alias,
             backend,
+            cleanup,
         } satisfies SwapAliasRequest);
     }
 }

package/src/store/client.ts

@@ -8,6 +8,7 @@ import { APP_VERSION_HEADER, type BulkOperationPayload, type BulkOperationRespon
 import { warnUnknownOptions } from '../unknown-options.js';
 import { AgentsApi } from './AgentsApi.js';
 import { CollectionsApi } from './CollectionsApi.js';
+import { ContentApi } from './ContentApi.js';
 import { CostApi } from './CostApi.js';
 import { DataApi } from './DataApi.js';
 import { EmailApi } from './EmailApi.js';
@@ -122,6 +123,7 @@ export class ZenoClient extends AbstractFetchClient<ZenoClient> {
     agents = new AgentsApi(this);
     cost = new CostApi(this);
     objects = new ObjectsApi(this);
+    content = new ContentApi(this);
     types = new TypesApi(this);
     workflows = new WorkflowsApi(this);
     schedules = new SchedulesApi(this);

package/src/store/index.ts

@@ -1,4 +1,5 @@
 export * from './AgentsApi.js';
+export * from './ContentApi.js';
 export * from './client.js';
 export * from './DataApi.js';
 export * from './EmailApi.js';

package/src/AccountApi.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { VertesiaClient } from './client.js';
-
-describe('AccountApi', () => {
-    it('returns onboarding.completed_at as the ISO string received over JSON', async () => {
-        const completedAt = '2026-07-29T10:00:00.000Z';
-        const fetchMock = vi.fn(async () => {
-            return new Response(
-                JSON.stringify({
-                    id: 'account-id',
-                    onboarding: { completed: true, completed_at: completedAt },
-                }),
-                {
-                    status: 200,
-                    headers: { 'content-type': 'application/json' },
-                },
-            );
-        });
-        const client = new VertesiaClient({
-            serverUrl: 'https://api.example.com',
-            storeUrl: 'https://api.example.com',
-            fetch: fetchMock,
-        });
-
-        const account = await client.account.info();
-
-        expect(account.onboarding.completed_at).toBe(completedAt);
-        expect(account.onboarding.completed_at).not.toBeInstanceOf(Date);
-    });
-});