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

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

package/src/store/stream-gap.test.ts

@@ -1,230 +0,0 @@
-import { type AgentMessage, AgentMessageType } from '@vertesia/common';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { VertesiaClient } from '../client.js';
-
-class FakeEventSource {
-    static readonly CONNECTING = 0;
-    static readonly OPEN = 1;
-    static readonly CLOSED = 2;
-
-    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;
-
-    constructor(url: string) {
-        this.url = url;
-        FakeEventSource.urls.push(url);
-    }
-
-    close() {
-        this.readyState = FakeEventSource.CLOSED;
-    }
-
-    addEventListener() {}
-
-    removeEventListener() {}
-
-    dispatchEvent() {
-        return true;
-    }
-}
-
-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;
-}
-
-function message(timestamp: number): AgentMessage {
-    return {
-        type: AgentMessageType.THOUGHT,
-        timestamp,
-        workflow_run_id: 'run-1',
-        message: 'historical',
-        workstream_id: 'main',
-    };
-}
-
-function mockApiGet<T extends object>(api: T, response: unknown) {
-    return vi
-        .spyOn(api as unknown as { get: (path: string, options?: unknown) => Promise<unknown> }, 'get')
-        .mockResolvedValue(response);
-}
-
-describe('streamMessages GET-to-SSE handoff', () => {
-    beforeEach(() => {
-        FakeEventSource.urls = [];
-        vi.stubGlobal('EventSource', FakeEventSource);
-    });
-
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
-    });
-
-    it('uses a positive SSE since cursor for an agent run with empty initial history', async () => {
-        const client = createClient();
-        vi.spyOn(client.agents, 'retrieveMessages').mockResolvedValue([]);
-        const abort = new AbortController();
-
-        const stream = client.agents.streamMessages('agent-run-1', undefined, undefined, abort.signal);
-
-        await vi.waitFor(() => expect(FakeEventSource.urls).toHaveLength(1));
-
-        const streamUrl = new URL(FakeEventSource.urls[0]);
-        expect(streamUrl.searchParams.get('skipHistory')).toBe('true');
-        expect(Number(streamUrl.searchParams.get('since'))).toBeGreaterThan(0);
-
-        abort.abort();
-        await stream;
-    });
-
-    it('keeps the latest historical timestamp as the SSE since cursor for an agent run', async () => {
-        const client = createClient();
-        vi.spyOn(client.agents, 'retrieveMessages').mockResolvedValue([message(1_234)]);
-        const abort = new AbortController();
-
-        const stream = client.agents.streamMessages('agent-run-1', undefined, undefined, abort.signal);
-
-        await vi.waitFor(() => expect(FakeEventSource.urls).toHaveLength(1));
-
-        const streamUrl = new URL(FakeEventSource.urls[0]);
-        expect(streamUrl.searchParams.get('since')).toBe('1234');
-
-        abort.abort();
-        await stream;
-    });
-
-    it('delivers full agent history before closing on a terminal historical message', async () => {
-        const client = createClient();
-        const complete = {
-            ...message(1_000),
-            type: AgentMessageType.COMPLETE,
-            message: 'previous turn complete',
-        };
-        const latest = {
-            ...message(2_000),
-            message: 'newer historical message',
-        };
-        vi.spyOn(client.agents, 'retrieveMessages').mockResolvedValue([complete, latest]);
-        const delivered: AgentMessage[] = [];
-        const abort = new AbortController();
-
-        const stream = client.agents.streamMessages(
-            'agent-run-1',
-            (msg) => {
-                delivered.push(msg);
-            },
-            undefined,
-            abort.signal,
-        );
-
-        await vi.waitFor(() => expect(FakeEventSource.urls).toHaveLength(1));
-
-        expect(delivered.map((msg) => msg.message)).toEqual(['previous turn complete', 'newer historical message']);
-        expect(new URL(FakeEventSource.urls[0]).searchParams.get('since')).toBe('2000');
-
-        abort.abort();
-        await stream;
-    });
-
-    it('normalizes legacy agent history messages before returning them to the UI', async () => {
-        const client = createClient();
-        mockApiGet(client.agents, {
-            messages: [
-                {
-                    type: 8,
-                    timestamp: 1_000,
-                    workflow_run_id: 'legacy-run',
-                    message: 'What are the news headlines in France today?',
-                    workstream_id: 'main',
-                    details: { event_class: 'user_content' },
-                },
-                {
-                    type: 7,
-                    timestamp: 2_000,
-                    workflow_run_id: 'legacy-run',
-                    message: 'Here are the headlines.',
-                    workstream_id: 'main',
-                    details: { streamed: true },
-                },
-            ],
-        });
-
-        const messages = await client.agents.retrieveMessages('agent-run-1');
-
-        expect(messages).toEqual([
-            expect.objectContaining({
-                type: AgentMessageType.QUESTION,
-                timestamp: 1_000,
-                workflow_run_id: 'agent-run-1',
-                message: 'What are the news headlines in France today?',
-                details: { event_class: 'user_content' },
-            }),
-            expect.objectContaining({
-                type: AgentMessageType.ANSWER,
-                timestamp: 2_000,
-                workflow_run_id: 'agent-run-1',
-                message: 'Here are the headlines.',
-                details: { streamed: true },
-            }),
-        ]);
-    });
-
-    it('normalizes legacy workflow history messages before returning them to the UI', async () => {
-        const client = createClient();
-        mockApiGet(client.workflows, {
-            messages: [
-                {
-                    type: 'answer',
-                    timestamp: 3_000,
-                    workflow_run_id: 'legacy-run',
-                    message: 'Workflow answer',
-                    workstream_id: 'main',
-                },
-            ],
-        });
-
-        const messages = await client.workflows.retrieveMessages('workflow-1', 'workflow-run-1');
-
-        expect(messages).toEqual([
-            expect.objectContaining({
-                type: AgentMessageType.ANSWER,
-                timestamp: 3_000,
-                workflow_run_id: 'workflow-run-1',
-                message: 'Workflow answer',
-            }),
-        ]);
-    });
-
-    it('uses a positive SSE since cursor for a workflow run with empty initial history', async () => {
-        const client = createClient();
-        vi.spyOn(client.workflows, 'retrieveMessages').mockResolvedValue([]);
-        const abort = new AbortController();
-
-        const stream = client.workflows.streamMessages(
-            'workflow-1',
-            'workflow-run-1',
-            undefined,
-            undefined,
-            abort.signal,
-        );
-
-        await vi.waitFor(() => expect(FakeEventSource.urls).toHaveLength(1));
-
-        const streamUrl = new URL(FakeEventSource.urls[0]);
-        expect(streamUrl.searchParams.get('skipHistory')).toBe('true');
-        expect(Number(streamUrl.searchParams.get('since'))).toBeGreaterThan(0);
-
-        abort.abort();
-        await stream;
-    });
-});

package/src/store/stream-termination.test.ts

@@ -1,82 +0,0 @@
-import { type AgentMessage, AgentMessageType, type CompactMessage } from '@vertesia/common';
-import { describe, expect, it } from 'vitest';
-import { shouldCloseAgentRunStream, shouldCloseCompactRunStream } from './stream-termination.js';
-
-describe('stream termination', () => {
-    const rootRunId = 'root-run';
-
-    it('closes agent streams on the root run completion', () => {
-        const message: AgentMessage = {
-            type: AgentMessageType.COMPLETE,
-            timestamp: Date.now(),
-            workflow_run_id: rootRunId,
-            message: 'root complete',
-            workstream_id: 'main',
-            details: {
-                process_run_id: rootRunId,
-            },
-        };
-
-        expect(shouldCloseAgentRunStream(message, rootRunId)).toBe(true);
-    });
-
-    it('keeps agent streams open for child process completion on main', () => {
-        const message: AgentMessage = {
-            type: AgentMessageType.COMPLETE,
-            timestamp: Date.now(),
-            workflow_run_id: rootRunId,
-            message: 'child complete',
-            workstream_id: 'main',
-            details: {
-                process_run_id: 'child-run',
-            },
-        };
-
-        expect(shouldCloseAgentRunStream(message, rootRunId)).toBe(false);
-    });
-
-    it('keeps compact streams open for child process completion on main', () => {
-        const message: CompactMessage = {
-            t: AgentMessageType.COMPLETE,
-            m: 'child complete',
-            d: {
-                process_run_id: 'child-run',
-            },
-        };
-
-        expect(shouldCloseCompactRunStream(message, rootRunId)).toBe(false);
-    });
-
-    it('still closes streams for main completion without process metadata', () => {
-        const message: CompactMessage = {
-            t: AgentMessageType.COMPLETE,
-            m: 'conversation complete',
-        };
-
-        expect(shouldCloseCompactRunStream(message, rootRunId)).toBe(true);
-    });
-
-    it('keeps interactive root streams open when the conversation becomes idle', () => {
-        const message: AgentMessage = {
-            type: AgentMessageType.IDLE,
-            timestamp: Date.now(),
-            workflow_run_id: rootRunId,
-            message: 'Waiting for your command...',
-            workstream_id: 'main',
-        };
-
-        expect(shouldCloseAgentRunStream(message, rootRunId)).toBe(false);
-        expect(shouldCloseAgentRunStream(message, rootRunId, true)).toBe(true);
-    });
-
-    it('keeps compact streams open when a child workstream becomes idle', () => {
-        const message: CompactMessage = {
-            t: AgentMessageType.IDLE,
-            m: 'Child waiting',
-            w: 'implementation',
-        };
-
-        expect(shouldCloseCompactRunStream(message, rootRunId)).toBe(false);
-        expect(shouldCloseCompactRunStream(message, rootRunId, true)).toBe(false);
-    });
-});

package/src/store/uploadMimeType.test.ts

@@ -1,22 +0,0 @@
-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');
-    });
-});