@inferencesh/sdk 0.6.13 → 0.6.14

package/dist/agent/actions.test.js

@@ -1,5 +1,5 @@
 import { ChatStatusBusy, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, } from '../types';
-import { createActions } from './actions';
+import { createActions, getClientToolHandlers } from './actions';
 import * as agentApi from './api';
 import { PollManager } from '../http/poll';
 import { StreamableManager } from '../http/streamable';
@@ -230,6 +230,35 @@ describe('createActions', () => {
             expect(pollInstances[0].options.pollFunction).toBeDefined();
             expect(pollInstances[0].start).toHaveBeenCalled();
         });
+        it('should stop an existing stream manager before starting a new connection', async () => {
+            const { ctx, dispatch } = createTestContext();
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const firstManager = streamInstances[0];
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            expect(firstManager.stop).toHaveBeenCalled();
+            expect(streamInstances).toHaveLength(2);
+            expect(streamInstances[1].start).toHaveBeenCalled();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'connecting',
+            });
+        });
+        it('should dispatch streaming status when the stream manager starts', async () => {
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onStatusChange } });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            streamInstances[0].options.onStart?.();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'streaming',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('streaming');
+        });
     });
     describe('stopStream', () => {
         it('should clear the manager ref before stop so onEnd does not double-dispatch idle', async () => {
@@ -246,6 +275,19 @@ describe('createActions', () => {
             // Only the explicit stopStream dispatch, not a second from onEnd
             expect(idleDispatches).toHaveLength(1);
         });
+        it('should reset to idle when the stream ends unexpectedly with manager still set', async () => {
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onStatusChange } });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            streamInstances[0].options.onEnd?.();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'idle',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('idle');
+        });
         it('should clear the manager ref before poll stop so onStop does not double-dispatch idle', async () => {
             const onStatusChange = jest.fn();
             const { ctx, dispatch, setStreamManager } = createTestContext({
@@ -264,6 +306,22 @@ describe('createActions', () => {
             expect(idleDispatches).toHaveLength(1);
             expect(onStatusChange).toHaveBeenCalledWith('idle');
         });
+        it('should reset to idle when poll transport stops unexpectedly with manager still set', async () => {
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({
+                getStreamEnabled: () => false,
+                callbacks: { onStatusChange },
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            pollInstances[0].options.onStop?.();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'idle',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('idle');
+        });
     });
     describe('stream and poll error callbacks', () => {
         it('should forward stream errors to onError callback', async () => {
@@ -382,6 +440,22 @@ describe('createActions', () => {
         });
     });
     describe('pollChat', () => {
+        it('should dispatch streaming status when the poll manager starts', async () => {
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({
+                getStreamEnabled: () => false,
+                callbacks: { onStatusChange },
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            pollInstances[0].options.onStart?.();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'streaming',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('streaming');
+        });
         it('should fetch full chat when poll status changes', async () => {
             const { ctx: baseCtx } = createTestContext({ getStreamEnabled: () => false });
             const { ctx } = createTestContext({
@@ -715,3 +789,32 @@ describe('createActions', () => {
         });
     });
 });
+describe('getClientToolHandlers', () => {
+    it('returns an empty map when config is null', () => {
+        expect(getClientToolHandlers(null)).toEqual(new Map());
+    });
+    it('returns an empty map for template agent refs', () => {
+        expect(getClientToolHandlers({ agent: 'inference/my-agent' })).toEqual(new Map());
+    });
+    it('returns an empty map when ad-hoc config has no tools', () => {
+        expect(getClientToolHandlers({
+            core_app: { ref: 'openrouter/claude@abc' },
+            system_prompt: 'test',
+        })).toEqual(new Map());
+    });
+    it('extracts client tool handlers from ad-hoc config tools', () => {
+        const handler = jest.fn();
+        const map = getClientToolHandlers({
+            core_app: { ref: 'openrouter/claude@abc' },
+            system_prompt: 'test',
+            tools: [
+                {
+                    schema: { name: 'browser', type: ToolTypeClient, description: 'browse' },
+                    handler,
+                },
+            ],
+        });
+        expect(map.size).toBe(1);
+        expect(map.get('browser')).toBe(handler);
+    });
+});

package/dist/agent/api.test.js

@@ -125,6 +125,15 @@ describe('agent/api', () => {
             const body = JSON.parse(String(runInit.body));
             expect(body.input.attachments).toEqual([fileRecord]);
         });
+        it('should route template agent configs to /agents/run without agent_config', async () => {
+            mockJsonResponse(runResponse);
+            await sendMessage(makeClient(), { agent: 'agent-template-1' }, 'chat-existing', 'hi');
+            const [, init] = mockFetch.mock.calls[0];
+            const body = JSON.parse(String(init.body));
+            expect(body.agent).toBe('agent-template-1');
+            expect(body.chat_id).toBe('chat-existing');
+            expect(body).not.toHaveProperty('agent_config');
+        });
     });
     describe('submitToolResult', () => {
         it('should wrap string results in { result }', async () => {
@@ -143,6 +152,10 @@ describe('agent/api', () => {
             const [, init] = mockFetch.mock.calls[0];
             expect(JSON.parse(String(init.body))).toEqual(payload);
         });
+        it('should rethrow when the request fails', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('submit failed'));
+            await expect(submitToolResult(makeClient(), 'inv-3', 'done')).rejects.toThrow('submit failed');
+        });
     });
     describe('fetchChat', () => {
         it('should return chat data on success', async () => {
@@ -196,6 +209,14 @@ describe('agent/api', () => {
             mockFetch.mockRejectedValueOnce(new Error('approve failed'));
             await expect(approveTool(makeClient(), 'inv-1')).rejects.toThrow('approve failed');
         });
+        it('should rethrow when rejectTool request fails', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('reject failed'));
+            await expect(rejectTool(makeClient(), 'inv-1', 'unsafe')).rejects.toThrow('reject failed');
+        });
+        it('should rethrow when alwaysAllowTool request fails', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('allow failed'));
+            await expect(alwaysAllowTool(makeClient(), 'chat-1', 'inv-1', 'browser_tool')).rejects.toThrow('allow failed');
+        });
     });
     describe('getChatStreamConfig', () => {
         it('should delegate to HttpClient.getStreamableConfig for the chat stream path', () => {

package/dist/api/agents.test.js

@@ -1,7 +1,7 @@
 import { HttpClient } from '../http/client';
 import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
-import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
+import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, } from '../types';
 import { FilesAPI } from './files';
 import { AgentsAPI } from './agents';
 const mockFetch = jest.fn();
@@ -97,6 +97,40 @@ describe('Agent.sendMessage (polling mode)', () => {
             init.method === 'GET');
         expect(fullChatGets).toHaveLength(2);
     });
+    it('should dispatch onToolCall for in_progress client tool invocations', async () => {
+        const toolInvocation = {
+            id: 'tool-inv-progress',
+            type: ToolTypeClient,
+            status: ToolInvocationStatusInProgress,
+            function: { name: 'my_tool', arguments: { x: 2 } },
+        };
+        const messageWithTool = makeMessage({ tool_invocations: [toolInvocation] });
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusBusy,
+            chat_messages: [messageWithTool],
+        });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({
+            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-progress',
+            name: 'my_tool',
+            args: { x: 2 },
+        });
+    });
     it('should dispatch onToolCall once per client tool invocation', async () => {
         const toolInvocation = {
             id: 'tool-inv-1',
@@ -188,6 +222,30 @@ describe('Agent.sendMessage (polling mode)', () => {
         const output = await agent().run('no finish tool');
         expect(output).toBeNull();
     });
+    it('should warn on repeated poll errors without resolving sendMessage', async () => {
+        jest.useFakeTimers();
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockFetch.mockRejectedValue(new Error('status endpoint down'));
+        const sendPromise = agent().sendMessage('hello', { stream: false });
+        for (let i = 0; i < 6; i++) {
+            await Promise.resolve();
+            jest.advanceTimersByTime(20);
+            await Promise.resolve();
+        }
+        expect(warnSpy).toHaveBeenCalledWith('[Agent] Poll error:', expect.any(Error));
+        let settled = false;
+        sendPromise.then(() => {
+            settled = true;
+        });
+        await Promise.resolve();
+        expect(settled).toBe(false);
+        warnSpy.mockRestore();
+        jest.useRealTimers();
+    });
 });
 describe('Agent.sendMessage (streaming mode)', () => {
     beforeEach(() => {
@@ -220,6 +278,39 @@ describe('Agent.sendMessage (streaming mode)', () => {
         expect(result.userMessage).toEqual(userMessage);
         expect(onChat).toHaveBeenCalledWith(expect.objectContaining({ id: 'chat-1', status: ChatStatusIdle }));
     });
+    it('should dispatch onToolCall for in_progress tools from chat_messages stream events', async () => {
+        const toolInvocation = {
+            id: 'tool-inv-progress',
+            type: ToolTypeClient,
+            status: ToolInvocationStatusInProgress,
+            function: { name: 'my_tool', arguments: { x: 2 } },
+        };
+        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({
+                        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-progress',
+            name: 'my_tool',
+            args: { x: 2 },
+        });
+    });
     it('should dispatch onToolCall from chat_messages stream events', async () => {
         const toolInvocation = {
             id: 'tool-inv-1',
@@ -714,6 +805,20 @@ describe('Agent.getChat', () => {
         expect(url).toContain('/chats/chat-42');
         expect(init.method).toBe('GET');
     });
+    it('should expose currentChatId after sendMessage establishes a chat', async () => {
+        const agentInstance = agent();
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusBusy, chat_messages: [] });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusIdle, chat_messages: [] });
+        expect(agentInstance.currentChatId).toBeNull();
+        await agentInstance.sendMessage('hello', { stream: false });
+        expect(agentInstance.currentChatId).toBe('chat-1');
+    });
     it('should GET /chats/{id} with established chat id when chatId is omitted', async () => {
         const agentInstance = agent();
         mockJsonResponse({
@@ -797,6 +902,20 @@ describe('AgentsAPI (template CRUD)', () => {
         expect(url).toContain('/agents/internal-tools');
         expect(init.method).toBe('GET');
     });
+    it('should GET /agents/{id}/card for getA2ACard()', async () => {
+        const card = {
+            name: 'support-bot',
+            description: 'Customer support agent',
+            url: 'https://api.example.com/agents/support-bot',
+            version: '1.0.0',
+        };
+        mockJsonResponse(card);
+        const result = await api().getA2ACard('agent-1');
+        expect(result).toEqual(card);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/card');
+        expect(init.method).toBe('GET');
+    });
     it('should POST team_id for transferOwnership()', async () => {
         const agent = { id: 'agent-1' };
         mockJsonResponse(agent);

package/dist/api/files.test.js

@@ -41,6 +41,14 @@ describe('FilesAPI', () => {
         expect(init.method).toBe('DELETE');
     });
     describe('processInput', () => {
+        it('should return falsy inputs unchanged without uploading', async () => {
+            await expect(api().processInput(null)).resolves.toBeNull();
+            await expect(api().processInput(undefined)).resolves.toBeUndefined();
+            await expect(api().processInput(0)).resolves.toBe(0);
+            await expect(api().processInput(false)).resolves.toBe(false);
+            await expect(api().processInput('')).resolves.toBe('');
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
         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' });

package/dist/api/search.test.js

@@ -25,6 +25,17 @@ describe('SearchAPI', () => {
         expect(init.method).toBe('POST');
         expect(JSON.parse(init.body)).toEqual(payload);
     });
+    it('should forward conversation context in suggest() body', async () => {
+        const payload = {
+            query: 'flux',
+            context: 'previous conversation about image generation',
+            limit: 5,
+        };
+        mockJsonResponse({ results: [] });
+        await api().suggest(payload);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
     it('should POST /search for search()', async () => {
         const payload = { q: 'claude', type: 'apps', limit: 5 };
         const response = { hits: [{ id: 'app-1' }] };

package/dist/api/tasks.test.js

@@ -217,6 +217,27 @@ describe('TasksAPI.run (streaming mode)', () => {
         expect(result.status).toBe(TaskStatusCompleted);
         expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }), ['status']);
     });
+    it('should preserve session_id across partial stream updates that omit it', async () => {
+        setupStreamMocks([
+            `${JSON.stringify({
+                data: { status: TaskStatusRunning, id: 'task-1' },
+                fields: ['status'],
+            })}\n`,
+            `${JSON.stringify({
+                data: { status: TaskStatusCompleted, id: 'task-1', output: { ok: true } },
+                fields: ['status', 'output'],
+            })}\n`,
+        ], makeTask({ session_id: 'sess-persist' }));
+        const onPartialUpdate = jest.fn();
+        const result = await api().run({ app: 'test-app', input: {} }, {}, { wait: true, onPartialUpdate });
+        expect(result.session_id).toBe('sess-persist');
+        expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ session_id: 'sess-persist', status: TaskStatusRunning }), ['status']);
+        expect(onPartialUpdate).toHaveBeenLastCalledWith(expect.objectContaining({
+            session_id: 'sess-persist',
+            status: TaskStatusCompleted,
+            output: { ok: true },
+        }), ['status', 'output']);
+    });
 });
 describe('TasksAPI.run (HTTP contract)', () => {
     beforeEach(() => {

package/dist/http/poll.test.js

@@ -82,4 +82,65 @@ describe('PollManager', () => {
         await Promise.resolve();
         expect(onData.mock.calls.length).toBe(callsBefore);
     });
+    it('should not run overlapping polls when pollFunction is still in flight', async () => {
+        let resolvePoll = () => { };
+        const pollFunction = jest.fn().mockImplementation(() => new Promise((resolve) => {
+            resolvePoll = resolve;
+        }));
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+        });
+        manager.start();
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        resolvePoll({ status: 'ok' });
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(2);
+        manager.stop();
+    });
+    it('should ignore start() when polling is already active', async () => {
+        const onStart = jest.fn();
+        const pollFunction = jest.fn().mockResolvedValue({});
+        const manager = new PollManager({ pollFunction, onStart });
+        manager.start();
+        manager.start();
+        expect(onStart).toHaveBeenCalledTimes(1);
+        manager.stop();
+    });
+    it('should reset consecutive error count after a successful poll', async () => {
+        const onError = jest.fn();
+        const onStop = jest.fn();
+        const pollFunction = jest
+            .fn()
+            .mockRejectedValueOnce(new Error('fail 1'))
+            .mockResolvedValueOnce({ status: 'ok' })
+            .mockRejectedValueOnce(new Error('fail 2'))
+            .mockRejectedValueOnce(new Error('fail 3'));
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+            maxRetries: 2,
+            onError,
+            onStop,
+        });
+        manager.start();
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(onStop).not.toHaveBeenCalled();
+        expect(onError).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(onStop).toHaveBeenCalled();
+        expect(onError).toHaveBeenCalledTimes(3);
+        manager.stop();
+    });
 });

package/dist/http/streamable.test.js

@@ -152,6 +152,18 @@ describe('streamable', () => {
             }
         }).rejects.toThrow('HTTP 401: Unauthorized');
     });
+    it('should throw when the response has no body', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            body: null,
+        });
+        await expect(async () => {
+            for await (const _ of streamable('http://test.com/stream')) {
+                // consume
+            }
+        }).rejects.toThrow('No response body');
+    });
     // Edge cases for chunking/buffering
     describe('chunking edge cases', () => {
         it('should handle message split across many chunks', async () => {
@@ -379,6 +391,68 @@ describe('StreamableManager', () => {
         await manager.start();
         expect(events).toEqual(['start', 'data', 'end']);
     });
+    it('should dispatch typed events to addEventListener subscribers', async () => {
+        global.fetch = mockFetch([
+            '{"event":"chats","data":{"id":"chat-1","status":"busy"}}\n',
+            '{"event":"chat_messages","data":{"id":"msg-1","content":"hi"}}\n',
+        ]);
+        const onChat = jest.fn();
+        const onMessage = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onData: jest.fn(),
+        });
+        manager.addEventListener('chats', onChat);
+        manager.addEventListener('chat_messages', onMessage);
+        await manager.start();
+        expect(onChat).toHaveBeenCalledWith({ id: 'chat-1', status: 'busy' });
+        expect(onMessage).toHaveBeenCalledWith({ id: 'msg-1', content: 'hi' });
+    });
+    it('should stop dispatching to an unsubscribed listener', async () => {
+        global.fetch = mockFetch([
+            '{"event":"chats","data":{"id":"chat-1"}}\n',
+        ]);
+        const removedListener = jest.fn();
+        const activeListener = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+        });
+        const unsubscribe = manager.addEventListener('chats', removedListener);
+        manager.addEventListener('chats', activeListener);
+        unsubscribe();
+        await manager.start();
+        expect(removedListener).not.toHaveBeenCalled();
+        expect(activeListener).toHaveBeenCalledWith({ id: 'chat-1' });
+    });
+    it('should ignore start() when a stream is already running', async () => {
+        let readCount = 0;
+        const mockReader = {
+            read: jest.fn().mockImplementation(async () => {
+                readCount++;
+                if (readCount > 3) {
+                    return { done: true, value: undefined };
+                }
+                await new Promise((resolve) => setTimeout(resolve, 20));
+                return { done: false, value: new TextEncoder().encode('{"id":1}\n') };
+            }),
+            releaseLock: jest.fn(),
+        };
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            body: { getReader: () => mockReader },
+        });
+        const onStart = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onStart,
+            onData: () => { },
+        });
+        const firstStart = manager.start();
+        await manager.start();
+        await firstStart;
+        expect(onStart).toHaveBeenCalledTimes(1);
+        expect(global.fetch).toHaveBeenCalledTimes(1);
+    });
     it('should handle stop()', async () => {
         let readCount = 0;
         const mockReader = {
@@ -407,4 +481,30 @@ describe('StreamableManager', () => {
         // Should have stopped before reading all 10
         expect(readCount).toBeLessThan(10);
     });
+    it('should call onError when the stream request fails', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: false,
+            status: 503,
+            text: async () => 'Service unavailable',
+        });
+        const onError = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onError,
+        });
+        await manager.start();
+        expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'HTTP 503: Service unavailable' }));
+    });
+    it('should route partial updates to onData when onPartialData is not provided', async () => {
+        global.fetch = mockFetch([
+            '{"data":{"id":1,"status":"busy"},"fields":["status"]}\n',
+        ]);
+        const onData = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onData,
+        });
+        await manager.start();
+        expect(onData).toHaveBeenCalledWith({ id: 1, status: 'busy' });
+    });
 });

package/dist/proxy/index.test.js

@@ -106,6 +106,23 @@ describe('processProxyRequest', () => {
             }),
         }));
     });
+    it('should prefer client Authorization header over env API key', async () => {
+        const target = 'https://api.inference.sh/v1/tasks/1';
+        await processProxyRequest(createTestAdapter({
+            header: (name) => {
+                if (name === INF_TARGET_HEADER)
+                    return target;
+                if (name === 'authorization')
+                    return 'Bearer client-session-token';
+                return undefined;
+            },
+        }));
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer client-session-token',
+            }),
+        }));
+    });
     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);

package/dist/stream.test.js

@@ -34,6 +34,15 @@ describe('StreamManager', () => {
             await manager.connect();
             expect(onStart).toHaveBeenCalled();
         });
+        it('should not call onStart when createEventSource returns null', async () => {
+            const onStart = jest.fn();
+            const manager = new StreamManager({
+                createEventSource: async () => null,
+                onStart,
+            });
+            await manager.connect();
+            expect(onStart).not.toHaveBeenCalled();
+        });
         it('should parse JSON messages and call onData', async () => {
             const onData = jest.fn();
             const manager = new StreamManager({

package/dist/types.d.ts

@@ -1983,6 +1983,7 @@ export interface UpdateIntegrationScopesRequest {
  */
 export interface SuggestRequest {
     query: string;
+    context?: string;
     limit?: number;
     category?: string;
     agent?: boolean;

package/package.json

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