@inferencesh/sdk 0.6.14 → 0.6.19

package/dist/api/flow-runs.test.d.ts

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

package/dist/api/flow-runs.test.js

@@ -1,97 +0,0 @@
-import { HttpClient } from '../http/client';
-import { FlowRunsAPI } from './flow-runs';
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockJsonResponse(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-}
-describe('FlowRunsAPI', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new FlowRunsAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should POST flow and input for create()', async () => {
-        const flowRun = { id: 'fr-1', flow: 'flow-1' };
-        mockJsonResponse(flowRun);
-        const result = await api().create('flow-1', { prompt: 'hi' });
-        expect(result).toEqual(flowRun);
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({
-            flow: 'flow-1',
-            input: { prompt: 'hi' },
-        });
-    });
-    it('should POST /flowruns/{id}/cancel for cancel()', async () => {
-        mockJsonResponse(null);
-        await api().cancel('fr-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/flowruns/fr-1/cancel');
-        expect(init.method).toBe('POST');
-    });
-    it('should open SSE on /flowruns/{id}/stream for stream()', async () => {
-        const http = new HttpClient({ apiKey: 'test-key' });
-        const createEventSource = jest
-            .spyOn(http, 'createEventSource')
-            .mockResolvedValue(null);
-        const flowRuns = new FlowRunsAPI(http);
-        await flowRuns.stream('fr-42');
-        expect(createEventSource).toHaveBeenCalledWith('/flowruns/fr-42/stream');
-        createEventSource.mockRestore();
-    });
-    it('should open task SSE for streamTasks()', async () => {
-        const http = new HttpClient({ apiKey: 'test-key' });
-        const createEventSource = jest
-            .spyOn(http, 'createEventSource')
-            .mockResolvedValue(null);
-        const flowRuns = new FlowRunsAPI(http);
-        await flowRuns.streamTasks('fr-42');
-        expect(createEventSource).toHaveBeenCalledWith('/flowruns/fr-42/tasks/stream');
-        createEventSource.mockRestore();
-    });
-    it('should POST /flowruns/list for list()', async () => {
-        const page = { items: [{ id: 'fr-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('/flowruns/list');
-        expect(init.method).toBe('POST');
-    });
-    it('should GET /flowruns/{id} for get()', async () => {
-        const flowRun = { id: 'fr-1' };
-        mockJsonResponse(flowRun);
-        const result = await api().get('fr-1');
-        expect(result).toEqual(flowRun);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/flowruns/fr-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST /flowruns/{id}/clone for clone()', async () => {
-        const flowRun = { id: 'fr-clone' };
-        mockJsonResponse(flowRun);
-        const result = await api().clone('fr-1');
-        expect(result).toEqual(flowRun);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/flowruns/fr-1/clone');
-        expect(init.method).toBe('POST');
-    });
-    it('should POST /flowruns/{id} for update()', async () => {
-        const flowRun = { id: 'fr-1', fail_on_error: false };
-        mockJsonResponse(flowRun);
-        const result = await api().update('fr-1', { fail_on_error: false });
-        expect(result).toEqual(flowRun);
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ fail_on_error: false });
-    });
-    it('should POST visibility for updateVisibility()', async () => {
-        const flowRun = { id: 'fr-1', visibility: 'public' };
-        mockJsonResponse(flowRun);
-        await api().updateVisibility('fr-1', 'public');
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ visibility: 'public' });
-    });
-});

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

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

package/dist/api/flows.test.js

@@ -1,118 +0,0 @@
-import { HttpClient } from '../http/client';
-import { FlowsAPI } from './flows';
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockJsonResponse(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-}
-describe('FlowsAPI', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new FlowsAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should POST name for create()', async () => {
-        const flow = { id: 'flow-1', name: 'My Flow' };
-        mockJsonResponse(flow);
-        const result = await api().create('My Flow');
-        expect(result).toEqual(flow);
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ name: 'My Flow' });
-    });
-    it('should POST /flows/{id}/app for createApp()', async () => {
-        const app = { id: 'app-from-flow' };
-        mockJsonResponse(app);
-        const result = await api().createApp('flow-1');
-        expect(result).toEqual(app);
-        const [url] = mockFetch.mock.calls[0];
-        expect(url).toContain('/flows/flow-1/app');
-    });
-    it('should open SSE on /flows/{id}/stream for stream()', async () => {
-        const http = new HttpClient({ apiKey: 'test-key' });
-        const createEventSource = jest
-            .spyOn(http, 'createEventSource')
-            .mockResolvedValue(null);
-        const flows = new FlowsAPI(http);
-        await flows.stream('flow-5');
-        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.test.d.ts

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

package/dist/api/integrations.test.js

@@ -1,109 +0,0 @@
-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.test.d.ts

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

package/dist/api/knowledge.test.js

@@ -1,238 +0,0 @@
-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' });
-    });
-    it('should GET /knowledge/{id} for get()', async () => {
-        const entry = { id: 'know-1', name: 'docs' };
-        mockJsonResponse(entry);
-        const result = await api().get('know-1');
-        expect(result).toEqual(entry);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/knowledge/know-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST /knowledge/{id} for update()', async () => {
-        const entry = { id: 'know-1', name: 'updated' };
-        mockJsonResponse(entry);
-        const result = await api().update('know-1', { name: 'updated' });
-        expect(result).toEqual(entry);
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
-    });
-    it('should DELETE /knowledge/{id} for delete()', async () => {
-        mockJsonResponse(null);
-        await api().delete('know-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/knowledge/know-1');
-        expect(init.method).toBe('DELETE');
-    });
-    it('should POST /knowledge/{id}/versions/list for listVersions()', async () => {
-        const page = { items: [{ id: 'ver-1' }], next_cursor: null };
-        mockJsonResponse(page);
-        const result = await api().listVersions('know-1', { limit: 10 });
-        expect(result).toEqual(page);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/knowledge/know-1/versions/list');
-        expect(JSON.parse(init.body)).toEqual({ limit: 10 });
-    });
-    it('should GET /knowledge/{id}/versions/{versionId} for getVersion()', async () => {
-        const version = { id: 'ver-1', knowledge_id: 'know-1' };
-        mockJsonResponse(version);
-        const result = await api().getVersion('know-1', 'ver-1');
-        expect(result).toEqual(version);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/knowledge/know-1/versions/ver-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST visibility for updateVisibility()', async () => {
-        const entry = { id: 'know-1', visibility: 'team' };
-        mockJsonResponse(entry);
-        await api().updateVisibility('know-1', 'team');
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
-    });
-});
-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');
-    });
-    it('should GET /skills/resolve with ref only when skill is omitted', async () => {
-        const resolved = { ref: 'acme/skill@v1' };
-        mockJsonResponse(resolved);
-        const result = await api().resolve('acme/skill@v1');
-        expect(result).toEqual(resolved);
-        const [url] = mockFetch.mock.calls[0];
-        expect(url).toContain('/skills/resolve');
-        expect(url).toContain('ref=acme');
-        expect(url).not.toContain('skill=');
-    });
-    it('should GET /skills/{namespace}/{name}/content for getContent()', async () => {
-        mockJsonResponse({ body: '# Skill instructions' });
-        const result = await api().getContent('acme', 'research');
-        expect(result).toEqual({ body: '# Skill instructions' });
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/skills/acme/research/content');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST team_id for transferOwnership()', async () => {
-        const skill = { id: 'skill-1' };
-        mockJsonResponse(skill);
-        await api().transferOwnership('skill-1', 'team-8');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/skills/skill-1/transfer');
-        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-8' });
-    });
-    it('should POST /skills/list for list()', async () => {
-        const page = { items: [{ id: 'skill-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('/skills/list');
-        expect(init.method).toBe('POST');
-    });
-    it('should GET /skills/{id} for get()', async () => {
-        const skill = { id: 'skill-1', name: 'research' };
-        mockJsonResponse(skill);
-        const result = await api().get('skill-1');
-        expect(result).toEqual(skill);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/skills/skill-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST /skills for create()', async () => {
-        const payload = { namespace: 'acme', name: 'research' };
-        const skill = { id: 'skill-new', ...payload };
-        mockJsonResponse(skill);
-        const result = await api().create(payload);
-        expect(result).toEqual(skill);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/skills');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual(payload);
-    });
-    it('should POST /skills/{id} for update()', async () => {
-        const skill = { id: 'skill-1', name: 'updated' };
-        mockJsonResponse(skill);
-        const result = await api().update('skill-1', { name: 'updated' });
-        expect(result).toEqual(skill);
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
-    });
-    it('should DELETE /skills/{id} for delete()', async () => {
-        mockJsonResponse(null);
-        await api().delete('skill-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/skills/skill-1');
-        expect(init.method).toBe('DELETE');
-    });
-    it('should POST /skills/{id}/versions/list for listVersions()', async () => {
-        const page = { items: [{ id: 'ver-1' }], next_cursor: null };
-        mockJsonResponse(page);
-        const result = await api().listVersions('skill-1', { limit: 5 });
-        expect(result).toEqual(page);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/skills/skill-1/versions/list');
-        expect(JSON.parse(init.body)).toEqual({ limit: 5 });
-    });
-    it('should GET /skills/{id}/versions/{versionId} for getVersion()', async () => {
-        const version = { id: 'ver-1', skill_id: 'skill-1' };
-        mockJsonResponse(version);
-        const result = await api().getVersion('skill-1', 'ver-1');
-        expect(result).toEqual(version);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/skills/skill-1/versions/ver-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST visibility for updateVisibility()', async () => {
-        const skill = { id: 'skill-1', visibility: 'team' };
-        mockJsonResponse(skill);
-        await api().updateVisibility('skill-1', 'team');
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
-    });
-});

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

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