@inferencesh/sdk 0.6.12 → 0.6.13

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferencesh/sdk",
-  "version": "0.6.12",
+  "version": "0.6.13",
   "description": "Official JavaScript/TypeScript SDK for inference.sh - Run AI models with a simple API",
   "type": "module",
   "main": "dist/index.js",
@@ -89,7 +89,7 @@
     "@sveltejs/kit": "^2.60.1",
     "svelte": "^5.55.7",
     "@types/express": "^5.0.0",
-    "@types/jest": "^29.5.12",
+    "@types/jest": "^30.0.0",
     "@types/node": "^24.1.0",
     "@types/react": "^19.1.12",
     "@typescript-eslint/eslint-plugin": "^8.38.0",
@@ -97,7 +97,7 @@
     "eslint": "^9.32.0",
     "eslint-config-prettier": "^10.1.8",
     "hono": "^4.0.0",
-    "jest": "^29.7.0",
+    "jest": "^30.4.2",
     "next": "^16.2.6",
     "prettier": "^3.6.2",
     "react": "^19.2.3",