@inferencesh/sdk 0.6.7 → 0.6.10

package/dist/agent/api.test.js

@@ -0,0 +1,208 @@
+import { HttpClient } from '../http/client';
+import { FilesAPI } from '../api/files';
+import { sendAdHocMessage, sendTemplateMessage, sendMessage, submitToolResult, approveTool, rejectTool, alwaysAllowTool, fetchChat, stopChat, getChatStreamConfig, } from './api';
+import { ToolTypeClient } from '../types';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+function makeClient() {
+    const http = new HttpClient({ apiKey: 'test-key' });
+    const files = new FilesAPI(http);
+    return { http, files };
+}
+const adHocConfig = {
+    name: 'test-agent',
+    core_app: { ref: 'openrouter/claude@abc' },
+    system_prompt: 'Be helpful',
+};
+const runResponse = {
+    user_message: { id: 'u1', chat_id: 'chat-1', role: 'user' },
+    assistant_message: { id: 'a1', chat_id: 'chat-1', role: 'assistant' },
+};
+describe('agent/api', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('sendAdHocMessage', () => {
+        it('should return null when the API response omits messages', async () => {
+            mockJsonResponse({});
+            const result = await sendAdHocMessage(makeClient(), adHocConfig, null, 'hello');
+            expect(result).toBeNull();
+        });
+        it('should strip client tool handlers from the agents/run request body', async () => {
+            mockJsonResponse(runResponse);
+            const handler = jest.fn().mockReturnValue('ok');
+            await sendAdHocMessage(makeClient(), {
+                ...adHocConfig,
+                tools: [
+                    {
+                        schema: {
+                            name: 'browser_tool',
+                            type: ToolTypeClient,
+                            description: 'runs in browser',
+                        },
+                        handler,
+                    },
+                ],
+            }, null, 'hello');
+            const [, init] = mockFetch.mock.calls[0];
+            const body = JSON.parse(String(init.body));
+            expect(body.agent_config.tools[0]).toEqual({
+                name: 'browser_tool',
+                type: ToolTypeClient,
+                description: 'runs in browser',
+            });
+            expect(body.agent_config.tools[0]).not.toHaveProperty('handler');
+            expect(handler).not.toHaveBeenCalled();
+        });
+    });
+    describe('sendTemplateMessage', () => {
+        it('should return null when assistant_message is missing', async () => {
+            mockJsonResponse({
+                user_message: { id: 'u1', chat_id: 'chat-1', role: 'user' },
+            });
+            const result = await sendTemplateMessage(makeClient(), { agent: 'agent-1' }, null, 'hello');
+            expect(result).toBeNull();
+        });
+        it('should omit empty agent field for existing chats', async () => {
+            mockJsonResponse(runResponse);
+            await sendTemplateMessage(makeClient(), { agent: '' }, 'chat-existing', 'hi');
+            const [, init] = mockFetch.mock.calls[0];
+            const body = JSON.parse(String(init.body));
+            expect(body.chat_id).toBe('chat-existing');
+            expect(body).not.toHaveProperty('agent');
+        });
+    });
+    describe('sendMessage', () => {
+        it('should pass FileRef attachments without uploading', async () => {
+            mockJsonResponse(runResponse);
+            const fileRef = {
+                id: 'f1',
+                uri: 'inf://files/abc',
+                filename: 'image.png',
+                content_type: 'image/png',
+            };
+            await sendMessage(makeClient(), adHocConfig, null, 'see image', [fileRef]);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            const [, init] = mockFetch.mock.calls[0];
+            const body = JSON.parse(String(init.body));
+            expect(body.input.attachments).toEqual([fileRef]);
+        });
+        it('should omit attachments when every file upload fails', async () => {
+            const client = makeClient();
+            const uploadSpy = jest
+                .spyOn(client.files, 'upload')
+                .mockRejectedValue(new Error('upload failed'));
+            mockJsonResponse(runResponse);
+            const file = new File(['data'], 'doc.txt', { type: 'text/plain' });
+            await sendMessage(client, adHocConfig, null, 'with file', [file]);
+            const [, init] = mockFetch.mock.calls[0];
+            const body = JSON.parse(String(init.body));
+            expect(body.input.attachments).toBeUndefined();
+            uploadSpy.mockRestore();
+        });
+        it('should upload File inputs before sending', async () => {
+            const fileRecord = {
+                id: 'file-1',
+                uri: 'inf://files/uploaded',
+                filename: 'hello.txt',
+                upload_url: 'https://upload.example/put',
+                content_type: 'text/plain',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            mockJsonResponse(runResponse);
+            const file = new File(['hello'], 'hello.txt', { type: 'text/plain' });
+            await sendMessage(makeClient(), adHocConfig, null, 'with file', [file]);
+            expect(mockFetch).toHaveBeenCalledTimes(3);
+            const [, runInit] = mockFetch.mock.calls[2];
+            const body = JSON.parse(String(runInit.body));
+            expect(body.input.attachments).toEqual([fileRecord]);
+        });
+    });
+    describe('submitToolResult', () => {
+        it('should wrap string results in { result }', async () => {
+            mockJsonResponse(null);
+            await submitToolResult(makeClient(), 'inv-1', 'done');
+            const [url, init] = mockFetch.mock.calls[0];
+            expect(url).toContain('/tools/inv-1');
+            expect(JSON.parse(String(init.body))).toEqual({ result: 'done' });
+        });
+        it('should pass structured action objects through unchanged', async () => {
+            mockJsonResponse(null);
+            const payload = {
+                action: { type: 'approve', payload: { ok: true } },
+            };
+            await submitToolResult(makeClient(), 'inv-2', payload);
+            const [, init] = mockFetch.mock.calls[0];
+            expect(JSON.parse(String(init.body))).toEqual(payload);
+        });
+    });
+    describe('fetchChat', () => {
+        it('should return chat data on success', async () => {
+            const chat = { id: 'chat-1', status: 'idle' };
+            mockJsonResponse(chat);
+            const result = await fetchChat(makeClient(), 'chat-1');
+            expect(result).toEqual(chat);
+        });
+        it('should return null and not throw when the request fails', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('network error'));
+            const result = await fetchChat(makeClient(), 'chat-1');
+            expect(result).toBeNull();
+        });
+    });
+    describe('stopChat', () => {
+        it('should POST to /chats/{id}/stop', async () => {
+            mockJsonResponse(null);
+            await stopChat(makeClient(), 'chat-1');
+            const [url, init] = mockFetch.mock.calls[0];
+            expect(url).toContain('/chats/chat-1/stop');
+            expect(init.method).toBe('POST');
+        });
+        it('should swallow errors without throwing', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('stop failed'));
+            await expect(stopChat(makeClient(), 'chat-1')).resolves.toBeUndefined();
+        });
+    });
+    describe('HIL tool approval', () => {
+        it('approveTool should POST to /tools/{id}/invoke', async () => {
+            mockJsonResponse(null);
+            await approveTool(makeClient(), 'inv-approve');
+            const [url, init] = mockFetch.mock.calls[0];
+            expect(url).toContain('/tools/inv-approve/invoke');
+            expect(init.method).toBe('POST');
+        });
+        it('rejectTool should POST reason to /tools/{id}/reject', async () => {
+            mockJsonResponse(null);
+            await rejectTool(makeClient(), 'inv-reject', 'not safe');
+            const [url, init] = mockFetch.mock.calls[0];
+            expect(url).toContain('/tools/inv-reject/reject');
+            expect(JSON.parse(String(init.body))).toEqual({ reason: 'not safe' });
+        });
+        it('alwaysAllowTool should POST tool_name to the chat tools endpoint', async () => {
+            mockJsonResponse(null);
+            await alwaysAllowTool(makeClient(), 'chat-1', 'inv-allow', 'browser_tool');
+            const [url, init] = mockFetch.mock.calls[0];
+            expect(url).toContain('/chats/chat-1/tools/inv-allow/always-allow');
+            expect(JSON.parse(String(init.body))).toEqual({ tool_name: 'browser_tool' });
+        });
+        it('should rethrow when approveTool request fails', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('approve failed'));
+            await expect(approveTool(makeClient(), 'inv-1')).rejects.toThrow('approve failed');
+        });
+    });
+    describe('getChatStreamConfig', () => {
+        it('should delegate to HttpClient.getStreamableConfig for the chat stream path', () => {
+            const client = makeClient();
+            const config = getChatStreamConfig(client, 'chat-xyz');
+            expect(config.url).toContain('/chats/chat-xyz/stream');
+            expect(config.headers).toEqual(expect.objectContaining({ Authorization: expect.stringContaining('Bearer') }));
+        });
+    });
+});

package/dist/agent/reducer.test.js

@@ -124,4 +124,8 @@ describe('chatReducer', () => {
         });
         expect(errored.error).toBe('stream failed');
     });
+    it('should return the same state for unknown action types', () => {
+        const state = chatReducer(initialState, { type: 'UNKNOWN' });
+        expect(state).toBe(initialState);
+    });
 });

package/dist/agent/types.test.d.ts

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

package/dist/agent/types.test.js

@@ -0,0 +1,75 @@
+import { ToolTypeClient } from '../types';
+import { isAdHocConfig, isTemplateConfig, isClientTool, extractToolSchemas, extractClientToolHandlers, } from './types';
+describe('agent/types helpers', () => {
+    const adHocConfig = {
+        core_app: { ref: 'openrouter/claude@abc' },
+        system_prompt: 'test',
+    };
+    const templateConfig = {
+        agent: 'acme/support@latest',
+    };
+    describe('isAdHocConfig', () => {
+        it('returns true when core_app is present', () => {
+            expect(isAdHocConfig(adHocConfig)).toBe(true);
+        });
+        it('returns false for template config', () => {
+            expect(isAdHocConfig(templateConfig)).toBe(false);
+        });
+    });
+    describe('isTemplateConfig', () => {
+        it('returns true when agent reference is present', () => {
+            expect(isTemplateConfig(templateConfig)).toBe(true);
+        });
+        it('returns false for ad-hoc config', () => {
+            expect(isTemplateConfig(adHocConfig)).toBe(false);
+        });
+    });
+    describe('isClientTool', () => {
+        it('detects client tools with schema and handler', () => {
+            const clientTool = {
+                schema: { name: 'browser_tool', type: ToolTypeClient, description: 'x' },
+                handler: jest.fn(),
+            };
+            expect(isClientTool(clientTool)).toBe(true);
+        });
+        it('returns false for plain AgentTool schemas', () => {
+            expect(isClientTool({ name: 'server_tool', type: ToolTypeClient, description: 'x' })).toBe(false);
+        });
+    });
+    describe('extractToolSchemas', () => {
+        it('unwraps client tools to schemas only', () => {
+            const handler = jest.fn();
+            const schemas = extractToolSchemas([
+                { name: 'server', type: ToolTypeClient, description: 's' },
+                {
+                    schema: { name: 'client', type: ToolTypeClient, description: 'c' },
+                    handler,
+                },
+            ]);
+            expect(schemas).toEqual([
+                { name: 'server', type: ToolTypeClient, description: 's' },
+                { name: 'client', type: ToolTypeClient, description: 'c' },
+            ]);
+        });
+    });
+    describe('extractClientToolHandlers', () => {
+        it('builds a name-to-handler map from mixed tools', () => {
+            const handlerA = jest.fn();
+            const handlerB = jest.fn();
+            const map = extractClientToolHandlers([
+                { name: 'ignored', type: ToolTypeClient, description: 'no handler' },
+                {
+                    schema: { name: 'tool_a', type: ToolTypeClient, description: 'a' },
+                    handler: handlerA,
+                },
+                {
+                    schema: { name: 'tool_b', type: ToolTypeClient, description: 'b' },
+                    handler: handlerB,
+                },
+            ]);
+            expect(map.size).toBe(2);
+            expect(map.get('tool_a')).toBe(handlerA);
+            expect(map.get('tool_b')).toBe(handlerB);
+        });
+    });
+});

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();
@@ -36,18 +53,15 @@ describe('Agent.sendMessage (polling mode)', () => {
         const userMessage = makeMessage({ id: 'user-1', role: 'user' });
         const assistantMessage = makeMessage({ id: 'asst-1' });
         mockJsonResponse({
-            success: true,
-            data: { user_message: userMessage, assistant_message: assistantMessage },
+            user_message: userMessage, assistant_message: assistantMessage,
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusBusy, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusBusy, chat_messages: [],
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusIdle, chat_messages: [],
         });
         const onChat = jest.fn();
         const result = await agent().sendMessage('hello', { stream: false, onChat });
@@ -64,27 +78,20 @@ describe('Agent.sendMessage (polling mode)', () => {
         };
         const messageWithTool = makeMessage({ tool_invocations: [toolInvocation] });
         mockJsonResponse({
-            success: true,
-            data: {
-                user_message: makeMessage({ id: 'user-1', role: 'user' }),
-                assistant_message: makeMessage(),
-            },
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: {
-                id: 'chat-1',
-                status: ChatStatusBusy,
-                chat_messages: [messageWithTool],
-            },
+            id: 'chat-1',
+            status: ChatStatusBusy,
+            chat_messages: [messageWithTool],
         });
         // Same status again — stub poll should not re-dispatch tool
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [messageWithTool] },
+            id: 'chat-1', status: ChatStatusIdle, chat_messages: [messageWithTool],
         });
         const onMessage = jest.fn();
         const onToolCall = jest.fn();
@@ -100,27 +107,237 @@ describe('Agent.sendMessage (polling mode)', () => {
         const userMessage = makeMessage({ id: 'user-1', role: 'user' });
         const assistantMessage = makeMessage();
         mockJsonResponse({
-            success: true,
-            data: { user_message: userMessage, assistant_message: assistantMessage },
+            user_message: userMessage, assistant_message: assistantMessage,
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusBusy },
+            id: 'chat-1', status: ChatStatusBusy,
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle },
+            id: 'chat-1', status: ChatStatusIdle,
         });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, output: { answer: 42 } },
+            id: 'chat-1', status: ChatStatusIdle, output: { answer: 42 },
         });
         const output = await agent().run('compute');
         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({
+                        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({
+                        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({
+            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('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({
+                        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({
+            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 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({
+            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();
+        mockJsonResponse(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({
+            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 });
+        agentInstance.reset();
+        jest.clearAllMocks();
+        await agentInstance.stopChat();
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+});
 describe('Agent.submitToolResult', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -128,7 +345,7 @@ describe('Agent.submitToolResult', () => {
     it('should JSON-stringify structured action results', async () => {
         const http = new HttpClient({ apiKey: 'test-key' });
         const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
-        mockJsonResponse({ success: true, data: null });
+        mockJsonResponse(null);
         const payload = {
             action: { type: 'form_submit', payload: { field: 'value' } },
             form_data: { field: 'value' },
@@ -139,3 +356,40 @@ describe('Agent.submitToolResult', () => {
         expect(body.result).toBe(JSON.stringify(payload));
     });
 });
+describe('AgentsAPI (template CRUD)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        return new AgentsAPI(http, new FilesAPI(http));
+    };
+    it('should GET /agents/internal-tools for getInternalTools()', async () => {
+        const tools = [{ name: 'search', description: 'Search the web' }];
+        mockJsonResponse(tools);
+        const result = await api().getInternalTools();
+        expect(result).toEqual(tools);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/internal-tools');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST team_id for transferOwnership()', async () => {
+        const agent = { id: 'agent-1' };
+        mockJsonResponse(agent);
+        await api().transferOwnership('agent-1', 'team-42');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/transfer');
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-42' });
+    });
+    it('should POST /agents for createAgent()', async () => {
+        const payload = { name: 'support-bot', core_app: { ref: 'app/ref' } };
+        const created = { id: 'agent-new', ...payload };
+        mockJsonResponse(created);
+        const result = await api().createAgent(payload);
+        expect(result).toEqual(created);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+});

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

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