@inferencesh/sdk 0.6.7 → 0.6.8

package/dist/agent/actions.test.js

@@ -0,0 +1,404 @@
+import { ChatStatusBusy, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
+import { createActions } from './actions';
+import * as agentApi from './api';
+import { PollManager } from '../http/poll';
+import { StreamableManager } from '../http/streamable';
+jest.mock('./api');
+jest.mock('../http/streamable');
+jest.mock('../http/poll');
+const mockAgentApi = agentApi;
+function makeMessage(overrides = {}) {
+    return {
+        id: 'msg-1',
+        chat_id: 'chat-full-id-123',
+        role: 'assistant',
+        content: 'hello',
+        ...overrides,
+    };
+}
+function createTestContext(overrides = {}) {
+    const dispatch = jest.fn();
+    let streamManager;
+    const getStreamManager = () => streamManager;
+    const setStreamManager = jest.fn((manager) => {
+        streamManager = manager;
+    });
+    const adHocConfig = {
+        core_app: { ref: 'openrouter/claude@abc' },
+        system_prompt: 'test',
+    };
+    const ctx = {
+        client: {
+            http: {
+                request: jest.fn(),
+                getStreamableConfig: jest.fn(() => ({ url: 'https://stream.test', headers: {} })),
+                getStreamDefault: jest.fn(() => true),
+                getPollIntervalMs: jest.fn(() => 50),
+            },
+            files: { upload: jest.fn() },
+        },
+        dispatch,
+        getConfig: () => adHocConfig,
+        getChatId: () => 'chat-short',
+        getClientToolHandlers: () => new Map(),
+        getStreamManager,
+        setStreamManager,
+        getStreamEnabled: () => true,
+        getPollIntervalMs: () => 50,
+        callbacks: {},
+        ...overrides,
+    };
+    return { ctx, dispatch, setStreamManager };
+}
+describe('createActions', () => {
+    let pollInstances;
+    let streamInstances;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        pollInstances = [];
+        streamInstances = [];
+        PollManager.mockImplementation((options) => {
+            const instance = {
+                options,
+                start: jest.fn(),
+                stop: jest.fn(),
+            };
+            pollInstances.push(instance);
+            return instance;
+        });
+        StreamableManager.mockImplementation((options) => {
+            const instance = {
+                options,
+                addEventListener: jest.fn(),
+                start: jest.fn(),
+                stop: jest.fn(),
+            };
+            streamInstances.push(instance);
+            return instance;
+        });
+        mockAgentApi.fetchChat.mockResolvedValue({
+            id: 'chat-full-id-123',
+            status: ChatStatusBusy,
+            chat_messages: [],
+        });
+        mockAgentApi.getChatStreamConfig.mockReturnValue({
+            url: 'https://api.test/chats/chat-full-id-123/stream',
+            headers: {},
+        });
+        mockAgentApi.sendMessage.mockResolvedValue({
+            chatId: 'chat-full-id-123',
+            userMessage: makeMessage({ id: 'u1', role: 'user' }),
+            assistantMessage: makeMessage(),
+        });
+        mockAgentApi.submitToolResult.mockResolvedValue(undefined);
+    });
+    describe('updateMessage (via stream listeners)', () => {
+        it('should ignore messages for a different chat when IDs do not prefix-match', async () => {
+            const { ctx, dispatch } = createTestContext({ getChatId: () => 'other-chat' });
+            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: 'unrelated-chat-id' }));
+            expect(dispatch).not.toHaveBeenCalledWith(expect.objectContaining({ type: 'UPDATE_MESSAGE' }));
+        });
+        it('should accept messages when chat_id is a prefix extension of the short chatId', async () => {
+            const { ctx, dispatch } = createTestContext({ getChatId: () => 'chat-short' });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-short');
+            await Promise.resolve();
+            const onMessage = streamInstances[0].addEventListener.mock.calls.find(([event]) => event === 'chat_messages')?.[1];
+            onMessage(makeMessage({ chat_id: 'chat-short-full-suffix' }));
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'UPDATE_MESSAGE',
+                payload: expect.objectContaining({ chat_id: 'chat-short-full-suffix' }),
+            });
+        });
+        it('should run the handler and submit its result when a client tool is available', async () => {
+            const handler = jest.fn().mockResolvedValue('tool 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-ok',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusAwaitingInput,
+                        function: { name: 'my_tool', arguments: { x: 1 } },
+                    },
+                ],
+            }));
+            await Promise.resolve();
+            expect(handler).toHaveBeenCalledWith({ x: 1 });
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledWith(ctx.client, 'tool-inv-ok', 'tool 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({
+                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-err',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusAwaitingInput,
+                        function: { name: 'my_tool', arguments: {} },
+                    },
+                ],
+            }));
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledWith(ctx.client, 'tool-inv-err', expect.stringContaining('handler boom'));
+        });
+        it('should submit not_available when a client tool has no handler', async () => {
+            const { ctx } = createTestContext({
+                getClientToolHandlers: () => new Map([['other_tool', jest.fn().mockResolvedValue('ok')]]),
+            });
+            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-missing-handler',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusAwaitingInput,
+                        function: { name: 'missing_tool', arguments: {} },
+                    },
+                ],
+            }));
+            await Promise.resolve();
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledWith(ctx.client, 'tool-missing-handler', expect.stringContaining('not_available'));
+        });
+    });
+    describe('streamChat', () => {
+        it('should use PollManager when streaming is disabled', async () => {
+            const { ctx } = createTestContext({
+                getStreamEnabled: () => false,
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            expect(PollManager).toHaveBeenCalled();
+            expect(StreamableManager).not.toHaveBeenCalled();
+            expect(pollInstances[0].options.pollFunction).toBeDefined();
+            expect(pollInstances[0].start).toHaveBeenCalled();
+        });
+    });
+    describe('stopStream', () => {
+        it('should clear the manager ref before stop so onEnd does not double-dispatch idle', async () => {
+            const { ctx, dispatch, setStreamManager } = createTestContext();
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const manager = streamInstances[0];
+            internalActions.stopStream();
+            expect(setStreamManager).toHaveBeenCalledWith(undefined);
+            expect(manager.stop).toHaveBeenCalled();
+            manager.options.onEnd?.();
+            const idleDispatches = dispatch.mock.calls.filter(([action]) => action.type === 'SET_CONNECTION_STATUS' && action.payload === 'idle');
+            // Only the explicit stopStream dispatch, not a second from onEnd
+            expect(idleDispatches).toHaveLength(1);
+        });
+    });
+    describe('publicActions.sendMessage', () => {
+        it('should call onChatCreated and start streaming for a new chat', async () => {
+            const onChatCreated = jest.fn();
+            const { ctx } = createTestContext({
+                getChatId: () => null,
+                callbacks: { onChatCreated },
+            });
+            const { publicActions } = createActions(ctx);
+            await publicActions.sendMessage('hello');
+            expect(onChatCreated).toHaveBeenCalledWith('chat-full-id-123');
+            expect(StreamableManager).toHaveBeenCalled();
+        });
+        it('should reset connection status when the API returns no result', async () => {
+            mockAgentApi.sendMessage.mockResolvedValueOnce(null);
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({
+                callbacks: { onStatusChange },
+            });
+            const { publicActions } = createActions(ctx);
+            await publicActions.sendMessage('hello');
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'idle',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('idle');
+        });
+        it('should dispatch error state when sendMessage throws', async () => {
+            mockAgentApi.sendMessage.mockRejectedValueOnce(new Error('send failed'));
+            const onError = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onError } });
+            const { publicActions } = createActions(ctx);
+            await publicActions.sendMessage('hello');
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'error',
+            });
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_ERROR',
+                payload: 'send failed',
+            });
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'send failed' }));
+        });
+        it('should ignore whitespace-only messages', async () => {
+            const { ctx } = createTestContext();
+            const { publicActions } = createActions(ctx);
+            await publicActions.sendMessage('   ');
+            expect(mockAgentApi.sendMessage).not.toHaveBeenCalled();
+        });
+    });
+    describe('streamChat error handling', () => {
+        it('should reset to idle when initial fetchChat fails', async () => {
+            mockAgentApi.fetchChat.mockRejectedValueOnce(new Error('fetch failed'));
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onStatusChange } });
+            const { internalActions } = createActions(ctx);
+            await internalActions.streamChat('chat-full-id-123');
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'idle',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('idle');
+            expect(StreamableManager).not.toHaveBeenCalled();
+        });
+        it('should dispatch UPDATE_CHAT when chats stream events arrive', async () => {
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onStatusChange } });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const onChat = streamInstances[0].addEventListener.mock.calls.find(([event]) => event === 'chats')?.[1];
+            onChat({ id: 'chat-full-id-123', status: ChatStatusBusy });
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'UPDATE_CHAT',
+                payload: expect.objectContaining({ status: ChatStatusBusy }),
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('streaming');
+        });
+    });
+    describe('pollChat', () => {
+        it('should fetch full chat when poll status changes', 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
+                .mockResolvedValueOnce({
+                id: 'chat-full-id-123',
+                status: ChatStatusBusy,
+                chat_messages: [],
+            })
+                .mockResolvedValueOnce({
+                id: 'chat-full-id-123',
+                status: ChatStatusBusy,
+                chat_messages: [makeMessage()],
+            });
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            await pollInstances[0].options.onData?.({ status: 'idle' });
+            await Promise.resolve();
+            expect(mockAgentApi.fetchChat).toHaveBeenCalledTimes(2);
+        });
+        it('should call onError when poll fetch fails', async () => {
+            const onError = jest.fn();
+            const { ctx: baseCtx } = createTestContext({ getStreamEnabled: () => false });
+            const { ctx } = createTestContext({
+                getStreamEnabled: () => false,
+                callbacks: { onError },
+                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: [],
+            })
+                .mockRejectedValueOnce(new Error('poll fetch failed'));
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            await pollInstances[0].options.onData?.({ status: 'idle' });
+            await Promise.resolve();
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'poll fetch failed' }));
+        });
+    });
+    describe('client tool deduplication', () => {
+        it('should not submit the same client tool invocation twice', async () => {
+            const handler = jest.fn().mockResolvedValue('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];
+            const toolMessage = makeMessage({
+                chat_id: 'chat-short',
+                tool_invocations: [
+                    {
+                        id: 'tool-inv-dup',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusAwaitingInput,
+                        function: { name: 'my_tool', arguments: {} },
+                    },
+                ],
+            });
+            onMessage(toolMessage);
+            onMessage(toolMessage);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(handler).toHaveBeenCalledTimes(1);
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('publicActions lifecycle', () => {
+        it('reset should stop stream and dispatch RESET', async () => {
+            const { ctx, dispatch } = createTestContext();
+            const { publicActions } = createActions(ctx);
+            await publicActions.sendMessage('hello');
+            publicActions.reset();
+            expect(dispatch).toHaveBeenCalledWith({ type: 'RESET' });
+        });
+        it('stopGeneration should call stopChat when chatId exists', async () => {
+            const { ctx } = createTestContext({ getChatId: () => 'chat-short' });
+            const { publicActions } = createActions(ctx);
+            publicActions.stopGeneration();
+            expect(mockAgentApi.stopChat).toHaveBeenCalledWith(ctx.client, 'chat-short');
+        });
+        it('submitToolResult should set error state when API fails', async () => {
+            mockAgentApi.submitToolResult.mockRejectedValueOnce(new Error('submit failed'));
+            const onError = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onError } });
+            const { publicActions } = createActions(ctx);
+            await expect(publicActions.submitToolResult('inv-1', 'result')).rejects.toThrow('submit failed');
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'error',
+            });
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'submit failed' }));
+        });
+    });
+});

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

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

package/dist/agent/api.test.js

@@ -0,0 +1,130 @@
+import { HttpClient } from '../http/client';
+import { FilesAPI } from '../api/files';
+import { sendAdHocMessage, sendTemplateMessage, sendMessage, submitToolResult, 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 strip client tool handlers from the agents/run request body', async () => {
+            mockJsonResponse({ success: true, data: 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 omit empty agent field for existing chats', async () => {
+            mockJsonResponse({ success: true, data: 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({ success: true, data: 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 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({ success: true, data: [fileRecord] });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            mockJsonResponse({ success: true, data: 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({ success: true, data: 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({ success: true, data: 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('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);
+        });
+    });
+});