@inferencesh/sdk 0.6.8 → 0.6.12

package/dist/http/client.test.js

@@ -1,7 +1,10 @@
 import { HttpClient, createHttpClient } from './client';
 import { InferenceError, RequirementsNotMetException } from './errors';
+import { EventSource } from 'eventsource';
+jest.mock('eventsource');
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
+const MockEventSource = EventSource;
 function mockJsonResponse(body, status = 200, ok = true) {
     mockFetch.mockResolvedValueOnce({
         ok,
@@ -38,17 +41,12 @@ describe('HttpClient', () => {
     describe('request', () => {
         const client = () => new HttpClient({ apiKey: 'test-key' });
         it('should return parsed data on success', async () => {
-            mockJsonResponse({ success: true, data: { id: 'task-1' } });
+            mockJsonResponse({ id: 'task-1' });
             const result = await client().request('get', '/tasks/task-1');
             expect(result).toEqual({ id: 'task-1' });
         });
-        it('should return null when success is true but data field is omitted', async () => {
-            mockJsonResponse({ success: true });
-            const result = await client().request('post', '/tasks/task-1/cancel');
-            expect(result).toBeNull();
-        });
-        it('should return null when success is true with explicit data: null', async () => {
-            mockJsonResponse({ success: true, data: null });
+        it('should return null for null response body', async () => {
+            mockJsonResponse(null);
             const result = await client().request('post', '/tasks/task-1/cancel');
             expect(result).toBeNull();
         });
@@ -61,8 +59,8 @@ describe('HttpClient', () => {
             const result = await client().request('delete', '/tasks/task-1');
             expect(result).toBeUndefined();
         });
-        it('should throw InferenceError when success is false', async () => {
-            mockJsonResponse({ success: false, error: { message: 'Invalid request' } });
+        it('should throw InferenceError on non-ok response', async () => {
+            mockJsonResponse({ message: 'Invalid request' }, 400, false);
             const err = await client().request('get', '/tasks/1').catch((e) => e);
             expect(err).toBeInstanceOf(InferenceError);
             expect(err.message).toContain('Invalid request');
@@ -91,7 +89,7 @@ describe('HttpClient', () => {
                 .mockResolvedValueOnce({
                 ok: true,
                 status: 200,
-                text: () => Promise.resolve(JSON.stringify({ success: true, data: { ok: true } })),
+                text: () => Promise.resolve(JSON.stringify({ ok: true })),
             });
             const result = await httpClient.request('get', '/tasks/1');
             expect(result).toEqual({ ok: true });
@@ -99,7 +97,7 @@ describe('HttpClient', () => {
         });
         it('should route through proxy with x-inf-target-url header', async () => {
             const proxyClient = new HttpClient({ proxyUrl: 'https://proxy.example.com' });
-            mockJsonResponse({ success: true, data: { id: '1' } });
+            mockJsonResponse({ id: '1' });
             await proxyClient.request('get', '/tasks/1');
             expect(mockFetch).toHaveBeenCalledWith('https://proxy.example.com', expect.objectContaining({
                 headers: expect.objectContaining({
@@ -108,7 +106,7 @@ describe('HttpClient', () => {
             }));
         });
         it('should serialize array query params as JSON', async () => {
-            mockJsonResponse({ success: true, data: [] });
+            mockJsonResponse([]);
             await client().request('get', '/tasks', {
                 params: { ids: ['a', 'b'] },
             });
@@ -116,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,
@@ -127,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', () => {
@@ -148,5 +265,171 @@ 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(() => {
+            MockEventSource.mockReset();
+        });
+        it('should attach Bearer token in direct mode via 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' });
+            await client.createEventSource('/tasks/task-1/stream');
+            expect(capturedFetch).toBeDefined();
+            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 sse-key',
+                }),
+            }));
+        });
+        it('should route through proxy with target URL header on custom fetch', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((url, options) => {
+                capturedFetch = options?.fetch;
+                expect(url).toContain('https://proxy.example.com');
+                expect(url).toContain('__inf_target=');
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({ proxyUrl: 'https://proxy.example.com' });
+            await client.createEventSource('/tasks/task-1/stream');
+            await capturedFetch('https://proxy.example.com', { headers: {} });
+            expect(mockFetch).toHaveBeenCalledWith('https://proxy.example.com', expect.objectContaining({
+                headers: expect.objectContaining({
+                    'x-inf-target-url': 'https://api.inference.sh/tasks/task-1/stream',
+                }),
+            }));
+        });
+        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/proxy/express.test.d.ts

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

package/dist/proxy/express.test.js

@@ -0,0 +1,106 @@
+import { INF_TARGET_HEADER } from './index';
+import { createHandler } from './express';
+function createMockResponse() {
+    const res = {
+        statusCode: 200,
+        headers: {},
+        body: undefined,
+        chunks: [],
+        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;
+        },
+        write(chunk) {
+            this.chunks.push(chunk);
+        },
+        end() {
+            return;
+        },
+    };
+    return res;
+}
+describe('express createHandler', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'express-test-key';
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('should return 400 when target URL is missing', async () => {
+        const handler = createHandler();
+        const req = {
+            method: 'POST',
+            body: {},
+            headers: {},
+            query: {},
+        };
+        const res = createMockResponse();
+        await handler(req, res, jest.fn());
+        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 handler = createHandler();
+        const target = 'https://api.inference.sh/v1/run';
+        const req = {
+            method: 'POST',
+            body: { prompt: 'hi' },
+            headers: { [INF_TARGET_HEADER]: target },
+            query: {},
+        };
+        const res = createMockResponse();
+        await handler(req, res, jest.fn());
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toEqual({ ok: true });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer express-test-key',
+            }),
+        }));
+    });
+    it('should stream SSE responses with res.write()', 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 req = {
+            method: 'POST',
+            body: {},
+            headers: { [INF_TARGET_HEADER]: target },
+            query: {},
+        };
+        const res = createMockResponse();
+        await handler(req, res, jest.fn());
+        expect(res.statusCode).toBe(200);
+        expect(res.chunks.length).toBeGreaterThan(0);
+        expect(res.body).toBeUndefined();
+    });
+});

package/dist/proxy/index.test.js

@@ -1,4 +1,4 @@
-import { INF_TARGET_HEADER, INF_TARGET_PARAM, processProxyRequest, } from './index';
+import { INF_TARGET_HEADER, INF_TARGET_PARAM, headersToRecord, processProxyRequest, } from './index';
 function createTestAdapter(overrides = {}) {
     const state = { status: 0 };
     const adapter = {
@@ -26,6 +26,15 @@ function createTestAdapter(overrides = {}) {
     };
     return adapter;
 }
+describe('headersToRecord', () => {
+    it('should convert Headers to a plain record', () => {
+        const headers = new Headers({ 'x-test': 'value', 'content-type': 'application/json' });
+        expect(headersToRecord(headers)).toEqual({
+            'x-test': 'value',
+            'content-type': 'application/json',
+        });
+    });
+});
 describe('processProxyRequest', () => {
     const originalFetch = global.fetch;
     const originalApiKey = process.env.INFERENCE_API_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({