@inferencesh/sdk 0.6.4 → 0.6.6

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 {};