@inferencesh/sdk 0.6.6 → 0.6.8

package/dist/api/agents.test.js

@@ -20,6 +20,23 @@ function makeMessage(overrides = {}) {
         ...overrides,
     };
 }
+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('Agent.sendMessage (polling mode)', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -121,6 +138,247 @@ describe('Agent.sendMessage (polling mode)', () => {
         expect(output).toEqual({ answer: 42 });
     });
 });
+describe('Agent.sendMessage (streaming mode)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const streamingAgent = () => {
+        const http = new HttpClient({ apiKey: 'test-key', stream: true });
+        return new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+    };
+    it('should wait until chat is idle via typed stream events', async () => {
+        const userMessage = makeMessage({ id: 'user-1', role: 'user' });
+        const assistantMessage = makeMessage({ id: 'asst-1' });
+        mockFetch.mockImplementation((url) => {
+            if (url.includes('/agents/run')) {
+                return Promise.resolve({
+                    ok: true,
+                    status: 200,
+                    text: () => Promise.resolve(JSON.stringify({
+                        success: true,
+                        data: { user_message: userMessage, assistant_message: assistantMessage },
+                    })),
+                });
+            }
+            return Promise.resolve(mockNdjsonStream([
+                `${JSON.stringify({ event: 'chats', data: { id: 'chat-1', status: ChatStatusBusy } })}\n`,
+                `${JSON.stringify({ event: 'chats', data: { id: 'chat-1', status: ChatStatusIdle } })}\n`,
+            ]));
+        });
+        const onChat = jest.fn();
+        const result = await streamingAgent().sendMessage('hello', { onChat });
+        expect(result.userMessage).toEqual(userMessage);
+        expect(onChat).toHaveBeenCalledWith(expect.objectContaining({ id: 'chat-1', status: ChatStatusIdle }));
+    });
+    it('should dispatch onToolCall from chat_messages stream events', async () => {
+        const toolInvocation = {
+            id: 'tool-inv-1',
+            type: ToolTypeClient,
+            status: ToolInvocationStatusAwaitingInput,
+            function: { name: 'my_tool', arguments: { x: 1 } },
+        };
+        const messageWithTool = makeMessage({ tool_invocations: [toolInvocation] });
+        mockFetch.mockImplementation((url) => {
+            if (url.includes('/agents/run')) {
+                return Promise.resolve({
+                    ok: true,
+                    status: 200,
+                    text: () => Promise.resolve(JSON.stringify({
+                        success: true,
+                        data: {
+                            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+                            assistant_message: makeMessage(),
+                        },
+                    })),
+                });
+            }
+            return Promise.resolve(mockNdjsonStream([
+                `${JSON.stringify({ event: 'chat_messages', data: messageWithTool })}\n`,
+                `${JSON.stringify({ event: 'chats', data: { id: 'chat-1', status: ChatStatusIdle } })}\n`,
+            ]));
+        });
+        const onToolCall = jest.fn();
+        await streamingAgent().sendMessage('run tool', { onToolCall });
+        expect(onToolCall).toHaveBeenCalledTimes(1);
+        expect(onToolCall).toHaveBeenCalledWith({
+            id: 'tool-inv-1',
+            name: 'my_tool',
+            args: { x: 1 },
+        });
+    });
+    it('should open the stream before POST when continuing an existing chat', async () => {
+        const http = new HttpClient({
+            apiKey: 'test-key',
+            stream: true,
+            pollIntervalMs: 20,
+        });
+        const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+        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: [] },
+        });
+        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+        });
+        await agentInstance.sendMessage('first', { stream: false });
+        const callOrder = [];
+        mockFetch.mockImplementation((url) => {
+            callOrder.push(url);
+            if (url.includes('/agents/run')) {
+                return Promise.resolve({
+                    ok: true,
+                    status: 200,
+                    text: () => Promise.resolve(JSON.stringify({
+                        success: true,
+                        data: {
+                            user_message: makeMessage({ id: 'user-2', role: 'user' }),
+                            assistant_message: makeMessage({ id: 'asst-2' }),
+                        },
+                    })),
+                });
+            }
+            return Promise.resolve(mockNdjsonStream([
+                `${JSON.stringify({ event: 'chats', data: { id: 'chat-1', status: ChatStatusIdle } })}\n`,
+            ]));
+        });
+        await agentInstance.sendMessage('second', { onChat: jest.fn() });
+        const streamIndex = callOrder.findIndex((u) => u.includes('/stream'));
+        const runIndex = callOrder.findIndex((u) => u.includes('/agents/run'));
+        expect(streamIndex).toBeGreaterThanOrEqual(0);
+        expect(runIndex).toBeGreaterThanOrEqual(0);
+        expect(streamIndex).toBeLessThan(runIndex);
+    });
+});
+describe('Agent.sendMessage (file attachments)', () => {
+    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 route image and non-image URIs into images vs files on the run request', async () => {
+        const imageFile = {
+            id: 'file-img',
+            uri: 'inf://files/img',
+            filename: 'photo.png',
+            content_type: 'image/png',
+        };
+        const docFile = {
+            id: 'file-doc',
+            uri: 'inf://files/doc',
+            filename: 'notes.pdf',
+            content_type: 'application/pdf',
+        };
+        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: [] },
+        });
+        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+        });
+        await agent().sendMessage('see attachments', {
+            stream: false,
+            files: [imageFile, docFile],
+        });
+        const runCall = mockFetch.mock.calls.find(([url]) => String(url).includes('/agents/run'));
+        const body = JSON.parse(String(runCall[1].body));
+        expect(body.input.images).toEqual(['inf://files/img']);
+        expect(body.input.files).toEqual(['inf://files/doc']);
+        expect(mockFetch.mock.calls.filter(([url]) => String(url).includes('/files')).length).toBe(0);
+    });
+});
+describe('Agent lifecycle', () => {
+    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('stopChat should no-op when there is no active chat', async () => {
+        await agent().stopChat();
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+    it('stopChat should POST to /chats/{id}/stop when a chat exists', async () => {
+        const agentInstance = agent();
+        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: [] },
+        });
+        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+        });
+        await agentInstance.sendMessage('hello', { stream: false });
+        jest.clearAllMocks();
+        mockJsonResponse({ success: true, data: null });
+        await agentInstance.stopChat();
+        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/chats/chat-1/stop'), expect.anything());
+    });
+    it('reset should clear chat state so stopChat is a no-op', async () => {
+        const agentInstance = agent();
+        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: [] },
+        });
+        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({
+            success: true,
+            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+        });
+        await agentInstance.sendMessage('hello', { stream: false });
+        agentInstance.reset();
+        jest.clearAllMocks();
+        await agentInstance.stopChat();
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+});
 describe('Agent.submitToolResult', () => {
     beforeEach(() => {
         jest.clearAllMocks();

package/dist/api/sessions.d.ts

@@ -8,7 +8,8 @@ import { AppSessionDTO } from '../types';
  *
  * @example
  * ```typescript
- * const client = new Inference({ apiKey: '...' });
+ * import { inference } from '@inferencesh/sdk';
+ * const client = inference({ apiKey: '...' });
  *
  * // Get session info
  * const info = await client.sessions.get('sess_abc123');

package/dist/api/sessions.js

@@ -6,7 +6,8 @@
  *
  * @example
  * ```typescript
- * const client = new Inference({ apiKey: '...' });
+ * import { inference } from '@inferencesh/sdk';
+ * const client = inference({ apiKey: '...' });
  *
  * // Get session info
  * const info = await client.sessions.get('sess_abc123');

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

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

package/dist/api/sessions.test.js

@@ -0,0 +1,49 @@
+import { HttpClient } from '../http/client';
+import { SessionsAPI } from './sessions';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('SessionsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new SessionsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should GET /sessions/{id} for get()', async () => {
+        const session = { id: 'sess_1', status: 'active' };
+        mockJsonResponse({ success: true, data: session });
+        const result = await api().get('sess_1');
+        expect(result).toEqual(session);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions/sess_1');
+        expect(init.method).toBe('GET');
+    });
+    it('should return an empty array when list() response is null', async () => {
+        mockJsonResponse({ success: true, data: null });
+        const result = await api().list();
+        expect(result).toEqual([]);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions');
+    });
+    it('should POST /sessions/{id}/keepalive for keepalive()', async () => {
+        const session = { id: 'sess_2', status: 'active' };
+        mockJsonResponse({ success: true, data: session });
+        const result = await api().keepalive('sess_2');
+        expect(result).toEqual(session);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions/sess_2/keepalive');
+        expect(init.method).toBe('POST');
+    });
+    it('should DELETE /sessions/{id} for end()', async () => {
+        mockJsonResponse({ success: true, data: null });
+        await api().end('sess_3');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions/sess_3');
+        expect(init.method).toBe('DELETE');
+    });
+});

package/dist/api/tasks.test.js

@@ -62,6 +62,20 @@ describe('TasksAPI.run (polling mode)', () => {
         mockJsonResponse({ success: true, data: cancelledTask });
         await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false })).rejects.toThrow('task cancelled');
     });
+    it('should reject when full task fetch fails after status change', async () => {
+        const runningTask = makeTask();
+        mockJsonResponse({ success: true, data: runningTask });
+        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
+        mockJsonResponse({ success: true, data: { status: TaskStatusCompleted } });
+        mockFetch.mockRejectedValueOnce(new Error('network down'));
+        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false })).rejects.toThrow('network down');
+    });
+    it('should reject when status polling fails', async () => {
+        const runningTask = makeTask();
+        mockJsonResponse({ success: true, data: runningTask });
+        mockFetch.mockRejectedValueOnce(new Error('status endpoint down'));
+        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false })).rejects.toThrow('status endpoint down');
+    });
     it('should parse string terminal statuses from the status endpoint', async () => {
         const runningTask = makeTask();
         const completedTask = makeTask({ status: TaskStatusCompleted });

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')