@inferencesh/sdk 0.20.1 → 0.22.0

package/dist/proxy/index.js

@@ -4,13 +4,26 @@
  * Protects API keys by proxying requests from frontend apps through your server.
  * Supports Next.js (App & Page Router), Express, Hono, Remix, and SvelteKit.
  *
+ * The proxy forwards only what a frontend needs to run things (app runs,
+ * agent chats, and reading or streaming their task or chat; see
+ * PROXY_ENDPOINTS) and refuses every other API call with 403.
+ *
  * @example Next.js App Router
  * ```typescript
  * // app/api/inference/proxy/route.ts
  * import { createHandler } from "@inferencesh/sdk/proxy/nextjs";
- * export const { GET, POST, PUT } = createHandler();
+ * export const { GET, POST } = createHandler({
+ *     allowedEndpoints: ["my-team/support-agent"],
+ *     isAuthenticated: async (req) => Boolean(req.cookies.get("session")),
+ * });
  * ```
  */
+// With the .js extension: dist/proxy/index.js is the one proxy entry that
+// loads in plain Node ESM (no bundler), and Node does not add extensions.
+import { isHttpsOrLoopback } from "../http/loopback.js";
+// The calls the proxy forwards, generated by go/api from its route table
+// (`make proxy-endpoints`, copied here by `make types`). Do not edit it here.
+import manifest from "./endpoints.json" with { type: "json" };
 // ============================================================================
 // Constants
 // ============================================================================
@@ -20,11 +33,330 @@ export const INF_TARGET_HEADER = "x-inf-target-url";
 export const INF_TARGET_PARAM = "__inf_target";
 /** Default proxy route path */
 export const PROXY_PATH = "/api/inference/proxy";
-/** Valid inference.sh domain pattern */
-const VALID_DOMAIN_PATTERN = /(\.|^)inference\.sh$/;
+/** The API the proxy forwards to unless `apiUrl` or `apiBaseUrl` says otherwise. */
+export const DEFAULT_API_URL = "https://api.inference.sh";
+/**
+ * Default `maxUploadBytes`: 100 MiB, well under the API's own per-file limit
+ * (storage.max_upload_bytes, 5 GiB by default).
+ */
+export const DEFAULT_MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
 /** Headers stripped from response (fetch auto-decompresses) */
 const STRIP_RESPONSE_HEADERS = ["content-length", "content-encoding"];
 // ============================================================================
+// Endpoint policy
+// ============================================================================
+/**
+ * What the proxy forwards with the site's API key.
+ *
+ * A frontend needs the proxy to run things: run an app, start or continue an
+ * agent chat, and read or stream the resulting task or chat. PROXY_ENDPOINTS
+ * lists exactly the calls the SDK's own client makes for that (`run`,
+ * `agent().sendMessage`, the agent chat provider) and nothing else, so
+ * secrets, API keys, billing, account, file listings and app/agent management
+ * are never reachable through it.
+ *
+ * `allowedEndpoints` then limits which apps and agents may be run. It is
+ * checked where a request names one: a new run or chat, a chat handed to
+ * another agent, an agent's info. A request about an existing task or chat
+ * names it by id, and the proxy cannot tell which app or agent that id
+ * belongs to: the id holder may use every id call below on it.
+ *
+ * Tool approvals are not forwarded. The API takes an approval (approve,
+ * reject, always allow, resolve an interrupt, answer a question awaiting a
+ * person) only from the account holder's own sign-in, never from an API key,
+ * and the proxy signs with a key. Agents behind a proxy should not use
+ * approval-gated tools.
+ */
+/**
+ * Ids of tasks, chats, messages, tool calls and the like, in the shape the
+ * API mints them: a lowercase 26-character ULID (Crockford base32, no i, l,
+ * o or u). Literal routes beside an id (`/tasks/stream`, `/chats/list`, ...)
+ * never match.
+ */
+const ID = "[0-9a-hjkmnp-tv-z]{26}";
+/** One segment of an agent ref in a path (namespace, name, name@version). */
+const SEGMENT = "[A-Za-z0-9._@:-]+";
+/** API routes under /agents/{id}/ that are not an agent's namespace/name. */
+const AGENT_SUBROUTES = "(?!(?:card|versions|rules)$)";
+/**
+ * The proxy's own checks, by manifest route. A route here that the manifest
+ * does not list is never forwarded (a test keeps the two in step).
+ */
+export const PROXY_ENDPOINT_RULES = {
+    // Apps: only the app, its input and how to follow the run: no workers,
+    // infra, session, webhook, schedule, setup or metadata from a visitor.
+    "POST /apps/run": {
+        ref: { body: "app", refuse: ["app_id", "version_id"] },
+        onlyFields: ["app", "app_id", "version_id", "function", "input", "stream", "wait"],
+    },
+    "POST /files": { onlyFields: ["files"], validate: checkUpload },
+    // Agents: the agent a chat starts with or is handed to.
+    "POST /agents/run": { ref: { body: "agent", refuse: ["agent_config"] } },
+    "POST /chats": { ref: { body: "agent", refuse: [] } },
+    "POST /chats/{id}/agent": { ref: { body: "agent", refuse: [] } },
+    "GET /agents/{namespace}/{name}": { ref: { path: true } },
+};
+/** A route with its placeholders unnamed ("POST /chats/{}/messages"), to compare routes. */
+const routeKey = (route) => route.replace(/\{\w+\}/g, "{}");
+const RULES_BY_KEY = new Map(Object.entries(PROXY_ENDPOINT_RULES).map(([route, rules]) => [routeKey(route), rules]));
+/** The regexp for a manifest path: an agent ref's segments, ids everywhere else. */
+function pathPattern(template) {
+    const source = template
+        .split(/(\{\w+\})/)
+        .map((part) => {
+        if (part === "{namespace}")
+            return SEGMENT;
+        if (part === "{name}")
+            return `${AGENT_SUBROUTES}${SEGMENT}`;
+        if (/^\{\w+\}$/.test(part))
+            return ID;
+        return part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    })
+        .join("");
+    return new RegExp(`^${source}$`);
+}
+function fromManifest(e) {
+    if (e.method !== "GET" && e.method !== "POST")
+        throw new Error(`proxy manifest: unsupported method ${e.method} ${e.path}`);
+    const route = `${e.method} ${e.path}`;
+    return {
+        method: e.method,
+        route,
+        path: pathPattern(e.path),
+        purpose: e.purpose,
+        scopes: e.scopes,
+        ...RULES_BY_KEY.get(routeKey(route)),
+    };
+}
+/** The API's proxy manifest as shipped in this package. */
+export const PROXY_MANIFEST = manifest;
+/**
+ * The calls the proxy forwards: exactly the manifest's, with the proxy's
+ * request checks. Everything else is refused with 403.
+ */
+export const PROXY_ENDPOINTS = PROXY_MANIFEST.endpoints.map(fromManifest);
+/** PROXY_ENDPOINTS and what pickProxyEndpoint derived from them: the only entries `endpoints` takes. */
+const SANCTIONED = new WeakSet(PROXY_ENDPOINTS);
+/** The PROXY_ENDPOINTS entry for a request, or undefined when the proxy does not forward it. */
+export function matchProxyEndpoint(method, pathname, endpoints = PROXY_ENDPOINTS) {
+    const m = method.toUpperCase();
+    return endpoints.find((e) => e.method === m && e.path.test(pathname));
+}
+/**
+ * The PROXY_ENDPOINTS entry for `route` ("METHOD /path", with `{id}`,
+ * `{namespace}` and `{name}` placeholders, e.g. "POST /chats/{id}/messages"),
+ * optionally narrowed: `onlyFields` must be a subset of the entry's own,
+ * and `validate` runs after the entry's own check. For the `endpoints`
+ * option. Throws when the proxy does not forward the route.
+ */
+export function pickProxyEndpoint(route, narrow = {}) {
+    const [method = "", template = ""] = route.split(" ");
+    const key = routeKey(`${method.toUpperCase()} ${template}`);
+    const base = PROXY_ENDPOINTS.find((e) => routeKey(e.route) === key);
+    if (!base)
+        throw new Error(`pickProxyEndpoint: "${route}" is not in PROXY_ENDPOINTS`);
+    const { onlyFields, validate } = narrow;
+    const wider = onlyFields?.find((field) => base.onlyFields && !base.onlyFields.includes(field));
+    if (wider !== undefined)
+        throw new Error(`pickProxyEndpoint: "${route}" does not take "${wider}"`);
+    const picked = {
+        ...base,
+        onlyFields: onlyFields ?? base.onlyFields,
+        validate: !validate ? base.validate : (body, limits) => base.validate?.(body, limits) ?? validate(body, limits),
+    };
+    SANCTIONED.add(picked);
+    return picked;
+}
+/** File fields `POST /files` takes (models.PartialFile). */
+const UPLOAD_FILE_FIELDS = ["uri", "path", "content_type", "size", "filename"];
+/**
+ * `POST /files` through the proxy: one file, its declared size within
+ * maxUploadBytes, no category (uploads land in the default "files" category).
+ */
+function checkUpload(body, limits) {
+    for (const files of fieldValues(body, "files")) {
+        if (!Array.isArray(files) || files.length !== 1) {
+            return { status: 403, error: "the inference.sh proxy uploads one file per request" };
+        }
+        const file = files[0];
+        if (file === null || typeof file !== "object" || Array.isArray(file)) {
+            return { status: 400, error: "files[0] must be a JSON object" };
+        }
+        const fields = file;
+        const extra = Object.keys(fields).find((key) => !UPLOAD_FILE_FIELDS.includes(foldKey(key)));
+        if (extra !== undefined) {
+            return { status: 403, error: `"files[0].${extra}" cannot be set through the inference.sh proxy` };
+        }
+        const sizes = fieldValues(fields, "size");
+        if (sizes.length === 0)
+            return { status: 400, error: "files[0].size is required" };
+        for (const size of sizes) {
+            if (typeof size !== "number" || !Number.isInteger(size) || size <= 0) {
+                return { status: 400, error: "files[0].size must be a positive integer" };
+            }
+            if (size > limits.maxUploadBytes) {
+                return { status: 413, error: `file is larger than this proxy's upload limit (${limits.maxUploadBytes} bytes)` };
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * `namespace/name` of an app or agent ref, parsed the way the API parses it
+ * (`[type/]namespace/name[@version][:function]`), or undefined when the ref
+ * names no namespace (an id, or a bare name).
+ */
+function refName(ref) {
+    let full = ref;
+    const colon = ref.lastIndexOf(":");
+    const at = ref.lastIndexOf("@");
+    if (colon !== -1 && (at === -1 || colon > at))
+        full = ref.slice(0, colon);
+    const versionAt = full.lastIndexOf("@");
+    const fullName = versionAt === -1 ? full : full.slice(0, versionAt);
+    const parts = fullName.split("/");
+    if (parts.length < 2)
+        return undefined;
+    let namespace = parts[0];
+    let name = parts.slice(1).join("/");
+    if (parts.length >= 3 && ["knowledge", "skill", "app", "agent"].includes(parts[0])) {
+        namespace = parts[1];
+        name = parts.slice(2).join("/");
+    }
+    if (!namespace || !name)
+        return undefined;
+    return `${namespace}/${name}`;
+}
+/**
+ * Compile allowedEndpoints. Globs: `*` matches within one path segment, so
+ * "ana/*" is every app and agent of the namespace "ana", at any version.
+ * With `exact`, each entry is a whole ref.
+ */
+function compileEndpointPatterns(patterns, exact) {
+    return patterns.map((pattern) => {
+        if (exact) {
+            if (typeof pattern !== "string" || pattern.includes("*") || refName(pattern) === undefined) {
+                throw new Error(`allowedEndpoints: "${pattern}" is not an app or agent ref (e.g. "ana/helper@v2")`);
+            }
+            return (ref) => ref === pattern;
+        }
+        if (typeof pattern !== "string" || refName(pattern) !== pattern) {
+            throw new Error(`allowedEndpoints: "${pattern}" is not a namespace/name pattern (e.g. "ana/helper" or "ana/*")`);
+        }
+        const source = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*");
+        const glob = new RegExp(`^${source}$`);
+        return (ref) => {
+            const name = refName(ref);
+            return name !== undefined && glob.test(name);
+        };
+    });
+}
+/**
+ * allowedEndpoints compiled once per options array (adapters pass the same
+ * array on every request), with a bad entry's error kept so every request
+ * answers it.
+ */
+const compiledPatterns = new WeakMap();
+function endpointPatterns(patterns, exact) {
+    if (!patterns || patterns.length === 0)
+        return [];
+    let byMode = compiledPatterns.get(patterns);
+    if (!byMode)
+        compiledPatterns.set(patterns, (byMode = new Map()));
+    let compiled = byMode.get(exact);
+    if (!compiled) {
+        try {
+            compiled = compileEndpointPatterns(patterns, exact);
+        }
+        catch (e) {
+            compiled = e;
+        }
+        byMode.set(exact, compiled);
+    }
+    return compiled;
+}
+/**
+ * Go's encoding/json matches object keys to struct fields case-insensitively
+ * (with Unicode folding: "ſ" is "s", "K" is "k"), so the API reads "Agent" or
+ * "AGENT" as "agent". Every key that folds to a field is that field.
+ */
+function foldKey(key) {
+    return key.toUpperCase().toLowerCase();
+}
+function fieldValues(body, field) {
+    return Object.keys(body).filter((key) => foldKey(key) === field).map((key) => body[key]);
+}
+/**
+ * Check a request against the endpoint list and allowedEndpoints. Returns a
+ * refusal, or undefined when the request may be forwarded.
+ *
+ * @param patterns compiled allowedEndpoints; empty means every app and agent.
+ * @param endpoints the calls forwarded (PROXY_ENDPOINTS or a subset).
+ */
+function checkProxyRequest(method, pathname, body, patterns, limits, endpoints) {
+    const m = method.toUpperCase();
+    const match = matchProxyEndpoint(m, pathname, endpoints);
+    if (!match) {
+        return {
+            status: 403,
+            error: `${m} ${pathname} is not available through the inference.sh proxy: it forwards app runs and agent chats only`,
+        };
+    }
+    const checkRef = match.ref !== undefined && patterns.length > 0;
+    if (!checkRef && !match.onlyFields && !match.validate)
+        return undefined;
+    if (match.ref && "path" in match.ref) {
+        const ref = pathname.slice("/agents/".length);
+        return allowedRef(ref, patterns) ? undefined : notAllowed(`agent "${ref}"`);
+    }
+    let json;
+    try {
+        json = body ? JSON.parse(body) : undefined;
+    }
+    catch {
+        return { status: 400, error: "request body must be JSON" };
+    }
+    if (json === null || typeof json !== "object" || Array.isArray(json)) {
+        return { status: 400, error: "request body must be a JSON object" };
+    }
+    const fields = json;
+    if (match.onlyFields) {
+        const extra = Object.keys(fields).find((key) => !match.onlyFields.includes(foldKey(key)));
+        if (extra !== undefined) {
+            return { status: 403, error: `"${extra}" cannot be set through the inference.sh proxy` };
+        }
+    }
+    if (match.validate) {
+        const refusal = match.validate(fields, limits);
+        if (refusal)
+            return refusal;
+    }
+    if (checkRef && match.ref && "body" in match.ref) {
+        for (const field of match.ref.refuse) {
+            if (fieldValues(fields, field).some((v) => v !== null && v !== undefined && v !== "")) {
+                return {
+                    status: 403,
+                    error: `"${field}" is not accepted when allowedEndpoints is set: name the app or agent by its namespace/name ref`,
+                };
+            }
+        }
+        const refs = fieldValues(fields, match.ref.body);
+        if (refs.length === 0) {
+            return { status: 403, error: `"${match.ref.body}" is required when allowedEndpoints is set` };
+        }
+        const refused = refs.find((ref) => !allowedRef(ref, patterns));
+        if (refused !== undefined)
+            return notAllowed(`${match.ref.body} ${JSON.stringify(refused)}`);
+    }
+    return undefined;
+}
+function allowedRef(ref, patterns) {
+    return typeof ref === "string" && patterns.some((matches) => matches(ref));
+}
+function notAllowed(what) {
+    return { status: 403, error: `${what} is not in this proxy's allowedEndpoints` };
+}
+// ============================================================================
 // Utilities
 // ============================================================================
 /** Get first value from header (may be array) */
@@ -37,14 +369,20 @@ function firstValue(value) {
 function envApiKey() {
     return process.env.INFERENCE_API_KEY;
 }
-/** Check if domain is allowed */
-function isAllowedDomain(host, extraDomains) {
-    if (VALID_DOMAIN_PATTERN.test(host))
+/** Whether a pattern matches the whole host (no partial or suffix match). */
+function matchesWholeHost(pattern, host) {
+    const whole = new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, ""));
+    const m = whole.exec(host);
+    return m !== null && m.index === 0 && m[0] === host;
+}
+/**
+ * The target must be the configured API's origin or a host the site listed
+ * in allowedDomains: the API key goes nowhere else.
+ */
+function isAllowedTarget(target, apiOrigin, extraDomains) {
+    if (target.origin === apiOrigin)
         return true;
-    if (extraDomains) {
-        return extraDomains.some((pattern) => pattern.test(host));
-    }
-    return false;
+    return (extraDomains ?? []).some((pattern) => matchesWholeHost(pattern, target.host));
 }
 // ============================================================================
 // Core Handler
@@ -60,6 +398,26 @@ function isAllowedDomain(host, extraDomains) {
  * @returns Promise resolving to the framework's response type
  */
 export async function processProxyRequest(adapter, options) {
+    // 0. Who may use the key: isAuthenticated when given, else
+    // allowUnauthorizedRequests (default true).
+    if (options?.isAuthenticated) {
+        if (!(await options.isAuthenticated(adapter.request))) {
+            return adapter.error(401, { error: "Unauthorized" });
+        }
+    }
+    else if (options?.allowUnauthorizedRequests === false) {
+        return adapter.error(401, {
+            error: "Unauthorized: this proxy sets allowUnauthorizedRequests: false without isAuthenticated",
+        });
+    }
+    const patterns = endpointPatterns(options?.allowedEndpoints, options?.exactRefs === true);
+    if (patterns instanceof Error) {
+        return adapter.error(500, { error: patterns.message });
+    }
+    const endpoints = options?.endpoints ?? PROXY_ENDPOINTS;
+    if (!endpoints.every((e) => SANCTIONED.has(e))) {
+        return adapter.error(500, { error: "endpoints: entries must come from PROXY_ENDPOINTS or pickProxyEndpoint" });
+    }
     // 1. Extract target URL (header first, query param fallback for SSE)
     let targetUrl = firstValue(adapter.header(INF_TARGET_HEADER));
     if (!targetUrl && adapter.query) {
@@ -73,28 +431,53 @@ export async function processProxyRequest(adapter, options) {
             error: `Missing ${INF_TARGET_HEADER} header or ${INF_TARGET_PARAM} query param`,
         });
     }
-    // 1b. Rewrite base URL if INFERENCE_API_BASE_URL is set
-    const overrideBase = options?.apiBaseUrl || process.env.INFERENCE_API_BASE_URL;
-    if (overrideBase) {
-        const parsed = new URL(targetUrl);
-        const override = new URL(overrideBase);
-        parsed.protocol = override.protocol;
-        parsed.host = override.host;
-        targetUrl = parsed.toString();
-    }
-    // 2. Validate target domain
-    let host;
+    // 1b. Parse, and rewrite the base URL if apiBaseUrl / INFERENCE_API_BASE_URL is set
+    let target;
+    let apiOrigin;
     try {
-        host = new URL(targetUrl).host;
+        target = new URL(targetUrl);
+        const overrideBase = options?.apiBaseUrl || process.env.INFERENCE_API_BASE_URL;
+        if (overrideBase) {
+            const override = new URL(overrideBase);
+            target.protocol = override.protocol;
+            target.host = override.host;
+            apiOrigin = override.origin;
+        }
+        else {
+            apiOrigin = new URL(options?.apiUrl || DEFAULT_API_URL).origin;
+        }
     }
     catch {
         return adapter.error(400, { error: "Invalid target URL" });
     }
-    if (!isAllowedDomain(host, options?.allowedDomains)) {
+    if (target.username || target.password) {
+        return adapter.error(400, { error: "Target URL must not carry credentials" });
+    }
+    targetUrl = target.toString();
+    // 2. Validate the target: https only (the API key rides on this request),
+    // and the configured API's origin or an explicitly allowed host.
+    if (!isHttpsOrLoopback(target)) {
         return adapter.error(412, {
-            error: `Target must be an inference.sh domain, got: ${host}`,
+            error: `Target must use https, got: ${target.protocol}`,
         });
     }
+    if (!isAllowedTarget(target, apiOrigin, options?.allowedDomains)) {
+        return adapter.error(412, {
+            error: `Target must be the API at ${apiOrigin}, got: ${target.host}`,
+        });
+    }
+    const maxUploadBytes = options?.maxUploadBytes ?? DEFAULT_MAX_UPLOAD_BYTES;
+    if (!(Number.isInteger(maxUploadBytes) && maxUploadBytes > 0)) {
+        return adapter.error(500, { error: "maxUploadBytes must be a positive integer" });
+    }
+    // 2b. Only the calls a frontend needs to run apps and agents, and only
+    // the allowed apps and agents. The body is read once, here, and the same
+    // string is what goes upstream.
+    const body = adapter.method.toUpperCase() === "GET" ? undefined : await adapter.body();
+    const refusal = checkProxyRequest(adapter.method, target.pathname, body, patterns, { maxUploadBytes }, endpoints);
+    if (refusal) {
+        return adapter.error(refusal.status, { error: refusal.error });
+    }
     // 3. Resolve API key
     const apiKey = options?.apiKey
         ?? (adapter.apiKey ? await adapter.apiKey() : undefined)
@@ -138,7 +521,8 @@ export async function processProxyRequest(adapter, options) {
             "user-agent": userAgent || proxyId,
             "x-inf-proxy": proxyId,
         },
-        body: adapter.method.toUpperCase() === "GET" ? undefined : await adapter.body(),
+        body,
+        signal: adapter.signal,
     });
     // 7. Forward response headers (strip compression headers since fetch decompresses)
     response.headers.forEach((value, key) => {

package/dist/proxy/nextjs.d.ts

@@ -5,17 +5,19 @@
  *
  * @example App Router (app/api/inference/proxy/route.ts)
  * ```typescript
- * import { handlers } from "@inferencesh/sdk/proxy/nextjs";
- * export const { GET, POST, PUT } = handlers;
+ * import { createHandler } from "@inferencesh/sdk/proxy/nextjs";
+ * export const { GET, POST } = createHandler({ allowedEndpoints: ["my-team/*"] });
  * ```
  *
  * @example Page Router (pages/api/inference/proxy.ts)
  * ```typescript
- * export { pageHandler as default } from "@inferencesh/sdk/proxy/nextjs";
+ * import { createPageHandler } from "@inferencesh/sdk/proxy/nextjs";
+ * export default createPageHandler({ allowedEndpoints: ["my-team/*"] });
  * ```
  */
 import { type NextRequest } from "next/server";
-import type { NextApiHandler } from "next/types";
+import type { NextApiHandler, NextApiRequest } from "next/types";
+import { type ProxyOptions } from "./index";
 /** Default proxy route path */
 export declare const PROXY_ROUTE = "/api/inference/proxy";
 /**
@@ -27,37 +29,47 @@ export declare const PROXY_ROUTE = "/api/inference/proxy";
  * @example
  * ```typescript
  * // pages/api/inference/proxy.ts
- * export { pageHandler as default } from "@inferencesh/sdk/proxy/nextjs";
+ * import { createPageHandler } from "@inferencesh/sdk/proxy/nextjs";
+ * export default createPageHandler({ allowedEndpoints: ["my-team/*"] });
  * ```
  */
+export declare function createPageHandler(options?: ProxyOptions<NextApiRequest>): NextApiHandler;
+/** Page Router handler with the default options. */
 export declare const pageHandler: NextApiHandler;
 /**
- * Create an App Router handler for the Inference.sh proxy.
+ * Create App Router route handlers for the Inference.sh proxy.
  * Supports full streaming passthrough for SSE responses.
+ *
+ * @example
+ * ```typescript
+ * // app/api/inference/proxy/route.ts
+ * import { createHandler } from "@inferencesh/sdk/proxy/nextjs";
+ * export const { GET, POST } = createHandler({ allowedEndpoints: ["my-team/*"] });
+ * ```
  */
-declare function appHandler(request: NextRequest): Promise<Response>;
+export declare function createHandler(options?: ProxyOptions<NextRequest>): {
+    GET: (request: NextRequest) => Promise<Response>;
+    POST: (request: NextRequest) => Promise<Response>;
+};
 /**
- * App Router route handlers.
+ * App Router route handlers with the default options.
  *
  * @example
  * ```typescript
  * // app/api/inference/proxy/route.ts
  * import { handlers } from "@inferencesh/sdk/proxy/nextjs";
- * export const { GET, POST, PUT } = handlers;
+ * export const { GET, POST } = handlers;
  * ```
  */
 export declare const handlers: {
-    GET: typeof appHandler;
-    POST: typeof appHandler;
-    PUT: typeof appHandler;
+    GET: (request: NextRequest) => Promise<Response>;
+    POST: (request: NextRequest) => Promise<Response>;
 };
 /** @deprecated Use pageHandler */
 export declare const handler: NextApiHandler;
 /** @deprecated Use handlers */
 export declare const route: {
-    handler: typeof appHandler;
-    GET: typeof appHandler;
-    POST: typeof appHandler;
-    PUT: typeof appHandler;
+    GET: (request: NextRequest) => Promise<Response>;
+    POST: (request: NextRequest) => Promise<Response>;
+    handler: (request: NextRequest) => Promise<Response>;
 };
-export {};