@inferencesh/sdk 0.6.12 → 0.6.14

package/dist/agent/actions.test.js

@@ -1,5 +1,5 @@
-import { ChatStatusBusy, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
-import { createActions } from './actions';
+import { ChatStatusBusy, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, } from '../types';
+import { createActions, getClientToolHandlers } from './actions';
 import * as agentApi from './api';
 import { PollManager } from '../http/poll';
 import { StreamableManager } from '../http/streamable';
@@ -94,6 +94,12 @@ describe('createActions', () => {
         mockAgentApi.approveTool.mockResolvedValue(undefined);
         mockAgentApi.rejectTool.mockResolvedValue(undefined);
         mockAgentApi.alwaysAllowTool.mockResolvedValue(undefined);
+        mockAgentApi.uploadFile.mockResolvedValue({
+            id: 'file-1',
+            uri: 'inf://files/uploaded',
+            filename: 'notes.txt',
+            content_type: 'text/plain',
+        });
     });
     describe('updateMessage (via stream listeners)', () => {
         it('should ignore messages for a different chat when IDs do not prefix-match', async () => {
@@ -141,6 +147,30 @@ describe('createActions', () => {
             expect(handler).toHaveBeenCalledWith({ x: 1 });
             expect(mockAgentApi.submitToolResult).toHaveBeenCalledWith(ctx.client, 'tool-inv-ok', 'tool ok');
         });
+        it('should dispatch client tool handlers when status is in_progress', async () => {
+            const handler = jest.fn().mockResolvedValue('in progress ok');
+            const { ctx } = createTestContext({
+                getClientToolHandlers: () => new Map([['my_tool', handler]]),
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const onMessage = streamInstances[0].addEventListener.mock.calls.find(([event]) => event === 'chat_messages')?.[1];
+            onMessage(makeMessage({
+                chat_id: 'chat-short',
+                tool_invocations: [
+                    {
+                        id: 'tool-inv-progress',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusInProgress,
+                        function: { name: 'my_tool', arguments: { y: 2 } },
+                    },
+                ],
+            }));
+            await Promise.resolve();
+            expect(handler).toHaveBeenCalledWith({ y: 2 });
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledWith(ctx.client, 'tool-inv-progress', 'in progress ok');
+        });
         it('should submit a JSON error when a client tool handler throws', async () => {
             const handler = jest.fn().mockRejectedValue(new Error('handler boom'));
             const { ctx } = createTestContext({
@@ -200,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 () => {
@@ -216,6 +275,78 @@ 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({
+                getStreamEnabled: () => false,
+                callbacks: { onStatusChange },
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const manager = pollInstances[0];
+            internalActions.stopStream();
+            expect(setStreamManager).toHaveBeenCalledWith(undefined);
+            expect(manager.stop).toHaveBeenCalled();
+            manager.options.onStop?.();
+            const idleDispatches = dispatch.mock.calls.filter(([action]) => action.type === 'SET_CONNECTION_STATUS' && action.payload === 'idle');
+            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 () => {
+            const onError = jest.fn();
+            const { ctx } = createTestContext({ callbacks: { onError } });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const streamError = new Error('stream connection lost');
+            streamInstances[0].options.onError?.(streamError);
+            expect(onError).toHaveBeenCalledWith(streamError);
+        });
+        it('should forward poll manager errors to onError callback', async () => {
+            const onError = jest.fn();
+            const { ctx } = createTestContext({
+                getStreamEnabled: () => false,
+                callbacks: { onError },
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const pollError = new Error('poll transport failed');
+            pollInstances[0].options.onError?.(pollError);
+            expect(onError).toHaveBeenCalledWith(pollError);
+        });
     });
     describe('publicActions.sendMessage', () => {
         it('should call onChatCreated and start streaming for a new chat', async () => {
@@ -265,6 +396,19 @@ describe('createActions', () => {
             await publicActions.sendMessage('   ');
             expect(mockAgentApi.sendMessage).not.toHaveBeenCalled();
         });
+        it('should no-op when agent config is missing', async () => {
+            const consoleError = jest.spyOn(console, 'error').mockImplementation(() => { });
+            const { ctx, dispatch } = createTestContext({ getConfig: () => null });
+            const { publicActions } = createActions(ctx);
+            await publicActions.sendMessage('hello');
+            expect(mockAgentApi.sendMessage).not.toHaveBeenCalled();
+            expect(dispatch).not.toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'streaming',
+            });
+            expect(consoleError).toHaveBeenCalledWith('[AgentSDK] No agent config provided');
+            consoleError.mockRestore();
+        });
     });
     describe('streamChat error handling', () => {
         it('should reset to idle when initial fetchChat fails', async () => {
@@ -296,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({
@@ -348,6 +508,77 @@ describe('createActions', () => {
             await Promise.resolve();
             expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'poll fetch failed' }));
         });
+        it('should not refetch chat when poll status is unchanged', async () => {
+            const { ctx: baseCtx } = createTestContext({ getStreamEnabled: () => false });
+            const { ctx } = createTestContext({
+                getStreamEnabled: () => false,
+                client: {
+                    ...baseCtx.client,
+                    http: { ...baseCtx.client.http, request: jest.fn().mockResolvedValue({ status: ChatStatusBusy }) },
+                },
+            });
+            const { internalActions } = createActions(ctx);
+            mockAgentApi.fetchChat.mockResolvedValue({
+                id: 'chat-full-id-123',
+                status: ChatStatusBusy,
+                chat_messages: [],
+            });
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            await pollInstances[0].options.onData?.({ status: ChatStatusBusy });
+            await Promise.resolve();
+            const fetchCountAfterFirst = mockAgentApi.fetchChat.mock.calls.length;
+            await pollInstances[0].options.onData?.({ status: ChatStatusBusy });
+            await Promise.resolve();
+            expect(mockAgentApi.fetchChat).toHaveBeenCalledTimes(fetchCountAfterFirst);
+        });
+        it('should dispatch client tools from poll path when status changes', async () => {
+            const handler = jest.fn().mockResolvedValue('poll ok');
+            const toolMessage = makeMessage({
+                chat_id: 'chat-short',
+                tool_invocations: [
+                    {
+                        id: 'tool-inv-poll',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusInProgress,
+                        function: { name: 'my_tool', arguments: { y: 2 } },
+                    },
+                ],
+            });
+            const { ctx: baseCtx } = createTestContext({
+                getStreamEnabled: () => false,
+                getClientToolHandlers: () => new Map([['my_tool', handler]]),
+            });
+            const { ctx } = createTestContext({
+                getStreamEnabled: () => false,
+                getClientToolHandlers: () => new Map([['my_tool', handler]]),
+                client: {
+                    ...baseCtx.client,
+                    http: {
+                        ...baseCtx.client.http,
+                        request: jest.fn().mockResolvedValue({ status: ChatStatusBusy }),
+                    },
+                },
+            });
+            const { internalActions } = createActions(ctx);
+            mockAgentApi.fetchChat
+                .mockResolvedValueOnce({
+                id: 'chat-full-id-123',
+                status: ChatStatusBusy,
+                chat_messages: [],
+            })
+                .mockResolvedValueOnce({
+                id: 'chat-full-id-123',
+                status: ChatStatusBusy,
+                chat_messages: [toolMessage],
+            });
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            await pollInstances[0].options.onData?.({ status: 'idle' });
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(handler).toHaveBeenCalledWith({ y: 2 });
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledWith(ctx.client, 'tool-inv-poll', 'poll ok');
+        });
     });
     describe('client tool deduplication', () => {
         it('should not submit the same client tool invocation twice', async () => {
@@ -378,6 +609,14 @@ describe('createActions', () => {
         });
     });
     describe('publicActions lifecycle', () => {
+        it('uploadFile should delegate to the API layer', async () => {
+            const file = new File(['hello'], 'notes.txt', { type: 'text/plain' });
+            const { ctx } = createTestContext();
+            const { publicActions } = createActions(ctx);
+            const result = await publicActions.uploadFile(file);
+            expect(mockAgentApi.uploadFile).toHaveBeenCalledWith(ctx.client, file);
+            expect(result).toEqual(expect.objectContaining({ uri: 'inf://files/uploaded', filename: 'notes.txt' }));
+        });
         it('reset should stop stream and dispatch RESET', async () => {
             const { ctx, dispatch } = createTestContext();
             const { publicActions } = createActions(ctx);
@@ -422,6 +661,38 @@ describe('createActions', () => {
                 payload: 'idle',
             });
         });
+        it('reset should allow the same client tool invocation to dispatch again', async () => {
+            const handler = jest.fn().mockResolvedValue('ok');
+            const { ctx } = createTestContext({
+                getClientToolHandlers: () => new Map([['my_tool', handler]]),
+            });
+            const { publicActions, internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const onMessage = streamInstances[0].addEventListener.mock.calls.find(([event]) => event === 'chat_messages')?.[1];
+            const toolMessage = makeMessage({
+                chat_id: 'chat-short',
+                tool_invocations: [
+                    {
+                        id: 'tool-inv-reset',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusAwaitingInput,
+                        function: { name: 'my_tool', arguments: {} },
+                    },
+                ],
+            });
+            onMessage(toolMessage);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(handler).toHaveBeenCalledTimes(1);
+            publicActions.reset();
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const onMessageAfterReset = streamInstances[1].addEventListener.mock.calls.find(([event]) => event === 'chat_messages')?.[1];
+            onMessageAfterReset(toolMessage);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(handler).toHaveBeenCalledTimes(2);
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledTimes(2);
+        });
     });
     describe('HIL tool actions', () => {
         it('approveTool should delegate to the API', async () => {
@@ -460,6 +731,33 @@ describe('createActions', () => {
             });
             expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'approve failed' }));
         });
+        it('rejectTool should set error state when API fails', async () => {
+            mockAgentApi.rejectTool.mockRejectedValueOnce(new Error('reject failed'));
+            const onError = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onError } });
+            const { publicActions } = createActions(ctx);
+            await expect(publicActions.rejectTool('inv-1', 'unsafe')).rejects.toThrow('reject failed');
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'error',
+            });
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'reject failed' }));
+        });
+        it('alwaysAllowTool should set error state when API fails', async () => {
+            mockAgentApi.alwaysAllowTool.mockRejectedValueOnce(new Error('allow failed'));
+            const onError = jest.fn();
+            const { ctx, dispatch } = createTestContext({
+                getChatId: () => 'chat-short',
+                callbacks: { onError },
+            });
+            const { publicActions } = createActions(ctx);
+            await expect(publicActions.alwaysAllowTool('inv-1', 'my_tool')).rejects.toThrow('allow failed');
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'error',
+            });
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'allow failed' }));
+        });
     });
     describe('setChatId', () => {
         it('should no-op when the chat id is unchanged', async () => {
@@ -491,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

@@ -1,6 +1,6 @@
 import { HttpClient } from '../http/client';
 import { FilesAPI } from '../api/files';
-import { sendAdHocMessage, sendTemplateMessage, sendMessage, submitToolResult, approveTool, rejectTool, alwaysAllowTool, fetchChat, stopChat, getChatStreamConfig, } from './api';
+import { sendAdHocMessage, sendTemplateMessage, sendMessage, submitToolResult, approveTool, rejectTool, alwaysAllowTool, fetchChat, stopChat, getChatStreamConfig, uploadFile, } from './api';
 import { ToolTypeClient } from '../types';
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
@@ -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', () => {
@@ -205,4 +226,21 @@ describe('agent/api', () => {
             expect(config.headers).toEqual(expect.objectContaining({ Authorization: expect.stringContaining('Bearer') }));
         });
     });
+    describe('uploadFile', () => {
+        it('should delegate to client.files.upload and return the uploaded file ref', async () => {
+            const client = makeClient();
+            const fileRecord = {
+                id: 'file-1',
+                uri: 'inf://files/uploaded',
+                filename: 'notes.txt',
+                content_type: 'text/plain',
+            };
+            const uploadSpy = jest.spyOn(client.files, 'upload').mockResolvedValue(fileRecord);
+            const file = new File(['hello'], 'notes.txt', { type: 'text/plain' });
+            const result = await uploadFile(client, file);
+            expect(uploadSpy).toHaveBeenCalledWith(file);
+            expect(result).toEqual(fileRecord);
+            uploadSpy.mockRestore();
+        });
+    });
 });