@inferencesh/sdk 0.6.14 → 0.6.19

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

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

package/dist/agent/api.test.js

@@ -1,246 +0,0 @@
-import { HttpClient } from '../http/client';
-import { FilesAPI } from '../api/files';
-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;
-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]);
-        });
-        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 () => {
-            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);
-        });
-        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 () => {
-            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');
-        });
-        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', () => {
-            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') }));
-        });
-    });
-    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/agent/reducer.test.d.ts

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

package/dist/agent/reducer.test.js

@@ -1,131 +0,0 @@
-import { ChatStatusBusy, ChatStatusIdle } from '../types';
-import { chatReducer, initialState } from './reducer';
-function makeMessage(id, order, chatId = 'chat-1') {
-    return {
-        id,
-        short_id: id,
-        created_at: '2026-01-01T00:00:00Z',
-        updated_at: '2026-01-01T00:00:00Z',
-        user_id: 'user-1',
-        team_id: 'team-1',
-        visibility: 'private',
-        chat_id: chatId,
-        order,
-        status: 'completed',
-        role: 'user',
-        content: [{ type: 'text', text: `message ${id}` }],
-    };
-}
-function makeChat(overrides = {}) {
-    return {
-        id: 'chat-1',
-        short_id: 'c1',
-        created_at: '2026-01-01T00:00:00Z',
-        updated_at: '2026-01-01T00:00:00Z',
-        user_id: 'user-1',
-        team_id: 'team-1',
-        visibility: 'private',
-        status: ChatStatusBusy,
-        name: 'Test chat',
-        description: '',
-        children: [],
-        chat_messages: [makeMessage('msg-1', 1), makeMessage('msg-2', 2)],
-        agent_data: {},
-        ...overrides,
-    };
-}
-describe('chatReducer', () => {
-    it('SET_CHAT should sort messages by order', () => {
-        const chat = makeChat({
-            chat_messages: [makeMessage('msg-2', 2), makeMessage('msg-1', 1)],
-        });
-        const next = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
-        expect(next.messages.map((m) => m.id)).toEqual(['msg-1', 'msg-2']);
-        expect(next.chat?.status).toBe(ChatStatusBusy);
-    });
-    it('UPDATE_CHAT should update chat metadata without replacing messages', () => {
-        const chat = makeChat();
-        const withMessages = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
-        const idleChat = makeChat({ status: ChatStatusIdle, chat_messages: [] });
-        const next = chatReducer(withMessages, { type: 'UPDATE_CHAT', payload: idleChat });
-        expect(next.chat?.status).toBe(ChatStatusIdle);
-        expect(next.messages).toHaveLength(2);
-        expect(next.messages.map((m) => m.id)).toEqual(['msg-1', 'msg-2']);
-    });
-    it('UPDATE_CHAT with null payload should leave state unchanged', () => {
-        const chat = makeChat();
-        const withChat = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
-        const next = chatReducer(withChat, { type: 'UPDATE_CHAT', payload: null });
-        expect(next).toBe(withChat);
-    });
-    it('UPDATE_MESSAGE should replace an existing message by id', () => {
-        const chat = makeChat();
-        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
-        const updated = makeMessage('msg-1', 1);
-        updated.content = [{ type: 'text', text: 'edited' }];
-        const next = chatReducer(state, { type: 'UPDATE_MESSAGE', payload: updated });
-        expect(next.messages.find((m) => m.id === 'msg-1')?.content[0]?.text).toBe('edited');
-        expect(next.messages).toHaveLength(2);
-    });
-    it('UPDATE_MESSAGE should append and sort new messages', () => {
-        const chat = makeChat({ chat_messages: [makeMessage('msg-1', 1)] });
-        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
-        const next = chatReducer(state, { type: 'UPDATE_MESSAGE', payload: makeMessage('msg-2', 2) });
-        expect(next.messages.map((m) => m.id)).toEqual(['msg-1', 'msg-2']);
-    });
-    it('SET_CHAT with null should clear chat and messages', () => {
-        const chat = makeChat();
-        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
-        const next = chatReducer(state, { type: 'SET_CHAT', payload: null });
-        expect(next.chat).toBeNull();
-        expect(next.messages).toEqual([]);
-        expect(next.connectionStatus).toBe('idle');
-    });
-    it('ADD_MESSAGE should append and sort by order', () => {
-        const chat = makeChat({ chat_messages: [makeMessage('msg-1', 1)] });
-        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
-        const next = chatReducer(state, {
-            type: 'ADD_MESSAGE',
-            payload: makeMessage('msg-0', 0),
-        });
-        expect(next.messages.map((m) => m.id)).toEqual(['msg-0', 'msg-1']);
-    });
-    it('RESET should return initial state', () => {
-        const chat = makeChat();
-        const state = chatReducer(initialState, { type: 'SET_CHAT', payload: chat });
-        expect(chatReducer(state, { type: 'RESET' })).toEqual(initialState);
-    });
-    it('SET_CHAT_ID should update chatId', () => {
-        const next = chatReducer(initialState, { type: 'SET_CHAT_ID', payload: 'chat-99' });
-        expect(next.chatId).toBe('chat-99');
-    });
-    it('SET_MESSAGES should replace the message list', () => {
-        const messages = [makeMessage('msg-a', 1)];
-        const next = chatReducer(initialState, { type: 'SET_MESSAGES', payload: messages });
-        expect(next.messages).toEqual(messages);
-    });
-    it('ADD_MESSAGE after SET_MESSAGES should append and sort by order', () => {
-        const state = chatReducer(initialState, {
-            type: 'SET_MESSAGES',
-            payload: [makeMessage('msg-2', 2)],
-        });
-        const next = chatReducer(state, { type: 'ADD_MESSAGE', payload: makeMessage('msg-1', 1) });
-        expect(next.messages.map((m) => m.id)).toEqual(['msg-1', 'msg-2']);
-    });
-    it('SET_CONNECTION_STATUS and SET_ERROR should update connection fields', () => {
-        const streaming = chatReducer(initialState, {
-            type: 'SET_CONNECTION_STATUS',
-            payload: 'streaming',
-        });
-        expect(streaming.connectionStatus).toBe('streaming');
-        const errored = chatReducer(streaming, {
-            type: 'SET_ERROR',
-            payload: 'stream failed',
-        });
-        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

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

package/dist/agent/types.test.js

@@ -1,75 +0,0 @@
-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.d.ts

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