@inferencesh/sdk 0.6.10 → 0.6.12

package/dist/api/teams.test.js

@@ -0,0 +1,79 @@
+import { HttpClient } from '../http/client';
+import { TeamsAPI } from './teams';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('TeamsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new TeamsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should GET /me for me()', async () => {
+        const me = { user: { id: 'user-1' }, team: { id: 'team-1' } };
+        mockJsonResponse(me);
+        const result = await api().me();
+        expect(result).toEqual(me);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/me');
+        expect(init.method).toBe('GET');
+    });
+    it('should GET /teams for list()', async () => {
+        const teams = [{ id: 'team-1', name: 'Acme' }];
+        mockJsonResponse(teams);
+        const result = await api().list();
+        expect(result).toEqual(teams);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /teams for create()', async () => {
+        const payload = { name: 'New Team', username: 'new-team' };
+        const team = { id: 'team-new', ...payload };
+        mockJsonResponse(team);
+        const result = await api().create(payload);
+        expect(result).toEqual(team);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should GET /teams/check-username with username param for checkUsername()', async () => {
+        mockJsonResponse({ available: true });
+        const result = await api().checkUsername('acme-corp');
+        expect(result).toEqual({ available: true });
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/check-username');
+        expect(url).toContain('username=acme-corp');
+    });
+    it('should POST role for updateMemberRole()', async () => {
+        const member = { user_id: 'user-2', role: 'admin' };
+        mockJsonResponse(member);
+        await api().updateMemberRole('team-1', 'user-2', 'admin');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/members/user-2/role');
+        expect(JSON.parse(init.body)).toEqual({ role: 'admin' });
+    });
+    it('should DELETE /teams/{id}/members/{userId} for removeMember()', async () => {
+        mockJsonResponse(null);
+        await api().removeMember('team-1', 'user-3');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/members/user-3');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /teams/{id}/invites for createInvite()', async () => {
+        const payload = { email: 'dev@example.com', role: 'member' };
+        const invite = { id: 'inv-1', ...payload };
+        mockJsonResponse(invite);
+        const result = await api().createInvite('team-1', payload);
+        expect(result).toEqual(invite);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/invites');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+});

package/dist/http/client.d.ts

@@ -84,6 +84,11 @@ export declare class HttpClient {
         url: string;
         headers: Record<string, string>;
     };
+    /**
+     * Pull a human-readable detail string from a parsed problem+json / API error
+     * body (RFC 9457 `detail`/`title`, or a plain `message`).
+     */
+    private extractErrorDetail;
     /**
      * Create an EventSource for SSE streaming
      * @deprecated Use getStreamableConfig() with StreamableManager instead

package/dist/http/client.js

@@ -128,7 +128,7 @@ export class HttpClient {
             }
             let errorDetail;
             if (data && typeof data === 'object') {
-                errorDetail = data.detail || data.title || data.message || JSON.stringify(data);
+                errorDetail = this.extractErrorDetail(data) ?? JSON.stringify(data);
             }
             else if (responseText) {
                 errorDetail = responseText.slice(0, 500);
@@ -164,6 +164,16 @@ export class HttpClient {
         }
         return { url, headers };
     }
+    /**
+     * Pull a human-readable detail string from a parsed problem+json / API error
+     * body (RFC 9457 `detail`/`title`, or a plain `message`).
+     */
+    extractErrorDetail(data) {
+        if (!data || typeof data !== 'object')
+            return undefined;
+        const d = data;
+        return (d.detail || d.title || d.message);
+    }
     /**
      * Create an EventSource for SSE streaming
      * @deprecated Use getStreamableConfig() with StreamableManager instead
@@ -183,30 +193,39 @@ export class HttpClient {
             fetchUrl = targetUrl.toString();
         }
         const resolvedHeaders = this.resolveHeaders();
-        return Promise.resolve(new EventSource(fetchUrl, {
-            fetch: (input, init) => {
-                const headers = {
-                    ...init?.headers,
-                    ...resolvedHeaders,
-                };
-                if (isProxyMode) {
-                    // Proxy mode: also send target URL as header (for non-browser clients)
-                    headers['x-inf-target-url'] = targetUrl.toString();
+        // The EventSource error event omits the response body, so a failed initial
+        // connection (e.g. 403 otp_required) is handled here in the fetch wrapper:
+        // route it through onError like request() does, and hand the retried
+        // response (e.g. after OTP verification) back so the stream connects.
+        const doFetch = async (input, init) => {
+            const headers = {
+                ...init?.headers,
+                ...resolvedHeaders,
+            };
+            if (isProxyMode) {
+                headers['x-inf-target-url'] = targetUrl.toString();
+            }
+            else {
+                const token = this.getAuthToken();
+                if (token) {
+                    headers['Authorization'] = `Bearer ${token}`;
                 }
-                else {
-                    // Direct mode: include authorization header
-                    const token = this.getAuthToken();
-                    if (token) {
-                        headers['Authorization'] = `Bearer ${token}`;
-                    }
+            }
+            const response = await fetch(input, { ...init, headers, credentials: this.credentials });
+            if (!response.ok && this.onError) {
+                const body = await response.clone().text().catch(() => '');
+                let data;
+                try {
+                    data = JSON.parse(body);
                 }
-                return fetch(input, {
-                    ...init,
-                    headers,
-                    credentials: this.credentials,
-                });
-            },
-        }));
+                catch { /* non-JSON body */ }
+                const error = new InferenceError(response.status, this.extractErrorDetail(data) ?? 'Request failed', body);
+                const handled = await this.onError(error, () => doFetch(input, init));
+                return handled ?? response;
+            }
+            return response;
+        };
+        return Promise.resolve(new EventSource(fetchUrl, { fetch: doFetch }));
     }
 }
 /**

package/dist/http/client.test.js

@@ -114,6 +114,32 @@ describe('HttpClient', () => {
             expect(calledUrl).toContain('ids=');
             expect(decodeURIComponent(calledUrl)).toContain('["a","b"]');
         });
+        it('should serialize object query params as JSON', async () => {
+            mockJsonResponse([]);
+            await client().request('get', '/tasks', {
+                params: { filter: { status: 'active', team_id: 'team-1' } },
+            });
+            const calledUrl = mockFetch.mock.calls[0][0];
+            expect(calledUrl).toContain('filter=');
+            expect(decodeURIComponent(calledUrl)).toContain('"status":"active"');
+            expect(decodeURIComponent(calledUrl)).toContain('"team_id":"team-1"');
+        });
+        it('should omit Authorization when getToken returns null', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            const tokenClient = new HttpClient({ getToken: () => null });
+            await tokenClient.request('get', '/tasks/task-1');
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers.Authorization).toBeUndefined();
+        });
+        it('should omit Authorization when getToken returns undefined', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            const tokenClient = new HttpClient({ getToken: () => undefined });
+            await tokenClient.request('get', '/tasks/task-1');
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers.Authorization).toBeUndefined();
+        });
         it('should use top-level message field in HTTP error responses', async () => {
             mockFetch.mockResolvedValueOnce({
                 ok: false,
@@ -125,6 +151,99 @@ describe('HttpClient', () => {
                 message: expect.stringContaining('service unavailable'),
             });
         });
+        it('should use getToken for Authorization on regular requests', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            const tokenClient = new HttpClient({ getToken: () => 'dynamic-key' });
+            await tokenClient.request('get', '/tasks/task-1');
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers.Authorization).toBe('Bearer dynamic-key');
+        });
+        it('should resolve function-valued headers on each request', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            mockJsonResponse({ id: 'task-2' });
+            let teamId = 'team-a';
+            const client = new HttpClient({
+                apiKey: 'test-key',
+                headers: {
+                    'X-Team-ID': () => teamId,
+                    'X-Request-Id': () => 'req-1',
+                },
+            });
+            await client.request('get', '/tasks/task-1');
+            teamId = 'team-b';
+            await client.request('get', '/tasks/task-2');
+            const firstHeaders = mockFetch.mock.calls[0][1]?.headers;
+            const secondHeaders = mockFetch.mock.calls[1][1]?.headers;
+            expect(firstHeaders['X-Team-ID']).toBe('team-a');
+            expect(secondHeaders['X-Team-ID']).toBe('team-b');
+            expect(firstHeaders['X-Request-Id']).toBe('req-1');
+        });
+        it('should omit headers when a resolver returns undefined', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            const client = new HttpClient({
+                apiKey: 'test-key',
+                headers: {
+                    'X-Team-ID': () => undefined,
+                    'X-Custom': 'static',
+                },
+            });
+            await client.request('get', '/tasks/task-1');
+            const headers = mockFetch.mock.calls[0][1]?.headers;
+            expect(headers['X-Team-ID']).toBeUndefined();
+            expect(headers['X-Custom']).toBe('static');
+        });
+        it('should send X-API-Version 2 and X-Client-Source on every request', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            await client().request('get', '/tasks/task-1');
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers['X-API-Version']).toBe('2');
+            expect(headers['X-Client-Source']).toMatch(/inference-sdk-js\//);
+        });
+        it('should prefer RFC 9457 detail over title in error responses', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 422,
+                text: () => Promise.resolve(JSON.stringify({
+                    type: 'about:blank',
+                    title: 'Validation failed',
+                    detail: 'app field is required',
+                })),
+            });
+            await expect(client().request('post', '/apps')).rejects.toMatchObject({
+                name: 'InferenceError',
+                message: expect.stringContaining('app field is required'),
+            });
+        });
+        it('should fall back to RFC 9457 title when detail is absent', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 403,
+                text: () => Promise.resolve(JSON.stringify({ type: 'about:blank', title: 'Forbidden' })),
+            });
+            await expect(client().request('get', '/tasks/1')).rejects.toMatchObject({
+                name: 'InferenceError',
+                message: expect.stringContaining('Forbidden'),
+            });
+        });
+        it('should use raw response text when error body is not JSON', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 502,
+                text: () => Promise.resolve('Bad Gateway from upstream'),
+            });
+            await expect(client().request('get', '/tasks/1')).rejects.toMatchObject({
+                name: 'InferenceError',
+                message: expect.stringContaining('Bad Gateway from upstream'),
+            });
+        });
+        it('should not unwrap legacy v1 APIResponse envelopes', async () => {
+            const v1Envelope = { success: true, data: { id: 'task-legacy' } };
+            mockJsonResponse(v1Envelope);
+            const result = await client().request('get', '/tasks/legacy');
+            expect(result).toEqual(v1Envelope);
+        });
     });
     describe('getStreamableConfig', () => {
         it('should include bearer token in direct mode', () => {
@@ -146,6 +265,14 @@ describe('HttpClient', () => {
             }).getStreamableConfig('/tasks/task-1/stream');
             expect(config.headers.Authorization).toBe('Bearer dynamic-token');
         });
+        it('should include resolved dynamic headers for streaming requests', () => {
+            const config = new HttpClient({
+                apiKey: 'secret-key',
+                headers: { 'X-Team-ID': () => 'team-stream' },
+            }).getStreamableConfig('/tasks/task-1/stream');
+            expect(config.headers['X-Team-ID']).toBe('team-stream');
+            expect(config.headers.Authorization).toBe('Bearer secret-key');
+        });
     });
     describe('createEventSource', () => {
         beforeEach(() => {
@@ -186,5 +313,123 @@ describe('HttpClient', () => {
                 }),
             }));
         });
+        it('should attach resolved dynamic headers on SSE custom fetch', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({
+                apiKey: 'sse-key',
+                headers: { 'X-Team-ID': () => 'team-sse' },
+            });
+            await client.createEventSource('/tasks/task-1/stream');
+            await capturedFetch('https://api.inference.sh/tasks/task-1/stream', { headers: {} });
+            expect(mockFetch).toHaveBeenCalledWith('https://api.inference.sh/tasks/task-1/stream', expect.objectContaining({
+                headers: expect.objectContaining({
+                    'X-Team-ID': 'team-sse',
+                    Authorization: 'Bearer sse-key',
+                }),
+            }));
+        });
+        it('should use getToken for Authorization on SSE custom fetch', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({ getToken: () => 'session-token' });
+            await client.createEventSource('/tasks/task-1/stream');
+            await capturedFetch('https://api.inference.sh/tasks/task-1/stream', { headers: {} });
+            expect(mockFetch).toHaveBeenCalledWith('https://api.inference.sh/tasks/task-1/stream', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer session-token',
+                }),
+            }));
+        });
+        it('should omit Authorization on SSE fetch when getToken returns null', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({ getToken: () => null });
+            await client.createEventSource('/tasks/task-1/stream');
+            await capturedFetch('https://api.inference.sh/tasks/task-1/stream', { headers: {} });
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers.Authorization).toBeUndefined();
+        });
+        it('should return EventSource without awaiting the initial fetch', async () => {
+            MockEventSource.mockImplementation(() => ({ close: jest.fn() }));
+            const client = new HttpClient({ apiKey: 'sse-key' });
+            const eventSource = await client.createEventSource('/tasks/task-1/stream');
+            expect(eventSource).toBeDefined();
+            expect(MockEventSource).toHaveBeenCalled();
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
+        function mockFailedResponse(status, body) {
+            return {
+                ok: false,
+                status,
+                clone: () => ({
+                    text: () => Promise.resolve(body),
+                }),
+            };
+        }
+        it('should route failed initial SSE response through onError and return retried response', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            const onError = jest.fn(async (_error, retry) => retry());
+            const client = new HttpClient({ apiKey: 'sse-key', onError });
+            mockFetch
+                .mockResolvedValueOnce(mockFailedResponse(403, JSON.stringify({ detail: 'otp_required' })))
+                .mockResolvedValueOnce({ ok: true, status: 200 });
+            await client.createEventSource('/tasks/task-1/stream');
+            const response = await capturedFetch('https://api.inference.sh/tasks/task-1/stream', {});
+            expect(onError).toHaveBeenCalledTimes(1);
+            const [error] = onError.mock.calls[0];
+            expect(error).toBeInstanceOf(InferenceError);
+            expect(error.statusCode).toBe(403);
+            expect(error.message).toContain('otp_required');
+            expect(response).toEqual({ ok: true, status: 200 });
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
+        it('should return original failed response when onError does not retry', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            const failed = mockFailedResponse(401, JSON.stringify({ title: 'Unauthorized' }));
+            const onError = jest.fn(async () => undefined);
+            const client = new HttpClient({ apiKey: 'sse-key', onError });
+            mockFetch.mockResolvedValueOnce(failed);
+            await client.createEventSource('/tasks/task-1/stream');
+            const response = await capturedFetch('https://api.inference.sh/tasks/task-1/stream', {});
+            expect(onError).toHaveBeenCalledTimes(1);
+            expect(response).toBe(failed);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
+        it('should return failed response when no onError handler is configured', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            const failed = mockFailedResponse(503, 'service unavailable');
+            const client = new HttpClient({ apiKey: 'sse-key' });
+            mockFetch.mockResolvedValueOnce(failed);
+            await client.createEventSource('/tasks/task-1/stream');
+            const response = await capturedFetch('https://api.inference.sh/tasks/task-1/stream', {});
+            expect(response).toBe(failed);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
     });
 });

package/dist/http/errors.test.js

@@ -1,4 +1,5 @@
 import { InferenceError, RequirementsNotMetException, SessionEndedError, SessionExpiredError, SessionNotFoundError, WorkerLostError, isInferenceError, isRequirementsNotMetException, isSessionError, } from './errors';
+import { RequirementTypeIntegration, RequirementTypeScope, RequirementTypeSecret, } from '../types';
 describe('error type guards', () => {
     it('isRequirementsNotMetException should match instances and plain objects', () => {
         const instance = new RequirementsNotMetException([
@@ -43,6 +44,18 @@ describe('error classes', () => {
         expect(err.statusCode).toBe(412);
         expect(err.message).toBe('requirements not met');
     });
+    it('RequirementsNotMetException should preserve typed RequirementType values', () => {
+        const errors = [
+            { type: RequirementTypeSecret, key: 'API_KEY', message: 'Missing secret' },
+            { type: RequirementTypeIntegration, key: 'google', message: 'Not connected' },
+            { type: RequirementTypeScope, key: 'calendar.readonly', message: 'Missing scope' },
+        ];
+        const err = new RequirementsNotMetException(errors);
+        expect(err.errors[0].type).toBe('secret');
+        expect(err.errors[1].type).toBe('integration');
+        expect(err.errors[2].type).toBe('scope');
+        expect(isRequirementsNotMetException(err)).toBe(true);
+    });
     it('session error subclasses should expose sessionId and statusCode', () => {
         expect(new SessionNotFoundError('sess-a').sessionId).toBe('sess-a');
         expect(new SessionNotFoundError('sess-a').statusCode).toBe(404);

package/dist/index.d.ts

@@ -12,6 +12,14 @@ export { ChatsAPI } from './api/chats';
 export { FlowsAPI } from './api/flows';
 export { FlowRunsAPI } from './api/flow-runs';
 export { EnginesAPI } from './api/engines';
+export { KnowledgeAPI, SkillsAPI } from './api/knowledge';
+export { TeamsAPI, MeResponse } from './api/teams';
+export { SecretsAPI } from './api/secrets';
+export { ApiKeysAPI } from './api/api-keys';
+export { IntegrationsAPI } from './api/integrations';
+export { SearchAPI } from './api/search';
+export { ProjectsAPI } from './api/projects';
+export { MCPServersAPI } from './api/mcp-servers';
 export { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
 export type { ClientTool, ClientToolHandler } from './tool-builder';
 export { parseStatus, isTerminalStatus } from './utils';
@@ -27,6 +35,14 @@ import { ChatsAPI } from './api/chats';
 import { FlowsAPI } from './api/flows';
 import { FlowRunsAPI } from './api/flow-runs';
 import { EnginesAPI } from './api/engines';
+import { KnowledgeAPI, SkillsAPI } from './api/knowledge';
+import { TeamsAPI } from './api/teams';
+import { SecretsAPI } from './api/secrets';
+import { ApiKeysAPI } from './api/api-keys';
+import { IntegrationsAPI } from './api/integrations';
+import { SearchAPI } from './api/search';
+import { ProjectsAPI } from './api/projects';
+import { MCPServersAPI } from './api/mcp-servers';
 import { ApiAppRunRequest, TaskDTO as Task, AgentConfigInput as AgentConfig, FileDTO as File } from './types';
 export interface InferenceConfig {
     /** Your inference.sh API key (required unless using proxyUrl) */
@@ -68,6 +84,15 @@ export declare class Inference {
     readonly flows: FlowsAPI;
     readonly flowRuns: FlowRunsAPI;
     readonly engines: EnginesAPI;
+    readonly knowledge: KnowledgeAPI;
+    readonly skills: SkillsAPI;
+    readonly teams: TeamsAPI;
+    readonly secrets: SecretsAPI;
+    readonly apiKeys: ApiKeysAPI;
+    readonly integrations: IntegrationsAPI;
+    readonly search: SearchAPI;
+    readonly projects: ProjectsAPI;
+    readonly mcpServers: MCPServersAPI;
     constructor(config: InferenceConfig | HttpClientConfig);
     /** @internal */
     _request<T>(method: 'get' | 'post' | 'put' | 'delete', endpoint: string, options?: {

package/dist/index.js

@@ -16,6 +16,14 @@ export { ChatsAPI } from './api/chats';
 export { FlowsAPI } from './api/flows';
 export { FlowRunsAPI } from './api/flow-runs';
 export { EnginesAPI } from './api/engines';
+export { KnowledgeAPI, SkillsAPI } from './api/knowledge';
+export { TeamsAPI } from './api/teams';
+export { SecretsAPI } from './api/secrets';
+export { ApiKeysAPI } from './api/api-keys';
+export { IntegrationsAPI } from './api/integrations';
+export { SearchAPI } from './api/search';
+export { ProjectsAPI } from './api/projects';
+export { MCPServersAPI } from './api/mcp-servers';
 // Tool Builder (fluent API)
 export { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
 // Status utilities (handle both int and string status values)
@@ -35,6 +43,14 @@ import { ChatsAPI } from './api/chats';
 import { FlowsAPI } from './api/flows';
 import { FlowRunsAPI } from './api/flow-runs';
 import { EnginesAPI } from './api/engines';
+import { KnowledgeAPI, SkillsAPI } from './api/knowledge';
+import { TeamsAPI } from './api/teams';
+import { SecretsAPI } from './api/secrets';
+import { ApiKeysAPI } from './api/api-keys';
+import { IntegrationsAPI } from './api/integrations';
+import { SearchAPI } from './api/search';
+import { ProjectsAPI } from './api/projects';
+import { MCPServersAPI } from './api/mcp-servers';
 /**
  * Inference.sh SDK Client
  *
@@ -67,6 +83,15 @@ export class Inference {
         this.flows = new FlowsAPI(this.http);
         this.flowRuns = new FlowRunsAPI(this.http);
         this.engines = new EnginesAPI(this.http);
+        this.knowledge = new KnowledgeAPI(this.http);
+        this.skills = new SkillsAPI(this.http);
+        this.teams = new TeamsAPI(this.http);
+        this.secrets = new SecretsAPI(this.http);
+        this.apiKeys = new ApiKeysAPI(this.http);
+        this.integrations = new IntegrationsAPI(this.http);
+        this.search = new SearchAPI(this.http);
+        this.projects = new ProjectsAPI(this.http);
+        this.mcpServers = new MCPServersAPI(this.http);
     }
     // Legacy methods for backward compatibility
     /** @internal */

package/dist/tool-builder.test.js

@@ -1,5 +1,5 @@
 import { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
-import { ToolTypeClient, ToolTypeApp, ToolTypeAgent, ToolTypeHook, ToolTypeHTTP, ToolTypeMCP, IntegrationProviderGoogle, } from './types';
+import { ToolTypeClient, ToolTypeApp, ToolTypeAgent, ToolTypeHook, ToolTypeHTTP, ToolTypeMCP, IntegrationProviderGoogle, IntegrationProviderGoogleSA, } from './types';
 describe('Schema Helpers', () => {
     describe('string', () => {
         it('creates string schema without description', () => {
@@ -276,6 +276,16 @@ describe('HTTPToolBuilder (httpTool)', () => {
             integration_id: 'int-123',
         });
     });
+    it('should attach integration auth for google-sa service account provider', () => {
+        const t = httpTool('calendar_read', 'https://api.example.com/calendar')
+            .auth({ integration: IntegrationProviderGoogleSA, integrationId: 'sa-int-1' })
+            .build();
+        expect(t.http?.auth).toEqual({
+            type: 'integration',
+            provider: IntegrationProviderGoogleSA,
+            integration_id: 'sa-int-1',
+        });
+    });
     it('should attach api key auth with default header', () => {
         const t = httpTool('fetch', 'https://api.example.com').auth({ apiKey: 'KEY' }).build();
         expect(t.http?.auth).toEqual({