@inferencesh/sdk 0.4.4 → 0.4.8

package/dist/proxy/index.test.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+// Store original fetch
+const originalFetch = global.fetch;
+describe('Proxy Core', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    /**
+     * Helper to create a mock ProxyBehavior for testing
+     */
+    function createMockBehavior(overrides = {}) {
+        const responseHeaders = {};
+        const headers = {
+            [index_1.TARGET_URL_HEADER]: 'https://api.inference.sh/apps/run',
+            'content-type': 'application/json',
+        };
+        return {
+            id: 'test',
+            method: 'POST',
+            responseHeaders,
+            respondWith: jest.fn((status, data) => new Response(JSON.stringify(data), { status })),
+            sendResponse: jest.fn(async (res) => res),
+            getHeaders: () => headers,
+            getHeader: (name) => headers[name.toLowerCase()],
+            sendHeader: (name, value) => {
+                responseHeaders[name] = value;
+            },
+            getRequestBody: async () => JSON.stringify({ test: true }),
+            // Always provide resolveApiKey so we don't depend on env at load time
+            resolveApiKey: async () => 'test-api-key',
+            ...overrides,
+        };
+    }
+    describe('handleRequest', () => {
+        it('should return 400 when target URL header is missing', async () => {
+            const behavior = createMockBehavior({
+                getHeader: () => undefined,
+            });
+            await (0, index_1.handleRequest)(behavior);
+            expect(behavior.respondWith).toHaveBeenCalledWith(400, {
+                error: `Missing the ${index_1.TARGET_URL_HEADER} header`,
+            });
+        });
+        it('should return 400 for invalid URL', async () => {
+            const headers = {
+                [index_1.TARGET_URL_HEADER]: 'not-a-valid-url',
+            };
+            const behavior = createMockBehavior({
+                getHeaders: () => headers,
+                getHeader: (name) => headers[name.toLowerCase()],
+            });
+            await (0, index_1.handleRequest)(behavior);
+            expect(behavior.respondWith).toHaveBeenCalledWith(400, {
+                error: `Invalid ${index_1.TARGET_URL_HEADER} header: not a valid URL`,
+            });
+        });
+        it('should return 412 for non-inference.sh domains', async () => {
+            const headers = {
+                [index_1.TARGET_URL_HEADER]: 'https://evil.com/api',
+            };
+            const behavior = createMockBehavior({
+                getHeaders: () => headers,
+                getHeader: (name) => headers[name.toLowerCase()],
+            });
+            await (0, index_1.handleRequest)(behavior);
+            expect(behavior.respondWith).toHaveBeenCalledWith(412, {
+                error: `Invalid ${index_1.TARGET_URL_HEADER} header: must be an inference.sh domain`,
+            });
+        });
+        it('should return 401 when API key resolver returns undefined', async () => {
+            const behavior = createMockBehavior({
+                resolveApiKey: async () => undefined,
+            });
+            await (0, index_1.handleRequest)(behavior);
+            expect(behavior.respondWith).toHaveBeenCalledWith(401, {
+                error: 'Missing INFERENCE_API_KEY environment variable',
+            });
+        });
+        it('should accept valid inference.sh domains', async () => {
+            const validDomains = [
+                'https://api.inference.sh/apps/run',
+                'https://inference.sh/api/test',
+                'https://sub.api.inference.sh/endpoint',
+            ];
+            global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ success: true }), {
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+            }));
+            for (const targetUrl of validDomains) {
+                jest.clearAllMocks();
+                const headers = {
+                    [index_1.TARGET_URL_HEADER]: targetUrl,
+                    'content-type': 'application/json',
+                };
+                const behavior = createMockBehavior({
+                    getHeaders: () => headers,
+                    getHeader: (name) => headers[name.toLowerCase()],
+                });
+                await (0, index_1.handleRequest)(behavior);
+                expect(behavior.sendResponse).toHaveBeenCalled();
+                expect(behavior.respondWith).not.toHaveBeenCalled();
+            }
+        });
+        it('should forward x-inf-* headers', async () => {
+            global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ success: true }), {
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+            }));
+            const headers = {
+                [index_1.TARGET_URL_HEADER]: 'https://api.inference.sh/test',
+                'content-type': 'application/json',
+                'x-inf-custom-header': 'custom-value',
+                'x-inf-another': 'another-value',
+                'x-other-header': 'should-not-forward', // Not x-inf-*, shouldn't be forwarded
+            };
+            const behavior = createMockBehavior({
+                getHeaders: () => headers,
+                getHeader: (name) => headers[name.toLowerCase()],
+            });
+            await (0, index_1.handleRequest)(behavior);
+            expect(global.fetch).toHaveBeenCalledWith('https://api.inference.sh/test', expect.objectContaining({
+                headers: expect.objectContaining({
+                    'x-inf-custom-header': 'custom-value',
+                    'x-inf-another': 'another-value',
+                    authorization: 'Bearer test-api-key',
+                }),
+            }));
+            // Verify x-other-header was not forwarded
+            const fetchCall = global.fetch.mock.calls[0];
+            const fetchHeaders = fetchCall[1].headers;
+            expect(fetchHeaders['x-other-header']).toBeUndefined();
+        });
+        it('should use custom resolveApiKey function', async () => {
+            global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ success: true }), {
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+            }));
+            const behavior = createMockBehavior({
+                resolveApiKey: async () => 'custom-api-key',
+            });
+            await (0, index_1.handleRequest)(behavior);
+            expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                headers: expect.objectContaining({
+                    authorization: 'Bearer custom-api-key',
+                }),
+            }));
+        });
+        it('should not send body for GET requests', async () => {
+            global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ success: true }), {
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+            }));
+            const behavior = createMockBehavior({
+                method: 'GET',
+            });
+            await (0, index_1.handleRequest)(behavior);
+            expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                method: 'GET',
+                body: undefined,
+            }));
+        });
+        it('should copy response headers (excluding content-length/encoding)', async () => {
+            const responseHeaders = new Headers();
+            responseHeaders.set('x-custom-response', 'value');
+            responseHeaders.set('content-length', '100'); // Should be excluded
+            responseHeaders.set('content-encoding', 'gzip'); // Should be excluded
+            global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ success: true }), {
+                status: 200,
+                headers: responseHeaders,
+            }));
+            const behavior = createMockBehavior();
+            await (0, index_1.handleRequest)(behavior);
+            expect(behavior.responseHeaders['x-custom-response']).toBe('value');
+            expect(behavior.responseHeaders['content-length']).toBeUndefined();
+            expect(behavior.responseHeaders['content-encoding']).toBeUndefined();
+        });
+        it('should reject attempts to proxy to non-inference.sh subdomains', async () => {
+            const invalidDomains = [
+                'https://notinference.sh/api',
+                'https://inference.sh.evil.com/api',
+                'https://api.inference.io/test',
+            ];
+            for (const targetUrl of invalidDomains) {
+                const headers = {
+                    [index_1.TARGET_URL_HEADER]: targetUrl,
+                };
+                const behavior = createMockBehavior({
+                    getHeaders: () => headers,
+                    getHeader: (name) => headers[name.toLowerCase()],
+                });
+                await (0, index_1.handleRequest)(behavior);
+                expect(behavior.respondWith).toHaveBeenCalledWith(412, {
+                    error: `Invalid ${index_1.TARGET_URL_HEADER} header: must be an inference.sh domain`,
+                });
+            }
+        });
+    });
+    describe('fromHeaders', () => {
+        it('should convert Headers to plain object', () => {
+            const headers = new Headers();
+            headers.set('content-type', 'application/json');
+            headers.set('x-custom', 'value');
+            const result = (0, index_1.fromHeaders)(headers);
+            expect(result).toEqual({
+                'content-type': 'application/json',
+                'x-custom': 'value',
+            });
+        });
+        it('should handle empty headers', () => {
+            const headers = new Headers();
+            const result = (0, index_1.fromHeaders)(headers);
+            expect(result).toEqual({});
+        });
+    });
+});

package/dist/proxy/index.test.mjs

@@ -0,0 +1 @@
+export * from "./index.test.js";

package/dist/proxy/nextjs.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Next.js proxy handlers for Inference.sh API
+ *
+ * Supports both App Router (route handlers) and Page Router (API handlers).
+ *
+ * @example App Router (app/api/inference/proxy/route.ts)
+ * ```typescript
+ * import { route } from "@inferencesh/sdk/proxy/nextjs";
+ * export const { GET, POST, PUT } = route;
+ * ```
+ *
+ * @example Page Router (pages/api/inference/proxy.ts)
+ * ```typescript
+ * export { handler as default } from "@inferencesh/sdk/proxy/nextjs";
+ * ```
+ */
+import { type NextRequest } from "next/server";
+import type { NextApiHandler } from "next/types";
+/**
+ * The default proxy route path.
+ */
+export declare const PROXY_ROUTE = "/api/inference/proxy";
+/**
+ * Page Router handler for the Inference.sh proxy.
+ *
+ * Note: Page Router proxy doesn't support streaming responses.
+ * For streaming, use the App Router.
+ *
+ * @example
+ * ```typescript
+ * // pages/api/inference/proxy.ts
+ * export { handler as default } from "@inferencesh/sdk/proxy/nextjs";
+ * ```
+ */
+export declare const handler: NextApiHandler;
+/**
+ * App Router handler for the Inference.sh proxy.
+ *
+ * Supports full streaming passthrough for SSE responses.
+ *
+ * @param request - Next.js request object
+ * @returns Response object
+ */
+declare function routeHandler(request: NextRequest): Promise<Response>;
+/**
+ * App Router route exports.
+ *
+ * @example
+ * ```typescript
+ * // app/api/inference/proxy/route.ts
+ * import { route } from "@inferencesh/sdk/proxy/nextjs";
+ * export const { GET, POST, PUT } = route;
+ * ```
+ */
+export declare const route: {
+    handler: typeof routeHandler;
+    GET: typeof routeHandler;
+    POST: typeof routeHandler;
+    PUT: typeof routeHandler;
+};
+export {};

package/dist/proxy/nextjs.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Next.js proxy handlers for Inference.sh API
+ *
+ * Supports both App Router (route handlers) and Page Router (API handlers).
+ *
+ * @example App Router (app/api/inference/proxy/route.ts)
+ * ```typescript
+ * import { route } from "@inferencesh/sdk/proxy/nextjs";
+ * export const { GET, POST, PUT } = route;
+ * ```
+ *
+ * @example Page Router (pages/api/inference/proxy.ts)
+ * ```typescript
+ * export { handler as default } from "@inferencesh/sdk/proxy/nextjs";
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.route = exports.handler = exports.PROXY_ROUTE = void 0;
+const server_1 = require("next/server");
+const index_1 = require("./index");
+/**
+ * The default proxy route path.
+ */
+exports.PROXY_ROUTE = index_1.DEFAULT_PROXY_ROUTE;
+/**
+ * Page Router handler for the Inference.sh proxy.
+ *
+ * Note: Page Router proxy doesn't support streaming responses.
+ * For streaming, use the App Router.
+ *
+ * @example
+ * ```typescript
+ * // pages/api/inference/proxy.ts
+ * export { handler as default } from "@inferencesh/sdk/proxy/nextjs";
+ * ```
+ */
+const handler = async (request, response) => {
+    return (0, index_1.handleRequest)({
+        id: "nextjs-page-router",
+        method: request.method || "POST",
+        getRequestBody: async () => JSON.stringify(request.body),
+        getHeaders: () => request.headers,
+        getHeader: (name) => request.headers[name],
+        sendHeader: (name, value) => response.setHeader(name, value),
+        respondWith: (status, data) => response.status(status).json(data),
+        sendResponse: async (res) => {
+            if (res.headers.get("content-type")?.includes("application/json")) {
+                return response.status(res.status).json(await res.json());
+            }
+            return response.status(res.status).send(await res.text());
+        },
+    });
+};
+exports.handler = handler;
+/**
+ * App Router handler for the Inference.sh proxy.
+ *
+ * Supports full streaming passthrough for SSE responses.
+ *
+ * @param request - Next.js request object
+ * @returns Response object
+ */
+async function routeHandler(request) {
+    const responseHeaders = new Headers();
+    return await (0, index_1.handleRequest)({
+        id: "nextjs-app-router",
+        method: request.method,
+        getRequestBody: async () => request.text(),
+        getHeaders: () => (0, index_1.fromHeaders)(request.headers),
+        getHeader: (name) => request.headers.get(name),
+        sendHeader: (name, value) => responseHeaders.set(name, value),
+        respondWith: (status, data) => server_1.NextResponse.json(data, {
+            status,
+            headers: responseHeaders,
+        }),
+        sendResponse: index_1.responsePassthrough,
+    });
+}
+/**
+ * App Router route exports.
+ *
+ * @example
+ * ```typescript
+ * // app/api/inference/proxy/route.ts
+ * import { route } from "@inferencesh/sdk/proxy/nextjs";
+ * export const { GET, POST, PUT } = route;
+ * ```
+ */
+exports.route = {
+    handler: routeHandler,
+    GET: routeHandler,
+    POST: routeHandler,
+    PUT: routeHandler,
+};

package/dist/proxy/nextjs.mjs

@@ -0,0 +1 @@
+export * from "./nextjs.js";

package/dist/proxy/remix.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Remix proxy handler for Inference.sh API
+ *
+ * Works with Remix's loader and action functions.
+ *
+ * @example
+ * ```typescript
+ * // app/routes/api.inference.proxy.ts
+ * import { createRequestHandler } from "@inferencesh/sdk/proxy/remix";
+ *
+ * const handler = createRequestHandler();
+ *
+ * export const loader = handler;
+ * export const action = handler;
+ * ```
+ */
+export interface RemixProxyOptions {
+    /**
+     * Custom function to resolve the API key.
+     * Defaults to reading from INFERENCE_API_KEY environment variable.
+     */
+    resolveApiKey?: () => Promise<string | undefined>;
+}
+type RemixRequestHandler = (args: {
+    request: Request;
+}) => Promise<Response>;
+/**
+ * Creates a Remix request handler that proxies requests to the Inference.sh API.
+ *
+ * Use this as both a loader and action in your Remix route.
+ *
+ * @param options - Proxy options
+ * @returns A Remix request handler function
+ *
+ * @example
+ * ```typescript
+ * // app/routes/api.inference.proxy.ts
+ * import { createRequestHandler } from "@inferencesh/sdk/proxy/remix";
+ *
+ * const handler = createRequestHandler();
+ *
+ * export const loader = handler;
+ * export const action = handler;
+ * ```
+ */
+export declare function createRequestHandler({ resolveApiKey, }?: RemixProxyOptions): RemixRequestHandler;
+export {};

package/dist/proxy/remix.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Remix proxy handler for Inference.sh API
+ *
+ * Works with Remix's loader and action functions.
+ *
+ * @example
+ * ```typescript
+ * // app/routes/api.inference.proxy.ts
+ * import { createRequestHandler } from "@inferencesh/sdk/proxy/remix";
+ *
+ * const handler = createRequestHandler();
+ *
+ * export const loader = handler;
+ * export const action = handler;
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestHandler = createRequestHandler;
+const index_1 = require("./index");
+/**
+ * Creates a Remix request handler that proxies requests to the Inference.sh API.
+ *
+ * Use this as both a loader and action in your Remix route.
+ *
+ * @param options - Proxy options
+ * @returns A Remix request handler function
+ *
+ * @example
+ * ```typescript
+ * // app/routes/api.inference.proxy.ts
+ * import { createRequestHandler } from "@inferencesh/sdk/proxy/remix";
+ *
+ * const handler = createRequestHandler();
+ *
+ * export const loader = handler;
+ * export const action = handler;
+ * ```
+ */
+function createRequestHandler({ resolveApiKey = index_1.resolveApiKeyFromEnv, } = {}) {
+    return async ({ request }) => {
+        const responseHeaders = new Headers();
+        return (0, index_1.handleRequest)({
+            id: "remix",
+            method: request.method,
+            getRequestBody: async () => request.text(),
+            getHeaders: () => (0, index_1.fromHeaders)(request.headers),
+            getHeader: (name) => request.headers.get(name),
+            sendHeader: (name, value) => responseHeaders.set(name, value),
+            respondWith: (status, data) => new Response(JSON.stringify(data), {
+                status,
+                headers: {
+                    "Content-Type": "application/json",
+                    ...Object.fromEntries(responseHeaders.entries()),
+                },
+            }),
+            sendResponse: index_1.responsePassthrough,
+            resolveApiKey,
+        });
+    };
+}

package/dist/proxy/remix.mjs

@@ -0,0 +1 @@
+export * from "./remix.js";

package/dist/proxy/svelte.d.ts

@@ -0,0 +1,46 @@
+/**
+ * SvelteKit proxy handler for Inference.sh API
+ *
+ * Works with SvelteKit's +server.ts route handlers.
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/inference/proxy/+server.ts
+ * import { createRequestHandler } from "@inferencesh/sdk/proxy/svelte";
+ *
+ * const handler = createRequestHandler();
+ *
+ * export const GET = handler;
+ * export const POST = handler;
+ * export const PUT = handler;
+ * ```
+ */
+import type { RequestEvent } from "@sveltejs/kit";
+export interface SvelteProxyOptions {
+    /**
+     * Custom function to resolve the API key.
+     * Defaults to reading from INFERENCE_API_KEY environment variable.
+     */
+    resolveApiKey?: () => Promise<string | undefined>;
+}
+type SvelteRequestHandler = (event: RequestEvent) => Promise<Response>;
+/**
+ * Creates a SvelteKit request handler that proxies requests to the Inference.sh API.
+ *
+ * @param options - Proxy options
+ * @returns A SvelteKit request handler function
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/inference/proxy/+server.ts
+ * import { createRequestHandler } from "@inferencesh/sdk/proxy/svelte";
+ *
+ * const handler = createRequestHandler();
+ *
+ * export const GET = handler;
+ * export const POST = handler;
+ * export const PUT = handler;
+ * ```
+ */
+export declare function createRequestHandler({ resolveApiKey, }?: SvelteProxyOptions): SvelteRequestHandler;
+export {};

package/dist/proxy/svelte.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * SvelteKit proxy handler for Inference.sh API
+ *
+ * Works with SvelteKit's +server.ts route handlers.
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/inference/proxy/+server.ts
+ * import { createRequestHandler } from "@inferencesh/sdk/proxy/svelte";
+ *
+ * const handler = createRequestHandler();
+ *
+ * export const GET = handler;
+ * export const POST = handler;
+ * export const PUT = handler;
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestHandler = createRequestHandler;
+const index_1 = require("./index");
+/**
+ * Creates a SvelteKit request handler that proxies requests to the Inference.sh API.
+ *
+ * @param options - Proxy options
+ * @returns A SvelteKit request handler function
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/inference/proxy/+server.ts
+ * import { createRequestHandler } from "@inferencesh/sdk/proxy/svelte";
+ *
+ * const handler = createRequestHandler();
+ *
+ * export const GET = handler;
+ * export const POST = handler;
+ * export const PUT = handler;
+ * ```
+ */
+function createRequestHandler({ resolveApiKey = index_1.resolveApiKeyFromEnv, } = {}) {
+    return async (event) => {
+        const request = event.request;
+        const responseHeaders = new Headers();
+        return (0, index_1.handleRequest)({
+            id: "svelte",
+            method: request.method,
+            getRequestBody: async () => request.text(),
+            getHeaders: () => (0, index_1.fromHeaders)(request.headers),
+            getHeader: (name) => request.headers.get(name),
+            sendHeader: (name, value) => responseHeaders.set(name, value),
+            respondWith: (status, data) => new Response(JSON.stringify(data), {
+                status,
+                headers: {
+                    "Content-Type": "application/json",
+                    ...Object.fromEntries(responseHeaders.entries()),
+                },
+            }),
+            sendResponse: index_1.responsePassthrough,
+            resolveApiKey,
+        });
+    };
+}

package/dist/proxy/svelte.mjs

@@ -0,0 +1 @@
+export * from "./svelte.js";