@aigne/transport 0.1.0

package/lib/cjs/http-server/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./error.js";
+export * from "./server.js";

package/lib/cjs/http-server/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./error.js"), exports);
+__exportStar(require("./server.js"), exports);

package/lib/cjs/http-server/server.d.ts

@@ -0,0 +1,135 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import type { AIGNE } from "@aigne/core";
+import { z } from "zod";
+/**
+ * Schema for validating agent invocation payloads.
+ * Defines the expected structure for requests to invoke an agent.
+ *
+ * @hidden
+ */
+export declare const invokePayloadSchema: z.ZodObject<{
+    agent: z.ZodString;
+    input: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    options: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        streaming: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        streaming?: boolean | null | undefined;
+    }, {
+        streaming?: boolean | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    agent: string;
+    input: string | Record<string, unknown>;
+    options?: {
+        streaming?: boolean | null | undefined;
+    } | null | undefined;
+}, {
+    agent: string;
+    input: string | Record<string, unknown>;
+    options?: {
+        streaming?: boolean | null | undefined;
+    } | null | undefined;
+}>;
+/**
+ * Configuration options for the AIGNEHTTPServer.
+ * These options control various aspects of server behavior including
+ * request parsing, payload limits, and response handling.
+ */
+export interface AIGNEHTTPServerOptions {
+    /**
+     * Maximum body size for incoming HTTP requests.
+     * This controls the upper limit of request payload size when parsing raw HTTP requests.
+     * Only used when working with Node.js IncomingMessage objects that don't already have
+     * a pre-parsed body property (e.g., when not using Express middleware).
+     *
+     * @default "4mb"
+     */
+    maximumBodySize?: string;
+}
+/**
+ * AIGNEHTTPServer provides HTTP API access to AIGNE capabilities.
+ * It handles requests to invoke agents, manages response streaming,
+ * and supports multiple HTTP server frameworks including Node.js http,
+ * Express, and Fetch API compatible environments.
+ *
+ * @example
+ * Here's a simple example of how to use AIGNEServer with express:
+ * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-express}
+ *
+ * @example
+ * Here's an example of how to use AIGNEServer with Hono:
+ * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-hono}
+ */
+export declare class AIGNEHTTPServer {
+    engine: AIGNE;
+    options?: AIGNEHTTPServerOptions | undefined;
+    /**
+     * Creates a new AIGNEServer instance.
+     *
+     * @param engine - The AIGNE engine instance that will process agent invocations
+     * @param options - Configuration options for the server
+     */
+    constructor(engine: AIGNE, options?: AIGNEHTTPServerOptions | undefined);
+    /**
+     * Invokes an agent with the provided input and returns a standard web Response.
+     * This method serves as the primary API endpoint for agent invocation.
+     *
+     * The request can be provided in various formats to support different integration scenarios:
+     * - As a pre-parsed JavaScript object
+     * - As a Fetch API Request instance (for modern web frameworks)
+     * - As a Node.js IncomingMessage (for Express, Fastify, etc.)
+     *
+     * @param request - The agent invocation request in any supported format
+     * @returns A web standard Response object that can be returned directly in frameworks
+     *          like Hono, Next.js, or any Fetch API compatible environment
+     *
+     * @example
+     * Here's a simple example of how to use AIGNEServer with Hono:
+     * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-hono}
+     */
+    invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
+    /**
+     * Invokes an agent with the provided input and streams the response to a Node.js ServerResponse.
+     * This overload is specifically designed for Node.js HTTP server environments.
+     *
+     * The method handles both regular JSON responses and streaming Server-Sent Events (SSE)
+     * responses based on the options specified in the request.
+     *
+     * @param request - The agent invocation request in any supported format
+     * @param response - The Node.js ServerResponse object to write the response to
+     *
+     * @example
+     * Here's a simple example of how to use AIGNEServer with express:
+     * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-express}
+     */
+    invoke(request: Record<string, unknown> | Request | IncomingMessage, response: ServerResponse): Promise<void>;
+    /**
+     * Internal method that handles the core logic of processing an agent invocation request.
+     * Validates the request payload, finds the requested agent, and processes the invocation
+     * with either streaming or non-streaming response handling.
+     *
+     * @param request - The parsed or raw request to process
+     * @returns A standard Response object with the invocation result
+     * @private
+     */
+    _invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
+    /**
+     * Prepares and normalizes the input from various request types.
+     * Handles different request formats (Node.js IncomingMessage, Fetch API Request,
+     * or already parsed object) and extracts the JSON payload.
+     *
+     * @param request - The request object in any supported format
+     * @returns The normalized payload as a JavaScript object
+     * @private
+     */
+    _prepareInput(request: Record<string, unknown> | Request | IncomingMessage): Promise<Record<string, unknown>>;
+    /**
+     * Writes a web standard Response object to a Node.js ServerResponse.
+     * Handles streaming responses and error conditions appropriately.
+     *
+     * @param response - The web standard Response object to write
+     * @param res - The Node.js ServerResponse to write to
+     * @private
+     */
+    _writeResponse(response: Response, res: ServerResponse): Promise<void>;
+}

package/lib/cjs/http-server/server.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIGNEHTTPServer = exports.invokePayloadSchema = void 0;
+const node_http_1 = require("node:http");
+const event_stream_js_1 = require("@aigne/core/utils/event-stream.js");
+const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
+const content_type_1 = __importDefault(require("content-type"));
+const raw_body_1 = __importDefault(require("raw-body"));
+const zod_1 = require("zod");
+const error_js_1 = require("./error.js");
+/**
+ * Default maximum allowed size for request bodies when parsing raw HTTP requests.
+ * This limits the amount of data that can be uploaded to protect against denial of service attacks.
+ * Can be overridden via AIGNEServerOptions.
+ * @internal
+ */
+const DEFAULT_MAXIMUM_BODY_SIZE = "4mb";
+/**
+ * Schema for validating agent invocation payloads.
+ * Defines the expected structure for requests to invoke an agent.
+ *
+ * @hidden
+ */
+exports.invokePayloadSchema = zod_1.z.object({
+    agent: zod_1.z.string(),
+    input: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.string(), zod_1.z.unknown())]),
+    options: zod_1.z
+        .object({
+        streaming: zod_1.z.boolean().nullish(),
+    })
+        .nullish(),
+});
+/**
+ * AIGNEHTTPServer provides HTTP API access to AIGNE capabilities.
+ * It handles requests to invoke agents, manages response streaming,
+ * and supports multiple HTTP server frameworks including Node.js http,
+ * Express, and Fetch API compatible environments.
+ *
+ * @example
+ * Here's a simple example of how to use AIGNEServer with express:
+ * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-express}
+ *
+ * @example
+ * Here's an example of how to use AIGNEServer with Hono:
+ * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-hono}
+ */
+class AIGNEHTTPServer {
+    engine;
+    options;
+    /**
+     * Creates a new AIGNEServer instance.
+     *
+     * @param engine - The AIGNE engine instance that will process agent invocations
+     * @param options - Configuration options for the server
+     */
+    constructor(engine, options) {
+        this.engine = engine;
+        this.options = options;
+    }
+    async invoke(request, response) {
+        const result = await this._invoke(request);
+        if (response instanceof node_http_1.ServerResponse) {
+            await this._writeResponse(result, response);
+            return;
+        }
+        return result;
+    }
+    /**
+     * Internal method that handles the core logic of processing an agent invocation request.
+     * Validates the request payload, finds the requested agent, and processes the invocation
+     * with either streaming or non-streaming response handling.
+     *
+     * @param request - The parsed or raw request to process
+     * @returns A standard Response object with the invocation result
+     * @private
+     */
+    async _invoke(request) {
+        const { engine } = this;
+        try {
+            const payload = await this._prepareInput(request);
+            const { agent: agentName, input, options, } = (0, type_utils_js_1.tryOrThrow)(() => (0, type_utils_js_1.checkArguments)(`Invoke agent ${payload.agent}`, exports.invokePayloadSchema, payload), (error) => new error_js_1.ServerError(400, error.message));
+            const agent = engine.agents[agentName];
+            if (!agent)
+                throw new error_js_1.ServerError(404, `Agent ${agentName} not found`);
+            if (!options?.streaming) {
+                const result = await engine.invoke(agent, input);
+                return new Response(JSON.stringify(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            const stream = await engine.invoke(agent, input, { streaming: true });
+            return new Response(new event_stream_js_1.AgentResponseStreamSSE(stream), {
+                headers: {
+                    "Content-Type": "text/event-stream",
+                    "Cache-Control": "no-cache",
+                    "X-Accel-Buffering": "no",
+                },
+            });
+        }
+        catch (error) {
+            return new Response(JSON.stringify({ error: { message: error.message } }), {
+                status: error instanceof error_js_1.ServerError ? error.status : 500,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+    }
+    /**
+     * Prepares and normalizes the input from various request types.
+     * Handles different request formats (Node.js IncomingMessage, Fetch API Request,
+     * or already parsed object) and extracts the JSON payload.
+     *
+     * @param request - The request object in any supported format
+     * @returns The normalized payload as a JavaScript object
+     * @private
+     */
+    async _prepareInput(request) {
+        const contentTypeError = new error_js_1.ServerError(415, "Unsupported Media Type: Content-Type must be application/json");
+        if (request instanceof node_http_1.IncomingMessage) {
+            // Support for express with json() middleware
+            if ("body" in request && typeof request.body === "object") {
+                if (!(0, type_utils_js_1.isRecord)(request.body))
+                    throw contentTypeError;
+                return request.body;
+            }
+            // Support vanilla nodejs http server
+            const maximumBodySize = this.options?.maximumBodySize || DEFAULT_MAXIMUM_BODY_SIZE;
+            const ct = request.headers["content-type"];
+            if (!ct || !ct.includes("application/json"))
+                throw contentTypeError;
+            const parsedCt = content_type_1.default.parse(ct);
+            const raw = await (0, raw_body_1.default)(request, {
+                limit: maximumBodySize,
+                encoding: parsedCt.parameters.charset ?? "utf-8",
+            });
+            return (0, type_utils_js_1.tryOrThrow)(() => JSON.parse(raw.toString()), (error) => new error_js_1.ServerError(400, `Parse request body to json error: ${error.message}`));
+        }
+        if (request instanceof Request) {
+            if (!request.headers.get("content-type")?.includes("application/json")) {
+                throw contentTypeError;
+            }
+            return await request.json();
+        }
+        if (!(0, type_utils_js_1.isRecord)(request))
+            throw contentTypeError;
+        return request;
+    }
+    /**
+     * Writes a web standard Response object to a Node.js ServerResponse.
+     * Handles streaming responses and error conditions appropriately.
+     *
+     * @param response - The web standard Response object to write
+     * @param res - The Node.js ServerResponse to write to
+     * @private
+     */
+    async _writeResponse(response, res) {
+        try {
+            res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+            res.flushHeaders();
+            if (!response.body)
+                throw new Error("Response body is empty");
+            for await (const chunk of response.body) {
+                res.write(chunk);
+                // Support for express with compression middleware
+                if ("flush" in res && typeof res.flush === "function") {
+                    res.flush();
+                }
+            }
+        }
+        catch (error) {
+            if (!res.headersSent) {
+                res.writeHead(error instanceof error_js_1.ServerError ? error.status : 500, {
+                    "Content-Type": "application/json",
+                });
+            }
+            if (res.writable) {
+                res.write(JSON.stringify({ error: { message: error.message } }));
+            }
+        }
+        finally {
+            res.end();
+        }
+    }
+}
+exports.AIGNEHTTPServer = AIGNEHTTPServer;

package/lib/cjs/index.d.ts

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

package/lib/cjs/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/lib/dts/http-client/client.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Client module used to interact with the AIGNE framework.
+ */
+import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "@aigne/core";
+/**
+ * Configuration options for the AIGNEHTTPClient.
+ */
+export interface AIGNEHTTPClientOptions {
+    /**
+     * The URL of the AIGNE server to connect to.
+     * This should point to the base endpoint where the AIGNEServer is hosted.
+     */
+    url: string;
+}
+/**
+ * Options for invoking an agent through the AIGNEHTTPClient.
+ * Extends the standard AgentInvokeOptions with client-specific options.
+ */
+export interface AIGNEHTTPClientInvokeOptions extends AgentInvokeOptions {
+    /**
+     * Additional fetch API options to customize the HTTP request.
+     * These options will be merged with the default options used by the client.
+     */
+    fetchOptions?: Partial<RequestInit>;
+}
+/**
+ * Http client for interacting with a remote AIGNE server.
+ * AIGNEHTTPClient provides a client-side interface that matches the AIGNE API,
+ * allowing applications to invoke agents and receive responses from a remote AIGNE instance.
+ *
+ * @example
+ * Here's a simple example of how to use AIGNEClient:
+ * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-simple}
+ *
+ * @example
+ * Here's an example of how to use AIGNEClient with streaming response:
+ * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-streaming}
+ */
+export declare class AIGNEHTTPClient {
+    options: AIGNEHTTPClientOptions;
+    /**
+     * Creates a new AIGNEClient instance.
+     *
+     * @param options - Configuration options for connecting to the AIGNE server
+     */
+    constructor(options: AIGNEHTTPClientOptions);
+    /**
+     * Invokes an agent in non-streaming mode and returns the complete response.
+     *
+     * @param agent - Name of the agent to invoke
+     * @param input - Input message for the agent
+     * @param options - Options with streaming mode explicitly set to false or omitted
+     * @returns The complete agent response
+     *
+     * @example
+     * Here's a simple example of how to use AIGNEClient:
+     * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-simple}
+     */
+    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions & {
+        streaming?: false;
+    }): Promise<O>;
+    /**
+     * Invokes an agent with streaming mode enabled and returns a stream of response chunks.
+     *
+     * @param agent - Name of the agent to invoke
+     * @param input - Input message for the agent
+     * @param options - Options with streaming mode explicitly set to true
+     * @returns A stream of agent response chunks
+     *
+     * @example
+     * Here's an example of how to use AIGNEClient with streaming response:
+     * {@includeCode ../../test/http-client/http-client.test.ts#example-aigne-client-streaming}
+     */
+    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options: AIGNEHTTPClientInvokeOptions & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    /**
+     * Invokes an agent with the given input and options.
+     *
+     * @param agent - Name of the agent to invoke
+     * @param input - Input message for the agent
+     * @param options - Options for the invocation
+     * @returns Either a complete response or a response stream depending on the streaming option
+     */
+    invoke<I extends Message, O extends Message>(agent: string, input: string | I, options?: AIGNEHTTPClientInvokeOptions): Promise<AgentResponse<O>>;
+    /**
+     * Enhanced fetch method that handles error responses from the AIGNE server.
+     * This method wraps the standard fetch API to provide better error handling and reporting.
+     *
+     * @param args - Standard fetch API arguments (url and options)
+     * @returns A Response object if the request was successful
+     * @throws Error with detailed information if the request failed
+     *
+     * @private
+     */
+    fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
+}

package/lib/dts/http-client/index.d.ts

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

package/lib/dts/http-server/error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Custom error class for AIGNEServer HTTP-related errors.
+ * Extends the standard Error class with an HTTP status code property.
+ * This allows error responses to include appropriate HTTP status codes.
+ */
+export declare class ServerError extends Error {
+    status: number;
+    /**
+     * Creates a new ServerError instance.
+     *
+     * @param status - The HTTP status code for this error (e.g., 400, 404, 500)
+     * @param message - The error message describing what went wrong
+     */
+    constructor(status: number, message: string);
+}

package/lib/dts/http-server/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./error.js";
+export * from "./server.js";

package/lib/dts/http-server/server.d.ts

@@ -0,0 +1,135 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import type { AIGNE } from "@aigne/core";
+import { z } from "zod";
+/**
+ * Schema for validating agent invocation payloads.
+ * Defines the expected structure for requests to invoke an agent.
+ *
+ * @hidden
+ */
+export declare const invokePayloadSchema: z.ZodObject<{
+    agent: z.ZodString;
+    input: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    options: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        streaming: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        streaming?: boolean | null | undefined;
+    }, {
+        streaming?: boolean | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    agent: string;
+    input: string | Record<string, unknown>;
+    options?: {
+        streaming?: boolean | null | undefined;
+    } | null | undefined;
+}, {
+    agent: string;
+    input: string | Record<string, unknown>;
+    options?: {
+        streaming?: boolean | null | undefined;
+    } | null | undefined;
+}>;
+/**
+ * Configuration options for the AIGNEHTTPServer.
+ * These options control various aspects of server behavior including
+ * request parsing, payload limits, and response handling.
+ */
+export interface AIGNEHTTPServerOptions {
+    /**
+     * Maximum body size for incoming HTTP requests.
+     * This controls the upper limit of request payload size when parsing raw HTTP requests.
+     * Only used when working with Node.js IncomingMessage objects that don't already have
+     * a pre-parsed body property (e.g., when not using Express middleware).
+     *
+     * @default "4mb"
+     */
+    maximumBodySize?: string;
+}
+/**
+ * AIGNEHTTPServer provides HTTP API access to AIGNE capabilities.
+ * It handles requests to invoke agents, manages response streaming,
+ * and supports multiple HTTP server frameworks including Node.js http,
+ * Express, and Fetch API compatible environments.
+ *
+ * @example
+ * Here's a simple example of how to use AIGNEServer with express:
+ * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-express}
+ *
+ * @example
+ * Here's an example of how to use AIGNEServer with Hono:
+ * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-hono}
+ */
+export declare class AIGNEHTTPServer {
+    engine: AIGNE;
+    options?: AIGNEHTTPServerOptions | undefined;
+    /**
+     * Creates a new AIGNEServer instance.
+     *
+     * @param engine - The AIGNE engine instance that will process agent invocations
+     * @param options - Configuration options for the server
+     */
+    constructor(engine: AIGNE, options?: AIGNEHTTPServerOptions | undefined);
+    /**
+     * Invokes an agent with the provided input and returns a standard web Response.
+     * This method serves as the primary API endpoint for agent invocation.
+     *
+     * The request can be provided in various formats to support different integration scenarios:
+     * - As a pre-parsed JavaScript object
+     * - As a Fetch API Request instance (for modern web frameworks)
+     * - As a Node.js IncomingMessage (for Express, Fastify, etc.)
+     *
+     * @param request - The agent invocation request in any supported format
+     * @returns A web standard Response object that can be returned directly in frameworks
+     *          like Hono, Next.js, or any Fetch API compatible environment
+     *
+     * @example
+     * Here's a simple example of how to use AIGNEServer with Hono:
+     * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-hono}
+     */
+    invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
+    /**
+     * Invokes an agent with the provided input and streams the response to a Node.js ServerResponse.
+     * This overload is specifically designed for Node.js HTTP server environments.
+     *
+     * The method handles both regular JSON responses and streaming Server-Sent Events (SSE)
+     * responses based on the options specified in the request.
+     *
+     * @param request - The agent invocation request in any supported format
+     * @param response - The Node.js ServerResponse object to write the response to
+     *
+     * @example
+     * Here's a simple example of how to use AIGNEServer with express:
+     * {@includeCode ../../test/http-server/http-server.test.ts#example-aigne-server-express}
+     */
+    invoke(request: Record<string, unknown> | Request | IncomingMessage, response: ServerResponse): Promise<void>;
+    /**
+     * Internal method that handles the core logic of processing an agent invocation request.
+     * Validates the request payload, finds the requested agent, and processes the invocation
+     * with either streaming or non-streaming response handling.
+     *
+     * @param request - The parsed or raw request to process
+     * @returns A standard Response object with the invocation result
+     * @private
+     */
+    _invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
+    /**
+     * Prepares and normalizes the input from various request types.
+     * Handles different request formats (Node.js IncomingMessage, Fetch API Request,
+     * or already parsed object) and extracts the JSON payload.
+     *
+     * @param request - The request object in any supported format
+     * @returns The normalized payload as a JavaScript object
+     * @private
+     */
+    _prepareInput(request: Record<string, unknown> | Request | IncomingMessage): Promise<Record<string, unknown>>;
+    /**
+     * Writes a web standard Response object to a Node.js ServerResponse.
+     * Handles streaming responses and error conditions appropriately.
+     *
+     * @param response - The web standard Response object to write
+     * @param res - The Node.js ServerResponse to write to
+     * @private
+     */
+    _writeResponse(response: Response, res: ServerResponse): Promise<void>;
+}

package/lib/dts/index.d.ts

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