@inferencesh/sdk 0.6.10 → 0.6.13

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/proxy/hono.test.d.ts

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

package/dist/proxy/hono.test.js

@@ -0,0 +1,90 @@
+import { INF_TARGET_HEADER } from './index';
+import { createHandler } from './hono';
+function createMockContext(overrides = {}) {
+    const headers = new Headers(overrides.headers ?? {});
+    const url = overrides.url ?? 'http://localhost/api/inference/proxy';
+    return {
+        req: {
+            method: overrides.method ?? 'POST',
+            url,
+            raw: { headers },
+            header: (name) => headers.get(name) ?? undefined,
+            text: () => Promise.resolve(overrides.body ?? '{"ok":true}'),
+        },
+    };
+}
+describe('hono createHandler', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'hono-test-key';
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('should return 400 when target URL is missing', async () => {
+        const handler = createHandler();
+        const response = await handler(createMockContext());
+        expect(response.status).toBe(400);
+        expect(await response.json()).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or __inf_target query param`,
+        });
+    });
+    it('should proxy JSON responses', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const handler = createHandler();
+        const target = 'https://api.inference.sh/v1/run';
+        const response = await handler(createMockContext({
+            headers: { [INF_TARGET_HEADER]: target },
+        }));
+        expect(response.status).toBe(200);
+        expect(await response.json()).toEqual({ ok: true });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer hono-test-key',
+            }),
+        }));
+    });
+    it('should passthrough SSE streaming responses', async () => {
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(encoder.encode('data: {"x":1}\n\n'));
+                controller.close();
+            },
+        });
+        global.fetch = jest.fn().mockResolvedValue(new Response(stream, {
+            status: 200,
+            headers: { 'content-type': 'text/event-stream' },
+        }));
+        const handler = createHandler();
+        const target = 'https://api.inference.sh/v1/stream';
+        const response = await handler(createMockContext({
+            headers: { [INF_TARGET_HEADER]: target },
+        }));
+        expect(response.status).toBe(200);
+        expect(response.headers.get('content-type')).toContain('text/event-stream');
+        expect(await response.text()).toContain('data:');
+    });
+    it('should resolve API key via resolveApiKey option', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const handler = createHandler({
+            resolveApiKey: async () => 'custom-hono-key',
+        });
+        const target = 'https://api.inference.sh/v1/run';
+        await handler(createMockContext({
+            headers: { [INF_TARGET_HEADER]: target },
+        }));
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer custom-hono-key',
+            }),
+        }));
+    });
+});

package/dist/proxy/nextjs.test.d.ts

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

package/dist/proxy/nextjs.test.js

@@ -0,0 +1,125 @@
+import { INF_TARGET_HEADER } from './index';
+import { handlers, pageHandler } from './nextjs';
+function createMockPageResponse() {
+    const res = {
+        statusCode: 200,
+        headers: {},
+        body: undefined,
+        status(code) {
+            this.statusCode = code;
+            return this;
+        },
+        setHeader(name, value) {
+            this.headers[name] = value;
+        },
+        json(data) {
+            this.body = data;
+            return this;
+        },
+        send(data) {
+            this.body = data;
+            return this;
+        },
+    };
+    return res;
+}
+function createMockNextRequest(overrides = {}) {
+    const headers = new Headers(overrides.headers ?? {});
+    return {
+        method: overrides.method ?? 'POST',
+        url: overrides.url ?? 'http://localhost/api/inference/proxy',
+        headers,
+        text: () => Promise.resolve(overrides.body ?? '{"prompt":"hi"}'),
+    };
+}
+describe('nextjs pageHandler', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'nextjs-test-key';
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('should return 400 when target URL is missing', async () => {
+        const req = { method: 'POST', body: {}, headers: {}, query: {} };
+        const res = createMockPageResponse();
+        await pageHandler(req, res);
+        expect(res.statusCode).toBe(400);
+        expect(res.body).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or __inf_target query param`,
+        });
+    });
+    it('should proxy JSON responses through res.json()', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const target = 'https://api.inference.sh/v1/run';
+        const req = {
+            method: 'POST',
+            body: { prompt: 'hi' },
+            headers: { [INF_TARGET_HEADER]: target },
+            query: {},
+        };
+        const res = createMockPageResponse();
+        await pageHandler(req, res);
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toEqual({ ok: true });
+    });
+    it('should proxy non-JSON responses through res.send()', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response('plain text', {
+            status: 200,
+            headers: { 'content-type': 'text/plain' },
+        }));
+        const target = 'https://api.inference.sh/v1/run';
+        const req = {
+            method: 'POST',
+            body: {},
+            headers: { [INF_TARGET_HEADER]: target },
+            query: {},
+        };
+        const res = createMockPageResponse();
+        await pageHandler(req, res);
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toBe('plain text');
+    });
+});
+describe('nextjs handlers (App Router)', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'nextjs-test-key';
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('should return 400 when target URL is missing', async () => {
+        const response = await handlers.GET(createMockNextRequest());
+        expect(response.status).toBe(400);
+        expect(await response.json()).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or __inf_target query param`,
+        });
+    });
+    it('should passthrough streaming responses via Response body', async () => {
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(encoder.encode('data: {"x":1}\n\n'));
+                controller.close();
+            },
+        });
+        global.fetch = jest.fn().mockResolvedValue(new Response(stream, {
+            status: 200,
+            headers: { 'content-type': 'text/event-stream' },
+        }));
+        const target = 'https://api.inference.sh/v1/stream';
+        const response = await handlers.GET(createMockNextRequest({
+            method: 'GET',
+            headers: { [INF_TARGET_HEADER]: target },
+        }));
+        expect(response.status).toBe(200);
+        expect(response.body).toBeDefined();
+        expect(response.headers.get('content-type')).toContain('text/event-stream');
+    });
+});

package/dist/proxy/remix.test.d.ts

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

package/dist/proxy/remix.test.js

@@ -0,0 +1,66 @@
+import { INF_TARGET_HEADER } from './index';
+import { createHandler } from './remix';
+describe('remix createHandler', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'remix-test-key';
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('should return 400 when target URL is missing', async () => {
+        const handler = createHandler();
+        const request = new Request('http://localhost/api/inference/proxy', {
+            method: 'POST',
+            body: '{}',
+        });
+        const response = await handler({ request });
+        expect(response.status).toBe(400);
+        expect(await response.json()).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or __inf_target query param`,
+        });
+    });
+    it('should proxy JSON responses with framework remix', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const target = 'https://api.inference.sh/v1/run';
+        const handler = createHandler();
+        const request = new Request('http://localhost/api/inference/proxy', {
+            method: 'POST',
+            headers: { [INF_TARGET_HEADER]: target },
+            body: '{"prompt":"hi"}',
+        });
+        const response = await handler({ request });
+        expect(response.status).toBe(200);
+        expect(await response.json()).toEqual({ ok: true });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer remix-test-key',
+            }),
+        }));
+    });
+    it('should use custom resolveApiKey when provided', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const handler = createHandler({
+            resolveApiKey: async () => 'custom-remix-key',
+        });
+        const target = 'https://api.inference.sh/v1/run';
+        const request = new Request('http://localhost/api/inference/proxy', {
+            method: 'POST',
+            headers: { [INF_TARGET_HEADER]: target },
+            body: '{}',
+        });
+        await handler({ request });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer custom-remix-key',
+            }),
+        }));
+    });
+});

package/dist/proxy/svelte.test.d.ts

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

package/dist/proxy/svelte.test.js

@@ -0,0 +1,69 @@
+import { INF_TARGET_HEADER } from './index';
+import { createHandler } from './svelte';
+function createMockRequestEvent(request) {
+    return { request };
+}
+describe('svelte createHandler', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'svelte-test-key';
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('should return 400 when target URL is missing', async () => {
+        const handler = createHandler();
+        const request = new Request('http://localhost/api/inference/proxy', {
+            method: 'POST',
+            body: '{}',
+        });
+        const response = await handler(createMockRequestEvent(request));
+        expect(response.status).toBe(400);
+        expect(await response.json()).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or __inf_target query param`,
+        });
+    });
+    it('should proxy JSON responses with framework sveltekit', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const target = 'https://api.inference.sh/v1/run';
+        const handler = createHandler();
+        const request = new Request('http://localhost/api/inference/proxy', {
+            method: 'POST',
+            headers: { [INF_TARGET_HEADER]: target },
+            body: '{"prompt":"hi"}',
+        });
+        const response = await handler(createMockRequestEvent(request));
+        expect(response.status).toBe(200);
+        expect(await response.json()).toEqual({ ok: true });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer svelte-test-key',
+            }),
+        }));
+    });
+    it('should use custom resolveApiKey when provided', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const handler = createHandler({
+            resolveApiKey: async () => 'custom-svelte-key',
+        });
+        const target = 'https://api.inference.sh/v1/run';
+        const request = new Request('http://localhost/api/inference/proxy', {
+            method: 'POST',
+            headers: { [INF_TARGET_HEADER]: target },
+            body: '{}',
+        });
+        await handler(createMockRequestEvent(request));
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer custom-svelte-key',
+            }),
+        }));
+    });
+});

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({