@inferencesh/sdk 0.6.12 → 0.6.13

package/dist/agent/actions.test.js

@@ -1,4 +1,4 @@
-import { ChatStatusBusy, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
+import { ChatStatusBusy, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, } from '../types';
 import { createActions } from './actions';
 import * as agentApi from './api';
 import { PollManager } from '../http/poll';
@@ -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({
@@ -216,6 +246,49 @@ describe('createActions', () => {
             // Only the explicit stopStream dispatch, not a second from onEnd
             expect(idleDispatches).toHaveLength(1);
         });
+        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');
+        });
+    });
+    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 +338,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 () => {
@@ -348,6 +434,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 +535,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 +587,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 +657,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 () => {

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;
@@ -205,4 +205,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();
+        });
+    });
 });

package/dist/api/agents.test.js

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import { StreamableManager } from '../http/streamable';
+import { PollManager } from '../http/poll';
 import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
 import { FilesAPI } from './files';
 import { AgentsAPI } from './agents';
@@ -70,6 +71,32 @@ describe('Agent.sendMessage (polling mode)', () => {
         expect(result.assistantMessage).toEqual(assistantMessage);
         expect(onChat).toHaveBeenCalledWith(expect.objectContaining({ id: 'chat-1', status: ChatStatusIdle }));
     });
+    it('should skip full GET /chats when poll status is unchanged', async () => {
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusBusy,
+            chat_messages: [],
+        });
+        // Same status again — pollUntilIdle should return a stub without fetching full chat
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusIdle,
+            chat_messages: [],
+        });
+        await agent().sendMessage('hello', { stream: false });
+        const fullChatGets = mockFetch.mock.calls.filter(([url, init]) => String(url).includes('/chats/chat-1') &&
+            !String(url).includes('/status') &&
+            !String(url).includes('/stop') &&
+            init.method === 'GET');
+        expect(fullChatGets).toHaveLength(2);
+    });
     it('should dispatch onToolCall once per client tool invocation', async () => {
         const toolInvocation = {
             id: 'tool-inv-1',
@@ -104,6 +131,30 @@ describe('Agent.sendMessage (polling mode)', () => {
             args: { x: 1 },
         });
     });
+    it('should call onMessage for each chat message during polling', async () => {
+        const msg1 = makeMessage({ id: 'msg-1', content: 'first' });
+        const msg2 = makeMessage({ id: 'msg-2', content: 'second' });
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusBusy,
+            chat_messages: [msg1, msg2],
+        });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusIdle,
+            chat_messages: [msg1, msg2],
+        });
+        const onMessage = jest.fn();
+        await agent().sendMessage('hello', { stream: false, onMessage });
+        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'msg-1', content: 'first' }));
+        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'msg-2', content: 'second' }));
+    });
     it('should return chat output from run() after polling completes', async () => {
         const userMessage = makeMessage({ id: 'user-1', role: 'user' });
         const assistantMessage = makeMessage();
@@ -124,6 +175,19 @@ describe('Agent.sendMessage (polling mode)', () => {
         const output = await agent().run('compute');
         expect(output).toEqual({ answer: 42 });
     });
+    it('should return null from run() when the chat has no finish output', async () => {
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusBusy });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusIdle });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusIdle, output: null });
+        const output = await agent().run('no finish tool');
+        expect(output).toBeNull();
+    });
 });
 describe('Agent.sendMessage (streaming mode)', () => {
     beforeEach(() => {
@@ -189,6 +253,19 @@ describe('Agent.sendMessage (streaming mode)', () => {
             args: { x: 1 },
         });
     });
+    it('should return immediately without waiting when stream is true and no callbacks', async () => {
+        const userMessage = makeMessage({ id: 'user-1', role: 'user' });
+        const assistantMessage = makeMessage({ id: 'asst-1' });
+        mockJsonResponse({
+            user_message: userMessage,
+            assistant_message: assistantMessage,
+        });
+        const result = await streamingAgent().sendMessage('hello');
+        expect(result.userMessage).toEqual(userMessage);
+        expect(result.assistantMessage).toEqual(assistantMessage);
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        expect(mockFetch.mock.calls[0][0]).toContain('/agents/run');
+    });
     it('should open the stream before POST when continuing an existing chat', async () => {
         const http = new HttpClient({
             apiKey: 'test-key',
@@ -281,6 +358,79 @@ describe('Agent.sendMessage (file attachments)', () => {
         expect(body.input.files).toEqual(['inf://files/doc']);
         expect(mockFetch.mock.calls.filter(([url]) => String(url).includes('/files')).length).toBe(0);
     });
+    it('should upload Blob attachments before POST /agents/run', async () => {
+        const fileRecord = {
+            id: 'file-blob',
+            uri: 'inf://files/blob-direct',
+            upload_url: 'https://upload.example.com/put',
+            content_type: 'image/png',
+        };
+        mockJsonResponse([fileRecord]);
+        mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+        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: [] });
+        const blob = new Blob(['png-bytes'], { type: 'image/png' });
+        await agent().sendMessage('see image', { stream: false, files: [blob] });
+        const fileCreateCall = mockFetch.mock.calls.find(([url]) => String(url).includes('/files') && !String(url).includes('upload.example.com'));
+        expect(fileCreateCall).toBeDefined();
+        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/blob-direct']);
+        expect(body.input.files).toBeUndefined();
+    });
+});
+describe('Agent.sendMessage (template ref)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const templateAgent = (context) => {
+        const http = new HttpClient({
+            apiKey: 'test-key',
+            stream: false,
+            pollIntervalMs: 20,
+        });
+        return new AgentsAPI(http, new FilesAPI(http)).create('inference/my-agent', { context });
+    };
+    function mockRunAndPoll() {
+        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: [] });
+    }
+    it('should POST agent ref and context to /agents/run', async () => {
+        mockRunAndPoll();
+        await templateAgent({ tenant: 'acme' }).sendMessage('hello', { stream: false });
+        const runCall = mockFetch.mock.calls.find(([url]) => String(url).includes('/agents/run'));
+        const body = JSON.parse(String(runCall[1].body));
+        expect(body.agent).toBe('inference/my-agent');
+        expect(body.agent_config).toBeUndefined();
+        expect(body.context).toEqual({ tenant: 'acme' });
+        expect(body.chat_id).toBeNull();
+        expect(body.input.text).toBe('hello');
+    });
+    it('should include chat_id on follow-up messages', async () => {
+        const agentInstance = templateAgent();
+        mockRunAndPoll();
+        await agentInstance.sendMessage('first', { stream: false });
+        jest.clearAllMocks();
+        mockRunAndPoll();
+        await agentInstance.sendMessage('second', { stream: false });
+        const runCall = mockFetch.mock.calls.find(([url]) => String(url).includes('/agents/run'));
+        const body = JSON.parse(String(runCall[1].body));
+        expect(body.agent).toBe('inference/my-agent');
+        expect(body.chat_id).toBe('chat-1');
+        expect(body.input.text).toBe('second');
+    });
 });
 describe('Agent.sendMessage (ad-hoc config)', () => {
     beforeEach(() => {
@@ -319,6 +469,31 @@ describe('Agent.sendMessage (ad-hoc config)', () => {
         expect(body.agent_name).toBe('adhoc-bot');
         expect(body.input.text).toBe('hello');
     });
+    it('should prefer AgentOptions.name over config.name for agent_name', async () => {
+        const http = new HttpClient({
+            apiKey: 'test-key',
+            stream: false,
+            pollIntervalMs: 20,
+        });
+        const namedAgent = new AgentsAPI(http, new FilesAPI(http)).create({
+            core_app: { ref: 'openrouter/claude@latest' },
+            system_prompt: 'You are helpful',
+            name: 'config-name',
+        }, { name: 'override-name' });
+        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: [] });
+        await namedAgent.sendMessage('hello', { stream: false });
+        const runCall = mockFetch.mock.calls.find(([url]) => String(url).includes('/agents/run'));
+        const body = JSON.parse(String(runCall[1].body));
+        expect(body.agent_name).toBe('override-name');
+        expect(body.agent_config.name).toBe('config-name');
+    });
 });
 describe('Agent lifecycle', () => {
     beforeEach(() => {
@@ -356,6 +531,28 @@ describe('Agent lifecycle', () => {
         await agentInstance.stopChat();
         expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/chats/chat-1/stop'), expect.anything());
     });
+    it('disconnect should stop active poll managers', async () => {
+        jest.useFakeTimers();
+        const stopSpy = jest.spyOn(PollManager.prototype, 'stop');
+        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: [] });
+        const sendPromise = agentInstance.sendMessage('hello', {
+            stream: false,
+            pollIntervalMs: 5000,
+        });
+        await Promise.resolve();
+        await jest.advanceTimersByTimeAsync(0);
+        agentInstance.disconnect();
+        expect(stopSpy).toHaveBeenCalled();
+        stopSpy.mockRestore();
+        jest.useRealTimers();
+        sendPromise.catch(() => undefined);
+    });
     it('disconnect should stop active stream managers', async () => {
         const http = new HttpClient({
             apiKey: 'test-key',
@@ -436,6 +633,64 @@ describe('Agent lifecycle', () => {
         await agentInstance.stopChat();
         expect(mockFetch).not.toHaveBeenCalled();
     });
+    it('reset should allow onToolCall to fire again for the same invocation id', async () => {
+        const toolInvocation = {
+            id: 'tool-inv-reset',
+            type: ToolTypeClient,
+            status: ToolInvocationStatusAwaitingInput,
+            function: { name: 'my_tool', arguments: { x: 1 } },
+        };
+        const messageWithTool = makeMessage({ tool_invocations: [toolInvocation] });
+        const agentInstance = agent();
+        const onMessage = jest.fn();
+        const onToolCall = jest.fn();
+        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: ChatStatusBusy });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusIdle,
+            chat_messages: [messageWithTool],
+        });
+        await agentInstance.sendMessage('run tool', { stream: false, onMessage, onToolCall });
+        expect(onToolCall).toHaveBeenCalledTimes(1);
+        agentInstance.reset();
+        jest.clearAllMocks();
+        onToolCall.mockClear();
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-2', role: 'user' }),
+            assistant_message: makeMessage({ id: 'asst-2' }),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusBusy,
+            chat_messages: [messageWithTool],
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusIdle,
+            chat_messages: [messageWithTool],
+        });
+        await agentInstance.sendMessage('run tool again', { stream: false, onMessage, onToolCall });
+        expect(onToolCall).toHaveBeenCalledTimes(1);
+        expect(onToolCall).toHaveBeenCalledWith({
+            id: 'tool-inv-reset',
+            name: 'my_tool',
+            args: { x: 1 },
+        });
+    });
 });
 describe('Agent.getChat', () => {
     beforeEach(() => {
@@ -459,11 +714,41 @@ describe('Agent.getChat', () => {
         expect(url).toContain('/chats/chat-42');
         expect(init.method).toBe('GET');
     });
+    it('should GET /chats/{id} with established chat id when chatId is omitted', 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: [] });
+        await agentInstance.sendMessage('hello', { stream: false });
+        jest.clearAllMocks();
+        const chat = { id: 'chat-1', status: 'idle', chat_messages: [] };
+        mockJsonResponse(chat);
+        const result = await agentInstance.getChat();
+        expect(result).toEqual(chat);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1');
+        expect(init.method).toBe('GET');
+    });
 });
 describe('Agent.submitToolResult', () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
+    it('should POST plain string results to /tools/{invocationId}', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+        mockJsonResponse(null);
+        await agentInstance.submitToolResult('inv-plain', 'done');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/tools/inv-plain');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(String(init.body))).toEqual({ result: 'done' });
+    });
     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');