universal-llm-client 4.2.0 → 4.5.0

package/src/tests/http.test.ts

@@ -1,200 +1,200 @@
-/**
- * Tests for http.ts — Universal HTTP utilities
- */
-import { describe, it, expect, mock, beforeEach, afterEach } from 'bun:test';
-import { httpRequest, parseNDJSON, parseSSE, buildHeaders } from '../http.js';
-import { AIModelApiType } from '../interfaces.js';
-
-describe('httpRequest', () => {
-    const originalFetch = globalThis.fetch;
-
-    afterEach(() => {
-        globalThis.fetch = originalFetch;
-    });
-
-    it('makes a GET request and parses JSON', async () => {
-        globalThis.fetch = mock(async () =>
-            new Response(JSON.stringify({ ok: true }), {
-                status: 200,
-                headers: { 'Content-Type': 'application/json' },
-            })
-        ) as typeof fetch;
-
-        const result = await httpRequest<{ ok: boolean }>('http://test.com/api');
-        expect(result.ok).toBe(true);
-        expect(result.status).toBe(200);
-        expect(result.data.ok).toBe(true);
-    });
-
-    it('makes a POST request with body', async () => {
-        let capturedBody: string | undefined;
-        globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
-            capturedBody = init?.body as string;
-            return new Response(JSON.stringify({ received: true }), {
-                status: 200,
-                headers: { 'Content-Type': 'application/json' },
-            });
-        }) as typeof fetch;
-
-        await httpRequest('http://test.com/api', {
-            method: 'POST',
-            body: { message: 'hello' },
-        });
-
-        expect(capturedBody).toBe(JSON.stringify({ message: 'hello' }));
-    });
-
-    it('throws on non-OK response', async () => {
-        globalThis.fetch = mock(async () =>
-            new Response('Unauthorized', { status: 401 })
-        ) as typeof fetch;
-
-        expect(httpRequest('http://test.com/api')).rejects.toThrow('HTTP 401');
-    });
-
-    it('includes custom headers', async () => {
-        let capturedHeaders: HeadersInit | undefined;
-        globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
-            capturedHeaders = init?.headers;
-            return new Response(JSON.stringify({}), { status: 200 });
-        }) as typeof fetch;
-
-        await httpRequest('http://test.com/api', {
-            headers: { 'X-Custom': 'value' },
-        });
-
-        expect(capturedHeaders).toHaveProperty('X-Custom', 'value');
-    });
-});
-
-describe('parseNDJSON', () => {
-    it('parses newline-delimited JSON', async () => {
-        async function* source(): AsyncGenerator<string> {
-            yield '{"a":1}\n{"b":2}\n';
-        }
-
-        const results: Record<string, number>[] = [];
-        for await (const item of parseNDJSON<Record<string, number>>(source())) {
-            results.push(item);
-        }
-
-        expect(results).toHaveLength(2);
-        expect(results[0]).toEqual({ a: 1 });
-        expect(results[1]).toEqual({ b: 2 });
-    });
-
-    it('handles chunks split across JSON boundaries', async () => {
-        async function* source(): AsyncGenerator<string> {
-            yield '{"a":';
-            yield '1}\n{"b":2';
-            yield '}\n';
-        }
-
-        const results: unknown[] = [];
-        for await (const item of parseNDJSON(source())) {
-            results.push(item);
-        }
-
-        expect(results).toHaveLength(2);
-    });
-
-    it('skips empty lines', async () => {
-        async function* source(): AsyncGenerator<string> {
-            yield '{"a":1}\n\n\n{"b":2}\n';
-        }
-
-        const results: unknown[] = [];
-        for await (const item of parseNDJSON(source())) {
-            results.push(item);
-        }
-
-        expect(results).toHaveLength(2);
-    });
-
-    it('handles remaining buffer content', async () => {
-        async function* source(): AsyncGenerator<string> {
-            yield '{"a":1}';
-        }
-
-        const results: unknown[] = [];
-        for await (const item of parseNDJSON(source())) {
-            results.push(item);
-        }
-
-        expect(results).toHaveLength(1);
-    });
-});
-
-describe('parseSSE', () => {
-    it('parses server-sent events', async () => {
-        async function* source(): AsyncGenerator<string> {
-            yield 'data: {"content":"hello"}\n\ndata: {"content":"world"}\n\n';
-        }
-
-        const results: { event?: string; data: string }[] = [];
-        for await (const event of parseSSE(source())) {
-            results.push(event);
-        }
-
-        expect(results).toHaveLength(2);
-        expect(results[0]!.data).toBe('{"content":"hello"}');
-        expect(results[1]!.data).toBe('{"content":"world"}');
-    });
-
-    it('skips [DONE] events', async () => {
-        async function* source(): AsyncGenerator<string> {
-            yield 'data: {"content":"hello"}\n\ndata: [DONE]\n\n';
-        }
-
-        const results: unknown[] = [];
-        for await (const event of parseSSE(source())) {
-            results.push(event);
-        }
-
-        expect(results).toHaveLength(1);
-    });
-
-    it('extracts event type', async () => {
-        async function* source(): AsyncGenerator<string> {
-            yield 'event: custom\ndata: {"test":true}\n\n';
-        }
-
-        const results: { event?: string; data: string }[] = [];
-        for await (const event of parseSSE(source())) {
-            results.push(event);
-        }
-
-        expect(results).toHaveLength(1);
-        expect(results[0]!.event).toBe('custom');
-    });
-});
-
-describe('buildHeaders', () => {
-    it('returns Content-Type header', () => {
-        const headers = buildHeaders({
-            model: 'test',
-            url: 'http://test.com',
-            apiType: AIModelApiType.Ollama,
-        });
-        expect(headers['Content-Type']).toBe('application/json');
-    });
-
-    it('adds Authorization header when apiKey is set', () => {
-        const headers = buildHeaders({
-            model: 'test',
-            url: 'http://test.com',
-            apiType: AIModelApiType.OpenAI,
-            apiKey: 'sk-test',
-        });
-        expect(headers['Authorization']).toBe('Bearer sk-test');
-    });
-
-    it('omits Authorization when no apiKey', () => {
-        const headers = buildHeaders({
-            model: 'test',
-            url: 'http://test.com',
-            apiType: AIModelApiType.Ollama,
-        });
-        expect(headers['Authorization']).toBeUndefined();
-    });
-});
+/**
+ * Tests for http.ts — Universal HTTP utilities
+ */
+import { describe, it, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { httpRequest, parseNDJSON, parseSSE, buildHeaders } from '../http.js';
+import { AIModelApiType } from '../interfaces.js';
+
+describe('httpRequest', () => {
+    const originalFetch = globalThis.fetch;
+
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+
+    it('makes a GET request and parses JSON', async () => {
+        globalThis.fetch = mock(async () =>
+            new Response(JSON.stringify({ ok: true }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            })
+        ) as typeof fetch;
+
+        const result = await httpRequest<{ ok: boolean }>('http://test.com/api');
+        expect(result.ok).toBe(true);
+        expect(result.status).toBe(200);
+        expect(result.data.ok).toBe(true);
+    });
+
+    it('makes a POST request with body', async () => {
+        let capturedBody: string | undefined;
+        globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
+            capturedBody = init?.body as string;
+            return new Response(JSON.stringify({ received: true }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }) as typeof fetch;
+
+        await httpRequest('http://test.com/api', {
+            method: 'POST',
+            body: { message: 'hello' },
+        });
+
+        expect(capturedBody).toBe(JSON.stringify({ message: 'hello' }));
+    });
+
+    it('throws on non-OK response', async () => {
+        globalThis.fetch = mock(async () =>
+            new Response('Unauthorized', { status: 401 })
+        ) as typeof fetch;
+
+        expect(httpRequest('http://test.com/api')).rejects.toThrow('HTTP 401');
+    });
+
+    it('includes custom headers', async () => {
+        let capturedHeaders: HeadersInit | undefined;
+        globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
+            capturedHeaders = init?.headers;
+            return new Response(JSON.stringify({}), { status: 200 });
+        }) as typeof fetch;
+
+        await httpRequest('http://test.com/api', {
+            headers: { 'X-Custom': 'value' },
+        });
+
+        expect(capturedHeaders).toHaveProperty('X-Custom', 'value');
+    });
+});
+
+describe('parseNDJSON', () => {
+    it('parses newline-delimited JSON', async () => {
+        async function* source(): AsyncGenerator<string> {
+            yield '{"a":1}\n{"b":2}\n';
+        }
+
+        const results: Record<string, number>[] = [];
+        for await (const item of parseNDJSON<Record<string, number>>(source())) {
+            results.push(item);
+        }
+
+        expect(results).toHaveLength(2);
+        expect(results[0]).toEqual({ a: 1 });
+        expect(results[1]).toEqual({ b: 2 });
+    });
+
+    it('handles chunks split across JSON boundaries', async () => {
+        async function* source(): AsyncGenerator<string> {
+            yield '{"a":';
+            yield '1}\n{"b":2';
+            yield '}\n';
+        }
+
+        const results: unknown[] = [];
+        for await (const item of parseNDJSON(source())) {
+            results.push(item);
+        }
+
+        expect(results).toHaveLength(2);
+    });
+
+    it('skips empty lines', async () => {
+        async function* source(): AsyncGenerator<string> {
+            yield '{"a":1}\n\n\n{"b":2}\n';
+        }
+
+        const results: unknown[] = [];
+        for await (const item of parseNDJSON(source())) {
+            results.push(item);
+        }
+
+        expect(results).toHaveLength(2);
+    });
+
+    it('handles remaining buffer content', async () => {
+        async function* source(): AsyncGenerator<string> {
+            yield '{"a":1}';
+        }
+
+        const results: unknown[] = [];
+        for await (const item of parseNDJSON(source())) {
+            results.push(item);
+        }
+
+        expect(results).toHaveLength(1);
+    });
+});
+
+describe('parseSSE', () => {
+    it('parses server-sent events', async () => {
+        async function* source(): AsyncGenerator<string> {
+            yield 'data: {"content":"hello"}\n\ndata: {"content":"world"}\n\n';
+        }
+
+        const results: { event?: string; data: string }[] = [];
+        for await (const event of parseSSE(source())) {
+            results.push(event);
+        }
+
+        expect(results).toHaveLength(2);
+        expect(results[0]!.data).toBe('{"content":"hello"}');
+        expect(results[1]!.data).toBe('{"content":"world"}');
+    });
+
+    it('skips [DONE] events', async () => {
+        async function* source(): AsyncGenerator<string> {
+            yield 'data: {"content":"hello"}\n\ndata: [DONE]\n\n';
+        }
+
+        const results: unknown[] = [];
+        for await (const event of parseSSE(source())) {
+            results.push(event);
+        }
+
+        expect(results).toHaveLength(1);
+    });
+
+    it('extracts event type', async () => {
+        async function* source(): AsyncGenerator<string> {
+            yield 'event: custom\ndata: {"test":true}\n\n';
+        }
+
+        const results: { event?: string; data: string }[] = [];
+        for await (const event of parseSSE(source())) {
+            results.push(event);
+        }
+
+        expect(results).toHaveLength(1);
+        expect(results[0]!.event).toBe('custom');
+    });
+});
+
+describe('buildHeaders', () => {
+    it('returns Content-Type header', () => {
+        const headers = buildHeaders({
+            model: 'test',
+            url: 'http://test.com',
+            apiType: AIModelApiType.Ollama,
+        });
+        expect(headers['Content-Type']).toBe('application/json');
+    });
+
+    it('adds Authorization header when apiKey is set', () => {
+        const headers = buildHeaders({
+            model: 'test',
+            url: 'http://test.com',
+            apiType: AIModelApiType.OpenAI,
+            apiKey: 'sk-test',
+        });
+        expect(headers['Authorization']).toBe('Bearer sk-test');
+    });
+
+    it('omits Authorization when no apiKey', () => {
+        const headers = buildHeaders({
+            model: 'test',
+            url: 'http://test.com',
+            apiType: AIModelApiType.Ollama,
+        });
+        expect(headers['Authorization']).toBeUndefined();
+    });
+});

package/src/tests/interfaces.test.ts

@@ -1,117 +1,117 @@
-/**
- * Tests for interfaces.ts — Helper functions and type utilities
- */
-import { describe, it, expect } from 'bun:test';
-import {
-    textContent,
-    imageContent,
-    multimodalMessage,
-    extractTextContent,
-    hasImages,
-    AIModelApiType,
-    AIModelType,
-} from '../interfaces.js';
-
-describe('Helper Functions', () => {
-    describe('textContent', () => {
-        it('creates a text content part', () => {
-            const result = textContent('Hello');
-            expect(result).toEqual({ type: 'text', text: 'Hello' });
-        });
-    });
-
-    describe('imageContent', () => {
-        it('creates an image content part from base64', () => {
-            const result = imageContent('abc123');
-            expect(result.type).toBe('image_url');
-            expect(result.image_url.url).toBe('data:image/jpeg;base64,abc123');
-        });
-
-        it('creates an image content part from URL', () => {
-            const result = imageContent('https://example.com/image.jpg');
-            expect(result.image_url.url).toBe('https://example.com/image.jpg');
-        });
-
-        it('creates an image content part from data URI', () => {
-            const result = imageContent('data:image/png;base64,abc');
-            expect(result.image_url.url).toBe('data:image/png;base64,abc');
-        });
-
-        it('respects custom mimeType', () => {
-            const result = imageContent('abc123', 'image/png');
-            expect(result.image_url.url).toBe('data:image/png;base64,abc123');
-        });
-
-        it('includes detail parameter', () => {
-            const result = imageContent('https://example.com/img.jpg', 'image/jpeg', 'low');
-            expect(result.image_url.detail).toBe('low');
-        });
-    });
-
-    describe('multimodalMessage', () => {
-        it('creates a user message with text and images', () => {
-            const msg = multimodalMessage('Describe this', ['base64img']);
-            expect(msg.role).toBe('user');
-            expect(Array.isArray(msg.content)).toBe(true);
-            const parts = msg.content as Array<{ type: string }>;
-            expect(parts).toHaveLength(2);
-            expect(parts[0]!.type).toBe('text');
-            expect(parts[1]!.type).toBe('image_url');
-        });
-
-        it('handles multiple images', () => {
-            const msg = multimodalMessage('Compare', ['img1', 'img2', 'img3']);
-            const parts = msg.content as Array<{ type: string }>;
-            expect(parts).toHaveLength(4); // 1 text + 3 images
-        });
-    });
-
-    describe('extractTextContent', () => {
-        it('extracts text from string content', () => {
-            expect(extractTextContent('Hello')).toBe('Hello');
-        });
-
-        it('extracts text from content parts array', () => {
-            const content = [
-                textContent('Hello'),
-                imageContent('img'),
-                textContent(' World'),
-            ];
-            expect(extractTextContent(content)).toBe('Hello World');
-        });
-
-        it('returns empty string from image-only content', () => {
-            const content = [imageContent('img')];
-            expect(extractTextContent(content)).toBe('');
-        });
-    });
-
-    describe('hasImages', () => {
-        it('returns false for string content', () => {
-            expect(hasImages('Hello')).toBe(false);
-        });
-
-        it('returns false for text-only content parts', () => {
-            expect(hasImages([textContent('Hello')])).toBe(false);
-        });
-
-        it('returns true for content with images', () => {
-            expect(hasImages([textContent('Hello'), imageContent('img')])).toBe(true);
-        });
-    });
-});
-
-describe('Enums', () => {
-    it('AIModelApiType has expected values', () => {
-        expect(AIModelApiType.Ollama).toBe('ollama');
-        expect(AIModelApiType.OpenAI).toBe('openai');
-        expect(AIModelApiType.Google).toBe('google');
-        expect(AIModelApiType.Vertex).toBe('vertex');
-        expect(AIModelApiType.LlamaCpp).toBe('llamacpp');
-    });
-
-    it('AIModelType has expected values', () => {
-        expect(AIModelType.Chat).toBe('chat');
-        expect(AIModelType.Embedding).toBe('embedding');
-    });
-});
+/**
+ * Tests for interfaces.ts — Helper functions and type utilities
+ */
+import { describe, it, expect } from 'bun:test';
+import {
+    textContent,
+    imageContent,
+    multimodalMessage,
+    extractTextContent,
+    hasImages,
+    AIModelApiType,
+    AIModelType,
+} from '../interfaces.js';
+
+describe('Helper Functions', () => {
+    describe('textContent', () => {
+        it('creates a text content part', () => {
+            const result = textContent('Hello');
+            expect(result).toEqual({ type: 'text', text: 'Hello' });
+        });
+    });
+
+    describe('imageContent', () => {
+        it('creates an image content part from base64', () => {
+            const result = imageContent('abc123');
+            expect(result.type).toBe('image_url');
+            expect(result.image_url.url).toBe('data:image/jpeg;base64,abc123');
+        });
+
+        it('creates an image content part from URL', () => {
+            const result = imageContent('https://example.com/image.jpg');
+            expect(result.image_url.url).toBe('https://example.com/image.jpg');
+        });
+
+        it('creates an image content part from data URI', () => {
+            const result = imageContent('data:image/png;base64,abc');
+            expect(result.image_url.url).toBe('data:image/png;base64,abc');
+        });
+
+        it('respects custom mimeType', () => {
+            const result = imageContent('abc123', 'image/png');
+            expect(result.image_url.url).toBe('data:image/png;base64,abc123');
+        });
+
+        it('includes detail parameter', () => {
+            const result = imageContent('https://example.com/img.jpg', 'image/jpeg', 'low');
+            expect(result.image_url.detail).toBe('low');
+        });
+    });
+
+    describe('multimodalMessage', () => {
+        it('creates a user message with text and images', () => {
+            const msg = multimodalMessage('Describe this', ['base64img']);
+            expect(msg.role).toBe('user');
+            expect(Array.isArray(msg.content)).toBe(true);
+            const parts = msg.content as Array<{ type: string }>;
+            expect(parts).toHaveLength(2);
+            expect(parts[0]!.type).toBe('text');
+            expect(parts[1]!.type).toBe('image_url');
+        });
+
+        it('handles multiple images', () => {
+            const msg = multimodalMessage('Compare', ['img1', 'img2', 'img3']);
+            const parts = msg.content as Array<{ type: string }>;
+            expect(parts).toHaveLength(4); // 1 text + 3 images
+        });
+    });
+
+    describe('extractTextContent', () => {
+        it('extracts text from string content', () => {
+            expect(extractTextContent('Hello')).toBe('Hello');
+        });
+
+        it('extracts text from content parts array', () => {
+            const content = [
+                textContent('Hello'),
+                imageContent('img'),
+                textContent(' World'),
+            ];
+            expect(extractTextContent(content)).toBe('Hello World');
+        });
+
+        it('returns empty string from image-only content', () => {
+            const content = [imageContent('img')];
+            expect(extractTextContent(content)).toBe('');
+        });
+    });
+
+    describe('hasImages', () => {
+        it('returns false for string content', () => {
+            expect(hasImages('Hello')).toBe(false);
+        });
+
+        it('returns false for text-only content parts', () => {
+            expect(hasImages([textContent('Hello')])).toBe(false);
+        });
+
+        it('returns true for content with images', () => {
+            expect(hasImages([textContent('Hello'), imageContent('img')])).toBe(true);
+        });
+    });
+});
+
+describe('Enums', () => {
+    it('AIModelApiType has expected values', () => {
+        expect(AIModelApiType.Ollama).toBe('ollama');
+        expect(AIModelApiType.OpenAI).toBe('openai');
+        expect(AIModelApiType.Google).toBe('google');
+        expect(AIModelApiType.Vertex).toBe('vertex');
+        expect(AIModelApiType.LlamaCpp).toBe('llamacpp');
+    });
+
+    it('AIModelType has expected values', () => {
+        expect(AIModelType.Chat).toBe('chat');
+        expect(AIModelType.Embedding).toBe('embedding');
+    });
+});