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

package/src/store/EventsApi.test.ts

@@ -1,131 +0,0 @@
-import type { EventDeliveryStreamSnapshot } from '@vertesia/common';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { VertesiaClient } from '../client.js';
-
-type Listener = (event: MessageEvent) => void;
-
-class FakeEventSource {
-    static readonly CONNECTING = 0;
-    static readonly OPEN = 1;
-    static readonly CLOSED = 2;
-
-    static instances: FakeEventSource[] = [];
-    static urls: string[] = [];
-
-    readonly url: string;
-    readonly withCredentials = false;
-    readyState = FakeEventSource.CONNECTING;
-    onopen: ((event: Event) => void) | null = null;
-    onmessage: ((event: MessageEvent) => void) | null = null;
-    onerror: ((event: Event) => void) | null = null;
-    private readonly listeners = new Map<string, Listener[]>();
-
-    constructor(url: string) {
-        this.url = url;
-        FakeEventSource.urls.push(url);
-        FakeEventSource.instances.push(this);
-    }
-
-    close() {
-        this.readyState = FakeEventSource.CLOSED;
-    }
-
-    addEventListener(type: string, listener: Listener) {
-        const listeners = this.listeners.get(type) ?? [];
-        listeners.push(listener);
-        this.listeners.set(type, listeners);
-    }
-
-    removeEventListener() {}
-
-    dispatchEvent() {
-        return true;
-    }
-
-    emit(type: string, data: unknown, lastEventId = '') {
-        const event = { data: JSON.stringify(data), lastEventId } as MessageEvent;
-        for (const listener of this.listeners.get(type) ?? []) {
-            listener(event);
-        }
-        if (type === 'message') {
-            this.onmessage?.(event);
-        }
-    }
-}
-
-function createClient(): VertesiaClient {
-    const client = new VertesiaClient({
-        serverUrl: 'https://studio.example.test',
-        storeUrl: 'https://store.example.test',
-    });
-    client.withAuthCallback(async () => 'Bearer test-token');
-    return client;
-}
-
-describe('EventsApi.subscribeDeliveries', () => {
-    beforeEach(() => {
-        FakeEventSource.instances = [];
-        FakeEventSource.urls = [];
-        vi.stubGlobal('EventSource', FakeEventSource);
-    });
-
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
-    });
-
-    it('serializes stream filters and auth token into the EventSource URL', async () => {
-        const client = createClient();
-        const subscription = client.events.subscribeDeliveries({
-            resource_id: 'agentic-coworker-platform',
-            resource_type: ['app', 'workflow_run'],
-            event_category: ['workflow', 'system'],
-            action: ['create', 'workflow_completed'],
-            outbox_status: ['failed'],
-            include_event: true,
-            poll_interval_ms: 1500,
-            on_envelope: () => {},
-        });
-
-        await vi.waitFor(() => expect(FakeEventSource.urls).toHaveLength(1));
-        const url = new URL(FakeEventSource.urls[0]);
-
-        expect(url.href).toContain('https://store.example.test/api/v1/events/stream');
-        expect(url.searchParams.get('access_token')).toBe('test-token');
-        expect(url.searchParams.get('resource_id')).toBe('agentic-coworker-platform');
-        expect(url.searchParams.get('resource_type')).toBe('app,workflow_run');
-        expect(url.searchParams.get('event_category')).toBe('workflow,system');
-        expect(url.searchParams.get('action')).toBe('create,workflow_completed');
-        expect(url.searchParams.get('outbox_status')).toBe('failed');
-        expect(url.searchParams.get('include_event')).toBe('true');
-        expect(url.searchParams.get('poll_interval_ms')).toBe('1500');
-
-        subscription.close();
-    });
-
-    it('dispatches typed snapshot envelopes to the snapshot callback', async () => {
-        const client = createClient();
-        const snapshots: EventDeliveryStreamSnapshot[] = [];
-        const subscription = client.events.subscribeDeliveries({
-            resource_id: 'demo-app',
-            on_snapshot: (_items, envelope) => snapshots.push(envelope),
-        });
-
-        await vi.waitFor(() => expect(FakeEventSource.instances).toHaveLength(1));
-        FakeEventSource.instances[0].emit(
-            'snapshot',
-            {
-                type: 'snapshot',
-                emitted_at: '2026-06-27T00:00:00.000Z',
-                cursor: 'evt_1',
-                deliveries: [],
-            } satisfies EventDeliveryStreamSnapshot,
-            'evt_1',
-        );
-
-        expect(snapshots).toHaveLength(1);
-        expect(snapshots[0].cursor).toBe('evt_1');
-
-        subscription.close();
-    });
-});

package/src/store/FilesApi.test.ts

@@ -1,118 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { ZenoClient } from './client.js';
-
-describe('FilesApi', () => {
-    it('retrieves a durable audio result through the authenticated file API', async () => {
-        const bytes = new Uint8Array([82, 73, 70, 70, 1, 2, 3]);
-        const sign = vi.fn(async () => Response.json({ url: 'https://signed.example/speech.wav' }));
-        vi.stubGlobal(
-            'fetch',
-            vi.fn(async () => new Response(bytes, { headers: { 'content-type': 'audio/wav' } })),
-        );
-        const client = new ZenoClient({ serverUrl: 'https://store.test', apikey: 'test-token', fetch: sign });
-        const stream = await client.files.downloadFile('gs://bucket/runs/run-1/media/speech.wav');
-        expect(new Uint8Array(await new Response(stream).arrayBuffer())).toEqual(bytes);
-        expect(sign).toHaveBeenCalledOnce();
-    });
-
-    afterEach(() => {
-        vi.restoreAllMocks();
-        vi.unstubAllGlobals();
-    });
-
-    it('retries signed upload URL creation after a transient connection failure', async () => {
-        let attempts = 0;
-        const fetchSignedUploadUrl = async (): Promise<Response> => {
-            attempts++;
-            if (attempts === 1) {
-                throw new TypeError('fetch failed');
-            }
-            return new Response(
-                JSON.stringify({ id: 'file-1', path: 'agents/run/conversation.json', url: 'https://signed' }),
-                {
-                    status: 200,
-                    headers: { 'content-type': 'application/json' },
-                },
-            );
-        };
-
-        const client = new ZenoClient({
-            serverUrl: 'https://store.test',
-            apikey: 'token',
-            fetch: fetchSignedUploadUrl,
-        });
-
-        const result = await client.files.getUploadUrl({
-            name: 'conversation.json',
-            id: 'agents/run/conversation.json',
-        });
-
-        expect(result).toEqual({ id: 'file-1', path: 'agents/run/conversation.json', url: 'https://signed' });
-        expect(attempts).toBe(2);
-    });
-
-    it('retries signed upload URL creation after a transient 503', async () => {
-        let attempts = 0;
-        const fetchSignedUploadUrl = async (): Promise<Response> => {
-            attempts++;
-            if (attempts === 1) {
-                return new Response(JSON.stringify({ message: 'try again' }), {
-                    status: 503,
-                    headers: { 'content-type': 'application/json' },
-                });
-            }
-            return new Response(
-                JSON.stringify({ id: 'file-1', path: 'agents/run/conversation.json', url: 'https://signed' }),
-                {
-                    status: 200,
-                    headers: { 'content-type': 'application/json' },
-                },
-            );
-        };
-
-        const client = new ZenoClient({
-            serverUrl: 'https://store.test',
-            apikey: 'token',
-            fetch: fetchSignedUploadUrl,
-        });
-
-        const result = await client.files.getUploadUrl({
-            name: 'conversation.json',
-            id: 'agents/run/conversation.json',
-        });
-
-        expect(result).toEqual({ id: 'file-1', path: 'agents/run/conversation.json', url: 'https://signed' });
-        expect(attempts).toBe(2);
-    });
-
-    it('does not expose a signed URL when a file download returns 404', async () => {
-        const signedUrl =
-            'https://storage.googleapis.com/test-bucket/agents/run/files/missing.png?X-Goog-Credential=secret&X-Goog-Signature=do-not-log';
-        const fetchDownloadUrl = (): Promise<Response> =>
-            Promise.resolve(
-                new Response(JSON.stringify({ url: signedUrl }), {
-                    status: 200,
-                    headers: { 'content-type': 'application/json' },
-                }),
-            );
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(null, { status: 404, statusText: 'Not Found' })));
-        const consoleError = vi.spyOn(console, 'error').mockImplementation(() => undefined);
-        const client = new ZenoClient({
-            serverUrl: 'https://store.test',
-            apikey: 'token',
-            fetch: fetchDownloadUrl,
-        });
-
-        const error = await client.files.downloadFile('agents/run/files/missing.png').catch((cause: unknown) => cause);
-
-        expect(error).toMatchObject({
-            name: 'FileDownloadError',
-            status: 404,
-            message: 'File download not found: agents/run/files/missing.png',
-        });
-        expect(String(error)).not.toContain('X-Goog-Credential');
-        expect(String(error)).not.toContain('X-Goog-Signature');
-        expect(String(error)).not.toContain('do-not-log');
-        expect(consoleError).not.toHaveBeenCalled();
-    });
-});

package/src/store/ObjectsApi.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { ZenoClient } from './client.js';
-
-describe('ObjectsApi revision labels', () => {
-    it.each(['v1.2', 'Review — 日本語', 'Révision – café', '100% complete & reviewed + approved'])(
-        'preserves the revision label %s through the query contract',
-        async (revisionLabel) => {
-            const requests: Request[] = [];
-            const client = new ZenoClient({
-                serverUrl: 'https://api.example.com',
-                fetch: vi.fn(async () => Response.json({ id: 'document-id' })),
-                onRequest: (request) => requests.push(request),
-            });
-
-            await client.objects.update(
-                'document-id',
-                { name: 'Updated document' },
-                {
-                    createRevision: true,
-                    revisionLabel,
-                    ifMatch: 'previous-etag',
-                },
-            );
-
-            expect(requests).toHaveLength(1);
-            const request = requests[0];
-            expect(request.method).toBe('PUT');
-            expect(new URL(request.url).searchParams.get('revision_label')).toBe(revisionLabel);
-            expect(request.headers.has('x-revision-label')).toBe(false);
-            expect(request.headers.get('x-create-revision')).toBe('true');
-            expect(request.headers.get('if-match')).toBe('previous-etag');
-            expect(await request.clone().json()).toEqual({ name: 'Updated document' });
-        },
-    );
-
-    it('does not send a label when updating in place', async () => {
-        const requests: Request[] = [];
-        const client = new ZenoClient({
-            serverUrl: 'https://api.example.com',
-            fetch: vi.fn(async () => Response.json({ id: 'document-id' })),
-            onRequest: (request) => requests.push(request),
-        });
-
-        await client.objects.update('document-id', {}, { revisionLabel: 'Unused — label' });
-
-        expect(new URL(requests[0].url).searchParams.has('revision_label')).toBe(false);
-        expect(requests[0].headers.has('x-create-revision')).toBe(false);
-        expect(requests[0].headers.has('x-revision-label')).toBe(false);
-    });
-});

package/src/store/ProcessApi.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { ZenoClient } from './client.js';
-
-function createClient(requests: Request[]) {
-    return new ZenoClient({
-        serverUrl: 'https://zeno.example.com',
-        fetch: vi.fn(async () => Response.json([])),
-        onRequest: (request) => requests.push(request),
-    });
-}
-
-describe('ProcessApi.list', () => {
-    it.each([
-        ['canonical', { all_versions: true }],
-        ['deprecated', { allVersions: true }],
-    ])('maps the %s all-versions option to the wire query', async (_name, query) => {
-        const requests: Request[] = [];
-        const client = createClient(requests);
-
-        await client.processes.list(query);
-
-        expect(requests[0]?.url).toBe('https://zeno.example.com/api/v1/processes?all_versions=true');
-    });
-});

package/src/store/ViewsApi.test.ts

@@ -1,33 +0,0 @@
-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/signed-url.test.ts

@@ -1,204 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { fetchSignedUrl } from './signed-url.js';
-
-function streamOf(chunk: Uint8Array): ReadableStream {
-    return new ReadableStream({
-        start(controller) {
-            controller.enqueue(chunk);
-            controller.close();
-        },
-    });
-}
-
-function response(status: number, body = '', headers?: Record<string, string>): Response {
-    return new Response(status === 204 ? null : body, { status, headers });
-}
-
-describe('fetchSignedUrl', () => {
-    let fetchMock: ReturnType<typeof vi.fn>;
-
-    beforeEach(() => {
-        fetchMock = vi.fn();
-        vi.stubGlobal('fetch', fetchMock);
-        // Make backoff instantaneous so the tests don't actually wait.
-        vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
-    });
-
-    async function runAllTimers<T>(promise: Promise<T>): Promise<T> {
-        await vi.runAllTimersAsync();
-        return promise;
-    }
-
-    it('returns immediately on a successful response', async () => {
-        fetchMock.mockResolvedValueOnce(response(200, 'ok'));
-        const res = await runAllTimers(fetchSignedUrl('https://storage/x'));
-        expect(res.status).toBe(200);
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-
-    it('retries on a 503 and succeeds', async () => {
-        fetchMock
-            .mockResolvedValueOnce(response(503, 'try later'))
-            .mockResolvedValueOnce(response(503, 'try later'))
-            .mockResolvedValueOnce(response(200, 'ok'));
-        const res = await runAllTimers(fetchSignedUrl('https://storage/x', { method: 'PUT', body: 'data' }));
-        expect(res.status).toBe(200);
-        expect(fetchMock).toHaveBeenCalledTimes(3);
-    });
-
-    it('retries on connection errors and succeeds', async () => {
-        fetchMock.mockRejectedValueOnce(new TypeError('network error')).mockResolvedValueOnce(response(200, 'ok'));
-        const res = await runAllTimers(fetchSignedUrl('https://storage/x'));
-        expect(res.status).toBe(200);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-    });
-
-    it('does not retry non-retryable statuses (404)', async () => {
-        fetchMock.mockResolvedValueOnce(response(404, 'missing'));
-        const res = await runAllTimers(fetchSignedUrl('https://storage/x'));
-        expect(res.status).toBe(404);
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-
-    it('returns the last retryable response after exhausting attempts', async () => {
-        fetchMock.mockResolvedValue(response(503, 'down'));
-        const res = await runAllTimers(fetchSignedUrl('https://storage/x', { attempts: 3 }));
-        expect(res.status).toBe(503);
-        expect(fetchMock).toHaveBeenCalledTimes(3);
-    });
-
-    it('throws the connection error after exhausting attempts', async () => {
-        const err = new TypeError('network down');
-        fetchMock.mockRejectedValue(err);
-        // Attach the rejection expectation before advancing timers to avoid an
-        // unhandled rejection while the backoff timer is pending.
-        const assertion = expect(fetchSignedUrl('https://storage/x', { attempts: 2 })).rejects.toThrow('network down');
-        await vi.runAllTimersAsync();
-        await assertion;
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-    });
-
-    it('buffers a ReadableStream body so it can be replayed across retries', async () => {
-        const bodies: unknown[] = [];
-        fetchMock.mockImplementation((_url: string, init: RequestInit) => {
-            bodies.push(init.body);
-            return Promise.resolve(bodies.length < 2 ? response(503, 'retry') : response(200, 'ok'));
-        });
-
-        const stream = streamOf(new TextEncoder().encode('hello'));
-        const res = await runAllTimers(
-            fetchSignedUrl('https://storage/x', { method: 'PUT', body: stream as unknown as BodyInit }),
-        );
-
-        expect(res.status).toBe(200);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-        // The stream was buffered into a replayable Blob, and the same instance was reused on retry.
-        expect(bodies[0]).toBeInstanceOf(Blob);
-        expect(bodies[0]).toBe(bodies[1]);
-    });
-
-    it('buffers a string-chunk ReadableStream body without throwing (regression: non-Uint8Array chunk)', async () => {
-        const bodies: unknown[] = [];
-        fetchMock.mockImplementation((_url: string, init: RequestInit) => {
-            bodies.push(init.body);
-            return Promise.resolve(response(200, 'ok'));
-        });
-
-        // A web stream that yields *string* chunks — what `Readable.toWeb(Readable.from(text))`
-        // produces (NodeStreamSource wraps text bodies this way). `new Response(stream).blob()`
-        // rejects these under undici with "Received non-Uint8Array chunk"; the helper must
-        // encode them to bytes instead.
-        const stream = new ReadableStream<string>({
-            start(controller) {
-                controller.enqueue('hello ');
-                controller.enqueue('world');
-                controller.close();
-            },
-        });
-
-        const res = await runAllTimers(
-            fetchSignedUrl('https://storage/x', { method: 'PUT', body: stream as unknown as BodyInit }),
-        );
-
-        expect(res.status).toBe(200);
-        expect(bodies[0]).toBeInstanceOf(Blob);
-        expect(await (bodies[0] as Blob).text()).toBe('hello world');
-    });
-
-    it('buffers a mixed-chunk ReadableStream body, encoding strings and keeping bytes', async () => {
-        const bodies: unknown[] = [];
-        fetchMock.mockImplementation((_url: string, init: RequestInit) => {
-            bodies.push(init.body);
-            return Promise.resolve(response(200, 'ok'));
-        });
-
-        const stream = new ReadableStream<string | Uint8Array>({
-            start(controller) {
-                controller.enqueue('a');
-                controller.enqueue(new TextEncoder().encode('b'));
-                controller.close();
-            },
-        });
-
-        const res = await runAllTimers(
-            fetchSignedUrl('https://storage/x', { method: 'PUT', body: stream as unknown as BodyInit }),
-        );
-
-        expect(res.status).toBe(200);
-        expect(bodies[0]).toBeInstanceOf(Blob);
-        expect(await (bodies[0] as Blob).text()).toBe('ab');
-    });
-
-    it('throws on an object-mode stream chunk instead of silently corrupting the upload', async () => {
-        const stream = new ReadableStream<unknown>({
-            start(controller) {
-                controller.enqueue({ not: 'bytes' });
-                controller.close();
-            },
-        });
-
-        await expect(
-            fetchSignedUrl('https://storage/x', { method: 'PUT', body: stream as unknown as BodyInit }),
-        ).rejects.toThrow(TypeError);
-        // The bad body is rejected before any network call is attempted.
-        expect(fetchMock).not.toHaveBeenCalled();
-        expect(stream.locked).toBe(false);
-    });
-
-    it('honors a numeric Retry-After header when scheduling the retry', async () => {
-        fetchMock
-            .mockResolvedValueOnce(response(503, 'slow down', { 'retry-after': '30' }))
-            .mockResolvedValueOnce(response(200, 'ok'));
-        const pending = fetchSignedUrl('https://storage/x');
-        await vi.advanceTimersByTimeAsync(29999);
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        await vi.advanceTimersByTimeAsync(1);
-        const res = await pending;
-        expect(res.status).toBe(200);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-    });
-});
-
-describe('Retry-After request budget', () => {
-    it.each(['3600', '2147484', '1e308', new Date(Date.now() + 3600000).toUTCString()])(
-        'returns the intact response without an early retry for %s',
-        async (retryAfter) => {
-            const res = new Response('retry later', { status: 503, headers: { 'Retry-After': retryAfter } });
-            const fetch = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(res);
-            try {
-                const result = await fetchSignedUrl('https://storage/x');
-                expect(result).toBe(res);
-                expect(await result.text()).toBe('retry later');
-                expect(fetch).toHaveBeenCalledTimes(1);
-            } finally {
-                fetch.mockRestore();
-            }
-        },
-    );
-});