@inferencesh/sdk 0.6.5 → 0.6.7

package/README.md

@@ -409,7 +409,7 @@ import type { Task, ApiTaskRequest, RunOptions } from '@inferencesh/sdk';
 - [documentation](https://inference.sh/docs) — getting started guides and api reference
 - [blog](https://inference.sh/blog) — tutorials on ai agents, image generation, and more
 - [app store](https://app.inference.sh) — browse 250+ ai models
-- [discord](https://discord.gg/RM77SWSbyT) — community support
+- [discord](https://discord.gg/inference) — community support
 - [github](https://github.com/inference-sh) — open source projects
 
 ## license

package/dist/agent/reducer.test.d.ts

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

package/dist/agent/reducer.test.js

@@ -0,0 +1,127 @@
+import { ChatStatusBusy, ChatStatusIdle } from '../types';
+import { chatReducer, initialState } from './reducer';
+function makeMessage(id, order, chatId = 'chat-1') {
+    return {
+        id,
+        short_id: id,
+        created_at: '2026-01-01T00:00:00Z',
+        updated_at: '2026-01-01T00:00:00Z',
+        user_id: 'user-1',
+        team_id: 'team-1',
+        visibility: 'private',
+        chat_id: chatId,
+        order,
+        status: 'completed',
+        role: 'user',
+        content: [{ type: 'text', text: `message ${id}` }],
+    };
+}
+function makeChat(overrides = {}) {
+    return {
+        id: 'chat-1',
+        short_id: 'c1',
+        created_at: '2026-01-01T00:00:00Z',
+        updated_at: '2026-01-01T00:00:00Z',
+        user_id: 'user-1',
+        team_id: 'team-1',
+        visibility: 'private',
+        status: ChatStatusBusy,
+        name: 'Test chat',
+        description: '',
+        children: [],
+        chat_messages: [makeMessage('msg-1', 1), makeMessage('msg-2', 2)],
+        agent_data: {},
+        ...overrides,
+    };
+}
+describe('chatReducer', () => {
+    it('SET_CHAT should sort messages by order', () => {
+        const chat = makeChat({
+            chat_messages: [makeMessage('msg-2', 2), makeMessage('msg-1', 1)],
+        });
+        const next = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
+        expect(next.messages.map((m) => m.id)).toEqual(['msg-1', 'msg-2']);
+        expect(next.chat?.status).toBe(ChatStatusBusy);
+    });
+    it('UPDATE_CHAT should update chat metadata without replacing messages', () => {
+        const chat = makeChat();
+        const withMessages = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
+        const idleChat = makeChat({ status: ChatStatusIdle, chat_messages: [] });
+        const next = chatReducer(withMessages, { type: 'UPDATE_CHAT', payload: idleChat });
+        expect(next.chat?.status).toBe(ChatStatusIdle);
+        expect(next.messages).toHaveLength(2);
+        expect(next.messages.map((m) => m.id)).toEqual(['msg-1', 'msg-2']);
+    });
+    it('UPDATE_CHAT with null payload should leave state unchanged', () => {
+        const chat = makeChat();
+        const withChat = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
+        const next = chatReducer(withChat, { type: 'UPDATE_CHAT', payload: null });
+        expect(next).toBe(withChat);
+    });
+    it('UPDATE_MESSAGE should replace an existing message by id', () => {
+        const chat = makeChat();
+        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
+        const updated = makeMessage('msg-1', 1);
+        updated.content = [{ type: 'text', text: 'edited' }];
+        const next = chatReducer(state, { type: 'UPDATE_MESSAGE', payload: updated });
+        expect(next.messages.find((m) => m.id === 'msg-1')?.content[0]?.text).toBe('edited');
+        expect(next.messages).toHaveLength(2);
+    });
+    it('UPDATE_MESSAGE should append and sort new messages', () => {
+        const chat = makeChat({ chat_messages: [makeMessage('msg-1', 1)] });
+        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
+        const next = chatReducer(state, { type: 'UPDATE_MESSAGE', payload: makeMessage('msg-2', 2) });
+        expect(next.messages.map((m) => m.id)).toEqual(['msg-1', 'msg-2']);
+    });
+    it('SET_CHAT with null should clear chat and messages', () => {
+        const chat = makeChat();
+        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
+        const next = chatReducer(state, { type: 'SET_CHAT', payload: null });
+        expect(next.chat).toBeNull();
+        expect(next.messages).toEqual([]);
+        expect(next.connectionStatus).toBe('idle');
+    });
+    it('ADD_MESSAGE should append and sort by order', () => {
+        const chat = makeChat({ chat_messages: [makeMessage('msg-1', 1)] });
+        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
+        const next = chatReducer(state, {
+            type: 'ADD_MESSAGE',
+            payload: makeMessage('msg-0', 0),
+        });
+        expect(next.messages.map((m) => m.id)).toEqual(['msg-0', 'msg-1']);
+    });
+    it('RESET should return initial state', () => {
+        const chat = makeChat();
+        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
+        expect(chatReducer(state, { type: 'RESET' })).toEqual(initialState);
+    });
+    it('SET_CHAT_ID should update chatId', () => {
+        const next = chatReducer(initialState, { type: 'SET_CHAT_ID', payload: 'chat-99' });
+        expect(next.chatId).toBe('chat-99');
+    });
+    it('SET_MESSAGES should replace the message list', () => {
+        const messages = [makeMessage('msg-a', 1)];
+        const next = chatReducer(initialState, { type: 'SET_MESSAGES', payload: messages });
+        expect(next.messages).toEqual(messages);
+    });
+    it('ADD_MESSAGE after SET_MESSAGES should append and sort by order', () => {
+        const state = chatReducer(initialState, {
+            type: 'SET_MESSAGES',
+            payload: [makeMessage('msg-2', 2)],
+        });
+        const next = chatReducer(state, { type: 'ADD_MESSAGE', payload: makeMessage('msg-1', 1) });
+        expect(next.messages.map((m) => m.id)).toEqual(['msg-1', 'msg-2']);
+    });
+    it('SET_CONNECTION_STATUS and SET_ERROR should update connection fields', () => {
+        const streaming = chatReducer(initialState, {
+            type: 'SET_CONNECTION_STATUS',
+            payload: 'streaming',
+        });
+        expect(streaming.connectionStatus).toBe('streaming');
+        const errored = chatReducer(streaming, {
+            type: 'SET_ERROR',
+            payload: 'stream failed',
+        });
+        expect(errored.error).toBe('stream failed');
+    });
+});

package/dist/api/agents.test.d.ts

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

package/dist/api/agents.test.js

@@ -0,0 +1,141 @@
+import { HttpClient } from '../http/client';
+import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
+import { FilesAPI } from './files';
+import { AgentsAPI } from './agents';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+function makeMessage(overrides = {}) {
+    return {
+        id: 'msg-1',
+        chat_id: 'chat-1',
+        role: 'assistant',
+        content: 'hello',
+        ...overrides,
+    };
+}
+describe('Agent.sendMessage (polling mode)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const agent = () => {
+        const http = new HttpClient({
+            apiKey: 'test-key',
+            stream: false,
+            pollIntervalMs: 20,
+        });
+        return new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+    };
+    it('should wait until chat is idle when stream is false', async () => {
+        const userMessage = makeMessage({ id: 'user-1', role: 'user' });
+        const assistantMessage = makeMessage({ id: 'asst-1' });
+        mockJsonResponse({
+            success: true,
+            data: { user_message: userMessage, assistant_message: assistantMessage },
+        });
+        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusBusy, chat_messages: [] },
+        });
+        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+        });
+        const onChat = jest.fn();
+        const result = await agent().sendMessage('hello', { stream: false, onChat });
+        expect(result.userMessage).toEqual(userMessage);
+        expect(result.assistantMessage).toEqual(assistantMessage);
+        expect(onChat).toHaveBeenCalledWith(expect.objectContaining({ id: 'chat-1', status: ChatStatusIdle }));
+    });
+    it('should dispatch onToolCall once per client tool invocation', async () => {
+        const toolInvocation = {
+            id: 'tool-inv-1',
+            type: ToolTypeClient,
+            status: ToolInvocationStatusAwaitingInput,
+            function: { name: 'my_tool', arguments: { x: 1 } },
+        };
+        const messageWithTool = makeMessage({ tool_invocations: [toolInvocation] });
+        mockJsonResponse({
+            success: true,
+            data: {
+                user_message: makeMessage({ id: 'user-1', role: 'user' }),
+                assistant_message: makeMessage(),
+            },
+        });
+        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({
+            success: true,
+            data: {
+                id: 'chat-1',
+                status: ChatStatusBusy,
+                chat_messages: [messageWithTool],
+            },
+        });
+        // Same status again — stub poll should not re-dispatch tool
+        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [messageWithTool] },
+        });
+        const onMessage = jest.fn();
+        const onToolCall = jest.fn();
+        await agent().sendMessage('run tool', { stream: false, onMessage, onToolCall });
+        expect(onToolCall).toHaveBeenCalledTimes(1);
+        expect(onToolCall).toHaveBeenCalledWith({
+            id: 'tool-inv-1',
+            name: 'my_tool',
+            args: { x: 1 },
+        });
+    });
+    it('should return chat output from run() after polling completes', async () => {
+        const userMessage = makeMessage({ id: 'user-1', role: 'user' });
+        const assistantMessage = makeMessage();
+        mockJsonResponse({
+            success: true,
+            data: { user_message: userMessage, assistant_message: assistantMessage },
+        });
+        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusBusy },
+        });
+        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusIdle },
+        });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusIdle, output: { answer: 42 } },
+        });
+        const output = await agent().run('compute');
+        expect(output).toEqual({ answer: 42 });
+    });
+});
+describe('Agent.submitToolResult', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should JSON-stringify structured action results', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+        mockJsonResponse({ success: true, data: null });
+        const payload = {
+            action: { type: 'form_submit', payload: { field: 'value' } },
+            form_data: { field: 'value' },
+        };
+        await agentInstance.submitToolResult('inv-99', payload);
+        const [, init] = mockFetch.mock.calls[0];
+        const body = JSON.parse(String(init.body));
+        expect(body.result).toBe(JSON.stringify(payload));
+    });
+});

package/dist/api/files.test.d.ts

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

package/dist/api/files.test.js

@@ -0,0 +1,68 @@
+import { HttpClient } from '../http/client';
+import { FilesAPI } from './files';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('FilesAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new FilesAPI(new HttpClient({ apiKey: 'test-key' }));
+    describe('processInput', () => {
+        it('should not treat short plain strings as base64 file uploads', async () => {
+            const result = await api().processInput({ key: 'key1', note: 'hello' });
+            expect(result).toEqual({ key: 'key1', note: 'hello' });
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
+        it('should upload data URIs embedded in nested objects', async () => {
+            const fileRecord = {
+                id: 'file-1',
+                uri: 'inf://files/abc',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'image/png',
+            };
+            mockJsonResponse({ success: true, data: [fileRecord] });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const input = {
+                prompt: 'draw',
+                image: 'data:image/png;base64,iVBORw0KGgo=',
+            };
+            const result = (await api().processInput(input));
+            expect(result.prompt).toBe('draw');
+            expect(result.image).toBe('inf://files/abc');
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('upload', () => {
+        it('should reject invalid data URI format when uploading content', async () => {
+            mockJsonResponse({
+                success: true,
+                data: [{ id: 'file-x', uri: '', upload_url: 'https://upload.example.com/put' }],
+            });
+            await expect(api().upload('data:invalid')).rejects.toThrow('Invalid data URI format');
+        });
+        it('should decode URL-safe base64 in data URIs', async () => {
+            const fileRecord = {
+                id: 'file-2',
+                uri: 'inf://files/def',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'text/plain',
+            };
+            mockJsonResponse({ success: true, data: [fileRecord] });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            // "SGVsbG8" is "Hello" in standard base64; URL-safe variant uses '-' instead of '+'
+            const dataUri = 'data:text/plain;base64,SGVsbG8';
+            const result = await api().upload(dataUri);
+            expect(result.uri).toBe('inf://files/def');
+            const putCall = mockFetch.mock.calls[1];
+            expect(putCall[0]).toBe('https://upload.example.com/put');
+            expect(putCall[1]?.method).toBe('PUT');
+        });
+    });
+});

package/dist/api/tasks.d.ts

@@ -7,12 +7,8 @@ export interface RunOptions {
     onPartialUpdate?: (update: Task, fields: string[]) => void;
     /** Wait for task completion (default: true) */
     wait?: boolean;
-    /** Auto-reconnect on connection loss (default: true) */
-    autoReconnect?: boolean;
-    /** Maximum reconnection attempts (default: 5) */
+    /** Maximum retry attempts when using polling mode (stream: false). Default: 5 */
     maxReconnects?: number;
-    /** Delay between reconnection attempts in ms (default: 1000) */
-    reconnectDelayMs?: number;
     /** Use SSE streaming (true) or polling (false). Overrides client default. */
     stream?: boolean;
     /** Polling interval in ms when stream is false. Overrides client default. */

package/dist/api/tasks.js

@@ -69,7 +69,7 @@ export class TasksAPI {
      * Run a task and optionally wait for completion
      */
     async run(params, processedInput, options = {}) {
-        const { onUpdate, onPartialUpdate, wait = true, autoReconnect = true, maxReconnects = 5, reconnectDelayMs = 1000, } = options;
+        const { onUpdate, onPartialUpdate, wait = true, } = options;
         const task = await this.http.request('post', '/apps/run', {
             data: {
                 ...params,

package/dist/api/tasks.test.d.ts

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

package/dist/api/tasks.test.js

@@ -0,0 +1,157 @@
+import { HttpClient } from '../http/client';
+import { TaskStatusCancelled, TaskStatusCompleted, TaskStatusFailed, TaskStatusRunning, } from '../types';
+import { TasksAPI } from './tasks';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+function makeTask(overrides = {}) {
+    return {
+        id: 'task-1',
+        status: TaskStatusRunning,
+        created_at: '2026-01-01T00:00:00Z',
+        updated_at: '2026-01-01T00:00:00Z',
+        input: { prompt: 'hi' },
+        output: null,
+        logs: [],
+        session_id: 'sess-1',
+        ...overrides,
+    };
+}
+describe('TasksAPI.run (polling mode)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new TasksAPI(new HttpClient({
+        apiKey: 'test-key',
+        stream: false,
+        pollIntervalMs: 20,
+    }));
+    it('should resolve when status polling detects completion', async () => {
+        const runningTask = makeTask();
+        const completedTask = makeTask({ status: TaskStatusCompleted, output: { ok: true } });
+        mockJsonResponse({ success: true, data: runningTask });
+        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
+        mockJsonResponse({ success: true, data: { status: TaskStatusCompleted } });
+        mockJsonResponse({ success: true, data: completedTask });
+        const onUpdate = jest.fn();
+        const result = await api().run({ app: 'test-app', input: {} }, { prompt: 'hi' }, { wait: true, stream: false, onUpdate });
+        expect(result.status).toBe(TaskStatusCompleted);
+        expect(onUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }));
+    });
+    it('should reject when polling detects a failed task', async () => {
+        const runningTask = makeTask();
+        const failedTask = makeTask({ status: TaskStatusFailed, error: 'model error' });
+        mockJsonResponse({ success: true, data: runningTask });
+        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
+        mockJsonResponse({ success: true, data: { status: TaskStatusFailed } });
+        mockJsonResponse({ success: true, data: failedTask });
+        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false })).rejects.toThrow('model error');
+    });
+    it('should reject when polling detects a cancelled task', async () => {
+        const runningTask = makeTask();
+        const cancelledTask = makeTask({ status: TaskStatusCancelled });
+        mockJsonResponse({ success: true, data: runningTask });
+        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
+        mockJsonResponse({ success: true, data: { status: TaskStatusCancelled } });
+        mockJsonResponse({ success: true, data: cancelledTask });
+        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false })).rejects.toThrow('task cancelled');
+    });
+    it('should parse string terminal statuses from the status endpoint', async () => {
+        const runningTask = makeTask();
+        const completedTask = makeTask({ status: TaskStatusCompleted });
+        mockJsonResponse({ success: true, data: runningTask });
+        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
+        mockJsonResponse({ success: true, data: { status: 'completed' } });
+        mockJsonResponse({ success: true, data: completedTask });
+        const result = await api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false });
+        expect(result.status).toBe(TaskStatusCompleted);
+    });
+});
+function mockNdjsonStream(chunks) {
+    let chunkIndex = 0;
+    const mockReader = {
+        read: jest.fn().mockImplementation(async () => {
+            if (chunkIndex >= chunks.length) {
+                return { done: true, value: undefined };
+            }
+            return { done: false, value: new TextEncoder().encode(chunks[chunkIndex++]) };
+        }),
+        releaseLock: jest.fn(),
+    };
+    return {
+        ok: true,
+        status: 200,
+        body: { getReader: () => mockReader },
+    };
+}
+describe('TasksAPI.run (general)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const streamingApi = () => new TasksAPI(new HttpClient({ apiKey: 'test-key', stream: true }));
+    it('should return immediately when wait is false', async () => {
+        const task = makeTask();
+        mockJsonResponse({ success: true, data: task });
+        const result = await streamingApi().run({ app: 'test-app', input: {} }, { prompt: 'hi' }, { wait: false });
+        expect(result.id).toBe('task-1');
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+});
+describe('TasksAPI.run (streaming mode)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new TasksAPI(new HttpClient({ apiKey: 'test-key', stream: true }));
+    function setupStreamMocks(ndjsonChunks, initialTask = makeTask()) {
+        mockFetch.mockImplementation((url) => {
+            if (url.includes('/apps/run')) {
+                return Promise.resolve({
+                    ok: true,
+                    status: 200,
+                    text: () => Promise.resolve(JSON.stringify({ success: true, data: initialTask })),
+                });
+            }
+            return Promise.resolve(mockNdjsonStream(ndjsonChunks));
+        });
+    }
+    it('should resolve when NDJSON stream reports completion', async () => {
+        setupStreamMocks([
+            `${JSON.stringify({ status: TaskStatusRunning, id: 'task-1' })}\n`,
+            `${JSON.stringify({ status: TaskStatusCompleted, id: 'task-1', output: { ok: true } })}\n`,
+        ]);
+        const onUpdate = jest.fn();
+        const result = await api().run({ app: 'test-app', input: {} }, { prompt: 'hi' }, { wait: true, onUpdate });
+        expect(result.status).toBe(TaskStatusCompleted);
+        expect(onUpdate).toHaveBeenCalled();
+    });
+    it('should reject when NDJSON stream reports failure', async () => {
+        setupStreamMocks([
+            `${JSON.stringify({ status: TaskStatusFailed, id: 'task-1', error: 'gpu OOM' })}\n`,
+        ]);
+        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true })).rejects.toThrow('gpu OOM');
+    });
+    it('should reject when NDJSON stream reports cancellation', async () => {
+        setupStreamMocks([
+            `${JSON.stringify({ status: TaskStatusCancelled, id: 'task-1' })}\n`,
+        ]);
+        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true })).rejects.toThrow('task cancelled');
+    });
+    it('should handle partial updates via onPartialUpdate', async () => {
+        setupStreamMocks([
+            `${JSON.stringify({
+                data: { status: TaskStatusCompleted, id: 'task-1', session_id: 'sess-1' },
+                fields: ['status'],
+            })}\n`,
+        ]);
+        const onPartialUpdate = jest.fn();
+        const result = await api().run({ app: 'test-app', input: {} }, {}, { wait: true, onPartialUpdate });
+        expect(result.status).toBe(TaskStatusCompleted);
+        expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }), ['status']);
+    });
+});

package/dist/http/client.test.d.ts

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

package/dist/http/client.test.js

@@ -0,0 +1,152 @@
+import { HttpClient, createHttpClient } from './client';
+import { InferenceError, RequirementsNotMetException } from './errors';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body, status = 200, ok = true) {
+    mockFetch.mockResolvedValueOnce({
+        ok,
+        status,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('HttpClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('should throw when no apiKey, getToken, or proxyUrl', () => {
+            expect(() => new HttpClient({})).toThrow('Either apiKey, getToken, or proxyUrl is required');
+        });
+        it('should allow proxyUrl without apiKey', () => {
+            const client = new HttpClient({ proxyUrl: 'https://proxy.example.com' });
+            expect(client.isProxyMode()).toBe(true);
+        });
+        it('should expose stream and poll interval config', () => {
+            const client = new HttpClient({
+                apiKey: 'key',
+                stream: false,
+                pollIntervalMs: 5000,
+            });
+            expect(client.getStreamDefault()).toBe(false);
+            expect(client.getPollIntervalMs()).toBe(5000);
+        });
+        it('createHttpClient should return an HttpClient instance', () => {
+            const client = createHttpClient({ apiKey: 'key' });
+            expect(client).toBeInstanceOf(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' } });
+            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 });
+            const result = await client().request('post', '/tasks/task-1/cancel');
+            expect(result).toBeNull();
+        });
+        it('should return undefined for 204 No Content', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 204,
+                text: () => Promise.resolve(''),
+            });
+            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' } });
+            const err = await client().request('get', '/tasks/1').catch((e) => e);
+            expect(err).toBeInstanceOf(InferenceError);
+            expect(err.message).toContain('Invalid request');
+        });
+        it('should throw RequirementsNotMetException on HTTP 412', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 412,
+                text: () => Promise.resolve(JSON.stringify({
+                    errors: [{ type: 'secret', key: 'API_KEY', message: 'Missing secret' }],
+                })),
+            });
+            await expect(client().request('post', '/apps/run')).rejects.toBeInstanceOf(RequirementsNotMetException);
+        });
+        it('should retry when onError handler calls retry', async () => {
+            const httpClient = new HttpClient({
+                apiKey: 'key',
+                onError: async (_error, retry) => retry(),
+            });
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                text: () => Promise.resolve('server error'),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ success: true, data: { ok: true } })),
+            });
+            const result = await httpClient.request('get', '/tasks/1');
+            expect(result).toEqual({ ok: true });
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
+        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' } });
+            await proxyClient.request('get', '/tasks/1');
+            expect(mockFetch).toHaveBeenCalledWith('https://proxy.example.com', expect.objectContaining({
+                headers: expect.objectContaining({
+                    'x-inf-target-url': 'https://api.inference.sh/tasks/1',
+                }),
+            }));
+        });
+        it('should serialize array query params as JSON', async () => {
+            mockJsonResponse({ success: true, data: [] });
+            await client().request('get', '/tasks', {
+                params: { ids: ['a', 'b'] },
+            });
+            const calledUrl = mockFetch.mock.calls[0][0];
+            expect(calledUrl).toContain('ids=');
+            expect(decodeURIComponent(calledUrl)).toContain('["a","b"]');
+        });
+        it('should use top-level message field in HTTP error responses', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 503,
+                text: () => Promise.resolve(JSON.stringify({ message: 'service unavailable' })),
+            });
+            await expect(client().request('get', '/tasks/1')).rejects.toMatchObject({
+                name: 'InferenceError',
+                message: expect.stringContaining('service unavailable'),
+            });
+        });
+    });
+    describe('getStreamableConfig', () => {
+        it('should include bearer token in direct mode', () => {
+            const config = new HttpClient({ apiKey: 'secret-key' }).getStreamableConfig('/tasks/task-1/stream');
+            expect(config.url).toBe('https://api.inference.sh/tasks/task-1/stream');
+            expect(config.headers.Authorization).toBe('Bearer secret-key');
+        });
+        it('should route through proxy with target URL header', () => {
+            const config = new HttpClient({
+                proxyUrl: 'https://proxy.example.com/api',
+            }).getStreamableConfig('/tasks/task-1/stream');
+            expect(config.url).toContain('https://proxy.example.com/api');
+            expect(config.url).toContain('__inf_target=');
+            expect(config.headers['x-inf-target-url']).toBe('https://api.inference.sh/tasks/task-1/stream');
+        });
+        it('should use getToken when apiKey is not set', () => {
+            const config = new HttpClient({
+                getToken: () => 'dynamic-token',
+            }).getStreamableConfig('/tasks/task-1/stream');
+            expect(config.headers.Authorization).toBe('Bearer dynamic-token');
+        });
+    });
+});

package/dist/http/errors.test.d.ts

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

package/dist/http/errors.test.js

@@ -0,0 +1,53 @@
+import { InferenceError, RequirementsNotMetException, SessionEndedError, SessionExpiredError, SessionNotFoundError, WorkerLostError, isInferenceError, isRequirementsNotMetException, isSessionError, } from './errors';
+describe('error type guards', () => {
+    it('isRequirementsNotMetException should match instances and plain objects', () => {
+        const instance = new RequirementsNotMetException([
+            { type: 'secret', key: 'K', message: 'missing' },
+        ]);
+        expect(isRequirementsNotMetException(instance)).toBe(true);
+        const plain = {
+            name: 'RequirementsNotMetException',
+            statusCode: 412,
+            errors: [{ type: 'secret', key: 'K', message: 'missing' }],
+        };
+        expect(isRequirementsNotMetException(plain)).toBe(true);
+        expect(isRequirementsNotMetException(new Error('other'))).toBe(false);
+    });
+    it('isInferenceError should match instances and plain objects', () => {
+        const instance = new InferenceError(500, 'server error');
+        expect(isInferenceError(instance)).toBe(true);
+        expect(isInferenceError({ name: 'InferenceError', statusCode: 404 })).toBe(true);
+        expect(isInferenceError({ name: 'InferenceError' })).toBe(false);
+    });
+    it('isSessionError should match session error subclasses and plain objects', () => {
+        const instance = new SessionNotFoundError('sess-1');
+        expect(isSessionError(instance)).toBe(true);
+        expect(isSessionError({
+            name: 'SessionNotFoundError',
+            sessionId: 'sess-1',
+            statusCode: 404,
+        })).toBe(true);
+        expect(isSessionError({ name: 'InferenceError', statusCode: 500 })).toBe(false);
+    });
+    it('session error subclasses should expose sessionId', () => {
+        expect(new SessionNotFoundError('sess-1').sessionId).toBe('sess-1');
+        expect(new SessionExpiredError('sess-2').statusCode).toBe(410);
+        expect(new SessionEndedError('sess-3').name).toBe('SessionEndedError');
+        expect(new WorkerLostError('sess-4').statusCode).toBe(500);
+    });
+});
+describe('error classes', () => {
+    it('RequirementsNotMetException.fromResponse should default empty errors', () => {
+        const err = RequirementsNotMetException.fromResponse({}, 412);
+        expect(err.errors).toEqual([]);
+        expect(err.statusCode).toBe(412);
+        expect(err.message).toBe('requirements not met');
+    });
+    it('session error subclasses should expose sessionId and statusCode', () => {
+        expect(new SessionNotFoundError('sess-a').sessionId).toBe('sess-a');
+        expect(new SessionNotFoundError('sess-a').statusCode).toBe(404);
+        expect(new SessionExpiredError('sess-b').statusCode).toBe(410);
+        expect(new SessionEndedError('sess-c').message).toContain('sess-c');
+        expect(new WorkerLostError('sess-d').name).toBe('WorkerLostError');
+    });
+});

package/dist/http/poll.test.d.ts

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

package/dist/http/poll.test.js

@@ -0,0 +1,85 @@
+import { PollManager } from './poll';
+describe('PollManager', () => {
+    beforeEach(() => {
+        jest.useFakeTimers();
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    it('should invoke onData after the immediate first poll', async () => {
+        const onData = jest.fn();
+        const pollFunction = jest.fn().mockResolvedValue({ status: 'running' });
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 1000,
+            onData,
+        });
+        manager.start();
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        expect(onData).toHaveBeenCalledWith({ status: 'running' });
+        manager.stop();
+    });
+    it('should poll repeatedly at intervalMs', async () => {
+        const pollFunction = jest.fn().mockResolvedValue({ status: 'running' });
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 1000,
+        });
+        manager.start();
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(1000);
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(2);
+        manager.stop();
+    });
+    it('should call onStart when started and onStop when stopped', async () => {
+        const onStart = jest.fn();
+        const onStop = jest.fn();
+        const pollFunction = jest.fn().mockResolvedValue({});
+        const manager = new PollManager({ pollFunction, onStart, onStop });
+        manager.start();
+        expect(onStart).toHaveBeenCalled();
+        manager.stop();
+        expect(onStop).toHaveBeenCalled();
+    });
+    it('should stop after maxRetries consecutive poll errors', async () => {
+        const onError = jest.fn();
+        const onStop = jest.fn();
+        const pollFunction = jest.fn().mockRejectedValue(new Error('network error'));
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+            maxRetries: 3,
+            onError,
+            onStop,
+        });
+        manager.start();
+        // Immediate first poll
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(onError).toHaveBeenCalledTimes(3);
+        expect(onStop).toHaveBeenCalled();
+        expect(pollFunction.mock.calls.length).toBeGreaterThanOrEqual(3);
+    });
+    it('should not invoke onData after stop', async () => {
+        const onData = jest.fn();
+        const pollFunction = jest.fn().mockResolvedValue({ status: 'running' });
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+            onData,
+        });
+        manager.start();
+        await Promise.resolve();
+        manager.stop();
+        const callsBefore = onData.mock.calls.length;
+        jest.advanceTimersByTime(500);
+        await Promise.resolve();
+        expect(onData.mock.calls.length).toBe(callsBefore);
+    });
+});

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

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

package/dist/proxy/index.test.js

@@ -0,0 +1,147 @@
+import { INF_TARGET_HEADER, INF_TARGET_PARAM, processProxyRequest, } from './index';
+function createTestAdapter(overrides = {}) {
+    const state = { status: 0 };
+    const adapter = {
+        framework: 'test',
+        method: 'POST',
+        body: async () => '{"ok":true}',
+        headers: () => ({}),
+        header: () => undefined,
+        query: () => undefined,
+        setHeader: (name, value) => {
+            state.headers = state.headers ?? {};
+            state.headers[name] = value;
+        },
+        error: (status, message) => {
+            state.status = status;
+            state.body = message;
+            return state;
+        },
+        respond: async (response) => {
+            state.status = response.status;
+            state.body = await response.text();
+            return state;
+        },
+        ...overrides,
+    };
+    return adapter;
+}
+describe('processProxyRequest', () => {
+    const originalFetch = global.fetch;
+    const originalApiKey = process.env.INFERENCE_API_KEY;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'env-test-key';
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+        if (originalApiKey === undefined) {
+            delete process.env.INFERENCE_API_KEY;
+        }
+        else {
+            process.env.INFERENCE_API_KEY = originalApiKey;
+        }
+    });
+    it('should reject requests without a target URL', async () => {
+        const result = await processProxyRequest(createTestAdapter());
+        expect(result.status).toBe(400);
+        expect(result.body).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or ${INF_TARGET_PARAM} query param`,
+        });
+        expect(global.fetch).not.toHaveBeenCalled();
+    });
+    it('should reject invalid target URLs', async () => {
+        const result = await processProxyRequest(createTestAdapter({
+            header: (name) => (name === INF_TARGET_HEADER ? 'not-a-url' : undefined),
+        }));
+        expect(result.status).toBe(400);
+        expect(result.body).toEqual({ error: 'Invalid target URL' });
+        expect(global.fetch).not.toHaveBeenCalled();
+    });
+    it('should reject non-inference.sh domains', async () => {
+        const result = await processProxyRequest(createTestAdapter({
+            header: (name) => name === INF_TARGET_HEADER ? 'https://evil.example.com/run' : undefined,
+        }));
+        expect(result.status).toBe(412);
+        expect(result.body).toEqual({
+            error: 'Target must be an inference.sh domain, got: evil.example.com',
+        });
+        expect(global.fetch).not.toHaveBeenCalled();
+    });
+    it('should reject when no API key is configured', async () => {
+        delete process.env.INFERENCE_API_KEY;
+        const result = await processProxyRequest(createTestAdapter({
+            header: (name) => name === INF_TARGET_HEADER ? 'https://api.inference.sh/run' : undefined,
+        }));
+        expect(result.status).toBe(401);
+        expect(result.body).toEqual({
+            error: 'Missing INFERENCE_API_KEY environment variable',
+        });
+        expect(global.fetch).not.toHaveBeenCalled();
+    });
+    it('should proxy valid inference.sh requests with env API key', async () => {
+        const target = 'https://api.inference.sh/v1/tasks/1';
+        const result = await processProxyRequest(createTestAdapter({
+            header: (name) => (name === INF_TARGET_HEADER ? target : undefined),
+        }));
+        expect(result.status).toBe(200);
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({
+                authorization: 'Bearer env-test-key',
+                'x-inf-proxy': '@inferencesh/sdk-proxy/test',
+            }),
+        }));
+    });
+    it('should use query param fallback when header is missing (SSE clients)', async () => {
+        const target = 'https://api.inference.sh/v1/stream';
+        const encoded = encodeURIComponent(target);
+        await processProxyRequest(createTestAdapter({
+            query: (name) => (name === INF_TARGET_PARAM ? encoded : undefined),
+        }));
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.any(Object));
+    });
+    it('should honor custom allowedDomains', async () => {
+        const target = 'https://cdn.custom.example/upload';
+        await processProxyRequest(createTestAdapter({
+            header: (name) => (name === INF_TARGET_HEADER ? target : undefined),
+        }), { apiKey: 'custom-key', allowedDomains: [/custom\.example$/] });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.any(Object));
+    });
+    it('should forward x-inf-* request headers to upstream', async () => {
+        const target = 'https://api.inference.sh/run';
+        await processProxyRequest(createTestAdapter({
+            header: (name) => {
+                if (name === INF_TARGET_HEADER)
+                    return target;
+                if (name === 'x-inf-session-id')
+                    return 'sess-123';
+                return undefined;
+            },
+            headers: () => ({
+                [INF_TARGET_HEADER]: target,
+                'x-inf-session-id': 'sess-123',
+            }),
+        }), { apiKey: 'key' });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                'x-inf-session-id': 'sess-123',
+            }),
+        }));
+    });
+    it('should omit body for GET requests', async () => {
+        const target = 'https://api.inference.sh/tasks/1';
+        await processProxyRequest(createTestAdapter({
+            method: 'GET',
+            header: (name) => (name === INF_TARGET_HEADER ? target : undefined),
+        }), { apiKey: 'key' });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            method: 'GET',
+            body: undefined,
+        }));
+    });
+});

package/dist/stream.test.js

@@ -128,6 +128,54 @@ describe('StreamManager', () => {
             expect(onData).not.toHaveBeenCalled();
         });
     });
+    describe('addEventListener', () => {
+        it('should deliver typed SSE events to registered listeners', 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();
+            manager.addEventListener('chats', onChat);
+            await manager.connect();
+            const payload = { id: 'chat-1', status: 'open' };
+            typedListeners.chats?.forEach((handler) => handler({ data: JSON.stringify(payload) }));
+            expect(onChat).toHaveBeenCalledWith(payload);
+        });
+        it('should unwrap partial wrappers for typed events', 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 onMessage = jest.fn();
+            manager.addEventListener('chat_messages', onMessage);
+            await manager.connect();
+            const inner = { id: 'msg-1', order: 1 };
+            typedListeners.chat_messages?.forEach((handler) => handler({
+                data: JSON.stringify({ data: inner, fields: ['order'] }),
+            }));
+            expect(onMessage).toHaveBeenCalledWith(inner);
+        });
+    });
     describe('reconnection', () => {
         it('should attempt reconnection on error when autoReconnect is true', async () => {
             jest.useFakeTimers();

package/dist/utils.test.d.ts

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

package/dist/utils.test.js

@@ -0,0 +1,43 @@
+import { TaskStatusCancelled, TaskStatusCompleted, TaskStatusFailed, TaskStatusRunning, TaskStatusUnknown, } from './types';
+import { isTerminalStatus, parseStatus } from './utils';
+describe('parseStatus', () => {
+    it('should return TaskStatusUnknown for null and undefined', () => {
+        expect(parseStatus(null)).toBe(TaskStatusUnknown);
+        expect(parseStatus(undefined)).toBe(TaskStatusUnknown);
+    });
+    it('should pass through numeric status values', () => {
+        expect(parseStatus(TaskStatusRunning)).toBe(TaskStatusRunning);
+        expect(parseStatus(TaskStatusCompleted)).toBe(TaskStatusCompleted);
+    });
+    it('should map lowercase string status names to TaskStatus', () => {
+        expect(parseStatus('running')).toBe(TaskStatusRunning);
+        expect(parseStatus('completed')).toBe(TaskStatusCompleted);
+        expect(parseStatus('failed')).toBe(TaskStatusFailed);
+        expect(parseStatus('cancelled')).toBe(TaskStatusCancelled);
+    });
+    it('should be case-insensitive for string statuses', () => {
+        expect(parseStatus('COMPLETED')).toBe(TaskStatusCompleted);
+        expect(parseStatus('Running')).toBe(TaskStatusRunning);
+    });
+    it('should return TaskStatusUnknown for unrecognized strings', () => {
+        expect(parseStatus('not_a_real_status')).toBe(TaskStatusUnknown);
+    });
+    it('should return TaskStatusUnknown for non-string non-number values', () => {
+        expect(parseStatus(true)).toBe(TaskStatusUnknown);
+    });
+});
+describe('isTerminalStatus', () => {
+    it('should be true for completed, failed, and cancelled (int or string)', () => {
+        expect(isTerminalStatus(TaskStatusCompleted)).toBe(true);
+        expect(isTerminalStatus(TaskStatusFailed)).toBe(true);
+        expect(isTerminalStatus(TaskStatusCancelled)).toBe(true);
+        expect(isTerminalStatus('completed')).toBe(true);
+        expect(isTerminalStatus('failed')).toBe(true);
+        expect(isTerminalStatus('cancelled')).toBe(true);
+    });
+    it('should be false for non-terminal statuses', () => {
+        expect(isTerminalStatus(TaskStatusRunning)).toBe(false);
+        expect(isTerminalStatus('running')).toBe(false);
+        expect(isTerminalStatus(null)).toBe(false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferencesh/sdk",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Official JavaScript/TypeScript SDK for inference.sh - Run AI models with a simple API",
   "type": "module",
   "main": "dist/index.js",