@inferencesh/sdk 0.6.14 → 0.6.19

package/dist/proxy/express.test.js

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

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

package/dist/proxy/hono.test.js

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

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

package/dist/proxy/index.test.js

@@ -1,173 +0,0 @@
-import { INF_TARGET_HEADER, INF_TARGET_PARAM, headersToRecord, processProxyRequest, } from './index';
-function createTestAdapter(overrides = {}) {
-    const state = { status: 0 };
-    const adapter = {
-        framework: 'test',
-        method: 'POST',
-        body: async () => '{"ok":true}',
-        headers: () => ({}),
-        header: () => undefined,
-        query: () => undefined,
-        setHeader: (name, value) => {
-            state.headers = state.headers ?? {};
-            state.headers[name] = value;
-        },
-        error: (status, message) => {
-            state.status = status;
-            state.body = message;
-            return state;
-        },
-        respond: async (response) => {
-            state.status = response.status;
-            state.body = await response.text();
-            return state;
-        },
-        ...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;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        process.env.INFERENCE_API_KEY = 'env-test-key';
-        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
-            status: 200,
-            headers: { 'content-type': 'application/json' },
-        }));
-    });
-    afterEach(() => {
-        global.fetch = originalFetch;
-        if (originalApiKey === undefined) {
-            delete process.env.INFERENCE_API_KEY;
-        }
-        else {
-            process.env.INFERENCE_API_KEY = originalApiKey;
-        }
-    });
-    it('should reject requests without a target URL', async () => {
-        const result = await processProxyRequest(createTestAdapter());
-        expect(result.status).toBe(400);
-        expect(result.body).toEqual({
-            error: `Missing ${INF_TARGET_HEADER} header or ${INF_TARGET_PARAM} query param`,
-        });
-        expect(global.fetch).not.toHaveBeenCalled();
-    });
-    it('should reject invalid target URLs', async () => {
-        const result = await processProxyRequest(createTestAdapter({
-            header: (name) => (name === INF_TARGET_HEADER ? 'not-a-url' : undefined),
-        }));
-        expect(result.status).toBe(400);
-        expect(result.body).toEqual({ error: 'Invalid target URL' });
-        expect(global.fetch).not.toHaveBeenCalled();
-    });
-    it('should reject non-inference.sh domains', async () => {
-        const result = await processProxyRequest(createTestAdapter({
-            header: (name) => name === INF_TARGET_HEADER ? 'https://evil.example.com/run' : undefined,
-        }));
-        expect(result.status).toBe(412);
-        expect(result.body).toEqual({
-            error: 'Target must be an inference.sh domain, got: evil.example.com',
-        });
-        expect(global.fetch).not.toHaveBeenCalled();
-    });
-    it('should reject when no API key is configured', async () => {
-        delete process.env.INFERENCE_API_KEY;
-        const result = await processProxyRequest(createTestAdapter({
-            header: (name) => name === INF_TARGET_HEADER ? 'https://api.inference.sh/run' : undefined,
-        }));
-        expect(result.status).toBe(401);
-        expect(result.body).toEqual({
-            error: 'Missing INFERENCE_API_KEY environment variable',
-        });
-        expect(global.fetch).not.toHaveBeenCalled();
-    });
-    it('should proxy valid inference.sh requests with env API key', async () => {
-        const target = 'https://api.inference.sh/v1/tasks/1';
-        const result = await processProxyRequest(createTestAdapter({
-            header: (name) => (name === INF_TARGET_HEADER ? target : undefined),
-        }));
-        expect(result.status).toBe(200);
-        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
-            method: 'POST',
-            headers: expect.objectContaining({
-                authorization: 'Bearer env-test-key',
-                'x-inf-proxy': '@inferencesh/sdk-proxy/test',
-            }),
-        }));
-    });
-    it('should prefer client Authorization header over env API key', async () => {
-        const target = 'https://api.inference.sh/v1/tasks/1';
-        await processProxyRequest(createTestAdapter({
-            header: (name) => {
-                if (name === INF_TARGET_HEADER)
-                    return target;
-                if (name === 'authorization')
-                    return 'Bearer client-session-token';
-                return undefined;
-            },
-        }));
-        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
-            headers: expect.objectContaining({
-                authorization: 'Bearer client-session-token',
-            }),
-        }));
-    });
-    it('should use query param fallback when header is missing (SSE clients)', async () => {
-        const target = 'https://api.inference.sh/v1/stream';
-        const encoded = encodeURIComponent(target);
-        await processProxyRequest(createTestAdapter({
-            query: (name) => (name === INF_TARGET_PARAM ? encoded : undefined),
-        }));
-        expect(global.fetch).toHaveBeenCalledWith(target, expect.any(Object));
-    });
-    it('should honor custom allowedDomains', async () => {
-        const target = 'https://cdn.custom.example/upload';
-        await processProxyRequest(createTestAdapter({
-            header: (name) => (name === INF_TARGET_HEADER ? target : undefined),
-        }), { apiKey: 'custom-key', allowedDomains: [/custom\.example$/] });
-        expect(global.fetch).toHaveBeenCalledWith(target, expect.any(Object));
-    });
-    it('should forward x-inf-* request headers to upstream', async () => {
-        const target = 'https://api.inference.sh/run';
-        await processProxyRequest(createTestAdapter({
-            header: (name) => {
-                if (name === INF_TARGET_HEADER)
-                    return target;
-                if (name === 'x-inf-session-id')
-                    return 'sess-123';
-                return undefined;
-            },
-            headers: () => ({
-                [INF_TARGET_HEADER]: target,
-                'x-inf-session-id': 'sess-123',
-            }),
-        }), { apiKey: 'key' });
-        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
-            headers: expect.objectContaining({
-                'x-inf-session-id': 'sess-123',
-            }),
-        }));
-    });
-    it('should omit body for GET requests', async () => {
-        const target = 'https://api.inference.sh/tasks/1';
-        await processProxyRequest(createTestAdapter({
-            method: 'GET',
-            header: (name) => (name === INF_TARGET_HEADER ? target : undefined),
-        }), { apiKey: 'key' });
-        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
-            method: 'GET',
-            body: undefined,
-        }));
-    });
-});

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

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

package/dist/proxy/nextjs.test.js

@@ -1,125 +0,0 @@
-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

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

package/dist/proxy/remix.test.js

@@ -1,66 +0,0 @@
-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

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

package/dist/proxy/svelte.test.js

@@ -1,69 +0,0 @@
-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/sessions.integration.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Sessions integration tests for @inferencesh/sdk
- *
- * These tests hit the real API and require INFERENCE_API_KEY to be set.
- * Run with: npm run test:integration
- *
- * Prerequisites:
- *   - API and scheduler must be running
- *   - Test app deployed: infsh/session-test
- *
- * @jest-environment node
- */
-export {};