@tstdl/base 0.93.181 → 0.93.183

package/ai/genkit/tests/token-limit-fallback.test.js

@@ -1,209 +0,0 @@
-/** biome-ignore-all lint/suspicious/useAwait: defineModel requires async */
-import { genkit, GenkitError, z } from 'genkit';
-import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import { CircuitBreakerState } from '../../../circuit-breaker/index.js';
-import { CircuitBreakerProvider } from '../../../circuit-breaker/provider.js';
-import { Logger } from '../../../logger/logger.js';
-import { setupIntegrationTest } from '../../../testing/index.js';
-import { timeout } from '../../../utils/timing.js';
-import { vertexAiMultiLocation } from '../multi-region.plugin.js';
-vi.mock('../../../utils/array/index.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        shuffle: vi.fn((items) => [...items]),
-    };
-});
-vi.mock('@genkit-ai/google-genai', () => ({
-    // biome-ignore lint/style/useNamingConvention: given
-    vertexAI: {
-        model: vi.fn((name) => ({
-            name: `vertexai/${name}`,
-            info: { label: 'mock' },
-            configSchema: z.object({}),
-        })),
-    },
-    // biome-ignore lint/style/useNamingConvention: given
-    googleAI: vi.fn(),
-}));
-describe('Genkit vertexai-multi-location Token Limit Fallback Tests', () => {
-    let ai;
-    let cbProvider;
-    let logger;
-    beforeAll(async () => {
-        const { injector } = await setupIntegrationTest({ modules: { circuitBreaker: true } });
-        cbProvider = injector.resolve(CircuitBreakerProvider);
-        logger = injector.resolve(Logger, 'Test');
-    });
-    beforeEach(async () => {
-        vi.clearAllMocks();
-        ai = genkit({
-            plugins: [
-                vertexAiMultiLocation({
-                    locations: ['region-1', 'region-2', 'region-3'],
-                    circuitBreakerProvider: cbProvider,
-                    logger,
-                    circuitBreakerConfig: { resetTimeout: 1_000_000, threshold: 1 },
-                    tokenLimitCircuitBreakerConfig: { resetTimeout: 10, threshold: 1 },
-                }),
-            ],
-        });
-        const config = { threshold: 1, resetTimeout: 1_000_000 };
-        await cbProvider.provide('genkit:vertex-ai:location:region-1', config).recordSuccess();
-        await cbProvider.provide('genkit:vertex-ai:location:region-2', config).recordSuccess();
-        await cbProvider.provide('genkit:vertex-ai:location:region-3', config).recordSuccess();
-        await cbProvider.provide('genkit:vertex-ai:location:region-1:token-limit', config).recordSuccess();
-        await cbProvider.provide('genkit:vertex-ai:location:region-2:token-limit', config).recordSuccess();
-        await cbProvider.provide('genkit:vertex-ai:location:region-3:token-limit', config).recordSuccess();
-    });
-    it('should fallback on token limit error but NOT trip main circuit breaker', async () => {
-        const tokenLimitErrorMessage = 'Unable to submit request because the input token count is 135224 but model only supports up to 131072.';
-        let region1Called = false;
-        let region2Called = false;
-        ai.defineModel({
-            name: 'vertexai/gemini-2.5-flash',
-        }, async (request) => {
-            if (request.config?.location === 'region-1') {
-                region1Called = true;
-                throw new GenkitError({
-                    status: 'INVALID_ARGUMENT',
-                    message: tokenLimitErrorMessage,
-                });
-            }
-            if (request.config?.location === 'region-2') {
-                region2Called = true;
-                return {
-                    message: {
-                        role: 'model',
-                        content: [{ text: 'success from region-2' }],
-                    },
-                };
-            }
-            throw new Error('Unexpected location');
-        });
-        const response = await ai.generate({
-            model: 'vertexai-multi-location/gemini-2.5-flash',
-            prompt: 'test',
-        });
-        expect(response.text).toBe('success from region-2');
-        expect(region1Called).toBe(true);
-        expect(region2Called).toBe(true);
-        // Verify main circuit breaker for region-1 is still CLOSED (allowed)
-        const cb = cbProvider.provide('genkit:vertex-ai:location:region-1', { threshold: 1, resetTimeout: 1000000 });
-        const status = await cb.check();
-        expect(status.state).toBe(CircuitBreakerState.Closed);
-        expect(status.allowed).toBe(true);
-    });
-    it('should skip locations with known token limits within the same request once it is known to be large', async () => {
-        const tokenLimitErrorMessage = 'Unable to submit request because the input token count is 135224 but model only supports up to 131072.';
-        // First, trip the token limit breaker for region-2
-        const tokenLimitCB2 = cbProvider.provide('genkit:vertex-ai:location:region-2:token-limit', { threshold: 1, resetTimeout: 1000000 });
-        await tokenLimitCB2.recordFailure();
-        let region1Called = false;
-        let region2Called = false;
-        let region3Called = false;
-        ai.defineModel({
-            name: 'vertexai/gemini-2.5-flash',
-        }, async (request) => {
-            if (request.config?.location === 'region-1') {
-                region1Called = true;
-                throw new GenkitError({
-                    status: 'INVALID_ARGUMENT',
-                    message: tokenLimitErrorMessage,
-                });
-            }
-            if (request.config?.location === 'region-2') {
-                region2Called = true;
-                return { message: { role: 'model', content: [{ text: 'success from region-2' }] } };
-            }
-            if (request.config?.location === 'region-3') {
-                region3Called = true;
-                return {
-                    message: {
-                        role: 'model',
-                        content: [{ text: 'success from region-3' }],
-                    },
-                };
-            }
-            throw new Error('Unexpected location');
-        });
-        // Initial shuffle is mocked to [region-1, region-2, region-3]
-        const response = await ai.generate({
-            model: 'vertexai-multi-location/gemini-2.5-flash',
-            prompt: 'test',
-        });
-        expect(response.text).toBe('success from region-3');
-        expect(region1Called).toBe(true); // Fails, makes request "known to be large"
-        expect(region2Called).toBe(false); // Should be skipped because it is known to have a low limit
-        expect(region3Called).toBe(true); // Should be tried as it is not known to be limited
-    });
-    it('should record success for token limit breaker when it succeeds after being known to be large', async () => {
-        const tokenLimitErrorMessage = 'Unable to submit request because the input token count is 135224 but model only supports up to 131072.';
-        let region1Called = false;
-        let region2Called = false;
-        let region3Called = false;
-        ai.defineModel({ name: 'vertexai/gemini-2.5-flash' }, async (request) => {
-            if (request.config?.location === 'region-1') {
-                region1Called = true;
-                throw new GenkitError({
-                    status: 'INVALID_ARGUMENT',
-                    message: tokenLimitErrorMessage,
-                });
-            }
-            if (request.config?.location === 'region-2') {
-                region2Called = true;
-                return { message: { role: 'model', content: [{ text: 'success from region-2' }] } };
-            }
-            if (request.config?.location === 'region-3') {
-                region3Called = true;
-                return { message: { role: 'model', content: [{ text: 'success from region-3' }] } };
-            }
-            throw new Error(`Unexpected location: ${request.config?.location}`);
-        });
-        // Initial shuffle is [region-1, region-2, region-3].
-        // Let's use a very short reset timeout for region-2.
-        const shortConfig = { threshold: 1, resetTimeout: 10 };
-        const tokenLimitCBShort = cbProvider.provide('genkit:vertex-ai:location:region-2:token-limit', shortConfig);
-        await tokenLimitCBShort.recordFailure();
-        // Small delay to ensure it goes to Half-Open
-        await timeout(50);
-        await ai.generate({
-            model: 'vertexai-multi-location/gemini-2.5-flash',
-            prompt: 'test',
-        });
-        expect(region1Called).toBe(true);
-        expect(region2Called).toBe(true); // Should NOT be skipped because it is Half-Open
-        expect(region3Called).toBe(false);
-        const status = await tokenLimitCBShort.check();
-        expect(status.state).toBe(CircuitBreakerState.Closed);
-    });
-    it('should record success for token limit breaker via usage-based learning (proactive success)', async () => {
-        // We want to verify that if a request has many tokens, it records success even if isLargeRequest was false.
-        const tokenLimitThreshold = 131_072;
-        const aiWithThreshold = genkit({
-            plugins: [
-                vertexAiMultiLocation({
-                    locations: ['region-1'],
-                    circuitBreakerProvider: cbProvider,
-                    logger,
-                    tokenLimitThreshold,
-                }),
-            ],
-        });
-        // Trip the breaker first
-        const tokenLimitCB = cbProvider.provide('genkit:vertex-ai:location:region-1:token-limit', { threshold: 1, resetTimeout: 1000000 });
-        await tokenLimitCB.recordFailure();
-        aiWithThreshold.defineModel({ name: 'vertexai/gemini-2.5-flash' }, async () => ({
-            message: { role: 'model', content: [{ text: 'success' }] },
-            usage: { inputTokens: tokenLimitThreshold + 1 },
-        }));
-        // This request is NOT known to be large initially.
-        // But it returns usage > threshold.
-        await aiWithThreshold.generate({
-            model: 'vertexai-multi-location/gemini-2.5-flash',
-            prompt: 'test',
-        });
-        const status = await tokenLimitCB.check();
-        expect(status.state).toBe(CircuitBreakerState.Closed);
-    });
-});

package/ai/prompts/tests/prompt-builder.test.d.ts

@@ -1 +0,0 @@
-export {};

package/ai/prompts/tests/prompt-builder.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { StringSchema } from '../../../schema/schemas/string.js';
-import { promptBuilder } from '../prompt-builder.js';
-describe('PromptBuilder', () => {
-    it('should add output schema to the prompt', () => {
-        const builder = promptBuilder()
-            .setRole('Test Role')
-            .setOutputSchema(new StringSchema({ description: 'Test Description' }))
-            .setTask('Test Task');
-        const prompt = builder.buildUserPrompt();
-        const text = prompt[0].text;
-        expect(text).toContain('# **Output Schema**');
-        expect(text).toContain('"type": "string"');
-        expect(text).toContain('"description": "Test Description"');
-        // Check order: Role -> Output Schema -> Task
-        const roleIndex = text.indexOf('# **Role**');
-        const schemaIndex = text.indexOf('# **Output Schema**');
-        const taskIndex = text.indexOf('# **Task**');
-        expect(roleIndex).toBeLessThan(schemaIndex);
-        expect(schemaIndex).toBeLessThan(taskIndex);
-    });
-});

package/ai/tests/instructions-formatter.test.d.ts

@@ -1 +0,0 @@
-export {};

package/ai/tests/instructions-formatter.test.js

@@ -1,116 +0,0 @@
-/** biome-ignore-all lint/style/useNamingConvention: instructions are uppercase */
-import { describe, expect, test } from 'vitest';
-import { formatInstructions, orderedList, sections, unorderedList } from '../prompts/instructions-formatter.js';
-describe('Instructions Formatter', () => {
-    test('should format a simple unordered list of strings', () => {
-        const instructions = ['Item 1', 'Item 2'];
-        const result = formatInstructions(instructions);
-        expect(result).toBe(`- Item 1
-- Item 2`);
-    });
-    test('should format an object as sections by default', () => {
-        const instructions = {
-            'Section 1': 'Content 1',
-            'Section 2': 'Content 2',
-        };
-        const result = formatInstructions(instructions);
-        expect(result).toBe(`# Section 1
-
-Content 1
-
-# Section 2
-
-Content 2`);
-    });
-    test('should format nested unordered lists', () => {
-        const instructions = unorderedList({
-            Parent: unorderedList([
-                'Child 1',
-                'Child 2',
-            ]),
-        });
-        const result = formatInstructions(instructions);
-        expect(result).toBe(`- **Parent:**
-    - Child 1
-    - Child 2`);
-    });
-    test('should format ordered lists', () => {
-        const instructions = orderedList(['First', 'Second']);
-        const result = formatInstructions(instructions);
-        expect(result).toBe(`1. First
-2. Second`);
-    });
-    test('should format nested mixed lists', () => {
-        const instructions = orderedList({
-            'Step 1': unorderedList([
-                'Substep A',
-                'Substep B',
-            ]),
-        });
-        const result = formatInstructions(instructions);
-        expect(result).toBe(`1. **Step 1:**
-    - Substep A
-    - Substep B`);
-    });
-    test('should handle hanging indents for multi-line strings', () => {
-        const instructions = unorderedList([
-            `Line 1
-Line 2`,
-        ]);
-        const result = formatInstructions(instructions);
-        expect(result).toBe(`- Line 1
-  Line 2`);
-    });
-    test('should handle sections with instructions', () => {
-        const instructions = sections('General Info', {
-            SubSection: 'Details',
-        });
-        const result = formatInstructions(instructions);
-        expect(result).toBe(`General Info
-
-# SubSection
-
-Details`);
-    });
-    test('should handle nested sections (incrementing H level)', () => {
-        const instructions = sections({
-            'Level 1': sections({
-                'Level 2': 'Deep content',
-            }),
-        });
-        const result = formatInstructions(instructions);
-        expect(result).toBe(`# Level 1
-
-## Level 2
-
-Deep content`);
-    });
-    test('should handle complex nested structures with mixed styles', () => {
-        const instructions = sections({
-            Task: 'Perform the following actions',
-            Steps: orderedList({
-                'Step A': 'Do something',
-                'Step B': unorderedList([
-                    'Subtask B1',
-                    'Subtask B2',
-                ]),
-            }),
-            Conclusion: 'All done',
-        });
-        const expected = `# Task
-
-Perform the following actions
-
-# Steps
-
-1. **Step A:** Do something
-2. **Step B:**
-    - Subtask B1
-    - Subtask B2
-
-# Conclusion
-
-All done`;
-        expect(formatInstructions(instructions)).toBe(expected);
-    });
-});

package/ai/tests/steering.test.d.ts

@@ -1 +0,0 @@
-export {};

package/ai/tests/steering.test.js

@@ -1,37 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { fewShotPrompt, formatInstructions, languagePrompt, stylePrompt } from '../../ai/prompts/index.js';
-describe('ai-prompt-factories', () => {
-    test('fewShotPrompt should format positive examples', () => {
-        const prompt = formatInstructions(fewShotPrompt([
-            { input: { text: 'hello' }, output: { result: 'world' } },
-        ]));
-        expect(prompt).toContain('Examples');
-        expect(prompt).toContain('Example 1 (POSITIVE)');
-        expect(prompt).toContain('**Input:** {"text":"hello"}');
-        expect(prompt).toContain('**Output:** {"result":"world"}');
-    });
-    test('fewShotPrompt should format negative examples with reasons', () => {
-        const examples = [
-            { input: { text: 'bad' }, output: { result: 'no' }, isNegative: true, reason: 'This is not allowed' },
-        ];
-        const prompt = formatInstructions(fewShotPrompt(examples));
-        expect(prompt).toContain('Example 1 (NEGATIVE)');
-        expect(prompt).toContain('**Reason:** This is not allowed');
-    });
-    test('fewShotPrompt should format string examples without quotes', () => {
-        const prompt = formatInstructions(fewShotPrompt([
-            { input: 'input string', output: 'output string' },
-        ]));
-        expect(prompt).toContain('**Input:** input string');
-        expect(prompt).toContain('**Output:** output string');
-    });
-    test('languagePrompt should include the language', () => {
-        const prompt = languagePrompt('German');
-        expect(prompt).toBe('IMPORTANT: All generated text content MUST be in German.');
-    });
-    test('stylePrompt should include the instructions', () => {
-        const prompt = stylePrompt('Use formal tone.');
-        expect(prompt).toContain('Style & Formatting Instructions');
-        expect(prompt).toContain('Use formal tone.');
-    });
-});

package/api/client/tests/api-client.test.d.ts

@@ -1 +0,0 @@
-export {};

package/api/client/tests/api-client.test.js

@@ -1,194 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { CancellationToken } from '../../../cancellation/index.js';
-import { HttpClient } from '../../../http/client/index.js';
-import { bustCache } from '../../../http/index.js';
-import { object } from '../../../schema/index.js';
-import { DataStream } from '../../../sse/data-stream.js';
-import { ServerSentEvents } from '../../../sse/server-sent-events.js';
-import { defineApi } from '../../types.js';
-import { compileClient } from '../client.js';
-describe('ApiClient', () => {
-    it('should pass abortSignal and handle positional arguments', async () => {
-        const apiDefinition = defineApi({
-            resource: 'test',
-            endpoints: {
-                noParams: {
-                    method: 'GET',
-                    resource: 'no-params',
-                },
-                onlyParams: {
-                    method: 'GET',
-                    resource: 'only-params',
-                    parameters: object({
-                        id: String,
-                    }),
-                },
-                paramsAndBody: {
-                    method: 'POST',
-                    resource: 'params-and-body',
-                    parameters: object({
-                        id: String,
-                    }),
-                    body: object({
-                        data: String,
-                    }),
-                },
-            },
-        });
-        const mockHttpClient = Object.assign(Object.create(HttpClient.prototype), {
-            rawRequest: vi.fn().mockResolvedValue({
-                statusCode: 200,
-                hasBody: false,
-                close: vi.fn(),
-            }),
-            options: { baseUrl: 'http://localhost/' },
-        });
-        const Client = compileClient(apiDefinition);
-        const client = new Client(mockHttpClient);
-        const abortController = new AbortController();
-        const cancellationToken = new CancellationToken();
-        // 1. No params
-        await client.noParams({ cancellationSignal: abortController.signal });
-        expect(mockHttpClient.rawRequest).toHaveBeenLastCalledWith(expect.objectContaining({
-            url: expect.stringContaining('no-params'),
-        }));
-        let lastRequest = mockHttpClient.rawRequest.mock.calls.at(-1)[0];
-        expect(lastRequest.cancellationSignal.isSet).toBe(false);
-        abortController.abort();
-        expect(lastRequest.cancellationSignal.isSet).toBe(true);
-        // 2. Only params
-        await client.onlyParams({ id: '123' }, { cancellationSignal: cancellationToken.abortSignal });
-        expect(mockHttpClient.rawRequest).toHaveBeenLastCalledWith(expect.objectContaining({
-            url: expect.stringContaining('only-params'),
-            parameters: { id: '123' },
-        }));
-        lastRequest = mockHttpClient.rawRequest.mock.calls.at(-1)[0];
-        expect(lastRequest.cancellationSignal.isSet).toBe(false);
-        cancellationToken.set();
-        expect(lastRequest.cancellationSignal.isSet).toBe(true);
-        // 3. Params and body
-        const abortController3 = new AbortController();
-        await client.paramsAndBody({ id: '456' }, { data: 'val' }, { cancellationSignal: abortController3.signal });
-        expect(mockHttpClient.rawRequest).toHaveBeenLastCalledWith(expect.objectContaining({
-            url: expect.stringContaining('params-and-body'),
-            parameters: { id: '456' },
-            body: { json: { data: 'val' } },
-        }));
-        lastRequest = mockHttpClient.rawRequest.mock.calls.at(-1)[0];
-        expect(lastRequest.cancellationSignal.isSet).toBe(false);
-        abortController3.abort();
-        expect(lastRequest.cancellationSignal.isSet).toBe(true);
-        // 4. Omitted requestOptions
-        await client.onlyParams({ id: '789' });
-        expect(mockHttpClient.rawRequest).toHaveBeenLastCalledWith(expect.objectContaining({
-            url: expect.stringContaining('only-params'),
-            parameters: { id: '789' },
-        }));
-        lastRequest = mockHttpClient.rawRequest.mock.calls.at(-1)[0];
-        expect(lastRequest.cancellationSignal.isSet).toBe(false);
-    });
-    it('should handle different HTTP methods', async () => {
-        const apiDefinition = defineApi({
-            resource: 'methods',
-            endpoints: {
-                get: { method: 'GET' },
-                post: { method: 'POST' },
-                put: { method: 'PUT' },
-                patch: { method: 'PATCH' },
-                delete: { method: 'DELETE' },
-            },
-        });
-        const mockHttpClient = Object.assign(Object.create(HttpClient.prototype), {
-            rawRequest: vi.fn().mockResolvedValue({ statusCode: 200, hasBody: false, close: vi.fn() }),
-            options: { baseUrl: 'http://localhost/' },
-        });
-        const Client = compileClient(apiDefinition);
-        const client = new Client(mockHttpClient);
-        await client.get();
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].method).toBe('GET');
-        await client.post();
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].method).toBe('POST');
-        await client.put();
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].method).toBe('PUT');
-        await client.patch();
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].method).toBe('PATCH');
-        await client.delete();
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].method).toBe('DELETE');
-    });
-    it('should handle body types', async () => {
-        const apiDefinition = defineApi({
-            resource: 'body',
-            endpoints: {
-                json: { method: 'POST', body: object({ foo: String }) },
-                text: { method: 'POST', body: String },
-                binary: { method: 'POST', body: Uint8Array },
-            },
-        });
-        const mockHttpClient = Object.assign(Object.create(HttpClient.prototype), {
-            rawRequest: vi.fn().mockResolvedValue({ statusCode: 200, hasBody: false, close: vi.fn() }),
-            options: { baseUrl: 'http://localhost/' },
-        });
-        const Client = compileClient(apiDefinition);
-        const client = new Client(mockHttpClient);
-        await client.json(undefined, { foo: 'bar' });
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].body).toEqual({ json: { foo: 'bar' } });
-        await client.text(undefined, 'hello');
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].body).toEqual({ text: 'hello' });
-        const buffer = new Uint8Array([1, 2, 3]);
-        await client.binary(undefined, buffer);
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].body).toEqual({ binary: buffer });
-    });
-    it('should handle credentials, bustCache and resource methods', async () => {
-        const apiDefinition = defineApi({
-            resource: 'features',
-            endpoints: {
-                withCredentials: { method: 'GET', credentials: true },
-                withBustCache: { method: 'GET', bustCache: true },
-            },
-        });
-        const mockHttpClient = Object.assign(Object.create(HttpClient.prototype), {
-            rawRequest: vi.fn().mockResolvedValue({ statusCode: 200, hasBody: false, close: vi.fn() }),
-            options: { baseUrl: 'http://localhost/' },
-        });
-        const Client = compileClient(apiDefinition);
-        const client = new Client(mockHttpClient);
-        await client.withCredentials();
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].credentials).toBe('include');
-        await client.withBustCache();
-        expect(mockHttpClient.rawRequest.mock.calls.at(-1)[0].context[bustCache]).toBe(true);
-        expect(Client.getEndpointResource('withCredentials')).not.toContain('withCredentials');
-        expect(Client.getEndpointUrl('withCredentials').href).toBe('http://baseurl/api/v1/features');
-        expect(client.getEndpointUrl('withCredentials').href).toBe('http://localhost/api/v1/features');
-    });
-    it('should handle Server Sent Events and DataStream', async () => {
-        const apiDefinition = defineApi({
-            resource: 'sse',
-            endpoints: {
-                events: { method: 'GET', result: ServerSentEvents },
-                stream: { method: 'GET', result: DataStream },
-            },
-        });
-        const mockEventSource = {
-            addEventListener: vi.fn(),
-            removeEventListener: vi.fn(),
-            close: vi.fn(),
-            readyState: 0,
-        };
-        const EventSourceMock = vi.fn().mockImplementation(function () {
-            return mockEventSource;
-        });
-        vi.stubGlobal('EventSource', EventSourceMock);
-        const mockHttpClient = Object.assign(Object.create(HttpClient.prototype), {
-            options: { baseUrl: 'http://localhost/' },
-        });
-        const Client = compileClient(apiDefinition);
-        const client = new Client(mockHttpClient);
-        const sse = await client.events();
-        expect(sse).toBeInstanceOf(ServerSentEvents);
-        expect(EventSourceMock).toHaveBeenCalledWith(expect.stringContaining('sse'), expect.any(Object));
-        const stream = await client.stream();
-        expect(stream).toBeInstanceOf(Object); // It's an Observable
-        expect(EventSourceMock).toHaveBeenCalledWith(expect.stringContaining('sse'), expect.any(Object));
-        vi.unstubAllGlobals();
-    });
-});

package/api/server/tests/csrf.middleware.test.d.ts

@@ -1 +0,0 @@
-export {};