@vertesia/client 1.5.0-dev.20260717.131047Z → 1.5.0-dev.20260725.083715Z

package/src/store/AnalyzeDocApi.ts

@@ -1,16 +1,10 @@
-import { ApiTopic, type ClientBase, type IRequestParams } from '@vertesia/api-fetch-client';
+import { ApiTopic, type ClientBase } from '@vertesia/api-fetch-client';
 import type {
-    AdaptedTable,
-    AdaptTablesRequest,
     DocAnalyzeRunStatusResponse,
-    DocAnalyzerResultResponse,
-    DocImage,
-    DocTableCsv,
-    DocTableJson,
-    ExportTableFormats,
-    GetAdaptedTablesRequestQuery,
-    PdfToRichtextOptions,
-    WorkflowRunStatus,
+    DocumentPrepOptions,
+    GroundedAssistantResponse,
+    GroundedExtractionRequest,
+    GroundedExtractionResultResponse,
 } from '@vertesia/common';
 
 export class AnalyzeDocApi extends ApiTopic {
@@ -21,7 +15,7 @@ export class AnalyzeDocApi extends ApiTopic {
         super(parent, `/${objectId}/analyze`);
     }
 
-    async start(payload: PdfToRichtextOptions): Promise<DocAnalyzeRunStatusResponse> {
+    async start(payload: DocumentPrepOptions): Promise<DocAnalyzeRunStatusResponse> {
         return this.post('/', { payload });
     }
 
@@ -29,51 +23,19 @@ export class AnalyzeDocApi extends ApiTopic {
         return this.get('/status');
     }
 
-    async getResults(): Promise<DocAnalyzerResultResponse> {
-        return this.get('/results');
+    async startGroundedExtraction(payload?: GroundedExtractionRequest): Promise<DocAnalyzeRunStatusResponse> {
+        return this.post('/grounded', { payload: payload ?? {} });
     }
 
-    async adaptTables(payload: AdaptTablesRequest): Promise<WorkflowRunStatus> {
-        return this.post('/adapt_tables', { payload });
+    async getGroundedExtractionResult(): Promise<GroundedExtractionResultResponse> {
+        return this.get('/grounded/result');
     }
 
-    async getAdaptedTables(
-        runId?: string,
-        query?: GetAdaptedTablesRequestQuery,
-    ): Promise<Record<number, AdaptedTable>> {
-        const path = runId ? `/adapt_tables/${runId}` : '/adapt_tables';
-
-        // Build query parameters
-        const queryParams: NonNullable<IRequestParams['query']> = {};
-        if (query?.format) queryParams.format = query.format;
-        if (query?.raw !== undefined) queryParams.raw = query.raw;
-
-        // If format is CSV, set response type to text to avoid automatic JSON parsing
-        const options: IRequestParams & { responseType?: 'text' } = { query: queryParams };
-        if (query?.format === 'csv') {
-            options.responseType = 'text';
-        }
-
-        return this.get(path, options);
-    }
-
-    async getXml(): Promise<string> {
-        return this.get('/xml');
-    }
-
-    async getTables(format?: ExportTableFormats): Promise<DocTableCsv[] | DocTableJson[]> {
-        const options: IRequestParams = {};
-        if (format) {
-            options.query = { format: format };
-        }
-        return this.get('/tables', options);
-    }
-
-    async getImages(): Promise<DocImage[]> {
-        return this.get('/images');
-    }
-
-    async getAnnotated(): Promise<{ url: string }> {
-        return this.get('/annotated');
+    /**
+     * Launch the interactive grounded extraction assistant for this document.
+     * Returns the agent_run_id used to stream/render the conversation.
+     */
+    async startGroundedAssistant(payload?: GroundedExtractionRequest): Promise<GroundedAssistantResponse> {
+        return this.post('/grounded/assistant', { payload: payload ?? {} });
     }
 }

package/src/store/FilesApi.ts

@@ -17,6 +17,7 @@ import type {
 } from '@vertesia/common';
 import { StreamSource } from '../StreamSource.js';
 import { fetchSignedUrl } from './signed-url.js';
+import { getUploadMimeTypeHint, resolveUploadMimeType } from './uploadMimeType.js';
 
 export const MEMORIES_PREFIX = 'memories';
 export const ARTIFACTS_PREFIX = 'agents';
@@ -137,7 +138,7 @@ export class FilesApi extends ApiTopic {
     ): Promise<{ source: string; name: string; type?: string; etag?: string }[]> {
         const fileDescriptors = sources.map((s) => ({
             name: s.name,
-            mime_type: s.type,
+            mime_type: getUploadMimeTypeHint(s.type),
             id: s instanceof StreamSource ? s.id : undefined,
         }));
 
@@ -153,7 +154,7 @@ export class FilesApi extends ApiTopic {
                     const idx = i + j;
                     const { url, id, mime_type } = files[idx];
                     const isStream = source instanceof StreamSource;
-                    const sourceMimeType = source.type || mime_type;
+                    const sourceMimeType = resolveUploadMimeType(source.type, mime_type);
 
                     const res = await fetchSignedUrl(url, {
                         method: 'PUT',
@@ -193,13 +194,18 @@ export class FilesApi extends ApiTopic {
      */
     async uploadFileWithPath(source: StreamSource | File): Promise<{ id: string; path: string }> {
         const isStream = source instanceof StreamSource;
-        const { url, id, path } = await this.getUploadUrl(source);
+        const { url, id, path, mime_type } = await this.getUploadUrl({
+            id: isStream ? source.id : undefined,
+            name: source.name,
+            mime_type: getUploadMimeTypeHint(source.type),
+        });
+        const sourceMimeType = resolveUploadMimeType(source.type, mime_type) || 'application/gzip';
 
         const res = await fetchSignedUrl(url, {
             method: 'PUT',
             body: isStream ? source.stream : source,
             headers: {
-                'Content-Type': source.type || 'application/gzip',
+                'Content-Type': sourceMimeType,
             },
         }).catch((err) => {
             console.error('Failed to upload file', { err, url, id, path });

package/src/store/ObjectsApi.ts

@@ -56,6 +56,7 @@ import { StreamSource } from '../StreamSource.js';
 import { AnalyzeDocApi } from './AnalyzeDocApi.js';
 import type { ZenoClient } from './client.js';
 import { fetchSignedUrl } from './signed-url.js';
+import { getUploadMimeTypeHint, resolveUploadMimeType } from './uploadMimeType.js';
 
 type ContentObjectWritePayload = Omit<CreateContentObjectPayload, 'content'> & {
     content?: ContentSource | File | StreamSource;
@@ -259,9 +260,9 @@ export class ObjectsApi extends ApiTopic {
         const { url, id, mime_type } = await this.getUploadUrl({
             id: isStream ? source.id : undefined,
             name: source.name,
-            mime_type: source.type,
+            mime_type: getUploadMimeTypeHint(source.type),
         });
-        const sourceMimeType = source.type || mime_type;
+        const sourceMimeType = resolveUploadMimeType(source.type, mime_type);
 
         // upload the file content to the signed URL
         const res = await fetchSignedUrl(url, {

package/src/store/ViewsApi.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ZenoClient } from './client.js';
+
+describe('StoreViewsApi', () => {
+    it('uses the View execution resource for persisted and draft execution', async () => {
+        const requests: Request[] = [];
+        const fetchMock = vi.fn(async () => {
+            return new Response(JSON.stringify({}), {
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+            });
+        });
+        const client = new ZenoClient({
+            serverUrl: 'https://api.example.com',
+            fetch: fetchMock,
+            onRequest: (request) => requests.push(request),
+        });
+
+        await client.views.execute('app:content:document-library');
+        await client.views.preview({
+            configuration: {
+                name: 'Document library',
+                description: 'Browse documents.',
+                scope: {},
+            },
+        });
+
+        expect(requests.map((request) => request.url)).toEqual([
+            'https://api.example.com/api/v1/view-executions/app%3Acontent%3Adocument-library/execute',
+            'https://api.example.com/api/v1/view-executions/preview',
+        ]);
+    });
+});

package/src/store/ViewsApi.ts

@@ -0,0 +1,20 @@
+import { ApiTopic, type ClientBase } from '@vertesia/api-fetch-client';
+import type { ExecuteViewRequest, PreviewViewExperienceRequest, ViewExecutionResult } from '@vertesia/common';
+
+export class StoreViewsApi extends ApiTopic {
+    constructor(parent: ClientBase) {
+        super(parent, '/api/v1/view-executions');
+    }
+
+    execute(id: string, payload: ExecuteViewRequest = {}): Promise<ViewExecutionResult> {
+        return this.post(`/${encodeURIComponent(id)}/execute`, { payload });
+    }
+
+    /**
+     * Validate and execute an unsaved View configuration without persisting it.
+     * Returns the same normalized results as {@link execute}.
+     */
+    preview(payload: PreviewViewExperienceRequest): Promise<ViewExecutionResult> {
+        return this.post('/preview', { payload });
+    }
+}

package/src/store/client.ts

@@ -24,6 +24,7 @@ import { RenderingApi } from './RenderingApi.js';
 import { SchedulesApi } from './SchedulesApi.js';
 import { TaskApi } from './TaskApi.js';
 import { TypesApi } from './TypesApi.js';
+import { StoreViewsApi } from './ViewsApi.js';
 import { VERSION, VERSION_HEADER } from './version.js';
 import { WorkflowsApi } from './WorkflowsApi.js';
 
@@ -125,4 +126,5 @@ export class ZenoClient extends AbstractFetchClient<ZenoClient> {
     query = new QueryApi(this);
     hiveMemory = new HiveMemoryApi(this);
     rendering = new RenderingApi(this);
+    views = new StoreViewsApi(this);
 }

package/src/store/index.ts

@@ -20,5 +20,6 @@ export * from './signed-url.js';
 export * from './TaskApi.js';
 export * from './TypeCatalogApi.js';
 export * from './TypesApi.js';
+export * from './ViewsApi.js';
 export { APP_VERSION_HEADER } from './version.js';
 export * from './WorkflowsApi.js';

package/src/store/uploadMimeType.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { getUploadMimeTypeHint, resolveUploadMimeType } from './uploadMimeType.js';
+
+describe('upload MIME type resolution', () => {
+    it('keeps a specific browser-provided content type', () => {
+        expect(getUploadMimeTypeHint('text/plain')).toBe('text/plain');
+        expect(resolveUploadMimeType('text/plain', 'text/markdown')).toBe('text/plain');
+    });
+
+    it('uses filename inference when the browser reports generic binary content', () => {
+        expect(getUploadMimeTypeHint('application/octet-stream')).toBeUndefined();
+        expect(resolveUploadMimeType('application/octet-stream', 'text/markdown')).toBe('text/markdown');
+    });
+
+    it('uses filename inference when the browser omits the content type', () => {
+        expect(resolveUploadMimeType('', 'text/markdown')).toBe('text/markdown');
+    });
+
+    it('retains octet-stream when no more specific type can be inferred', () => {
+        expect(resolveUploadMimeType('application/octet-stream', undefined)).toBe('application/octet-stream');
+    });
+});

package/src/store/uploadMimeType.ts

@@ -0,0 +1,16 @@
+const GENERIC_BINARY_CONTENT_TYPE = 'application/octet-stream';
+
+function normalizedContentType(contentType: string | undefined): string | undefined {
+    return contentType?.split(';', 1)[0]?.trim().toLowerCase() || undefined;
+}
+
+export function getUploadMimeTypeHint(contentType: string | undefined): string | undefined {
+    return normalizedContentType(contentType) === GENERIC_BINARY_CONTENT_TYPE ? undefined : contentType || undefined;
+}
+
+export function resolveUploadMimeType(
+    sourceContentType: string | undefined,
+    inferredContentType: string | undefined,
+): string | undefined {
+    return getUploadMimeTypeHint(sourceContentType) || inferredContentType || sourceContentType || undefined;
+}