@inferencesh/sdk 0.6.8 → 0.6.12

package/dist/api/apps.test.js

@@ -0,0 +1,135 @@
+import { HttpClient } from '../http/client';
+import { AppsAPI } from './apps';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('AppsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new AppsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /apps/list for list()', async () => {
+        const apps = { items: [{ id: 'app-1' }], next_cursor: null };
+        mockJsonResponse(apps);
+        const result = await api().list({ limit: 10 });
+        expect(result).toEqual(apps);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/list');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ limit: 10 });
+    });
+    it('should GET /apps/{name} for getByName()', async () => {
+        const app = { id: 'app-1', name: 'inference/claude-haiku' };
+        mockJsonResponse(app);
+        const result = await api().getByName('inference/claude-haiku');
+        expect(result).toEqual(app);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/inference/claude-haiku');
+    });
+    it('should POST transfer with team_id for transferOwnership()', async () => {
+        const app = { id: 'app-1' };
+        mockJsonResponse(app);
+        await api().transferOwnership('app-1', 'team-99');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/transfer');
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-99' });
+    });
+    it('should POST license payload for saveLicense()', async () => {
+        const license = { app_id: 'app-1', license: 'key-abc' };
+        mockJsonResponse(license);
+        const result = await api().saveLicense('app-1', 'key-abc');
+        expect(result).toEqual(license);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ license: 'key-abc' });
+    });
+    it('should PUT /apps/{id}/versions/{versionId}/current for setCurrentVersion()', async () => {
+        const app = { id: 'app-1', current_version_id: 'ver-2' };
+        mockJsonResponse(app);
+        await api().setCurrentVersion('app-1', 'ver-2');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/versions/ver-2/current');
+        expect(init.method).toBe('PUT');
+    });
+    it('should POST /apps/{id}/duplicate for duplicate()', async () => {
+        const app = { id: 'app-copy' };
+        mockJsonResponse(app);
+        const result = await api().duplicate('app-1');
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/duplicate');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /apps/{id} for get()', async () => {
+        const app = { id: 'app-1', name: 'demo' };
+        mockJsonResponse(app);
+        const result = await api().get('app-1');
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should GET versioned app for getByVersionId()', async () => {
+        const app = { id: 'app-1', version_id: 'ver-1' };
+        mockJsonResponse(app);
+        const result = await api().getByVersionId('app-1', 'ver-1');
+        expect(result).toEqual(app);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/versions/ver-1');
+    });
+    it('should POST /apps for create()', async () => {
+        const app = { id: 'app-new', name: 'New App' };
+        mockJsonResponse(app);
+        const result = await api().create({ name: 'New App' });
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ name: 'New App' });
+    });
+    it('should POST /apps/{id} for update()', async () => {
+        const app = { id: 'app-1', description: 'updated' };
+        mockJsonResponse(app);
+        const result = await api().update('app-1', { description: 'updated' });
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1');
+        expect(JSON.parse(init.body)).toEqual({ description: 'updated' });
+    });
+    it('should DELETE /apps/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('app-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /apps/{id}/versions/list for listVersions()', async () => {
+        const versions = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(versions);
+        const result = await api().listVersions('app-1', { limit: 20 });
+        expect(result).toEqual(versions);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/versions/list');
+        expect(JSON.parse(init.body)).toEqual({ limit: 20 });
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const app = { id: 'app-1', visibility: 'private' };
+        mockJsonResponse(app);
+        await api().updateVisibility('app-1', 'private');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'private' });
+    });
+    it('should GET /apps/{id}/license for getLicense()', async () => {
+        const license = { app_id: 'app-1', license: 'MIT' };
+        mockJsonResponse(license);
+        const result = await api().getLicense('app-1');
+        expect(result).toEqual(license);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/license');
+    });
+});

package/dist/api/chats.d.ts

@@ -26,5 +26,19 @@ export declare class ChatsAPI {
      * Get chat trace (for debugging/observability)
      */
     getTrace(chatId: string): Promise<ChatTraceDTO>;
+    /**
+     * Get chat status
+     */
+    getStatus(chatId: string): Promise<{
+        status: string;
+    }>;
+    /**
+     * Stop chat generation
+     */
+    stop(chatId: string): Promise<void>;
+    /**
+     * Stream chat updates
+     */
+    stream(chatId: string): Promise<import("eventsource").EventSource | null>;
 }
 export declare function createChatsAPI(http: HttpClient): ChatsAPI;

package/dist/api/chats.js

@@ -35,6 +35,24 @@ export class ChatsAPI {
     async getTrace(chatId) {
         return this.http.request('get', `/chats/${chatId}/trace`);
     }
+    /**
+     * Get chat status
+     */
+    async getStatus(chatId) {
+        return this.http.request('get', `/chats/${chatId}/status`);
+    }
+    /**
+     * Stop chat generation
+     */
+    async stop(chatId) {
+        return this.http.request('post', `/chats/${chatId}/stop`);
+    }
+    /**
+     * Stream chat updates
+     */
+    stream(chatId) {
+        return this.http.createEventSource(`/chats/${chatId}/stream`);
+    }
 }
 export function createChatsAPI(http) {
     return new ChatsAPI(http);

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

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

package/dist/api/chats.test.js

@@ -0,0 +1,85 @@
+import { HttpClient } from '../http/client';
+import { ChatsAPI } from './chats';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('ChatsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new ChatsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should GET /chats/{id}/trace for getTrace()', async () => {
+        const trace = { chat_id: 'chat-1', spans: [] };
+        mockJsonResponse(trace);
+        const result = await api().getTrace('chat-1');
+        expect(result).toEqual(trace);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1/trace');
+        expect(init.method).toBe('GET');
+    });
+    it('should DELETE /chats/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('chat-9');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-9');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /chats/list for list()', async () => {
+        const page = { items: [{ id: 'chat-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list({ limit: 25 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/list');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ limit: 25 });
+    });
+    it('should GET /chats/{id} for get()', async () => {
+        const chat = { id: 'chat-1', status: 'open' };
+        mockJsonResponse(chat);
+        const result = await api().get('chat-1');
+        expect(result).toEqual(chat);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /chats/{id} for update()', async () => {
+        const chat = { id: 'chat-1', name: 'Renamed' };
+        mockJsonResponse(chat);
+        const result = await api().update('chat-1', { name: 'Renamed' });
+        expect(result).toEqual(chat);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'Renamed' });
+    });
+    it('should GET /chats/{id}/status for getStatus()', async () => {
+        mockJsonResponse({ status: 'busy' });
+        const result = await api().getStatus('chat-1');
+        expect(result).toEqual({ status: 'busy' });
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1/status');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /chats/{id}/stop for stop()', async () => {
+        mockJsonResponse(null);
+        await api().stop('chat-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1/stop');
+        expect(init.method).toBe('POST');
+    });
+    it('should open SSE on /chats/{id}/stream for stream()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const chats = new ChatsAPI(http);
+        await chats.stream('chat-42');
+        expect(createEventSource).toHaveBeenCalledWith('/chats/chat-42/stream');
+        createEventSource.mockRestore();
+    });
+});

package/dist/api/engines.d.ts

@@ -53,5 +53,17 @@ export declare class EnginesAPI {
      * Transfer engine ownership
      */
     transferOwnership(engineId: string, newTeamId: string): Promise<Engine>;
+    /**
+     * Extend engine duration
+     */
+    extend(engineId: string): Promise<void>;
+    /**
+     * Drain an engine
+     */
+    drain(engineId: string): Promise<void>;
+    /**
+     * Update an engine binary (drain + restart with new version)
+     */
+    updateBinary(engineId: string): Promise<void>;
 }
 export declare function createEnginesAPI(http: HttpClient): EnginesAPI;

package/dist/api/engines.js

@@ -71,6 +71,24 @@ export class EnginesAPI {
     async transferOwnership(engineId, newTeamId) {
         return this.http.request('post', `/engines/${engineId}/transfer`, { data: { team_id: newTeamId } });
     }
+    /**
+     * Extend engine duration
+     */
+    async extend(engineId) {
+        return this.http.request('post', `/engines/${engineId}/extend`);
+    }
+    /**
+     * Drain an engine
+     */
+    async drain(engineId) {
+        return this.http.request('post', `/engines/${engineId}/drain`);
+    }
+    /**
+     * Update an engine binary (drain + restart with new version)
+     */
+    async updateBinary(engineId) {
+        return this.http.request('post', `/engines/${engineId}/update`);
+    }
 }
 export function createEnginesAPI(http) {
     return new EnginesAPI(http);

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

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

package/dist/api/engines.test.js

@@ -0,0 +1,133 @@
+import { HttpClient } from '../http/client';
+import { EnginesAPI } from './engines';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('EnginesAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new EnginesAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST resource ids for getForResources()', async () => {
+        const engines = [{ id: 'eng-1' }];
+        mockJsonResponse(engines);
+        const result = await api().getForResources({
+            app_ids: ['app-1'],
+            agent_ids: ['agent-1'],
+        });
+        expect(result).toEqual(engines);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/resources');
+        expect(JSON.parse(init.body)).toEqual({
+            app_ids: ['app-1'],
+            agent_ids: ['agent-1'],
+        });
+    });
+    it('should POST /engines/{id}/stop for stop()', async () => {
+        mockJsonResponse(null);
+        await api().stop('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/stop');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /engines/{id}/restart for restart()', async () => {
+        mockJsonResponse(null);
+        await api().restart('eng-1');
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/restart');
+    });
+    it('should open SSE on /engines/{id}/stream for stream()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const engines = new EnginesAPI(http);
+        await engines.stream('eng-7');
+        expect(createEventSource).toHaveBeenCalledWith('/engines/eng-7/stream');
+        createEventSource.mockRestore();
+    });
+    it('should POST /engines/list for list()', async () => {
+        const page = { items: [{ id: 'eng-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list();
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /engines/{id} for get()', async () => {
+        const engine = { id: 'eng-1' };
+        mockJsonResponse(engine);
+        const result = await api().get('eng-1');
+        expect(result).toEqual(engine);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /engines for create()', async () => {
+        const engine = { id: 'eng-new', name: 'worker' };
+        mockJsonResponse(engine);
+        const result = await api().create({ name: 'worker' });
+        expect(result).toEqual(engine);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ name: 'worker' });
+    });
+    it('should POST /engines/{id} for update()', async () => {
+        const engine = { id: 'eng-1', name: 'updated' };
+        mockJsonResponse(engine);
+        const result = await api().update('eng-1', { name: 'updated' });
+        expect(result).toEqual(engine);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
+    });
+    it('should DELETE /engines/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const engine = { id: 'eng-1', visibility: 'team' };
+        mockJsonResponse(engine);
+        await api().updateVisibility('eng-1', 'team');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
+    });
+    it('should POST transfer with team_id for transferOwnership()', async () => {
+        const engine = { id: 'eng-1' };
+        mockJsonResponse(engine);
+        await api().transferOwnership('eng-1', 'team-7');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-7' });
+    });
+    it('should POST /engines/{id}/extend for extend()', async () => {
+        mockJsonResponse(null);
+        await api().extend('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/extend');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /engines/{id}/drain for drain()', async () => {
+        mockJsonResponse(null);
+        await api().drain('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/drain');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /engines/{id}/update for updateBinary()', async () => {
+        mockJsonResponse(null);
+        await api().updateBinary('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/update');
+        expect(init.method).toBe('POST');
+    });
+});