@inferencesh/sdk 0.6.12 → 0.6.14

package/dist/api/agents.test.js

@@ -1,6 +1,7 @@
 import { HttpClient } from '../http/client';
 import { StreamableManager } from '../http/streamable';
-import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
+import { PollManager } from '../http/poll';
+import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, } from '../types';
 import { FilesAPI } from './files';
 import { AgentsAPI } from './agents';
 const mockFetch = jest.fn();
@@ -70,6 +71,66 @@ 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 for in_progress client tool invocations', async () => {
+        const toolInvocation = {
+            id: 'tool-inv-progress',
+            type: ToolTypeClient,
+            status: ToolInvocationStatusInProgress,
+            function: { name: 'my_tool', arguments: { x: 2 } },
+        };
+        const messageWithTool = makeMessage({ tool_invocations: [toolInvocation] });
+        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: ChatStatusIdle });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusIdle,
+            chat_messages: [messageWithTool],
+        });
+        const onMessage = jest.fn();
+        const onToolCall = jest.fn();
+        await agent().sendMessage('run tool', { stream: false, onMessage, onToolCall });
+        expect(onToolCall).toHaveBeenCalledTimes(1);
+        expect(onToolCall).toHaveBeenCalledWith({
+            id: 'tool-inv-progress',
+            name: 'my_tool',
+            args: { x: 2 },
+        });
+    });
     it('should dispatch onToolCall once per client tool invocation', async () => {
         const toolInvocation = {
             id: 'tool-inv-1',
@@ -104,6 +165,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 +209,43 @@ 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();
+    });
+    it('should warn on repeated poll errors without resolving sendMessage', async () => {
+        jest.useFakeTimers();
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockFetch.mockRejectedValue(new Error('status endpoint down'));
+        const sendPromise = agent().sendMessage('hello', { stream: false });
+        for (let i = 0; i < 6; i++) {
+            await Promise.resolve();
+            jest.advanceTimersByTime(20);
+            await Promise.resolve();
+        }
+        expect(warnSpy).toHaveBeenCalledWith('[Agent] Poll error:', expect.any(Error));
+        let settled = false;
+        sendPromise.then(() => {
+            settled = true;
+        });
+        await Promise.resolve();
+        expect(settled).toBe(false);
+        warnSpy.mockRestore();
+        jest.useRealTimers();
+    });
 });
 describe('Agent.sendMessage (streaming mode)', () => {
     beforeEach(() => {
@@ -156,6 +278,39 @@ describe('Agent.sendMessage (streaming mode)', () => {
         expect(result.userMessage).toEqual(userMessage);
         expect(onChat).toHaveBeenCalledWith(expect.objectContaining({ id: 'chat-1', status: ChatStatusIdle }));
     });
+    it('should dispatch onToolCall for in_progress tools from chat_messages stream events', async () => {
+        const toolInvocation = {
+            id: 'tool-inv-progress',
+            type: ToolTypeClient,
+            status: ToolInvocationStatusInProgress,
+            function: { name: 'my_tool', arguments: { x: 2 } },
+        };
+        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-progress',
+            name: 'my_tool',
+            args: { x: 2 },
+        });
+    });
     it('should dispatch onToolCall from chat_messages stream events', async () => {
         const toolInvocation = {
             id: 'tool-inv-1',
@@ -189,6 +344,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 +449,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 +560,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 +622,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 +724,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 +805,55 @@ describe('Agent.getChat', () => {
         expect(url).toContain('/chats/chat-42');
         expect(init.method).toBe('GET');
     });
+    it('should expose currentChatId after sendMessage establishes a chat', 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: [] });
+        expect(agentInstance.currentChatId).toBeNull();
+        await agentInstance.sendMessage('hello', { stream: false });
+        expect(agentInstance.currentChatId).toBe('chat-1');
+    });
+    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');
@@ -512,6 +902,20 @@ describe('AgentsAPI (template CRUD)', () => {
         expect(url).toContain('/agents/internal-tools');
         expect(init.method).toBe('GET');
     });
+    it('should GET /agents/{id}/card for getA2ACard()', async () => {
+        const card = {
+            name: 'support-bot',
+            description: 'Customer support agent',
+            url: 'https://api.example.com/agents/support-bot',
+            version: '1.0.0',
+        };
+        mockJsonResponse(card);
+        const result = await api().getA2ACard('agent-1');
+        expect(result).toEqual(card);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/card');
+        expect(init.method).toBe('GET');
+    });
     it('should POST team_id for transferOwnership()', async () => {
         const agent = { id: 'agent-1' };
         mockJsonResponse(agent);

package/dist/api/files.test.js

@@ -41,6 +41,14 @@ describe('FilesAPI', () => {
         expect(init.method).toBe('DELETE');
     });
     describe('processInput', () => {
+        it('should return falsy inputs unchanged without uploading', async () => {
+            await expect(api().processInput(null)).resolves.toBeNull();
+            await expect(api().processInput(undefined)).resolves.toBeUndefined();
+            await expect(api().processInput(0)).resolves.toBe(0);
+            await expect(api().processInput(false)).resolves.toBe(false);
+            await expect(api().processInput('')).resolves.toBe('');
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
         it('should not treat short plain strings as base64 file uploads', async () => {
             const result = await api().processInput({ key: 'key1', note: 'hello' });
             expect(result).toEqual({ key: 'key1', note: 'hello' });

package/dist/api/knowledge.test.js

@@ -50,6 +50,55 @@ describe('KnowledgeAPI', () => {
         expect(url).toContain('/knowledge/know-1/transfer');
         expect(JSON.parse(init.body)).toEqual({ team_id: 'team-5' });
     });
+    it('should GET /knowledge/{id} for get()', async () => {
+        const entry = { id: 'know-1', name: 'docs' };
+        mockJsonResponse(entry);
+        const result = await api().get('know-1');
+        expect(result).toEqual(entry);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/know-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /knowledge/{id} for update()', async () => {
+        const entry = { id: 'know-1', name: 'updated' };
+        mockJsonResponse(entry);
+        const result = await api().update('know-1', { name: 'updated' });
+        expect(result).toEqual(entry);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
+    });
+    it('should DELETE /knowledge/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('know-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/know-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /knowledge/{id}/versions/list for listVersions()', async () => {
+        const page = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().listVersions('know-1', { limit: 10 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/know-1/versions/list');
+        expect(JSON.parse(init.body)).toEqual({ limit: 10 });
+    });
+    it('should GET /knowledge/{id}/versions/{versionId} for getVersion()', async () => {
+        const version = { id: 'ver-1', knowledge_id: 'know-1' };
+        mockJsonResponse(version);
+        const result = await api().getVersion('know-1', 'ver-1');
+        expect(result).toEqual(version);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/know-1/versions/ver-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const entry = { id: 'know-1', visibility: 'team' };
+        mockJsonResponse(entry);
+        await api().updateVisibility('know-1', 'team');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
+    });
 });
 describe('SkillsAPI', () => {
     beforeEach(() => {
@@ -91,4 +140,99 @@ describe('SkillsAPI', () => {
         expect(url).toContain('/store/skills/list');
         expect(init.method).toBe('POST');
     });
+    it('should GET /skills/resolve with ref only when skill is omitted', async () => {
+        const resolved = { ref: 'acme/skill@v1' };
+        mockJsonResponse(resolved);
+        const result = await api().resolve('acme/skill@v1');
+        expect(result).toEqual(resolved);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/resolve');
+        expect(url).toContain('ref=acme');
+        expect(url).not.toContain('skill=');
+    });
+    it('should GET /skills/{namespace}/{name}/content for getContent()', async () => {
+        mockJsonResponse({ body: '# Skill instructions' });
+        const result = await api().getContent('acme', 'research');
+        expect(result).toEqual({ body: '# Skill instructions' });
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/acme/research/content');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST team_id for transferOwnership()', async () => {
+        const skill = { id: 'skill-1' };
+        mockJsonResponse(skill);
+        await api().transferOwnership('skill-1', 'team-8');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1/transfer');
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-8' });
+    });
+    it('should POST /skills/list for list()', async () => {
+        const page = { items: [{ id: 'skill-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list({ limit: 10 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /skills/{id} for get()', async () => {
+        const skill = { id: 'skill-1', name: 'research' };
+        mockJsonResponse(skill);
+        const result = await api().get('skill-1');
+        expect(result).toEqual(skill);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /skills for create()', async () => {
+        const payload = { namespace: 'acme', name: 'research' };
+        const skill = { id: 'skill-new', ...payload };
+        mockJsonResponse(skill);
+        const result = await api().create(payload);
+        expect(result).toEqual(skill);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should POST /skills/{id} for update()', async () => {
+        const skill = { id: 'skill-1', name: 'updated' };
+        mockJsonResponse(skill);
+        const result = await api().update('skill-1', { name: 'updated' });
+        expect(result).toEqual(skill);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
+    });
+    it('should DELETE /skills/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('skill-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /skills/{id}/versions/list for listVersions()', async () => {
+        const page = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().listVersions('skill-1', { limit: 5 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1/versions/list');
+        expect(JSON.parse(init.body)).toEqual({ limit: 5 });
+    });
+    it('should GET /skills/{id}/versions/{versionId} for getVersion()', async () => {
+        const version = { id: 'ver-1', skill_id: 'skill-1' };
+        mockJsonResponse(version);
+        const result = await api().getVersion('skill-1', 'ver-1');
+        expect(result).toEqual(version);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/skill-1/versions/ver-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const skill = { id: 'skill-1', visibility: 'team' };
+        mockJsonResponse(skill);
+        await api().updateVisibility('skill-1', 'team');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
+    });
 });