@inferencesh/sdk 0.6.7 → 0.6.10

package/dist/http/client.test.js

@@ -1,7 +1,10 @@
 import { HttpClient, createHttpClient } from './client';
 import { InferenceError, RequirementsNotMetException } from './errors';
+import { EventSource } from 'eventsource';
+jest.mock('eventsource');
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
+const MockEventSource = EventSource;
 function mockJsonResponse(body, status = 200, ok = true) {
     mockFetch.mockResolvedValueOnce({
         ok,
@@ -38,17 +41,12 @@ describe('HttpClient', () => {
     describe('request', () => {
         const client = () => new HttpClient({ apiKey: 'test-key' });
         it('should return parsed data on success', async () => {
-            mockJsonResponse({ success: true, data: { id: 'task-1' } });
+            mockJsonResponse({ id: 'task-1' });
             const result = await client().request('get', '/tasks/task-1');
             expect(result).toEqual({ id: 'task-1' });
         });
-        it('should return null when success is true but data field is omitted', async () => {
-            mockJsonResponse({ success: true });
-            const result = await client().request('post', '/tasks/task-1/cancel');
-            expect(result).toBeNull();
-        });
-        it('should return null when success is true with explicit data: null', async () => {
-            mockJsonResponse({ success: true, data: null });
+        it('should return null for null response body', async () => {
+            mockJsonResponse(null);
             const result = await client().request('post', '/tasks/task-1/cancel');
             expect(result).toBeNull();
         });
@@ -61,8 +59,8 @@ describe('HttpClient', () => {
             const result = await client().request('delete', '/tasks/task-1');
             expect(result).toBeUndefined();
         });
-        it('should throw InferenceError when success is false', async () => {
-            mockJsonResponse({ success: false, error: { message: 'Invalid request' } });
+        it('should throw InferenceError on non-ok response', async () => {
+            mockJsonResponse({ message: 'Invalid request' }, 400, false);
             const err = await client().request('get', '/tasks/1').catch((e) => e);
             expect(err).toBeInstanceOf(InferenceError);
             expect(err.message).toContain('Invalid request');
@@ -91,7 +89,7 @@ describe('HttpClient', () => {
                 .mockResolvedValueOnce({
                 ok: true,
                 status: 200,
-                text: () => Promise.resolve(JSON.stringify({ success: true, data: { ok: true } })),
+                text: () => Promise.resolve(JSON.stringify({ ok: true })),
             });
             const result = await httpClient.request('get', '/tasks/1');
             expect(result).toEqual({ ok: true });
@@ -99,7 +97,7 @@ describe('HttpClient', () => {
         });
         it('should route through proxy with x-inf-target-url header', async () => {
             const proxyClient = new HttpClient({ proxyUrl: 'https://proxy.example.com' });
-            mockJsonResponse({ success: true, data: { id: '1' } });
+            mockJsonResponse({ id: '1' });
             await proxyClient.request('get', '/tasks/1');
             expect(mockFetch).toHaveBeenCalledWith('https://proxy.example.com', expect.objectContaining({
                 headers: expect.objectContaining({
@@ -108,7 +106,7 @@ describe('HttpClient', () => {
             }));
         });
         it('should serialize array query params as JSON', async () => {
-            mockJsonResponse({ success: true, data: [] });
+            mockJsonResponse([]);
             await client().request('get', '/tasks', {
                 params: { ids: ['a', 'b'] },
             });
@@ -149,4 +147,44 @@ describe('HttpClient', () => {
             expect(config.headers.Authorization).toBe('Bearer dynamic-token');
         });
     });
+    describe('createEventSource', () => {
+        beforeEach(() => {
+            MockEventSource.mockReset();
+        });
+        it('should attach Bearer token in direct mode via custom fetch', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({ apiKey: 'sse-key' });
+            await client.createEventSource('/tasks/task-1/stream');
+            expect(capturedFetch).toBeDefined();
+            await capturedFetch('https://api.inference.sh/tasks/task-1/stream', { headers: {} });
+            expect(mockFetch).toHaveBeenCalledWith('https://api.inference.sh/tasks/task-1/stream', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer sse-key',
+                }),
+            }));
+        });
+        it('should route through proxy with target URL header on custom fetch', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((url, options) => {
+                capturedFetch = options?.fetch;
+                expect(url).toContain('https://proxy.example.com');
+                expect(url).toContain('__inf_target=');
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({ proxyUrl: 'https://proxy.example.com' });
+            await client.createEventSource('/tasks/task-1/stream');
+            await capturedFetch('https://proxy.example.com', { headers: {} });
+            expect(mockFetch).toHaveBeenCalledWith('https://proxy.example.com', expect.objectContaining({
+                headers: expect.objectContaining({
+                    'x-inf-target-url': 'https://api.inference.sh/tasks/task-1/stream',
+                }),
+            }));
+        });
+    });
 });

package/dist/proxy/express.test.d.ts

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

package/dist/proxy/express.test.js

@@ -0,0 +1,106 @@
+import { INF_TARGET_HEADER } from './index';
+import { createHandler } from './express';
+function createMockResponse() {
+    const res = {
+        statusCode: 200,
+        headers: {},
+        body: undefined,
+        chunks: [],
+        status(code) {
+            this.statusCode = code;
+            return this;
+        },
+        setHeader(name, value) {
+            this.headers[name] = value;
+        },
+        json(data) {
+            this.body = data;
+            return this;
+        },
+        send(data) {
+            this.body = data;
+            return this;
+        },
+        write(chunk) {
+            this.chunks.push(chunk);
+        },
+        end() {
+            return;
+        },
+    };
+    return res;
+}
+describe('express createHandler', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'express-test-key';
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('should return 400 when target URL is missing', async () => {
+        const handler = createHandler();
+        const req = {
+            method: 'POST',
+            body: {},
+            headers: {},
+            query: {},
+        };
+        const res = createMockResponse();
+        await handler(req, res, jest.fn());
+        expect(res.statusCode).toBe(400);
+        expect(res.body).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or __inf_target query param`,
+        });
+    });
+    it('should proxy JSON responses through res.json()', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const handler = createHandler();
+        const target = 'https://api.inference.sh/v1/run';
+        const req = {
+            method: 'POST',
+            body: { prompt: 'hi' },
+            headers: { [INF_TARGET_HEADER]: target },
+            query: {},
+        };
+        const res = createMockResponse();
+        await handler(req, res, jest.fn());
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toEqual({ ok: true });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer express-test-key',
+            }),
+        }));
+    });
+    it('should stream SSE responses with res.write()', async () => {
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(encoder.encode('data: {"x":1}\n\n'));
+                controller.close();
+            },
+        });
+        global.fetch = jest.fn().mockResolvedValue(new Response(stream, {
+            status: 200,
+            headers: { 'content-type': 'text/event-stream' },
+        }));
+        const handler = createHandler();
+        const target = 'https://api.inference.sh/v1/stream';
+        const req = {
+            method: 'POST',
+            body: {},
+            headers: { [INF_TARGET_HEADER]: target },
+            query: {},
+        };
+        const res = createMockResponse();
+        await handler(req, res, jest.fn());
+        expect(res.statusCode).toBe(200);
+        expect(res.chunks.length).toBeGreaterThan(0);
+        expect(res.body).toBeUndefined();
+    });
+});

package/dist/proxy/index.test.js

@@ -1,4 +1,4 @@
-import { INF_TARGET_HEADER, INF_TARGET_PARAM, processProxyRequest, } from './index';
+import { INF_TARGET_HEADER, INF_TARGET_PARAM, headersToRecord, processProxyRequest, } from './index';
 function createTestAdapter(overrides = {}) {
     const state = { status: 0 };
     const adapter = {
@@ -26,6 +26,15 @@ function createTestAdapter(overrides = {}) {
     };
     return adapter;
 }
+describe('headersToRecord', () => {
+    it('should convert Headers to a plain record', () => {
+        const headers = new Headers({ 'x-test': 'value', 'content-type': 'application/json' });
+        expect(headersToRecord(headers)).toEqual({
+            'x-test': 'value',
+            'content-type': 'application/json',
+        });
+    });
+});
 describe('processProxyRequest', () => {
     const originalFetch = global.fetch;
     const originalApiKey = process.env.INFERENCE_API_KEY;

package/dist/stream.test.js

@@ -211,5 +211,144 @@ describe('StreamManager', () => {
             await new Promise((r) => setTimeout(r, 50));
             expect(createEventSource).toHaveBeenCalledTimes(1);
         });
+        it('should stop reconnecting after maxReconnects initial failures', async () => {
+            jest.useFakeTimers();
+            const onError = jest.fn();
+            const createEventSource = jest
+                .fn()
+                .mockResolvedValue(mockEventSource);
+            const manager = new StreamManager({
+                createEventSource,
+                autoReconnect: true,
+                maxReconnects: 2,
+                reconnectDelayMs: 100,
+                onError,
+            });
+            await manager.connect();
+            mockEventSource.onerror?.({});
+            jest.advanceTimersByTime(100);
+            await Promise.resolve();
+            expect(createEventSource).toHaveBeenCalledTimes(2);
+            mockEventSource.onerror?.({});
+            jest.advanceTimersByTime(100);
+            await Promise.resolve();
+            expect(createEventSource).toHaveBeenCalledTimes(3);
+            mockEventSource.onerror?.({});
+            jest.advanceTimersByTime(100);
+            await Promise.resolve();
+            expect(createEventSource).toHaveBeenCalledTimes(3);
+            jest.useRealTimers();
+        });
+        it('should call onError and stop when createEventSource throws', async () => {
+            jest.useFakeTimers();
+            const onError = jest.fn();
+            const createEventSource = jest
+                .fn()
+                .mockRejectedValue(new Error('connection refused'));
+            const manager = new StreamManager({
+                createEventSource,
+                autoReconnect: false,
+                onError,
+            });
+            await manager.connect();
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'connection refused' }));
+            jest.useRealTimers();
+        });
+    });
+    describe('stopAfter and clearStopTimeout', () => {
+        it('should stop after the configured delay', async () => {
+            jest.useFakeTimers();
+            const onStop = jest.fn();
+            const manager = new StreamManager({
+                createEventSource: async () => mockEventSource,
+                onStop,
+            });
+            await manager.connect();
+            manager.stopAfter(5000);
+            jest.advanceTimersByTime(5000);
+            expect(mockEventSource.close).toHaveBeenCalled();
+            expect(onStop).toHaveBeenCalled();
+            jest.useRealTimers();
+        });
+        it('should cancel a pending stop when clearStopTimeout is called', async () => {
+            jest.useFakeTimers();
+            const manager = new StreamManager({
+                createEventSource: async () => mockEventSource,
+            });
+            await manager.connect();
+            manager.stopAfter(5000);
+            manager.clearStopTimeout();
+            jest.advanceTimersByTime(5000);
+            expect(mockEventSource.close).not.toHaveBeenCalled();
+            jest.useRealTimers();
+        });
+    });
+    describe('addEventListener lifecycle', () => {
+        it('should register listeners on an existing connection when added after connect', async () => {
+            const typedListeners = {};
+            const eventSource = {
+                onmessage: null,
+                onerror: null,
+                close: jest.fn(),
+                addEventListener: (eventName, handler) => {
+                    const listeners = typedListeners[eventName] || new Set();
+                    listeners.add(handler);
+                    typedListeners[eventName] = listeners;
+                },
+            };
+            const manager = new StreamManager({
+                createEventSource: async () => eventSource,
+            });
+            await manager.connect();
+            const onChat = jest.fn();
+            manager.addEventListener('chats', onChat);
+            const payload = { id: 'chat-2' };
+            typedListeners.chats?.forEach((handler) => handler({ data: JSON.stringify(payload) }));
+            expect(onChat).toHaveBeenCalledWith(payload);
+        });
+        it('should remove a listener when the cleanup function is called', async () => {
+            const typedListeners = {};
+            const eventSource = {
+                onmessage: null,
+                onerror: null,
+                close: jest.fn(),
+                addEventListener: (eventName, handler) => {
+                    const listeners = typedListeners[eventName] || new Set();
+                    listeners.add(handler);
+                    typedListeners[eventName] = listeners;
+                },
+            };
+            const manager = new StreamManager({
+                createEventSource: async () => eventSource,
+            });
+            const onChat = jest.fn();
+            const unsubscribe = manager.addEventListener('chats', onChat);
+            await manager.connect();
+            unsubscribe();
+            typedListeners.chats?.forEach((handler) => handler({ data: '{"id":"chat-3"}' }));
+            expect(onChat).not.toHaveBeenCalled();
+        });
+        it('should call onError when typed event payload is invalid JSON', async () => {
+            const typedListeners = {};
+            const eventSource = {
+                onmessage: null,
+                onerror: null,
+                close: jest.fn(),
+                addEventListener: (eventName, handler) => {
+                    const listeners = typedListeners[eventName] || new Set();
+                    listeners.add(handler);
+                    typedListeners[eventName] = listeners;
+                },
+            };
+            const onError = jest.fn();
+            const manager = new StreamManager({
+                createEventSource: async () => eventSource,
+                onError,
+            });
+            manager.addEventListener('chats', jest.fn());
+            await manager.connect();
+            typedListeners.chats?.forEach((handler) => handler({ data: 'not-json' }));
+            expect(onError).toHaveBeenCalled();
+        });
     });
 });

package/dist/tool-builder.test.js

@@ -1,5 +1,5 @@
-import { tool, appTool, agentTool, webhookTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
-import { ToolTypeClient, ToolTypeApp, ToolTypeAgent, ToolTypeHook } from './types';
+import { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
+import { ToolTypeClient, ToolTypeApp, ToolTypeAgent, ToolTypeHook, ToolTypeHTTP, ToolTypeMCP, IntegrationProviderGoogle, } from './types';
 describe('Schema Helpers', () => {
     describe('string', () => {
         it('creates string schema without description', () => {
@@ -109,6 +109,18 @@ describe('ClientToolBuilder (tool)', () => {
         const t = tool('get_data').display('Get Data').build();
         expect(t.display_name).toBe('Get Data');
     });
+    it('creates tool with displayName alias', () => {
+        const t = tool('get_data').displayName('Get Data').build();
+        expect(t.display_name).toBe('Get Data');
+    });
+    it('returns schema and handler from handler()', async () => {
+        const clientTool = tool('greet')
+            .describe('Say hi')
+            .param('name', string('Name'))
+            .handler(async (args) => `Hello, ${args.name}`);
+        expect(clientTool.schema.name).toBe('greet');
+        expect(await clientTool.handler({ name: 'Ada' })).toBe('Hello, Ada');
+    });
     it('creates tool with parameters', () => {
         const t = tool('add')
             .param('a', number('First number'))
@@ -240,6 +252,61 @@ describe('AgentToolBuilder (agentTool)', () => {
         expect(t.require_approval).toBe(true);
     });
 });
+describe('HTTPToolBuilder (httpTool)', () => {
+    it('includes custom method and headers in the built tool', () => {
+        const t = httpTool('fetch', 'https://api.example.com/data')
+            .method('GET')
+            .header('X-Custom', '1')
+            .build();
+        expect(t.http?.method).toBe('GET');
+        expect(t.http?.headers).toEqual({ 'X-Custom': '1' });
+    });
+    it('omits method when POST is the default', () => {
+        const t = httpTool('post', 'https://api.example.com').build();
+        expect(t.http?.method).toBeUndefined();
+    });
+    it('should attach integration auth with provider and integration id', () => {
+        const t = httpTool('gmail_send', 'https://api.example.com/send')
+            .auth({ integration: IntegrationProviderGoogle, integrationId: 'int-123' })
+            .build();
+        expect(t.type).toBe(ToolTypeHTTP);
+        expect(t.http?.auth).toEqual({
+            type: 'integration',
+            provider: IntegrationProviderGoogle,
+            integration_id: 'int-123',
+        });
+    });
+    it('should attach api key auth with default header', () => {
+        const t = httpTool('fetch', 'https://api.example.com').auth({ apiKey: 'KEY' }).build();
+        expect(t.http?.auth).toEqual({
+            type: 'api_key',
+            secret: 'KEY',
+            header: 'X-API-Key',
+        });
+    });
+    it('should attach bearer auth', () => {
+        const t = httpTool('fetch', 'https://api.example.com')
+            .auth({ bearer: 'token-abc' })
+            .build();
+        expect(t.http?.auth).toEqual({
+            type: 'bearer',
+            secret: 'token-abc',
+        });
+    });
+    it('callTool should be an alias for httpTool', () => {
+        const t = callTool('ping', 'https://api.example.com/ping').method('GET').build();
+        expect(t.type).toBe(ToolTypeHTTP);
+        expect(t.http?.method).toBe('GET');
+    });
+});
+describe('MCPToolBuilder (mcpTool)', () => {
+    it('creates MCP tool with integration and tool name', () => {
+        const t = mcpTool('search_docs', 'int-mcp-1', 'search').describe('Search docs').build();
+        expect(t.type).toBe(ToolTypeMCP);
+        expect(t.mcp).toEqual({ integration_id: 'int-mcp-1', tool_name: 'search' });
+        expect(t.description).toBe('Search docs');
+    });
+});
 describe('WebhookToolBuilder (webhookTool)', () => {
     it('creates webhook tool with URL', () => {
         const t = webhookTool('notify', 'https://api.example.com/webhook')