@inferencesh/sdk 0.6.10 → 0.6.13

package/dist/api/flows.test.js

@@ -40,4 +40,79 @@ describe('FlowsAPI', () => {
         expect(createEventSource).toHaveBeenCalledWith('/flows/flow-5/stream');
         createEventSource.mockRestore();
     });
+    it('should POST /flows/list for list()', async () => {
+        const page = { items: [{ id: 'flow-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('/flows/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /flows/{id} for get()', async () => {
+        const flow = { id: 'flow-1', name: 'Demo' };
+        mockJsonResponse(flow);
+        const result = await api().get('flow-1');
+        expect(result).toEqual(flow);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /flows/{id} for update()', async () => {
+        const flow = { id: 'flow-1', name: 'Renamed' };
+        mockJsonResponse(flow);
+        const result = await api().update('flow-1', { name: 'Renamed' });
+        expect(result).toEqual(flow);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'Renamed' });
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const flow = { id: 'flow-1', visibility: 'public' };
+        mockJsonResponse(flow);
+        const result = await api().updateVisibility('flow-1', 'public');
+        expect(result).toEqual(flow);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/visibility');
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'public' });
+    });
+    it('should DELETE /flows/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('flow-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /flows/{id}/duplicate for duplicate()', async () => {
+        const flow = { id: 'flow-copy' };
+        mockJsonResponse(flow);
+        const result = await api().duplicate('flow-1');
+        expect(result).toEqual(flow);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/duplicate');
+    });
+    it('should POST /flows/{id}/versions/list for listVersions()', async () => {
+        const versions = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(versions);
+        const result = await api().listVersions('flow-1');
+        expect(result).toEqual(versions);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/versions/list');
+    });
+    it('should POST transfer with team_id for transferOwnership()', async () => {
+        const flow = { id: 'flow-1' };
+        mockJsonResponse(flow);
+        await api().transferOwnership('flow-1', 'team-42');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-42' });
+    });
+    it('should POST /flows/{id}/visibility for updateVisibility()', async () => {
+        const flow = { id: 'flow-1', visibility: 'public' };
+        mockJsonResponse(flow);
+        const result = await api().updateVisibility('flow-1', 'public');
+        expect(result).toEqual(flow);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/visibility');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'public' });
+    });
 });

package/dist/api/integrations.d.ts

@@ -0,0 +1,41 @@
+import { HttpClient } from '../http/client';
+import { IntegrationDTO, IntegrationConfigDTO, IntegrationConnectRequest, IntegrationConnectResponse, CursorListRequest, CursorListResponse } from '../types';
+/**
+ * Integrations API
+ */
+export declare class IntegrationsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List integrations with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<IntegrationDTO>>;
+    /**
+     * Get available integrations
+     */
+    listAvailable(): Promise<IntegrationConfigDTO[]>;
+    /**
+     * Get integration configs
+     */
+    getConfigs(): Promise<IntegrationConfigDTO[]>;
+    /**
+     * Get capabilities
+     */
+    getCapabilities(): Promise<unknown>;
+    /**
+     * Check requirements
+     */
+    checkRequirements(data: unknown): Promise<unknown>;
+    /**
+     * Connect an integration
+     */
+    connect(data: IntegrationConnectRequest): Promise<IntegrationConnectResponse>;
+    /**
+     * Get an integration by provider key
+     */
+    get(provider: string): Promise<IntegrationDTO>;
+    /**
+     * Disconnect an integration
+     */
+    disconnect(provider: string): Promise<void>;
+}

package/dist/api/integrations.js

@@ -0,0 +1,56 @@
+/**
+ * Integrations API
+ */
+export class IntegrationsAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List integrations with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/integrations/list', { data: params });
+    }
+    /**
+     * Get available integrations
+     */
+    async listAvailable() {
+        return this.http.request('get', '/integrations/available');
+    }
+    /**
+     * Get integration configs
+     */
+    async getConfigs() {
+        return this.http.request('get', '/integrations/configs');
+    }
+    /**
+     * Get capabilities
+     */
+    async getCapabilities() {
+        return this.http.request('get', '/integrations/capabilities');
+    }
+    /**
+     * Check requirements
+     */
+    async checkRequirements(data) {
+        return this.http.request('post', '/integrations/check', { data });
+    }
+    /**
+     * Connect an integration
+     */
+    async connect(data) {
+        return this.http.request('post', '/integrations', { data });
+    }
+    /**
+     * Get an integration by provider key
+     */
+    async get(provider) {
+        return this.http.request('get', `/integrations/${provider}`);
+    }
+    /**
+     * Disconnect an integration
+     */
+    async disconnect(provider) {
+        return this.http.request('delete', `/integrations/${provider}`);
+    }
+}

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

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

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 {};