@inference-gateway/sdk 0.3.0 → 0.3.2

package/dist/tests/client.test.js

@@ -2,229 +2,338 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const client_1 = require("@/client");
 const types_1 = require("@/types");
+const web_1 = require("node:stream/web");
+const node_util_1 = require("node:util");
 describe('InferenceGatewayClient', () => {
     let client;
-    const mockBaseUrl = 'http://localhost:8080';
+    const mockFetch = jest.fn();
     beforeEach(() => {
-        client = new client_1.InferenceGatewayClient(mockBaseUrl);
-        global.fetch = jest.fn();
+        client = new client_1.InferenceGatewayClient({
+            baseURL: 'http://localhost:8080/v1',
+            fetch: mockFetch,
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
     });
     describe('listModels', () => {
         it('should fetch available models', async () => {
-            const mockResponse = [
-                {
-                    provider: types_1.Provider.Ollama,
-                    models: [
-                        {
-                            name: 'llama2',
-                        },
-                    ],
-                },
-            ];
-            global.fetch.mockResolvedValueOnce({
+            const mockResponse = {
+                object: 'list',
+                data: [
+                    {
+                        id: 'gpt-4o',
+                        object: 'model',
+                        created: 1686935002,
+                        owned_by: 'openai',
+                    },
+                    {
+                        id: 'llama-3.3-70b-versatile',
+                        object: 'model',
+                        created: 1723651281,
+                        owned_by: 'groq',
+                    },
+                ],
+            };
+            mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: () => Promise.resolve(mockResponse),
             });
             const result = await client.listModels();
             expect(result).toEqual(mockResponse);
-            expect(global.fetch).toHaveBeenCalledWith(`${mockBaseUrl}/llms`, expect.objectContaining({
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/v1/models', expect.objectContaining({
+                method: 'GET',
                 headers: expect.any(Headers),
             }));
         });
-    });
-    describe('listModelsByProvider', () => {
         it('should fetch models for a specific provider', async () => {
             const mockResponse = {
-                provider: types_1.Provider.OpenAI,
-                models: [
+                object: 'list',
+                data: [
                     {
-                        name: 'gpt-4',
+                        id: 'gpt-4o',
+                        object: 'model',
+                        created: 1686935002,
+                        owned_by: 'openai',
                     },
                 ],
             };
-            global.fetch.mockResolvedValueOnce({
+            mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: () => Promise.resolve(mockResponse),
             });
-            const result = await client.listModelsByProvider(types_1.Provider.OpenAI);
+            const result = await client.listModels(types_1.Provider.OpenAI);
             expect(result).toEqual(mockResponse);
-            expect(global.fetch).toHaveBeenCalledWith(`${mockBaseUrl}/llms/${types_1.Provider.OpenAI}`, expect.objectContaining({
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/v1/models?provider=openai', expect.objectContaining({
+                method: 'GET',
                 headers: expect.any(Headers),
             }));
         });
-        it('should throw error when provider request fails', async () => {
+        it('should throw error when request fails', async () => {
             const errorMessage = 'Provider not found';
-            global.fetch.mockResolvedValueOnce({
+            mockFetch.mockResolvedValueOnce({
                 ok: false,
                 status: 404,
                 json: () => Promise.resolve({ error: errorMessage }),
             });
-            await expect(client.listModelsByProvider(types_1.Provider.OpenAI)).rejects.toThrow(errorMessage);
+            await expect(client.listModels(types_1.Provider.OpenAI)).rejects.toThrow(errorMessage);
         });
     });
-    describe('generateContent', () => {
-        it('should generate content with the specified provider', async () => {
+    describe('createChatCompletion', () => {
+        it('should create a chat completion', async () => {
             const mockRequest = {
-                provider: types_1.Provider.Ollama,
-                model: 'llama2',
+                model: 'gpt-4o',
                 messages: [
                     { role: types_1.MessageRole.System, content: 'You are a helpful assistant' },
                     { role: types_1.MessageRole.User, content: 'Hello' },
                 ],
             };
             const mockResponse = {
-                provider: types_1.Provider.Ollama,
-                response: {
-                    role: types_1.MessageRole.Assistant,
-                    model: 'llama2',
-                    content: 'Hi there!',
+                id: 'chatcmpl-123',
+                object: 'chat.completion',
+                created: 1677652288,
+                model: 'gpt-4o',
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: types_1.MessageRole.Assistant,
+                            content: 'Hello! How can I help you today?',
+                        },
+                        finish_reason: 'stop',
+                    },
+                ],
+                usage: {
+                    prompt_tokens: 10,
+                    completion_tokens: 8,
+                    total_tokens: 18,
                 },
             };
-            global.fetch.mockResolvedValueOnce({
+            mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: () => Promise.resolve(mockResponse),
             });
-            const result = await client.generateContent(mockRequest);
+            const result = await client.createChatCompletion(mockRequest);
             expect(result).toEqual(mockResponse);
-            expect(global.fetch).toHaveBeenCalledWith(`${mockBaseUrl}/llms/${mockRequest.provider}/generate`, expect.objectContaining({
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/v1/chat/completions', expect.objectContaining({
                 method: 'POST',
-                body: JSON.stringify({
-                    model: mockRequest.model,
-                    messages: mockRequest.messages,
-                }),
+                body: JSON.stringify(mockRequest),
             }));
         });
-    });
-    describe('healthCheck', () => {
-        it('should return true when API is healthy', async () => {
-            global.fetch.mockResolvedValueOnce({
+        it('should create a chat completion with a specific provider', async () => {
+            const mockRequest = {
+                model: 'claude-3-opus-20240229',
+                messages: [{ role: types_1.MessageRole.User, content: 'Hello' }],
+            };
+            const mockResponse = {
+                id: 'chatcmpl-456',
+                object: 'chat.completion',
+                created: 1677652288,
+                model: 'claude-3-opus-20240229',
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: types_1.MessageRole.Assistant,
+                            content: 'Hello! How can I assist you today?',
+                        },
+                        finish_reason: 'stop',
+                    },
+                ],
+                usage: {
+                    prompt_tokens: 5,
+                    completion_tokens: 8,
+                    total_tokens: 13,
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
                 ok: true,
-                json: () => Promise.resolve({}),
-            });
-            const result = await client.healthCheck();
-            expect(result).toBe(true);
-            expect(global.fetch).toHaveBeenCalledWith(`${mockBaseUrl}/health`, expect.any(Object));
-        });
-        it('should return false when API is unhealthy', async () => {
-            global.fetch.mockRejectedValueOnce(new Error('API error'));
-            const result = await client.healthCheck();
-            expect(result).toBe(false);
-        });
-    });
-    describe('error handling', () => {
-        it('should throw error when API request fails', async () => {
-            const errorMessage = 'Bad Request';
-            global.fetch.mockResolvedValueOnce({
-                ok: false,
-                status: 400,
-                json: () => Promise.resolve({ error: errorMessage }),
+                json: () => Promise.resolve(mockResponse),
             });
-            await expect(client.listModels()).rejects.toThrow(errorMessage);
+            const result = await client.createChatCompletion(mockRequest, types_1.Provider.Anthropic);
+            expect(result).toEqual(mockResponse);
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/v1/chat/completions?provider=anthropic', expect.objectContaining({
+                method: 'POST',
+                body: JSON.stringify(mockRequest),
+            }));
         });
     });
-    describe('generateContentStream', () => {
-        it('should handle SSE events correctly', async () => {
+    describe('streamChatCompletion', () => {
+        it('should handle streaming chat completions', async () => {
             const mockRequest = {
-                provider: types_1.Provider.Ollama,
-                model: 'llama2',
-                messages: [
-                    { role: types_1.MessageRole.System, content: 'You are a helpful assistant' },
-                    { role: types_1.MessageRole.User, content: 'Hello' },
-                ],
+                model: 'gpt-4o',
+                messages: [{ role: types_1.MessageRole.User, content: 'Hello' }],
             };
-            const mockStream = new TransformStream();
+            const mockStream = new web_1.TransformStream();
             const writer = mockStream.writable.getWriter();
-            const encoder = new TextEncoder();
-            global.fetch.mockResolvedValueOnce({
+            const encoder = new node_util_1.TextEncoder();
+            mockFetch.mockResolvedValueOnce({
                 ok: true,
                 body: mockStream.readable,
             });
             const callbacks = {
-                onMessageStart: jest.fn(),
-                onStreamStart: jest.fn(),
-                onContentStart: jest.fn(),
-                onContentDelta: jest.fn(),
-                onContentEnd: jest.fn(),
-                onMessageEnd: jest.fn(),
-                onStreamEnd: jest.fn(),
+                onOpen: jest.fn(),
+                onChunk: jest.fn(),
+                onContent: jest.fn(),
+                onFinish: jest.fn(),
+                onError: jest.fn(),
             };
-            const streamPromise = client.generateContentStream(mockRequest, callbacks);
-            await writer.write(encoder.encode('event: message-start\ndata: {"role": "assistant"}\n\n' +
-                'event: stream-start\ndata: {}\n\n' +
-                'event: content-start\ndata: {}\n\n' +
-                'event: content-delta\ndata: {"content": "Hello"}\n\n' +
-                'event: content-delta\ndata: {"content": " there!"}\n\n' +
-                'event: content-end\ndata: {}\n\n' +
-                'event: message-end\ndata: {}\n\n' +
-                'event: stream-end\ndata: {}\n\n'));
+            const streamPromise = client.streamChatCompletion(mockRequest, callbacks);
+            // Simulate SSE events
+            await writer.write(encoder.encode('data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}\n\n' +
+                'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"content":"Hello"},"finish_reason":null}]}\n\n' +
+                'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"content":"!"},"finish_reason":null}]}\n\n' +
+                'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\n' +
+                'data: [DONE]\n\n'));
             await writer.close();
             await streamPromise;
-            expect(callbacks.onMessageStart).toHaveBeenCalledWith('assistant');
-            expect(callbacks.onStreamStart).toHaveBeenCalledTimes(1);
-            expect(callbacks.onContentStart).toHaveBeenCalledTimes(1);
-            expect(callbacks.onContentDelta).toHaveBeenCalledWith('Hello');
-            expect(callbacks.onContentDelta).toHaveBeenCalledWith(' there!');
-            expect(callbacks.onContentEnd).toHaveBeenCalledTimes(1);
-            expect(callbacks.onMessageEnd).toHaveBeenCalledTimes(1);
-            expect(callbacks.onStreamEnd).toHaveBeenCalledTimes(1);
-            expect(global.fetch).toHaveBeenCalledWith(`${mockBaseUrl}/llms/${mockRequest.provider}/generate`, expect.objectContaining({
+            expect(callbacks.onOpen).toHaveBeenCalledTimes(1);
+            expect(callbacks.onChunk).toHaveBeenCalledTimes(4);
+            expect(callbacks.onContent).toHaveBeenCalledWith('Hello');
+            expect(callbacks.onContent).toHaveBeenCalledWith('!');
+            expect(callbacks.onFinish).toHaveBeenCalledTimes(1);
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/v1/chat/completions', expect.objectContaining({
                 method: 'POST',
                 body: JSON.stringify({
-                    model: mockRequest.model,
-                    messages: mockRequest.messages,
+                    ...mockRequest,
                     stream: true,
-                    ssevents: true,
                 }),
             }));
         });
-        it('should handle errors in the stream response', async () => {
+        it('should handle tool calls in streaming chat completions', async () => {
             const mockRequest = {
-                provider: types_1.Provider.Ollama,
-                model: 'llama2',
+                model: 'gpt-4o',
+                messages: [
+                    {
+                        role: types_1.MessageRole.User,
+                        content: 'What is the weather in San Francisco?',
+                    },
+                ],
+                tools: [
+                    {
+                        type: 'function',
+                        function: {
+                            name: 'get_weather',
+                            parameters: {
+                                type: 'object',
+                                properties: {
+                                    location: {
+                                        type: 'string',
+                                        description: 'The city and state, e.g. San Francisco, CA',
+                                    },
+                                },
+                                required: ['location'],
+                            },
+                        },
+                    },
+                ],
+            };
+            const mockStream = new web_1.TransformStream();
+            const writer = mockStream.writable.getWriter();
+            const encoder = new node_util_1.TextEncoder();
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                body: mockStream.readable,
+            });
+            const callbacks = {
+                onOpen: jest.fn(),
+                onChunk: jest.fn(),
+                onTool: jest.fn(),
+                onFinish: jest.fn(),
+            };
+            const streamPromise = client.streamChatCompletion(mockRequest, callbacks);
+            // Simulate SSE events with tool calls
+            await writer.write(encoder.encode('data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}\n\n' +
+                'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_123","type":"function","function":{"name":"get_weather"}}]},"finish_reason":null}]}\n\n' +
+                'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\\"location\\""}}]},"finish_reason":null}]}\n\n' +
+                'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":":\\"San Francisco, CA\\""}}]},"finish_reason":null}]}\n\n' +
+                'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"}"}}]},"finish_reason":null}]}\n\n' +
+                'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}\n\n' +
+                'data: [DONE]\n\n'));
+            await writer.close();
+            await streamPromise;
+            expect(callbacks.onOpen).toHaveBeenCalledTimes(1);
+            expect(callbacks.onChunk).toHaveBeenCalledTimes(6);
+            expect(callbacks.onTool).toHaveBeenCalledTimes(4); // Called for each chunk with tool_calls
+            expect(callbacks.onFinish).toHaveBeenCalledTimes(1);
+        });
+        it('should handle errors in streaming chat completions', async () => {
+            const mockRequest = {
+                model: 'gpt-4o',
                 messages: [{ role: types_1.MessageRole.User, content: 'Hello' }],
             };
-            global.fetch.mockResolvedValueOnce({
+            mockFetch.mockResolvedValueOnce({
                 ok: false,
                 status: 400,
                 json: () => Promise.resolve({ error: 'Bad Request' }),
             });
-            await expect(client.generateContentStream(mockRequest, {})).rejects.toThrow('Bad Request');
-        });
-        it('should handle non-readable response body', async () => {
-            const mockRequest = {
-                provider: types_1.Provider.Ollama,
-                model: 'llama2',
-                messages: [{ role: types_1.MessageRole.User, content: 'Hello' }],
+            const callbacks = {
+                onError: jest.fn(),
             };
-            global.fetch.mockResolvedValueOnce({
+            await expect(client.streamChatCompletion(mockRequest, callbacks)).rejects.toThrow('Bad Request');
+            expect(callbacks.onError).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('proxy', () => {
+        it('should proxy requests to a specific provider', async () => {
+            const mockResponse = { result: 'success' };
+            mockFetch.mockResolvedValueOnce({
                 ok: true,
-                body: null,
+                json: () => Promise.resolve(mockResponse),
+            });
+            const result = await client.proxy(types_1.Provider.OpenAI, 'embeddings', {
+                method: 'POST',
+                body: JSON.stringify({
+                    model: 'text-embedding-ada-002',
+                    input: 'Hello world',
+                }),
             });
-            await expect(client.generateContentStream(mockRequest, {})).rejects.toThrow('Response body is not readable');
+            expect(result).toEqual(mockResponse);
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/v1/proxy/openai/embeddings', expect.objectContaining({
+                method: 'POST',
+                body: JSON.stringify({
+                    model: 'text-embedding-ada-002',
+                    input: 'Hello world',
+                }),
+            }));
         });
-        it('should handle empty events in the stream', async () => {
-            const mockRequest = {
-                provider: types_1.Provider.Ollama,
-                model: 'llama2',
-                messages: [{ role: types_1.MessageRole.User, content: 'Hello' }],
-            };
-            const mockStream = new TransformStream();
-            const writer = mockStream.writable.getWriter();
-            const encoder = new TextEncoder();
-            global.fetch.mockResolvedValueOnce({
+    });
+    describe('healthCheck', () => {
+        it('should return true when API is healthy', async () => {
+            mockFetch.mockResolvedValueOnce({
                 ok: true,
-                body: mockStream.readable,
             });
-            const callbacks = {
-                onContentDelta: jest.fn(),
-            };
-            const streamPromise = client.generateContentStream(mockRequest, callbacks);
-            await writer.write(encoder.encode('\n\n'));
-            await writer.write(encoder.encode('event: content-delta\ndata: {"content": "Hello"}\n\n'));
-            await writer.close();
-            await streamPromise;
-            expect(callbacks.onContentDelta).toHaveBeenCalledTimes(1);
-            expect(callbacks.onContentDelta).toHaveBeenCalledWith('Hello');
+            const result = await client.healthCheck();
+            expect(result).toBe(true);
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/health');
+        });
+        it('should return false when API is unhealthy', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('API error'));
+            const result = await client.healthCheck();
+            expect(result).toBe(false);
+        });
+    });
+    describe('withOptions', () => {
+        it('should create a new client with merged options', () => {
+            const originalClient = new client_1.InferenceGatewayClient({
+                baseURL: 'http://localhost:8080/v1',
+                apiKey: 'test-key',
+                fetch: mockFetch,
+            });
+            const newClient = originalClient.withOptions({
+                defaultHeaders: { 'X-Custom-Header': 'value' },
+            });
+            expect(newClient).toBeInstanceOf(client_1.InferenceGatewayClient);
+            expect(newClient).not.toBe(originalClient);
+            // We can't directly test private properties, but we can test behavior
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({}),
+            });
+            newClient.listModels();
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/v1/models', expect.objectContaining({
+                headers: expect.any(Headers),
+            }));
         });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inference-gateway/sdk",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "An SDK written in Typescript for the [Inference Gateway](https://github.com/inference-gateway/inference-gateway).",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -18,7 +18,8 @@
     "ollama",
     "cloudflare",
     "cohere",
-    "typescript"
+    "typescript",
+    "deepseek"
   ],
   "author": "Eden Reich <eden.reich@gmail.com>",
   "license": "MIT",