@inferencesh/sdk 0.6.10 → 0.6.13

package/dist/api/knowledge.test.js

@@ -0,0 +1,238 @@
+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.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,98 @@
+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');
+    });
+    it('should GET /mcps/{slug} for get()', async () => {
+        const server = { slug: 'filesystem', name: 'Filesystem MCP' };
+        mockJsonResponse(server);
+        const result = await api().get('filesystem');
+        expect(result).toEqual(server);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcps/filesystem');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /mcp-servers/list for listOwned()', async () => {
+        const page = { items: [{ id: 'mcp-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().listOwned({ limit: 5 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcp-servers/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /mcp-servers/{id} for getOwned()', async () => {
+        const server = { id: 'mcp-1', name: 'My MCP' };
+        mockJsonResponse(server);
+        const result = await api().getOwned('mcp-1');
+        expect(result).toEqual(server);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcp-servers/mcp-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should DELETE /mcp-servers/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('mcp-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/mcp-servers/mcp-1');
+        expect(init.method).toBe('DELETE');
+    });
+});

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

package/dist/api/projects.js

@@ -0,0 +1,38 @@
+/**
+ * Projects API
+ */
+export class ProjectsAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List projects with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/projects/list', { data: params });
+    }
+    /**
+     * Get a project by ID
+     */
+    async get(id) {
+        return this.http.request('get', `/projects/${id}`);
+    }
+    /**
+     * Create a project
+     */
+    async create(data) {
+        return this.http.request('post', '/projects', { data });
+    }
+    /**
+     * Update a project
+     */
+    async update(id, data) {
+        return this.http.request('post', `/projects/${id}`, { data });
+    }
+    /**
+     * Delete a project
+     */
+    async delete(id) {
+        return this.http.request('delete', `/projects/${id}`);
+    }
+}

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

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

package/dist/api/projects.test.js

@@ -0,0 +1,61 @@
+import { HttpClient } from '../http/client';
+import { ProjectsAPI } from './projects';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('ProjectsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new ProjectsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /projects/list for list()', async () => {
+        const page = { items: [{ id: 'proj-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list({ limit: 20 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /projects/{id} for get()', async () => {
+        const project = { id: 'proj-1', name: 'Demo' };
+        mockJsonResponse(project);
+        const result = await api().get('proj-1');
+        expect(result).toEqual(project);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects/proj-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /projects for create()', async () => {
+        const payload = { name: 'New Project' };
+        const project = { id: 'proj-new', ...payload };
+        mockJsonResponse(project);
+        const result = await api().create(payload);
+        expect(result).toEqual(project);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects');
+        expect(init.method).toBe('POST');
+    });
+    it('should DELETE /projects/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('proj-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects/proj-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /projects/{id} for update()', async () => {
+        const project = { id: 'proj-1', name: 'Renamed' };
+        mockJsonResponse(project);
+        const result = await api().update('proj-1', { name: 'Renamed' });
+        expect(result).toEqual(project);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects/proj-1');
+        expect(JSON.parse(init.body)).toEqual({ name: 'Renamed' });
+    });
+});

package/dist/api/search.d.ts

@@ -0,0 +1,21 @@
+import { HttpClient } from '../http/client';
+import { SuggestRequest, SuggestResponse } from '../types';
+/**
+ * Search API
+ */
+export declare class SearchAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Unified search across skills, knowledge, and apps
+     */
+    suggest(params: Partial<SuggestRequest>): Promise<SuggestResponse>;
+    /**
+     * Full-text search via Meilisearch
+     */
+    search(params: {
+        q: string;
+        type?: string;
+        limit?: number;
+    }): Promise<unknown>;
+}

package/dist/api/search.js

@@ -0,0 +1,20 @@
+/**
+ * Search API
+ */
+export class SearchAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Unified search across skills, knowledge, and apps
+     */
+    async suggest(params) {
+        return this.http.request('post', '/suggest', { data: params });
+    }
+    /**
+     * Full-text search via Meilisearch
+     */
+    async search(params) {
+        return this.http.request('post', '/search', { data: params });
+    }
+}

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

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

package/dist/api/search.test.js

@@ -0,0 +1,39 @@
+import { HttpClient } from '../http/client';
+import { SearchAPI } from './search';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('SearchAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new SearchAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /suggest for suggest()', async () => {
+        const payload = { query: 'image gen', types: ['apps', 'skills'] };
+        const response = { results: [{ type: 'app', id: 'app-1' }] };
+        mockJsonResponse(response);
+        const result = await api().suggest(payload);
+        expect(result).toEqual(response);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/suggest');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should POST /search for search()', async () => {
+        const payload = { q: 'claude', type: 'apps', limit: 5 };
+        const response = { hits: [{ id: 'app-1' }] };
+        mockJsonResponse(response);
+        const result = await api().search(payload);
+        expect(result).toEqual(response);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/search');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+});