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

package/package.json

@@ -1,27 +1,28 @@
 {
   "name": "@vertesia/client",
-  "version": "1.6.0-dev.20260923.085325Z",
+  "version": "1.6.0-dev.20261008.064737Z",
   "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.19.0",
     "@vertesia/tsconfig": "0.1.0",
-    "rolldown": "1.2.8",
+    "rolldown": "1.2.11",
     "typescript": "7.0.2",
-    "vitest": "5.0.1"
+    "vitest": "5.0.2"
   },
   "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.20261008.064411Z",
+    "@vertesia/api-fetch-client": "1.6.0-dev.20261008.064737Z",
+    "@vertesia/common": "1.6.0-dev.20261008.064737Z",
+    "eventsource": "^5.1.2"
   },
   "exports": {
     ".": {
@@ -48,13 +49,13 @@
     "ai",
     "typescript"
   ],
-  "gitHead": "8732631fd8099bdcab4f5375da2309f3cff34e19",
+  "gitHead": "8ee3a33e9a7c3dbcd13937e971cbdcc5fad56717",
   "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/AuditTrailApi.ts

@@ -1,9 +1,13 @@
 import { ApiTopic, type ClientBase } from '@vertesia/api-fetch-client';
 import type {
+    AuditAdoptionQuery,
+    AuditAdoptionResponse,
     AuditAggregationQuery,
     AuditAggregationResponse,
     AuditTrailQuery,
     AuditTrailResponse,
+    AuditUsageQuery,
+    AuditUsageResponse,
 } from '@vertesia/common';
 
 export default class AuditTrailApi extends ApiTopic {
@@ -33,4 +37,12 @@ export default class AuditTrailApi extends ApiTopic {
     aggregate(query: AuditAggregationQuery): Promise<AuditAggregationResponse> {
         return this.post('/aggregate', { payload: query });
     }
+
+    adoption(query: AuditAdoptionQuery = {}): Promise<AuditAdoptionResponse> {
+        return this.post('/adoption', { payload: query });
+    }
+
+    usage(query: AuditUsageQuery = {}): Promise<AuditUsageResponse> {
+        return this.post('/usage', { payload: query });
+    }
 }

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/client.ts

@@ -11,8 +11,9 @@ 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 InternalSecretsApi from './InternalSecretsApi.js';
 import OAuthClientsApi from './OAuthClientsApi.js';
 import OAuthGrantsApi from './OAuthGrantsApi.js';
 import OAuthProvidersApi from './OAuthProvidersApi.js';
@@ -125,7 +126,6 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
     oauthProviders: OAuthProvidersApi;
     remoteMcpConnections: RemoteMcpConnectionsApi;
     secrets: SecretsApi;
-    internalSecrets: InternalSecretsApi;
 
     /**
      * Create a client from the given token.
@@ -257,7 +257,6 @@ export class VertesiaClient extends AbstractFetchClient<VertesiaClient> {
         this.oauthProviders = new OAuthProvidersApi(this);
         this.remoteMcpConnections = new RemoteMcpConnectionsApi(this);
         this.secrets = new SecretsApi(this);
-        this.internalSecrets = new InternalSecretsApi(this);
     }
 
     withApiVersion(version: string | number | null) {
@@ -445,6 +444,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/execute.ts

@@ -62,7 +62,7 @@ export async function executeInteraction<P = unknown>(
         if (response.status === ExecutionRunStatus.failed) {
             return response;
         }
-        await handleStreaming(client, response.id, onChunk);
+        return handleStreaming<P>(client, response.id, onChunk);
     }
     return response;
 }
@@ -105,13 +105,17 @@ export async function executeInteractionByName<P = unknown>(
         if (response.status === ExecutionRunStatus.failed) {
             return response;
         }
-        await handleStreaming(client, response.id, onChunk);
+        return handleStreaming<P>(client, response.id, onChunk);
     }
     return response;
 }
 
-function handleStreaming(client: VertesiaClient, runId: string, onChunk: (chunk: string) => void) {
-    return new Promise((resolve, reject) => {
+function handleStreaming<P>(
+    client: VertesiaClient,
+    runId: string,
+    onChunk: (chunk: string) => void,
+): Promise<InteractionExecutionResult<P>> {
+    return new Promise<InteractionExecutionResult<P>>((resolve, reject) => {
         void (async () => {
             try {
                 const EventSourceImpl = await EventSourceProvider();
@@ -133,6 +137,7 @@ function handleStreaming(client: VertesiaClient, runId: string, onChunk: (chunk:
                             onChunk?.(data);
                         }
                     } catch (err) {
+                        sse.close();
                         reject(err);
                     }
                 });
@@ -145,6 +150,12 @@ function handleStreaming(client: VertesiaClient, runId: string, onChunk: (chunk:
                         reject(err);
                     }
                 });
+                sse.addEventListener('error', () => {
+                    if (sse.readyState === EventSourceImpl.CLOSED) {
+                        sse.close();
+                        reject(new Error('Interaction result stream closed before completion'));
+                    }
+                });
             } catch (err) {
                 reject(err);
             }

package/src/index.ts

@@ -7,8 +7,6 @@ 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 InternalSecretsApi } from './InternalSecretsApi.js';
 export * from './managed-sse.js';
 export { default as OAuthClientsApi } from './OAuthClientsApi.js';
 export { default as OAuthGrantsApi } from './OAuthGrantsApi.js';

package/src/managed-sse.ts

@@ -101,6 +101,7 @@ export function openManagedEventSource<T>(options: ManagedEventSourceOptions<T>)
         }
         cleanupCurrentSource();
         const connectionDuration = connectionOpenedAt ? Date.now() - connectionOpenedAt : 0;
+        connectionOpenedAt = 0;
         if (connectionDuration > 5000) {
             reconnectAttempts = 0;
         }
@@ -147,11 +148,7 @@ export function openManagedEventSource<T>(options: ManagedEventSourceOptions<T>)
                 return;
             }
             const url = await resolveUrl(options.url);
-            if (
-                lastEventId &&
-                options.last_event_id_query_param &&
-                !url.searchParams.has(options.last_event_id_query_param)
-            ) {
+            if (lastEventId && options.last_event_id_query_param) {
                 url.searchParams.set(options.last_event_id_query_param, lastEventId);
             }
             withAccessToken(url, await options.get_access_token?.());

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.
      */
@@ -397,7 +406,7 @@ export class AgentsApi extends ApiTopic {
                 currentSse.close();
                 currentSse = null;
             }
-            if (signal && abortHandler) {
+            if (isClosed && signal && abortHandler) {
                 signal.removeEventListener('abort', abortHandler);
                 abortHandler = null;
             }
@@ -450,13 +459,14 @@ export class AgentsApi extends ApiTopic {
             try {
                 // Resume from the last message we handed to the caller, whether it came from
                 // history, SSE, or an earlier poll. The server returns messages with ts > since.
-                const recent = await this.retrieveMessages(id, lastMessageTimestamp || undefined);
+                const previousMessageTimestamp = lastMessageTimestamp;
+                const recent = await this.retrieveMessages(id, previousMessageTimestamp || undefined);
                 polledMessages = true;
                 for (const msg of recent) {
                     if (isClosed) return;
                     const timestamp = msg.timestamp || 0;
-                    if (timestamp <= lastMessageTimestamp) continue;
-                    lastMessageTimestamp = timestamp;
+                    if (timestamp <= previousMessageTimestamp) continue;
+                    lastMessageTimestamp = Math.max(lastMessageTimestamp, timestamp);
                     if (onMessage) onMessage(msg, exit);
                     if (isClosed) return;
                     if (shouldCloseAgentRunStream(msg, id, options?.closeOnIdle)) {

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/WorkflowsApi.ts

@@ -212,7 +212,7 @@ export class WorkflowsApi extends ApiTopic {
                     currentSse.close();
                     currentSse = null;
                 }
-                if (signal && abortHandler) {
+                if (isClosed && signal && abortHandler) {
                     signal.removeEventListener('abort', abortHandler);
                     abortHandler = null;
                 }
@@ -349,12 +349,14 @@ export class WorkflowsApi extends ApiTopic {
                                 `Failed to reconnect to SSE stream for run ${runId} after ${maxReconnectAttempts} attempts`,
                             );
                             isClosed = true;
+                            cleanup();
                             reject(
                                 new Error(`SSE connection failed after ${maxReconnectAttempts} reconnection attempts`),
                             );
                         }
                     };
                 } catch (err) {
+                    if (isClosed) return;
                     console.error('Error setting up SSE stream:', err);
                     if (reconnectAttempts < maxReconnectAttempts) {
                         const delay = calculateBackoffDelay(reconnectAttempts);
@@ -366,6 +368,8 @@ export class WorkflowsApi extends ApiTopic {
                             }
                         }, delay);
                     } else {
+                        isClosed = true;
+                        cleanup();
                         reject(err);
                     }
                 }

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/store/signed-url.ts

@@ -36,6 +36,33 @@ export interface SignedUrlFetchOptions {
     retryableStatuses?: ReadonlySet<number>;
 }
 
+const AZURE_BLOB_HOST_SUFFIX = '.blob.core.windows.net';
+
+/** Whether a signed URL points at Azure Blob Storage (a SAS URL on `<account>.blob.core.windows.net`). */
+export function isAzureBlobUrl(url: string): boolean {
+    try {
+        return new URL(url).hostname.toLowerCase().endsWith(AZURE_BLOB_HOST_SUFFIX);
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * The headers for a `PUT` of file content to a signed upload URL.
+ *
+ * Azure's Put Blob rejects a request without `x-ms-blob-type`, so it is added for Azure Blob URLs
+ * only. GCS and S3 requests are left untouched: from a browser every extra header must be allowed
+ * by the bucket's CORS policy, and a header those backends do not expect would fail the preflight.
+ */
+export function signedUrlUploadHeaders(
+    url: string,
+    headers?: Record<string, string>,
+): Record<string, string> | undefined {
+    if (!isAzureBlobUrl(url)) return headers;
+    if (headers && Object.keys(headers).some((name) => name.toLowerCase() === 'x-ms-blob-type')) return headers;
+    return { ...headers, 'x-ms-blob-type': 'BlockBlob' };
+}
+
 function sleep(ms: number): Promise<void> {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -145,6 +172,9 @@ async function toReplayableBody(body: BodyInit | null | undefined): Promise<Body
  * `Retry-After` response header up to 60 seconds. Longer delays return the response
  * without retrying so the caller can schedule recovery outside this request.
  *
+ * A `PUT` to an Azure Blob SAS URL gets the `x-ms-blob-type` header it requires (see
+ * {@link signedUrlUploadHeaders}).
+ *
  * The returned `Response` is only guaranteed to be retried while it carries a
  * retryable status; a non-retryable error response (e.g. 403, 404) is returned
  * as-is for the caller to handle.
@@ -160,12 +190,13 @@ export async function fetchSignedUrl(url: string, options: SignedUrlFetchOptions
     } = options;
 
     const body = await toReplayableBody(options.body);
+    const requestHeaders = method.toUpperCase() === 'PUT' ? signedUrlUploadHeaders(url, headers) : headers;
 
     let lastError: unknown;
     for (let attempt = 0; attempt < attempts; attempt++) {
         const isLastAttempt = attempt === attempts - 1;
         try {
-            const res = await fetch(url, { method, headers, body });
+            const res = await fetch(url, { method, headers: requestHeaders, body });
             if (res.ok || !retryableStatuses.has(res.status) || isLastAttempt) {
                 return res;
             }