@inferencesh/sdk 0.6.8 → 0.6.12

package/dist/api/agents.test.js

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import { StreamableManager } from '../http/streamable';
 import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
 import { FilesAPI } from './files';
 import { AgentsAPI } from './agents';
@@ -53,18 +54,15 @@ describe('Agent.sendMessage (polling mode)', () => {
         const userMessage = makeMessage({ id: 'user-1', role: 'user' });
         const assistantMessage = makeMessage({ id: 'asst-1' });
         mockJsonResponse({
-            success: true,
-            data: { user_message: userMessage, assistant_message: assistantMessage },
+            user_message: userMessage, assistant_message: assistantMessage,
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusBusy, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusBusy, chat_messages: [],
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusIdle, chat_messages: [],
         });
         const onChat = jest.fn();
         const result = await agent().sendMessage('hello', { stream: false, onChat });
@@ -81,27 +79,20 @@ describe('Agent.sendMessage (polling mode)', () => {
         };
         const messageWithTool = makeMessage({ tool_invocations: [toolInvocation] });
         mockJsonResponse({
-            success: true,
-            data: {
-                user_message: makeMessage({ id: 'user-1', role: 'user' }),
-                assistant_message: makeMessage(),
-            },
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: {
-                id: 'chat-1',
-                status: ChatStatusBusy,
-                chat_messages: [messageWithTool],
-            },
+            id: 'chat-1',
+            status: ChatStatusBusy,
+            chat_messages: [messageWithTool],
         });
         // Same status again — stub poll should not re-dispatch tool
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [messageWithTool] },
+            id: 'chat-1', status: ChatStatusIdle, chat_messages: [messageWithTool],
         });
         const onMessage = jest.fn();
         const onToolCall = jest.fn();
@@ -117,22 +108,18 @@ describe('Agent.sendMessage (polling mode)', () => {
         const userMessage = makeMessage({ id: 'user-1', role: 'user' });
         const assistantMessage = makeMessage();
         mockJsonResponse({
-            success: true,
-            data: { user_message: userMessage, assistant_message: assistantMessage },
+            user_message: userMessage, assistant_message: assistantMessage,
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusBusy },
+            id: 'chat-1', status: ChatStatusBusy,
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle },
+            id: 'chat-1', status: ChatStatusIdle,
         });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, output: { answer: 42 } },
+            id: 'chat-1', status: ChatStatusIdle, output: { answer: 42 },
         });
         const output = await agent().run('compute');
         expect(output).toEqual({ answer: 42 });
@@ -155,8 +142,7 @@ describe('Agent.sendMessage (streaming mode)', () => {
                     ok: true,
                     status: 200,
                     text: () => Promise.resolve(JSON.stringify({
-                        success: true,
-                        data: { user_message: userMessage, assistant_message: assistantMessage },
+                        user_message: userMessage, assistant_message: assistantMessage,
                     })),
                 });
             }
@@ -184,11 +170,8 @@ describe('Agent.sendMessage (streaming mode)', () => {
                     ok: true,
                     status: 200,
                     text: () => Promise.resolve(JSON.stringify({
-                        success: true,
-                        data: {
-                            user_message: makeMessage({ id: 'user-1', role: 'user' }),
-                            assistant_message: makeMessage(),
-                        },
+                        user_message: makeMessage({ id: 'user-1', role: 'user' }),
+                        assistant_message: makeMessage(),
                     })),
                 });
             }
@@ -214,21 +197,16 @@ describe('Agent.sendMessage (streaming mode)', () => {
         });
         const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
         mockJsonResponse({
-            success: true,
-            data: {
-                user_message: makeMessage({ id: 'user-1', role: 'user' }),
-                assistant_message: makeMessage(),
-            },
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusBusy, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusBusy, chat_messages: [],
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusIdle, chat_messages: [],
         });
         await agentInstance.sendMessage('first', { stream: false });
         const callOrder = [];
@@ -239,11 +217,8 @@ describe('Agent.sendMessage (streaming mode)', () => {
                     ok: true,
                     status: 200,
                     text: () => Promise.resolve(JSON.stringify({
-                        success: true,
-                        data: {
-                            user_message: makeMessage({ id: 'user-2', role: 'user' }),
-                            assistant_message: makeMessage({ id: 'asst-2' }),
-                        },
+                        user_message: makeMessage({ id: 'user-2', role: 'user' }),
+                        assistant_message: makeMessage({ id: 'asst-2' }),
                     })),
                 });
             }
@@ -285,21 +260,16 @@ describe('Agent.sendMessage (file attachments)', () => {
             content_type: 'application/pdf',
         };
         mockJsonResponse({
-            success: true,
-            data: {
-                user_message: makeMessage({ id: 'user-1', role: 'user' }),
-                assistant_message: makeMessage(),
-            },
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusBusy, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusBusy, chat_messages: [],
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusIdle, chat_messages: [],
         });
         await agent().sendMessage('see attachments', {
             stream: false,
@@ -312,6 +282,44 @@ describe('Agent.sendMessage (file attachments)', () => {
         expect(mockFetch.mock.calls.filter(([url]) => String(url).includes('/files')).length).toBe(0);
     });
 });
+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');
+    });
+});
 describe('Agent lifecycle', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -331,46 +339,96 @@ describe('Agent lifecycle', () => {
     it('stopChat should POST to /chats/{id}/stop when a chat exists', async () => {
         const agentInstance = agent();
         mockJsonResponse({
-            success: true,
-            data: {
-                user_message: makeMessage({ id: 'user-1', role: 'user' }),
-                assistant_message: makeMessage(),
-            },
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusBusy, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusBusy, chat_messages: [],
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusIdle, chat_messages: [],
         });
         await agentInstance.sendMessage('hello', { stream: false });
         jest.clearAllMocks();
-        mockJsonResponse({ success: true, data: null });
+        mockJsonResponse(null);
         await agentInstance.stopChat();
         expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/chats/chat-1/stop'), expect.anything());
     });
+    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({
-            success: true,
-            data: {
-                user_message: makeMessage({ id: 'user-1', role: 'user' }),
-                assistant_message: makeMessage(),
-            },
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusBusy } });
+        mockJsonResponse({ status: ChatStatusBusy });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusBusy, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusBusy, chat_messages: [],
         });
-        mockJsonResponse({ success: true, data: { status: ChatStatusIdle } });
+        mockJsonResponse({ status: ChatStatusIdle });
         mockJsonResponse({
-            success: true,
-            data: { id: 'chat-1', status: ChatStatusIdle, chat_messages: [] },
+            id: 'chat-1', status: ChatStatusIdle, chat_messages: [],
         });
         await agentInstance.sendMessage('hello', { stream: false });
         agentInstance.reset();
@@ -379,6 +437,29 @@ describe('Agent lifecycle', () => {
         expect(mockFetch).not.toHaveBeenCalled();
     });
 });
+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');
+    });
+});
 describe('Agent.submitToolResult', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -386,7 +467,7 @@ describe('Agent.submitToolResult', () => {
     it('should JSON-stringify structured action results', async () => {
         const http = new HttpClient({ apiKey: 'test-key' });
         const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
-        mockJsonResponse({ success: true, data: null });
+        mockJsonResponse(null);
         const payload = {
             action: { type: 'form_submit', payload: { field: 'value' } },
             form_data: { field: 'value' },
@@ -397,3 +478,133 @@ 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();
+    });
+    const api = () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        return new AgentsAPI(http, new FilesAPI(http));
+    };
+    it('should GET /agents/internal-tools for getInternalTools()', async () => {
+        const tools = [{ name: 'search', description: 'Search the web' }];
+        mockJsonResponse(tools);
+        const result = await api().getInternalTools();
+        expect(result).toEqual(tools);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/internal-tools');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST team_id for transferOwnership()', async () => {
+        const agent = { id: 'agent-1' };
+        mockJsonResponse(agent);
+        await api().transferOwnership('agent-1', 'team-42');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/transfer');
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-42' });
+    });
+    it('should POST /agents for createAgent()', async () => {
+        const payload = { name: 'support-bot', core_app: { ref: 'app/ref' } };
+        const created = { id: 'agent-new', ...payload };
+        mockJsonResponse(created);
+        const result = await api().createAgent(payload);
+        expect(result).toEqual(created);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    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) {

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

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