@inferencesh/sdk 0.6.10 → 0.6.13

package/dist/api/agents.test.js

@@ -1,4 +1,6 @@
 import { HttpClient } from '../http/client';
+import { StreamableManager } from '../http/streamable';
+import { PollManager } from '../http/poll';
 import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
 import { FilesAPI } from './files';
 import { AgentsAPI } from './agents';
@@ -69,6 +71,32 @@ describe('Agent.sendMessage (polling mode)', () => {
         expect(result.assistantMessage).toEqual(assistantMessage);
         expect(onChat).toHaveBeenCalledWith(expect.objectContaining({ id: 'chat-1', status: ChatStatusIdle }));
     });
+    it('should skip full GET /chats when poll status is unchanged', async () => {
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusBusy,
+            chat_messages: [],
+        });
+        // Same status again — pollUntilIdle should return a stub without fetching full chat
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusIdle,
+            chat_messages: [],
+        });
+        await agent().sendMessage('hello', { stream: false });
+        const fullChatGets = mockFetch.mock.calls.filter(([url, init]) => String(url).includes('/chats/chat-1') &&
+            !String(url).includes('/status') &&
+            !String(url).includes('/stop') &&
+            init.method === 'GET');
+        expect(fullChatGets).toHaveLength(2);
+    });
     it('should dispatch onToolCall once per client tool invocation', async () => {
         const toolInvocation = {
             id: 'tool-inv-1',
@@ -103,6 +131,30 @@ describe('Agent.sendMessage (polling mode)', () => {
             args: { x: 1 },
         });
     });
+    it('should call onMessage for each chat message during polling', async () => {
+        const msg1 = makeMessage({ id: 'msg-1', content: 'first' });
+        const msg2 = makeMessage({ id: 'msg-2', content: 'second' });
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusBusy,
+            chat_messages: [msg1, msg2],
+        });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusIdle,
+            chat_messages: [msg1, msg2],
+        });
+        const onMessage = jest.fn();
+        await agent().sendMessage('hello', { stream: false, onMessage });
+        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'msg-1', content: 'first' }));
+        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'msg-2', content: 'second' }));
+    });
     it('should return chat output from run() after polling completes', async () => {
         const userMessage = makeMessage({ id: 'user-1', role: 'user' });
         const assistantMessage = makeMessage();
@@ -123,6 +175,19 @@ describe('Agent.sendMessage (polling mode)', () => {
         const output = await agent().run('compute');
         expect(output).toEqual({ answer: 42 });
     });
+    it('should return null from run() when the chat has no finish output', async () => {
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusBusy });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusIdle });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusIdle, output: null });
+        const output = await agent().run('no finish tool');
+        expect(output).toBeNull();
+    });
 });
 describe('Agent.sendMessage (streaming mode)', () => {
     beforeEach(() => {
@@ -188,6 +253,19 @@ describe('Agent.sendMessage (streaming mode)', () => {
             args: { x: 1 },
         });
     });
+    it('should return immediately without waiting when stream is true and no callbacks', async () => {
+        const userMessage = makeMessage({ id: 'user-1', role: 'user' });
+        const assistantMessage = makeMessage({ id: 'asst-1' });
+        mockJsonResponse({
+            user_message: userMessage,
+            assistant_message: assistantMessage,
+        });
+        const result = await streamingAgent().sendMessage('hello');
+        expect(result.userMessage).toEqual(userMessage);
+        expect(result.assistantMessage).toEqual(assistantMessage);
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        expect(mockFetch.mock.calls[0][0]).toContain('/agents/run');
+    });
     it('should open the stream before POST when continuing an existing chat', async () => {
         const http = new HttpClient({
             apiKey: 'test-key',
@@ -280,6 +358,142 @@ 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(() => {
+        jest.clearAllMocks();
+    });
+    const adHocAgent = () => {
+        const http = new HttpClient({
+            apiKey: 'test-key',
+            stream: false,
+            pollIntervalMs: 20,
+        });
+        return new AgentsAPI(http, new FilesAPI(http)).create({
+            core_app: { ref: 'openrouter/claude@latest' },
+            system_prompt: 'You are helpful',
+            name: 'adhoc-bot',
+        });
+    };
+    it('should POST agent_config and agent_name instead of agent template ref', async () => {
+        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 adHocAgent().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).toBeUndefined();
+        expect(body.agent_config).toEqual({
+            core_app: { ref: 'openrouter/claude@latest' },
+            system_prompt: 'You are helpful',
+            name: 'adhoc-bot',
+        });
+        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(() => {
@@ -317,6 +531,88 @@ 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',
+            stream: true,
+            pollIntervalMs: 20,
+        });
+        const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+        const stopSpy = jest.spyOn(StreamableManager.prototype, 'stop');
+        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: 'chats', data: { id: 'chat-1', status: ChatStatusIdle } })}\n`,
+            ]));
+        });
+        await agentInstance.sendMessage('hello', { onChat: jest.fn() });
+        agentInstance.disconnect();
+        expect(stopSpy).toHaveBeenCalled();
+        stopSpy.mockRestore();
+    });
+    it('startStreaming should no-op when there is no active chat', () => {
+        const agentInstance = agent();
+        agentInstance.startStreaming();
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+    it('startStreaming should open the chat stream when chatId exists', 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('hello', { stream: false });
+        jest.clearAllMocks();
+        mockFetch.mockResolvedValue(mockNdjsonStream([
+            `${JSON.stringify({ event: 'chats', data: { id: 'chat-1', status: ChatStatusIdle } })}\n`,
+        ]));
+        agentInstance.startStreaming({ onChat: jest.fn() });
+        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/chats/chat-1/stream'), expect.anything());
+    });
     it('reset should clear chat state so stopChat is a no-op', async () => {
         const agentInstance = agent();
         mockJsonResponse({
@@ -337,11 +633,122 @@ 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(() => {
+        jest.clearAllMocks();
+    });
+    const agent = () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        return new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+    };
+    it('should return null without a chat id and no active chat', async () => {
+        const result = await agent().getChat();
+        expect(result).toBeNull();
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+    it('should GET /chats/{id} when chatId is provided', async () => {
+        const chat = { id: 'chat-42', status: 'idle', chat_messages: [] };
+        mockJsonResponse(chat);
+        const result = await agent().getChat('chat-42');
+        expect(result).toEqual(chat);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-42');
+        expect(init.method).toBe('GET');
+    });
+    it('should GET /chats/{id} with established chat id when chatId is omitted', async () => {
+        const agentInstance = agent();
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusBusy, chat_messages: [] });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusIdle, chat_messages: [] });
+        await agentInstance.sendMessage('hello', { stream: false });
+        jest.clearAllMocks();
+        const chat = { id: 'chat-1', status: 'idle', chat_messages: [] };
+        mockJsonResponse(chat);
+        const result = await agentInstance.getChat();
+        expect(result).toEqual(chat);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1');
+        expect(init.method).toBe('GET');
+    });
 });
 describe('Agent.submitToolResult', () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
+    it('should POST plain string results to /tools/{invocationId}', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+        mockJsonResponse(null);
+        await agentInstance.submitToolResult('inv-plain', 'done');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/tools/inv-plain');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(String(init.body))).toEqual({ result: 'done' });
+    });
     it('should JSON-stringify structured action results', async () => {
         const http = new HttpClient({ apiKey: 'test-key' });
         const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
@@ -356,6 +763,23 @@ describe('Agent.submitToolResult', () => {
         expect(body.result).toBe(JSON.stringify(payload));
     });
 });
+describe('AgentsAPI.submitToolResult', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        return new AgentsAPI(http, new FilesAPI(http));
+    };
+    it('should POST plain string results to /tools/{invocationId}', async () => {
+        mockJsonResponse(null);
+        await api().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' });
+    });
+});
 describe('AgentsAPI (template CRUD)', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -392,4 +816,80 @@ describe('AgentsAPI (template CRUD)', () => {
         expect(init.method).toBe('POST');
         expect(JSON.parse(init.body)).toEqual(payload);
     });
+    it('should GET /agents/{namespace}/{name} for getByName()', async () => {
+        const agent = { id: 'agent-1', name: 'my-agent' };
+        mockJsonResponse(agent);
+        const result = await api().getByName('inference', 'my-agent');
+        expect(result).toEqual(agent);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/inference/my-agent');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /agents/list for list()', async () => {
+        const page = { items: [{ id: 'agent-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('/agents/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /agents/{id} for get()', async () => {
+        const agent = { id: 'agent-1', name: 'support-bot' };
+        mockJsonResponse(agent);
+        const result = await api().get('agent-1');
+        expect(result).toEqual(agent);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /agents/{id} for update()', async () => {
+        const agent = { id: 'agent-1', name: 'updated' };
+        mockJsonResponse(agent);
+        const result = await api().update('agent-1', { name: 'updated' });
+        expect(result).toEqual(agent);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
+    });
+    it('should DELETE /agents/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('agent-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /agents/{id}/duplicate for duplicate()', async () => {
+        const agent = { id: 'agent-copy' };
+        mockJsonResponse(agent);
+        const result = await api().duplicate('agent-1');
+        expect(result).toEqual(agent);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/duplicate');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /agents/{id}/versions/list for listVersions()', async () => {
+        const page = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().listVersions('agent-1', { limit: 5 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/versions/list');
+        expect(JSON.parse(init.body)).toEqual({ limit: 5 });
+    });
+    it('should GET /agents/{id}/versions/{versionId} for getVersion()', async () => {
+        const version = { id: 'ver-1', agent_id: 'agent-1' };
+        mockJsonResponse(version);
+        const result = await api().getVersion('agent-1', 'ver-1');
+        expect(result).toEqual(version);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/versions/ver-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const agent = { id: 'agent-1', visibility: 'team' };
+        mockJsonResponse(agent);
+        await api().updateVisibility('agent-1', 'team');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
+    });
 });

package/dist/api/api-keys.d.ts

@@ -0,0 +1,24 @@
+import { HttpClient } from '../http/client';
+import { ApiKeyDTO, CursorListRequest, CursorListResponse } from '../types';
+/**
+ * API Keys API
+ */
+export declare class ApiKeysAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List API keys with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<ApiKeyDTO>>;
+    /**
+     * Create an API key
+     */
+    create(data: {
+        name: string;
+        scopes?: string[];
+    }): Promise<ApiKeyDTO>;
+    /**
+     * Delete an API key
+     */
+    delete(id: string): Promise<void>;
+}

package/dist/api/api-keys.js

@@ -0,0 +1,26 @@
+/**
+ * API Keys API
+ */
+export class ApiKeysAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List API keys with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/apikeys/list', { data: params });
+    }
+    /**
+     * Create an API key
+     */
+    async create(data) {
+        return this.http.request('post', '/apikeys', { data });
+    }
+    /**
+     * Delete an API key
+     */
+    async delete(id) {
+        return this.http.request('delete', `/apikeys/${id}`);
+    }
+}

package/dist/api/api-keys.test.d.ts

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

package/dist/api/api-keys.test.js

@@ -0,0 +1,44 @@
+import { HttpClient } from '../http/client';
+import { ApiKeysAPI } from './api-keys';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('ApiKeysAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new ApiKeysAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /apikeys/list for list()', async () => {
+        const page = { items: [{ id: 'key-1', name: 'CI' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list();
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apikeys/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /apikeys for create()', async () => {
+        const payload = { name: 'deploy-bot', scopes: ['tasks:read'] };
+        const key = { id: 'key-new', ...payload, key: 'inf_sk_abc' };
+        mockJsonResponse(key);
+        const result = await api().create(payload);
+        expect(result).toEqual(key);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apikeys');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should DELETE /apikeys/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('key-9');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apikeys/key-9');
+        expect(init.method).toBe('DELETE');
+    });
+});

package/dist/api/apps.js

@@ -87,7 +87,7 @@ export class AppsAPI {
      * Set the current (active) version of an app
      */
     async setCurrentVersion(appId, versionId) {
-        return this.http.request('post', `/apps/${appId}/current-version`, { data: { version_id: versionId } });
+        return this.http.request('put', `/apps/${appId}/versions/${versionId}/current`);
     }
 }
 export function createAppsAPI(http) {