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

package/package.json

@@ -1,27 +1,28 @@
 {
   "name": "@vertesia/client",
-  "version": "1.6.0-dev.20260923.085325Z",
+  "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.5",
+    "@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.1"
   },
   "dependencies": {
-    "@llumiverse/common": "1.6.0-dev.20260923.085100Z",
-    "@vertesia/api-fetch-client": "1.6.0-dev.20260923.085325Z",
-    "@vertesia/common": "1.6.0-dev.20260923.085325Z",
-    "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": "8732631fd8099bdcab4f5375da2309f3cff34e19",
+  "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/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/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/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/client.ts

@@ -11,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';
@@ -126,6 +129,7 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
     remoteMcpConnections: RemoteMcpConnectionsApi;
     secrets: SecretsApi;
     internalSecrets: InternalSecretsApi;
+    internalRunBudgets: InternalRunBudgetsApi;
 
     /**
      * Create a client from the given token.
@@ -258,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) {
@@ -445,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

@@ -8,6 +8,7 @@ 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.
      */

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);
-    });
-});

package/src/AppsApi.test.ts

@@ -1,132 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { VertesiaClient } from './client.js';
-
-describe('AppsApi', () => {
-    it('starts an in-place version rebuild without a caller-controlled payload', async () => {
-        const requests: Request[] = [];
-        const fetchMock = vi.fn(async () =>
-            Response.json({
-                workflow_id: 'workflow-1',
-                run_id: 'run-1',
-                app_id: 'sample-app',
-                version_id: 'version-1',
-                rebuild_version_record_id: 'record-1',
-            }),
-        );
-        const client = new VertesiaClient({
-            serverUrl: 'https://studio.example.com',
-            storeUrl: 'https://zeno.example.com',
-            fetch: fetchMock,
-            onRequest: (request) => requests.push(request),
-        });
-
-        const result = await client.apps.rebuildVersion('record-1');
-
-        expect(result.version_id).toBe('version-1');
-        expect(requests[0]?.method).toBe('POST');
-        expect(requests[0]?.url).toBe('https://studio.example.com/api/v1/apps/versions/record-1/rebuild');
-    });
-
-    it('deletes a version through its dedicated endpoint', async () => {
-        const requests: Request[] = [];
-        const fetchMock = vi.fn(async () =>
-            Response.json({
-                id: 'record-1',
-                app_id: 'sample-app',
-                version_id: 'version-1',
-                deleted: true,
-                warnings: [],
-            }),
-        );
-        const client = new VertesiaClient({
-            serverUrl: 'https://studio.example.com',
-            storeUrl: 'https://zeno.example.com',
-            fetch: fetchMock,
-            onRequest: (request) => requests.push(request),
-        });
-
-        const result = await client.apps.deleteVersion('record-1');
-
-        expect(result.deleted).toBe(true);
-        expect(requests[0]?.method).toBe('DELETE');
-        expect(requests[0]?.url).toBe('https://studio.example.com/api/v1/apps/versions/record-1');
-    });
-
-    it('returns the original response bytes and content type', async () => {
-        const requests: Request[] = [];
-        const bytes = new Uint8Array([0, 255, 10, 42]);
-        const fetchMock = vi.fn(
-            async () =>
-                new Response(bytes, {
-                    status: 200,
-                    headers: { 'content-type': 'application/octet-stream' },
-                }),
-        );
-        const client = new VertesiaClient({
-            serverUrl: 'https://studio.example.com',
-            storeUrl: 'https://zeno.example.com',
-            fetch: fetchMock,
-            onRequest: (request) => requests.push(request),
-        });
-
-        const response = await client.apps.getRepoFile('sample-app', 'docs/file.bin', { ref: 'feature/demo' });
-
-        expect(response.headers.get('content-type')).toBe('application/octet-stream');
-        expect(new Uint8Array(await response.arrayBuffer())).toEqual(bytes);
-        expect(requests[0]?.url).toBe(
-            'https://studio.example.com/api/v1/apps/sample-app/repo/file?path=docs%2Ffile.bin&ref=feature%2Fdemo',
-        );
-    });
-
-    it('uploads multiple documents as one multipart commit request', async () => {
-        const requests: Request[] = [];
-        const fetchMock = vi.fn(async () =>
-            Response.json({
-                ref: 'main',
-                previous_commit: '1'.repeat(40),
-                commit: '2'.repeat(40),
-                paths: ['docs/guide.md', 'docs/diagram.png'],
-            }),
-        );
-        const client = new VertesiaClient({
-            serverUrl: 'https://studio.example.com',
-            storeUrl: 'https://zeno.example.com',
-            fetch: fetchMock,
-            onRequest: (request) => requests.push(request),
-        });
-
-        const result = await client.apps.commitRepoDocuments(
-            'sample-app',
-            [
-                { path: 'docs/guide.md', content: new Blob(['# Guide']), fileName: 'guide.md' },
-                { path: 'docs/diagram.png', content: new Blob([new Uint8Array([1, 2, 3])]), fileName: 'diagram.png' },
-            ],
-            { ref: 'main', expectedHead: '1'.repeat(40), message: 'Add docs' },
-        );
-
-        expect(result.commit).toBe('2'.repeat(40));
-        const request = requests[0];
-        if (!request) {
-            throw new Error('Expected a multipart document request');
-        }
-        expect(request.url).toBe('https://studio.example.com/api/v1/apps/sample-app/repo/documents');
-        expect(request.headers.get('content-type')).toContain('multipart/form-data; boundary=');
-        const form = await request.formData();
-        expect(JSON.parse(String(form.get('metadata')))).toEqual({
-            ref: 'main',
-            expected_head: '1'.repeat(40),
-            message: 'Add docs',
-            files: [
-                { field: 'file_0', path: 'docs/guide.md' },
-                { field: 'file_1', path: 'docs/diagram.png' },
-            ],
-        });
-        const guideFile = form.get('file_0');
-        const diagramFile = form.get('file_1');
-        if (!(guideFile instanceof File) || !(diagramFile instanceof File)) {
-            throw new Error('Expected multipart file entries');
-        }
-        expect(guideFile.name).toBe('guide.md');
-        expect(diagramFile.size).toBe(3);
-    });
-});

package/src/EnvironmentsApi.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { VertesiaClient } from './client.js';
-
-describe('EnvironmentsApi', () => {
-    it('encodes model IDs in disableModel paths', async () => {
-        const requests: Request[] = [];
-        const fetchMock = vi.fn(async () => {
-            return new Response(
-                JSON.stringify({
-                    id: 'env-id',
-                    name: 'Test Environment',
-                    provider: 'test',
-                    account: 'account-id',
-                    created_by: 'user:test',
-                    updated_by: 'user:test',
-                    created_at: new Date(0).toISOString(),
-                    updated_at: new Date(0).toISOString(),
-                }),
-                {
-                    status: 200,
-                    headers: { 'content-type': 'application/json' },
-                },
-            );
-        });
-
-        const client = new VertesiaClient({
-            serverUrl: 'https://api.example.com',
-            storeUrl: 'https://api.example.com',
-            fetch: fetchMock,
-            onRequest: (request) => requests.push(request),
-        });
-
-        await client.environments.disableModel('env-id', 'provider/model#v?1');
-
-        expect(requests[0]?.url).toBe(
-            'https://api.example.com/api/v1/environments/env-id/models/enabled/provider%2Fmodel%23v%3F1',
-        );
-    });
-});