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

package/src/store/AgentsApi.stream.test.ts

@@ -1,354 +0,0 @@
-import { type AgentMessage, AgentMessageType, type CompactMessage } from '@vertesia/common';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { VertesiaClient } from '../client.js';
-
-const AGENT_RUN_ID = 'run-1';
-const STORE_URL = 'https://store.example.test';
-
-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;
-
-    constructor(url: string) {
-        this.url = url;
-        FakeEventSource.urls.push(url);
-        FakeEventSource.instances.push(this);
-    }
-
-    close() {
-        this.readyState = FakeEventSource.CLOSED;
-    }
-
-    addEventListener() {}
-    removeEventListener() {}
-    dispatchEvent() {
-        return true;
-    }
-
-    fail() {
-        this.onerror?.(new Event('error'));
-    }
-
-    emit(message: CompactMessage) {
-        this.onmessage?.({ data: JSON.stringify(message) } as MessageEvent);
-    }
-}
-
-interface Harness {
-    client: VertesiaClient;
-    /** `since` query value of every GET /updates call after the initial history fetch. */
-    pollSince: number[];
-    setHistory: (messages: CompactMessage[]) => void;
-    setPollResponse: (handler: (since: number) => CompactMessage[]) => void;
-    setRunStatus: (status: string) => void;
-    issuedTokens: string[];
-}
-
-function createHarness(): Harness {
-    let history: CompactMessage[] = [];
-    let pollResponse: (since: number) => CompactMessage[] = () => [];
-    let runStatus = 'running';
-    let historyServed = false;
-    const pollSince: number[] = [];
-    const issuedTokens: string[] = [];
-
-    const fetchMock = vi.fn(async (input: Request | string) => {
-        const url = new URL(typeof input === 'string' ? input : input.url);
-        if (url.pathname.endsWith('/updates')) {
-            if (!historyServed) {
-                historyServed = true;
-                return Response.json({ messages: history });
-            }
-            const since = Number(url.searchParams.get('since') ?? 0);
-            pollSince.push(since);
-            return Response.json({ messages: pollResponse(since) });
-        }
-        if (url.pathname.endsWith(`/${AGENT_RUN_ID}`)) {
-            return Response.json({ id: AGENT_RUN_ID, status: runStatus });
-        }
-        return Response.json({ error: 'not found' }, { status: 404 });
-    });
-
-    const client = new VertesiaClient({
-        serverUrl: 'https://studio.example.test',
-        storeUrl: STORE_URL,
-        fetch: fetchMock as unknown as typeof fetch,
-    });
-
-    // Mimics a refreshing credential provider: every call hands out a newer token.
-    client.withAuthCallback(async () => {
-        const token = `token-${issuedTokens.length + 1}`;
-        issuedTokens.push(token);
-        return `Bearer ${token}`;
-    });
-
-    return {
-        client,
-        pollSince,
-        issuedTokens,
-        setHistory: (messages) => {
-            history = messages;
-        },
-        setPollResponse: (handler) => {
-            pollResponse = handler;
-        },
-        setRunStatus: (status) => {
-            runStatus = status;
-        },
-    };
-}
-
-/** Advance fake timers and drain the microtask queue so awaited fetches settle. */
-async function settle(ms = 0) {
-    await vi.advanceTimersByTimeAsync(ms);
-    for (let i = 0; i < 20; i++) {
-        await Promise.resolve();
-    }
-}
-
-/** Longer than the capped backoff delay (30s + jitter). */
-const BACKOFF_CEILING_MS = 40000;
-
-async function failCurrentConnection() {
-    FakeEventSource.instances[FakeEventSource.instances.length - 1].fail();
-    await settle(BACKOFF_CEILING_MS);
-}
-
-describe('AgentsApi.streamMessages reconnection', () => {
-    let logs: string[];
-    let warnings: string[];
-
-    beforeEach(() => {
-        vi.useFakeTimers();
-        FakeEventSource.instances = [];
-        FakeEventSource.urls = [];
-        logs = [];
-        warnings = [];
-        vi.stubGlobal('EventSource', FakeEventSource);
-        vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
-            logs.push(args.map(String).join(' '));
-        });
-        vi.spyOn(console, 'warn').mockImplementation((...args: unknown[]) => {
-            warnings.push(args.map(String).join(' '));
-        });
-        vi.spyOn(console, 'error').mockImplementation(() => {});
-    });
-
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
-        vi.useRealTimers();
-    });
-
-    it('keeps interactive streams open on root IDLE by default', async () => {
-        const harness = createHarness();
-        const settled = vi.fn();
-        const received: AgentMessage[] = [];
-        const done = harness.client.agents
-            .streamMessages(AGENT_RUN_ID, (message) => received.push(message))
-            .then(settled);
-        await settle();
-
-        FakeEventSource.instances[0].emit({
-            t: AgentMessageType.IDLE,
-            m: 'Waiting for your command...',
-            w: 'main',
-            ts: 1_000,
-        });
-        await settle();
-        expect(settled).not.toHaveBeenCalled();
-
-        FakeEventSource.instances[0].emit({
-            t: AgentMessageType.ANSWER,
-            m: 'Follow-up response',
-            w: 'main',
-            ts: 1_500,
-        });
-        await settle();
-        expect(received.map((message) => message.message)).toEqual([
-            'Waiting for your command...',
-            'Follow-up response',
-        ]);
-
-        FakeEventSource.instances[0].emit({
-            t: AgentMessageType.COMPLETE,
-            m: 'Conversation complete',
-            w: 'main',
-            ts: 2_000,
-        });
-        await expect(done).resolves.toBeUndefined();
-    });
-
-    it('lets headless followers opt into closing on root IDLE', async () => {
-        const harness = createHarness();
-        const done = harness.client.agents.streamMessages(AGENT_RUN_ID, undefined, undefined, undefined, {
-            closeOnIdle: true,
-        });
-        await settle();
-
-        FakeEventSource.instances[0].emit({
-            t: AgentMessageType.IDLE,
-            m: 'Waiting for your command...',
-            w: 'main',
-            ts: 1_000,
-        });
-
-        await expect(done).resolves.toBeNull();
-    });
-
-    it('resolves a fresh auth token for every reconnection attempt', async () => {
-        const harness = createHarness();
-        const abort = new AbortController();
-        void harness.client.agents.streamMessages(AGENT_RUN_ID, undefined, undefined, abort.signal);
-        await settle();
-
-        expect(FakeEventSource.instances).toHaveLength(1);
-        await failCurrentConnection();
-        await failCurrentConnection();
-        expect(FakeEventSource.instances).toHaveLength(3);
-
-        const tokens = FakeEventSource.urls.map((url) => new URL(url).searchParams.get('access_token'));
-        expect(tokens).toHaveLength(3);
-        expect(new Set(tokens).size).toBe(3);
-        expect(tokens.every((token) => token?.startsWith('token-'))).toBe(true);
-
-        abort.abort();
-        await settle();
-    });
-
-    it('never announces an attempt number above the stated maximum', async () => {
-        const harness = createHarness();
-        const abort = new AbortController();
-        void harness.client.agents.streamMessages(AGENT_RUN_ID, undefined, undefined, abort.signal);
-        await settle();
-
-        // 10 reconnects are allowed; the 11th failure must degrade instead of announcing 11/10.
-        for (let i = 0; i < 11; i++) {
-            await failCurrentConnection();
-        }
-
-        const announced = logs
-            .map((line) => /\(attempt (\d+)\/(\d+)\)/.exec(line))
-            .filter((match): match is RegExpExecArray => match !== null)
-            .map((match) => ({ attempt: Number(match[1]), max: Number(match[2]) }));
-
-        expect(announced).toHaveLength(10);
-        expect(announced.map((entry) => entry.attempt)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-        expect(announced.every((entry) => entry.attempt <= entry.max)).toBe(true);
-        expect(FakeEventSource.instances).toHaveLength(11);
-        expect(warnings.some((line) => line.includes('SSE unavailable after 10 attempts'))).toBe(true);
-
-        abort.abort();
-        await settle();
-    });
-
-    it('polls GET /updates from the last received timestamp and emits the messages', async () => {
-        const harness = createHarness();
-        harness.setHistory([{ t: AgentMessageType.UPDATE, m: 'history', ts: 1000 }]);
-        harness.setPollResponse((since) =>
-            since < 2000 ? [{ t: AgentMessageType.UPDATE, m: 'polled', ts: 2000 }] : [],
-        );
-
-        const received: AgentMessage[] = [];
-        const abort = new AbortController();
-        void harness.client.agents.streamMessages(
-            AGENT_RUN_ID,
-            (message) => received.push(message),
-            undefined,
-            abort.signal,
-        );
-        await settle();
-
-        for (let i = 0; i < 11; i++) {
-            await failCurrentConnection();
-        }
-        await settle(6000);
-
-        // The first poll resumes at the history cursor, later polls at the last polled message.
-        expect(harness.pollSince[0]).toBe(1000);
-        expect(harness.pollSince[1]).toBe(2000);
-        expect(received.map((message) => message.message)).toEqual(['history', 'polled']);
-        // Polled messages reach the caller as fully-formed AgentMessages, like the SSE path.
-        expect(received[1]).toMatchObject({
-            type: AgentMessageType.UPDATE,
-            workflow_run_id: AGENT_RUN_ID,
-            workstream_id: 'main',
-            timestamp: 2000,
-        });
-
-        abort.abort();
-        await settle();
-    });
-
-    it('warns on every polling failure instead of failing silently', async () => {
-        const harness = createHarness();
-        harness.setHistory([{ t: AgentMessageType.UPDATE, m: 'history', ts: 1000 }]);
-        harness.setPollResponse(() => {
-            throw new Error('boom');
-        });
-
-        const abort = new AbortController();
-        void harness.client.agents.streamMessages(AGENT_RUN_ID, undefined, undefined, abort.signal);
-        await settle();
-
-        for (let i = 0; i < 11; i++) {
-            await failCurrentConnection();
-        }
-        await settle(6000);
-
-        const pollWarnings = warnings.filter((line) => line.includes('GET /updates failed while polling'));
-        expect(pollWarnings.length).toBeGreaterThanOrEqual(2);
-        expect(pollWarnings[0]).toContain('consecutive failures: 1');
-        expect(pollWarnings[1]).toContain('consecutive failures: 2');
-
-        abort.abort();
-        await settle();
-    });
-
-    it('retries SSE after the polling fallback so an outage is not permanent', async () => {
-        const harness = createHarness();
-        const abort = new AbortController();
-        void harness.client.agents.streamMessages(AGENT_RUN_ID, undefined, undefined, abort.signal);
-        await settle();
-
-        for (let i = 0; i < 11; i++) {
-            await failCurrentConnection();
-        }
-        const connectionsBeforeRetry = FakeEventSource.instances.length;
-        expect(warnings.some((line) => line.includes('SSE retried every 60s'))).toBe(true);
-
-        await settle(61000);
-
-        expect(FakeEventSource.instances.length).toBe(connectionsBeforeRetry + 1);
-        expect(logs.some((line) => line.includes('retrying the SSE connection'))).toBe(true);
-
-        abort.abort();
-        await settle();
-    });
-
-    it('closes the stream when polling observes a terminal run status', async () => {
-        const harness = createHarness();
-        const abort = new AbortController();
-        const done = harness.client.agents.streamMessages(AGENT_RUN_ID, undefined, undefined, abort.signal);
-        await settle();
-
-        for (let i = 0; i < 11; i++) {
-            await failCurrentConnection();
-        }
-        harness.setRunStatus('completed');
-        await settle(6000);
-
-        await expect(done).resolves.toBeNull();
-    });
-});

package/src/store/DataApi.test.ts

@@ -1,42 +0,0 @@
-import type { ImportDataPayload } from '@vertesia/common';
-import { describe, expect, it } from 'vitest';
-import { ZenoClient } from './client.js';
-
-describe('DataApi', () => {
-    // `import` is the name applications built against the 1.4 SDK call, through the client the
-    // platform serves them rather than one they bundle -- so renaming it (as 1.5 briefly did, to
-    // `importData`) breaks them at deploy time rather than at their next upgrade. This pins both
-    // the name and the request it issues.
-    it('exposes `import` as POST {store}/import with the data store header', async () => {
-        const requests: { url: string; method: string; storeHeader: string | null; body: string }[] = [];
-        const fetchImport = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-            const request = new Request(input, init);
-            requests.push({
-                url: request.url,
-                method: request.method,
-                storeHeader: request.headers.get('x-data-store-id'),
-                body: await request.text(),
-            });
-            return new Response(JSON.stringify({ id: 'import-1', status: 'completed' }), {
-                status: 200,
-                headers: { 'content-type': 'application/json' },
-            });
-        };
-
-        const client = new ZenoClient({ serverUrl: 'https://store.test', apikey: 'token', fetch: fetchImport });
-        const payload: ImportDataPayload = {
-            mode: 'append',
-            message: 'test import',
-            tables: { customers: { source: 'inline', data: [{ id: 1 }] } },
-        };
-
-        const job = await client.data.import('store-1', payload);
-
-        expect(job).toEqual({ id: 'import-1', status: 'completed' });
-        expect(requests).toHaveLength(1);
-        expect(requests[0].method).toBe('POST');
-        expect(requests[0].url).toBe('https://store.test/api/v1/data/store-1/import');
-        expect(requests[0].storeHeader).toBe('store-1');
-        expect(JSON.parse(requests[0].body)).toEqual(payload);
-    });
-});

package/src/store/EmbeddingsApi.test.ts

@@ -1,31 +0,0 @@
-import { SupportedEmbeddingTypes } from '@vertesia/common';
-import { describe, expect, it, vi } from 'vitest';
-import { ZenoClient } from './client.js';
-
-describe('EmbeddingsApi', () => {
-    it('omits the mode by default and sends the explicit sync override when requested', async () => {
-        const requests: Request[] = [];
-        const client = new ZenoClient({
-            serverUrl: 'https://store.example.com',
-            apikey: 'token',
-            fetch: vi.fn(
-                async () =>
-                    new Response(JSON.stringify({ status: 'success', message: 'started' }), {
-                        status: 200,
-                        headers: { 'content-type': 'application/json' },
-                    }),
-            ),
-            onRequest: (request) => requests.push(request),
-        });
-
-        await client.embeddings.recalculate(SupportedEmbeddingTypes.text);
-        await client.embeddings.recalculate(SupportedEmbeddingTypes.text, { mode: 'sync' });
-        await client.embeddings.recalculate(SupportedEmbeddingTypes.image, { force: true });
-
-        expect(requests.map(({ url }) => url)).toEqual([
-            'https://store.example.com/api/v1/embeddings/text/recalculate',
-            'https://store.example.com/api/v1/embeddings/text/recalculate?mode=sync',
-            'https://store.example.com/api/v1/embeddings/image/recalculate?force=true',
-        ]);
-    });
-});

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,105 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { ZenoClient } from './client.js';
-
-describe('FilesApi', () => {
-    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();
-    });
-});