@inferencesh/sdk 0.6.10 → 0.6.12

package/dist/api/integrations.test.js

@@ -0,0 +1,109 @@
+import { HttpClient } from '../http/client';
+import { IntegrationsAPI } from './integrations';
+import { IntegrationProviderGoogleSA } from '../types';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('IntegrationsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new IntegrationsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /integrations/list for list()', async () => {
+        const page = { items: [{ provider: 'slack' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list();
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/integrations/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /integrations/available for listAvailable()', async () => {
+        const available = [{ provider: 'github' }];
+        mockJsonResponse(available);
+        const result = await api().listAvailable();
+        expect(result).toEqual(available);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/integrations/available');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /integrations for connect()', async () => {
+        const payload = { provider: 'slack', config: { token: 'xoxb-123' } };
+        const response = { integration: { provider: 'slack' }, redirect_url: null };
+        mockJsonResponse(response);
+        const result = await api().connect(payload);
+        expect(result).toEqual(response);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/integrations');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should GET /integrations/{provider} for get()', async () => {
+        const integration = { provider: 'slack', status: 'connected' };
+        mockJsonResponse(integration);
+        const result = await api().get('slack');
+        expect(result).toEqual(integration);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/integrations/slack');
+        expect(init.method).toBe('GET');
+    });
+    it('should DELETE /integrations/{provider} for disconnect()', async () => {
+        mockJsonResponse(null);
+        await api().disconnect('slack');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/integrations/slack');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should GET /integrations/configs for getConfigs()', async () => {
+        const configs = [{ provider: 'github', scopes: ['repo'] }];
+        mockJsonResponse(configs);
+        const result = await api().getConfigs();
+        expect(result).toEqual(configs);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/integrations/configs');
+        expect(init.method).toBe('GET');
+    });
+    it('should GET /integrations/capabilities for getCapabilities()', async () => {
+        const capabilities = { slack: ['post_message'] };
+        mockJsonResponse(capabilities);
+        const result = await api().getCapabilities();
+        expect(result).toEqual(capabilities);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/integrations/capabilities');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST typed integration requirements with secrets and scopes for checkRequirements()', async () => {
+        const payload = {
+            integrations: [
+                {
+                    key: IntegrationProviderGoogleSA,
+                    secrets: ['GOOGLE_SA_JSON'],
+                    scopes: ['https://www.googleapis.com/auth/calendar'],
+                },
+            ],
+        };
+        const response = {
+            satisfied: false,
+            errors: [
+                {
+                    type: 'scope',
+                    message: 'Missing calendar scope',
+                    action: { type: 'add_scopes', provider: IntegrationProviderGoogleSA, scopes: ['https://www.googleapis.com/auth/calendar'] },
+                },
+            ],
+        };
+        mockJsonResponse(response);
+        const result = await api().checkRequirements(payload);
+        expect(result).toEqual(response);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/integrations/check');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+});

package/dist/api/knowledge.d.ts

@@ -0,0 +1,112 @@
+import { HttpClient } from '../http/client';
+import { KnowledgeDTO, KnowledgeVersionDTO, KnowledgeCreateRequest, SkillDTO, SkillVersionDTO, CursorListRequest, CursorListResponse, PublicSkillStoreDTO } from '../types';
+/**
+ * Knowledge API
+ */
+export declare class KnowledgeAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List knowledge entries with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<KnowledgeDTO>>;
+    /**
+     * Get a knowledge entry by ID
+     */
+    get(id: string): Promise<KnowledgeDTO>;
+    /**
+     * Get a knowledge entry by namespace/name
+     */
+    getByName(namespace: string, name: string): Promise<KnowledgeDTO>;
+    /**
+     * Create a knowledge entry
+     */
+    create(data: KnowledgeCreateRequest): Promise<KnowledgeDTO>;
+    /**
+     * Update a knowledge entry
+     */
+    update(id: string, data: Partial<KnowledgeDTO>): Promise<KnowledgeDTO>;
+    /**
+     * Delete a knowledge entry
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * List knowledge versions
+     */
+    listVersions(id: string, params?: Partial<CursorListRequest>): Promise<CursorListResponse<KnowledgeVersionDTO>>;
+    /**
+     * Get a specific version
+     */
+    getVersion(id: string, versionId: string): Promise<KnowledgeVersionDTO>;
+    /**
+     * Transfer ownership
+     */
+    transferOwnership(id: string, newTeamId: string): Promise<KnowledgeDTO>;
+    /**
+     * Update visibility
+     */
+    updateVisibility(id: string, visibility: string): Promise<KnowledgeDTO>;
+}
+/**
+ * Skills API
+ */
+export declare class SkillsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List skills with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<SkillDTO>>;
+    /**
+     * Get a skill by ID
+     */
+    get(id: string): Promise<SkillDTO>;
+    /**
+     * Get a skill by namespace/name
+     */
+    getByName(namespace: string, name: string): Promise<SkillDTO>;
+    /**
+     * Resolve a skill (store + GitHub fallback)
+     */
+    resolve(ref: string, skill?: string): Promise<unknown>;
+    /**
+     * Create/publish a skill
+     */
+    create(data: Partial<SkillDTO>): Promise<SkillDTO>;
+    /**
+     * Update a skill
+     */
+    update(id: string, data: Partial<SkillDTO>): Promise<SkillDTO>;
+    /**
+     * Delete a skill
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * List skill versions
+     */
+    listVersions(id: string, params?: Partial<CursorListRequest>): Promise<CursorListResponse<SkillVersionDTO>>;
+    /**
+     * Get a specific skill version
+     */
+    getVersion(id: string, versionId: string): Promise<SkillVersionDTO>;
+    /**
+     * Download a skill
+     */
+    download(namespace: string, name: string): Promise<unknown>;
+    /**
+     * Get skill content
+     */
+    getContent(namespace: string, name: string): Promise<unknown>;
+    /**
+     * Transfer ownership
+     */
+    transferOwnership(id: string, newTeamId: string): Promise<SkillDTO>;
+    /**
+     * Update visibility
+     */
+    updateVisibility(id: string, visibility: string): Promise<SkillDTO>;
+    /**
+     * List skills in the public store
+     */
+    listStore(params?: Partial<CursorListRequest>): Promise<CursorListResponse<PublicSkillStoreDTO>>;
+}

package/dist/api/knowledge.js

@@ -0,0 +1,163 @@
+/**
+ * Knowledge API
+ */
+export class KnowledgeAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List knowledge entries with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/knowledge/list', { data: params });
+    }
+    /**
+     * Get a knowledge entry by ID
+     */
+    async get(id) {
+        return this.http.request('get', `/knowledge/${id}`);
+    }
+    /**
+     * Get a knowledge entry by namespace/name
+     */
+    async getByName(namespace, name) {
+        return this.http.request('get', `/knowledge/${namespace}/${name}`);
+    }
+    /**
+     * Create a knowledge entry
+     */
+    async create(data) {
+        return this.http.request('post', '/knowledge', { data });
+    }
+    /**
+     * Update a knowledge entry
+     */
+    async update(id, data) {
+        return this.http.request('post', `/knowledge/${id}`, { data });
+    }
+    /**
+     * Delete a knowledge entry
+     */
+    async delete(id) {
+        return this.http.request('delete', `/knowledge/${id}`);
+    }
+    /**
+     * List knowledge versions
+     */
+    async listVersions(id, params) {
+        return this.http.request('post', `/knowledge/${id}/versions/list`, { data: params });
+    }
+    /**
+     * Get a specific version
+     */
+    async getVersion(id, versionId) {
+        return this.http.request('get', `/knowledge/${id}/versions/${versionId}`);
+    }
+    /**
+     * Transfer ownership
+     */
+    async transferOwnership(id, newTeamId) {
+        return this.http.request('post', `/knowledge/${id}/transfer`, { data: { team_id: newTeamId } });
+    }
+    /**
+     * Update visibility
+     */
+    async updateVisibility(id, visibility) {
+        return this.http.request('post', `/knowledge/${id}/visibility`, { data: { visibility } });
+    }
+}
+/**
+ * Skills API
+ */
+export class SkillsAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List skills with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/skills/list', { data: params });
+    }
+    /**
+     * Get a skill by ID
+     */
+    async get(id) {
+        return this.http.request('get', `/skills/${id}`);
+    }
+    /**
+     * Get a skill by namespace/name
+     */
+    async getByName(namespace, name) {
+        return this.http.request('get', `/skills/${namespace}/${name}`);
+    }
+    /**
+     * Resolve a skill (store + GitHub fallback)
+     */
+    async resolve(ref, skill) {
+        const params = { ref };
+        if (skill)
+            params.skill = skill;
+        return this.http.request('get', '/skills/resolve', { params });
+    }
+    /**
+     * Create/publish a skill
+     */
+    async create(data) {
+        return this.http.request('post', '/skills', { data });
+    }
+    /**
+     * Update a skill
+     */
+    async update(id, data) {
+        return this.http.request('post', `/skills/${id}`, { data });
+    }
+    /**
+     * Delete a skill
+     */
+    async delete(id) {
+        return this.http.request('delete', `/skills/${id}`);
+    }
+    /**
+     * List skill versions
+     */
+    async listVersions(id, params) {
+        return this.http.request('post', `/skills/${id}/versions/list`, { data: params });
+    }
+    /**
+     * Get a specific skill version
+     */
+    async getVersion(id, versionId) {
+        return this.http.request('get', `/skills/${id}/versions/${versionId}`);
+    }
+    /**
+     * Download a skill
+     */
+    async download(namespace, name) {
+        return this.http.request('get', `/skills/${namespace}/${name}/download`);
+    }
+    /**
+     * Get skill content
+     */
+    async getContent(namespace, name) {
+        return this.http.request('get', `/skills/${namespace}/${name}/content`);
+    }
+    /**
+     * Transfer ownership
+     */
+    async transferOwnership(id, newTeamId) {
+        return this.http.request('post', `/skills/${id}/transfer`, { data: { team_id: newTeamId } });
+    }
+    /**
+     * Update visibility
+     */
+    async updateVisibility(id, visibility) {
+        return this.http.request('post', `/skills/${id}/visibility`, { data: { visibility } });
+    }
+    /**
+     * List skills in the public store
+     */
+    async listStore(params) {
+        return this.http.request('post', '/store/skills/list', { data: params });
+    }
+}

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

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

package/dist/api/knowledge.test.js

@@ -0,0 +1,94 @@
+import { HttpClient } from '../http/client';
+import { KnowledgeAPI, SkillsAPI } from './knowledge';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('KnowledgeAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new KnowledgeAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /knowledge/list for list()', async () => {
+        const page = { items: [{ id: 'know-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('/knowledge/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /knowledge/{namespace}/{name} for getByName()', async () => {
+        const entry = { id: 'know-1', namespace: 'acme', name: 'docs' };
+        mockJsonResponse(entry);
+        const result = await api().getByName('acme', 'docs');
+        expect(result).toEqual(entry);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/acme/docs');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /knowledge for create()', async () => {
+        const payload = { namespace: 'acme', name: 'docs', content: 'hello' };
+        const entry = { id: 'know-new', ...payload };
+        mockJsonResponse(entry);
+        const result = await api().create(payload);
+        expect(result).toEqual(entry);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST team_id for transferOwnership()', async () => {
+        const entry = { id: 'know-1' };
+        mockJsonResponse(entry);
+        await api().transferOwnership('know-1', 'team-5');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/knowledge/know-1/transfer');
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-5' });
+    });
+});
+describe('SkillsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new SkillsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should GET /skills/resolve with ref param for resolve()', async () => {
+        const resolved = { ref: 'acme/skill@v1', content: '{}' };
+        mockJsonResponse(resolved);
+        const result = await api().resolve('acme/skill@v1', 'main');
+        expect(result).toEqual(resolved);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/resolve');
+        expect(url).toContain('ref=acme');
+        expect(url).toContain('skill=main');
+    });
+    it('should GET /skills/{namespace}/{name} for getByName()', async () => {
+        const skill = { id: 'skill-1', namespace: 'acme', name: 'research' };
+        mockJsonResponse(skill);
+        const result = await api().getByName('acme', 'research');
+        expect(result).toEqual(skill);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/acme/research');
+        expect(init.method).toBe('GET');
+    });
+    it('should GET /skills/{namespace}/{name}/download for download()', async () => {
+        mockJsonResponse({ url: 'https://cdn.example.com/skill.zip' });
+        await api().download('acme', 'research');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/skills/acme/research/download');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /store/skills/list for listStore()', async () => {
+        const page = { items: [{ namespace: 'public', name: 'starter' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().listStore();
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/store/skills/list');
+        expect(init.method).toBe('POST');
+    });
+});

package/dist/api/mcp-servers.d.ts

@@ -0,0 +1,45 @@
+import { HttpClient } from '../http/client';
+import { MCPServerDTO, CursorListRequest, CursorListResponse } from '../types';
+/**
+ * MCP Servers API
+ */
+export declare class MCPServersAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List public MCP servers
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<MCPServerDTO>>;
+    /**
+     * Get an MCP server by slug
+     */
+    get(slug: string): Promise<MCPServerDTO>;
+    /**
+     * List tools for an MCP server
+     */
+    listTools(slug: string): Promise<unknown[]>;
+    /**
+     * Call a tool on an MCP server
+     */
+    callTool(slug: string, tool: string, input: unknown): Promise<unknown>;
+    /**
+     * List user's own MCP servers
+     */
+    listOwned(params?: Partial<CursorListRequest>): Promise<CursorListResponse<MCPServerDTO>>;
+    /**
+     * Get a user's MCP server by ID
+     */
+    getOwned(id: string): Promise<MCPServerDTO>;
+    /**
+     * Create an MCP server
+     */
+    create(data: Partial<MCPServerDTO>): Promise<MCPServerDTO>;
+    /**
+     * Update an MCP server
+     */
+    update(id: string, data: Partial<MCPServerDTO>): Promise<MCPServerDTO>;
+    /**
+     * Delete an MCP server
+     */
+    delete(id: string): Promise<void>;
+}

package/dist/api/mcp-servers.js

@@ -0,0 +1,62 @@
+/**
+ * MCP Servers API
+ */
+export class MCPServersAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List public MCP servers
+     */
+    async list(params) {
+        return this.http.request('post', '/mcps/list', { data: params });
+    }
+    /**
+     * Get an MCP server by slug
+     */
+    async get(slug) {
+        return this.http.request('get', `/mcps/${slug}`);
+    }
+    /**
+     * List tools for an MCP server
+     */
+    async listTools(slug) {
+        return this.http.request('get', `/mcps/${slug}/tools`);
+    }
+    /**
+     * Call a tool on an MCP server
+     */
+    async callTool(slug, tool, input) {
+        return this.http.request('post', `/mcps/${slug}/tools/${tool}`, { data: input });
+    }
+    /**
+     * List user's own MCP servers
+     */
+    async listOwned(params) {
+        return this.http.request('post', '/mcp-servers/list', { data: params });
+    }
+    /**
+     * Get a user's MCP server by ID
+     */
+    async getOwned(id) {
+        return this.http.request('get', `/mcp-servers/${id}`);
+    }
+    /**
+     * Create an MCP server
+     */
+    async create(data) {
+        return this.http.request('post', '/mcp-servers', { data });
+    }
+    /**
+     * Update an MCP server
+     */
+    async update(id, data) {
+        return this.http.request('put', `/mcp-servers/${id}`, { data });
+    }
+    /**
+     * Delete an MCP server
+     */
+    async delete(id) {
+        return this.http.request('delete', `/mcp-servers/${id}`);
+    }
+}

package/dist/api/mcp-servers.test.d.ts

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

package/dist/api/mcp-servers.test.js

@@ -0,0 +1,64 @@
+import { HttpClient } from '../http/client';
+import { MCPServersAPI } from './mcp-servers';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('MCPServersAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new MCPServersAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /mcps/list for list()', async () => {
+        const page = { items: [{ slug: 'filesystem' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list();
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcps/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /mcps/{slug}/tools for listTools()', async () => {
+        const tools = [{ name: 'read_file' }];
+        mockJsonResponse(tools);
+        const result = await api().listTools('filesystem');
+        expect(result).toEqual(tools);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcps/filesystem/tools');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /mcps/{slug}/tools/{tool} for callTool()', async () => {
+        const input = { path: '/tmp/test.txt' };
+        const output = { content: 'hello' };
+        mockJsonResponse(output);
+        const result = await api().callTool('filesystem', 'read_file', input);
+        expect(result).toEqual(output);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcps/filesystem/tools/read_file');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(input);
+    });
+    it('should POST /mcp-servers for create()', async () => {
+        const payload = { name: 'My MCP', slug: 'my-mcp' };
+        const server = { id: 'mcp-1', ...payload };
+        mockJsonResponse(server);
+        const result = await api().create(payload);
+        expect(result).toEqual(server);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcp-servers');
+        expect(init.method).toBe('POST');
+    });
+    it('should PUT /mcp-servers/{id} for update()', async () => {
+        const server = { id: 'mcp-1', name: 'Updated MCP' };
+        mockJsonResponse(server);
+        await api().update('mcp-1', { name: 'Updated MCP' });
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcp-servers/mcp-1');
+        expect(init.method).toBe('PUT');
+    });
+});

package/dist/api/projects.d.ts

@@ -0,0 +1,29 @@
+import { HttpClient } from '../http/client';
+import { ProjectDTO, CursorListRequest, CursorListResponse } from '../types';
+/**
+ * Projects API
+ */
+export declare class ProjectsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List projects with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<ProjectDTO>>;
+    /**
+     * Get a project by ID
+     */
+    get(id: string): Promise<ProjectDTO>;
+    /**
+     * Create a project
+     */
+    create(data: Partial<ProjectDTO>): Promise<ProjectDTO>;
+    /**
+     * Update a project
+     */
+    update(id: string, data: Partial<ProjectDTO>): Promise<ProjectDTO>;
+    /**
+     * Delete a project
+     */
+    delete(id: string): Promise<void>;
+}