@pleaseai/agent 0.1.16 → 0.1.17

package/.output/server/node_modules/better-call/dist/context.mjs

@@ -0,0 +1,103 @@
+import { APIError, ValidationError } from "./error.mjs";
+import { isRequest } from "./utils.mjs";
+import { runValidation } from "./validator.mjs";
+import { getCryptoKey, verifySignature } from "./crypto.mjs";
+import { getCookieKey, parseCookies, serializeCookie, serializeSignedCookie } from "./cookies.mjs";
+
+//#region src/context.ts
+const createInternalContext = async (context, { options, path }) => {
+	const headers = new Headers();
+	let responseStatus = void 0;
+	const { data, error } = await runValidation(options, context);
+	if (error) throw new ValidationError(error.message, error.issues);
+	const requestHeaders = "headers" in context ? context.headers instanceof Headers ? context.headers : new Headers(context.headers) : "request" in context && isRequest(context.request) ? context.request.headers : null;
+	const requestCookies = requestHeaders?.get("cookie");
+	const parsedCookies = requestCookies ? parseCookies(requestCookies) : void 0;
+	const internalContext = {
+		...context,
+		body: data.body,
+		query: data.query,
+		path: context.path || path || "virtual:",
+		context: "context" in context && context.context ? context.context : {},
+		returned: void 0,
+		headers: context?.headers,
+		request: context?.request,
+		params: "params" in context ? context.params : void 0,
+		method: context.method ?? (Array.isArray(options.method) ? options.method[0] : options.method === "*" ? "GET" : options.method),
+		setHeader: (key, value) => {
+			headers.set(key, value);
+		},
+		getHeader: (key) => {
+			if (!requestHeaders) return null;
+			return requestHeaders.get(key);
+		},
+		getCookie: (key, prefix) => {
+			const finalKey = getCookieKey(key, prefix);
+			if (!finalKey) return null;
+			return parsedCookies?.get(finalKey) || null;
+		},
+		getSignedCookie: async (key, secret, prefix) => {
+			const finalKey = getCookieKey(key, prefix);
+			if (!finalKey) return null;
+			const value = parsedCookies?.get(finalKey);
+			if (!value) return null;
+			const signatureStartPos = value.lastIndexOf(".");
+			if (signatureStartPos < 1) return null;
+			const signedValue = value.substring(0, signatureStartPos);
+			const signature = value.substring(signatureStartPos + 1);
+			if (signature.length !== 44 || !signature.endsWith("=")) return null;
+			return await verifySignature(signature, signedValue, await getCryptoKey(secret)) ? signedValue : false;
+		},
+		setCookie: (key, value, options) => {
+			const cookie = serializeCookie(key, value, options);
+			headers.append("set-cookie", cookie);
+			return cookie;
+		},
+		setSignedCookie: async (key, value, secret, options) => {
+			const cookie = await serializeSignedCookie(key, value, secret, options);
+			headers.append("set-cookie", cookie);
+			return cookie;
+		},
+		redirect: (url) => {
+			headers.set("location", url);
+			return new APIError("FOUND", void 0, headers);
+		},
+		error: (status, body, headers) => {
+			return new APIError(status, body, headers);
+		},
+		setStatus: (status) => {
+			responseStatus = status;
+		},
+		json: (json, routerResponse) => {
+			if (!context.asResponse) return json;
+			return {
+				body: routerResponse?.body || json,
+				routerResponse,
+				_flag: "json"
+			};
+		},
+		responseHeaders: headers,
+		get responseStatus() {
+			return responseStatus;
+		}
+	};
+	for (const middleware of options.use || []) {
+		const response = await middleware({
+			...internalContext,
+			returnHeaders: true,
+			asResponse: false
+		});
+		if (response.response) Object.assign(internalContext.context, response.response);
+		/**
+		* Apply headers from the middleware to the endpoint headers
+		*/
+		if (response.headers) response.headers.forEach((value, key) => {
+			internalContext.responseHeaders.set(key, value);
+		});
+	}
+	return internalContext;
+};
+
+//#endregion
+export { createInternalContext };
+//# sourceMappingURL=context.mjs.map

package/.output/server/node_modules/better-call/dist/cookies.mjs

@@ -0,0 +1,84 @@
+import { tryDecode } from "./utils.mjs";
+import { signCookieValue } from "./crypto.mjs";
+
+//#region src/cookies.ts
+const getCookieKey = (key, prefix) => {
+	let finalKey = key;
+	if (prefix) if (prefix === "secure") finalKey = "__Secure-" + key;
+	else if (prefix === "host") finalKey = "__Host-" + key;
+	else return;
+	return finalKey;
+};
+/**
+* Parse an HTTP Cookie header string and returning an object of all cookie
+* name-value pairs.
+*
+* Inspired by https://github.com/unjs/cookie-es/blob/main/src/cookie/parse.ts
+*
+* @param str the string representing a `Cookie` header value
+*/
+function parseCookies(str) {
+	if (typeof str !== "string") throw new TypeError("argument str must be a string");
+	const cookies = /* @__PURE__ */ new Map();
+	let index = 0;
+	while (index < str.length) {
+		const eqIdx = str.indexOf("=", index);
+		if (eqIdx === -1) break;
+		let endIdx = str.indexOf(";", index);
+		if (endIdx === -1) endIdx = str.length;
+		else if (endIdx < eqIdx) {
+			index = str.lastIndexOf(";", eqIdx - 1) + 1;
+			continue;
+		}
+		const key = str.slice(index, eqIdx).trim();
+		if (!cookies.has(key)) {
+			let val = str.slice(eqIdx + 1, endIdx).trim();
+			if (val.codePointAt(0) === 34) val = val.slice(1, -1);
+			cookies.set(key, tryDecode(val));
+		}
+		index = endIdx + 1;
+	}
+	return cookies;
+}
+const _serialize = (key, value, opt = {}) => {
+	let cookie;
+	if (opt?.prefix === "secure") cookie = `${`__Secure-${key}`}=${value}`;
+	else if (opt?.prefix === "host") cookie = `${`__Host-${key}`}=${value}`;
+	else cookie = `${key}=${value}`;
+	if (key.startsWith("__Secure-") && !opt.secure) opt.secure = true;
+	if (key.startsWith("__Host-")) {
+		if (!opt.secure) opt.secure = true;
+		if (opt.path !== "/") opt.path = "/";
+		if (opt.domain) opt.domain = void 0;
+	}
+	if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+		if (opt.maxAge > 3456e4) throw new Error("Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.");
+		cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
+	}
+	if (opt.domain && opt.prefix !== "host") cookie += `; Domain=${opt.domain}`;
+	if (opt.path) cookie += `; Path=${opt.path}`;
+	if (opt.expires) {
+		if (opt.expires.getTime() - Date.now() > 3456e7) throw new Error("Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.");
+		cookie += `; Expires=${opt.expires.toUTCString()}`;
+	}
+	if (opt.httpOnly) cookie += "; HttpOnly";
+	if (opt.secure) cookie += "; Secure";
+	if (opt.sameSite) cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+	if (opt.partitioned) {
+		if (!opt.secure) opt.secure = true;
+		cookie += "; Partitioned";
+	}
+	return cookie;
+};
+const serializeCookie = (key, value, opt) => {
+	value = encodeURIComponent(value);
+	return _serialize(key, value, opt);
+};
+const serializeSignedCookie = async (key, value, secret, opt) => {
+	value = await signCookieValue(value, secret);
+	return _serialize(key, value, opt);
+};
+
+//#endregion
+export { getCookieKey, parseCookies, serializeCookie, serializeSignedCookie };
+//# sourceMappingURL=cookies.mjs.map

package/.output/server/node_modules/better-call/dist/crypto.mjs

@@ -0,0 +1,36 @@
+import { getWebcryptoSubtle } from "@better-auth/utils";
+
+//#region src/crypto.ts
+const algorithm = {
+	name: "HMAC",
+	hash: "SHA-256"
+};
+const getCryptoKey = async (secret) => {
+	const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
+	return await getWebcryptoSubtle().importKey("raw", secretBuf, algorithm, false, ["sign", "verify"]);
+};
+const verifySignature = async (base64Signature, value, secret) => {
+	try {
+		const signatureBinStr = atob(base64Signature);
+		const signature = new Uint8Array(signatureBinStr.length);
+		for (let i = 0, len = signatureBinStr.length; i < len; i++) signature[i] = signatureBinStr.charCodeAt(i);
+		return await getWebcryptoSubtle().verify(algorithm, secret, signature, new TextEncoder().encode(value));
+	} catch (e) {
+		return false;
+	}
+};
+const makeSignature = async (value, secret) => {
+	const key = await getCryptoKey(secret);
+	const signature = await getWebcryptoSubtle().sign(algorithm.name, key, new TextEncoder().encode(value));
+	return btoa(String.fromCharCode(...new Uint8Array(signature)));
+};
+const signCookieValue = async (value, secret) => {
+	const signature = await makeSignature(value, secret);
+	value = `${value}.${signature}`;
+	value = encodeURIComponent(value);
+	return value;
+};
+
+//#endregion
+export { getCryptoKey, signCookieValue, verifySignature };
+//# sourceMappingURL=crypto.mjs.map

package/.output/server/node_modules/better-call/dist/endpoint.mjs

@@ -0,0 +1,70 @@
+import { APIError, BetterCallError, ValidationError } from "./error.mjs";
+import { isAPIError, tryCatch } from "./utils.mjs";
+import { toResponse } from "./to-response.mjs";
+import { createInternalContext } from "./context.mjs";
+
+//#region src/endpoint.ts
+function createEndpoint(pathOrOptions, handlerOrOptions, handlerOrNever) {
+	const path = typeof pathOrOptions === "string" ? pathOrOptions : void 0;
+	const options = typeof handlerOrOptions === "object" ? handlerOrOptions : pathOrOptions;
+	const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : handlerOrNever;
+	if ((options.method === "GET" || options.method === "HEAD") && options.body) throw new BetterCallError("Body is not allowed with GET or HEAD methods");
+	if (path && /\/{2,}/.test(path)) throw new BetterCallError("Path cannot contain consecutive slashes");
+	const internalHandler = async (...inputCtx) => {
+		const context = inputCtx[0] || {};
+		const { data: internalContext, error: validationError } = await tryCatch(createInternalContext(context, {
+			options,
+			path
+		}));
+		if (validationError) {
+			if (!(validationError instanceof ValidationError)) throw validationError;
+			if (options.onValidationError) await options.onValidationError({
+				message: validationError.message,
+				issues: validationError.issues
+			});
+			throw new APIError(400, {
+				message: validationError.message,
+				code: "VALIDATION_ERROR"
+			});
+		}
+		const response = await handler(internalContext).catch(async (e) => {
+			if (isAPIError(e)) {
+				const onAPIError = options.onAPIError;
+				if (onAPIError) await onAPIError(e);
+				if (context.asResponse) return e;
+			}
+			throw e;
+		});
+		const headers = internalContext.responseHeaders;
+		const status = internalContext.responseStatus;
+		return context.asResponse ? toResponse(response, {
+			headers,
+			status
+		}) : context.returnHeaders ? context.returnStatus ? {
+			headers,
+			response,
+			status
+		} : {
+			headers,
+			response
+		} : context.returnStatus ? {
+			response,
+			status
+		} : response;
+	};
+	internalHandler.options = options;
+	internalHandler.path = path;
+	return internalHandler;
+}
+createEndpoint.create = (opts) => {
+	return (path, options, handler) => {
+		return createEndpoint(path, {
+			...options,
+			use: [...options?.use || [], ...opts?.use || []]
+		}, handler);
+	};
+};
+
+//#endregion
+export { createEndpoint };
+//# sourceMappingURL=endpoint.mjs.map

package/.output/server/node_modules/better-call/dist/error.mjs

@@ -0,0 +1,133 @@
+//#region src/error.ts
+function isErrorStackTraceLimitWritable() {
+	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+	if (desc === void 0) return Object.isExtensible(Error);
+	return Object.prototype.hasOwnProperty.call(desc, "writable") ? desc.writable : desc.set !== void 0;
+}
+/**
+* Hide internal stack frames from the error stack trace.
+*/
+function hideInternalStackFrames(stack) {
+	const lines = stack.split("\n    at ");
+	if (lines.length <= 1) return stack;
+	lines.splice(1, 1);
+	return lines.join("\n    at ");
+}
+/**
+* Creates a custom error class that hides stack frames.
+*/
+function makeErrorForHideStackFrame(Base, clazz) {
+	class HideStackFramesError extends Base {
+		#hiddenStack;
+		constructor(...args) {
+			if (isErrorStackTraceLimitWritable()) {
+				const limit = Error.stackTraceLimit;
+				Error.stackTraceLimit = 0;
+				super(...args);
+				Error.stackTraceLimit = limit;
+			} else super(...args);
+			const stack = (/* @__PURE__ */ new Error()).stack;
+			if (stack) this.#hiddenStack = hideInternalStackFrames(stack.replace(/^Error/, this.name));
+		}
+		get errorStack() {
+			return this.#hiddenStack;
+		}
+	}
+	Object.defineProperty(HideStackFramesError.prototype, "constructor", {
+		get() {
+			return clazz;
+		},
+		enumerable: false,
+		configurable: true
+	});
+	return HideStackFramesError;
+}
+const statusCodes = {
+	OK: 200,
+	CREATED: 201,
+	ACCEPTED: 202,
+	NO_CONTENT: 204,
+	MULTIPLE_CHOICES: 300,
+	MOVED_PERMANENTLY: 301,
+	FOUND: 302,
+	SEE_OTHER: 303,
+	NOT_MODIFIED: 304,
+	TEMPORARY_REDIRECT: 307,
+	BAD_REQUEST: 400,
+	UNAUTHORIZED: 401,
+	PAYMENT_REQUIRED: 402,
+	FORBIDDEN: 403,
+	NOT_FOUND: 404,
+	METHOD_NOT_ALLOWED: 405,
+	NOT_ACCEPTABLE: 406,
+	PROXY_AUTHENTICATION_REQUIRED: 407,
+	REQUEST_TIMEOUT: 408,
+	CONFLICT: 409,
+	GONE: 410,
+	LENGTH_REQUIRED: 411,
+	PRECONDITION_FAILED: 412,
+	PAYLOAD_TOO_LARGE: 413,
+	URI_TOO_LONG: 414,
+	UNSUPPORTED_MEDIA_TYPE: 415,
+	RANGE_NOT_SATISFIABLE: 416,
+	EXPECTATION_FAILED: 417,
+	"I'M_A_TEAPOT": 418,
+	MISDIRECTED_REQUEST: 421,
+	UNPROCESSABLE_ENTITY: 422,
+	LOCKED: 423,
+	FAILED_DEPENDENCY: 424,
+	TOO_EARLY: 425,
+	UPGRADE_REQUIRED: 426,
+	PRECONDITION_REQUIRED: 428,
+	TOO_MANY_REQUESTS: 429,
+	REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+	UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+	INTERNAL_SERVER_ERROR: 500,
+	NOT_IMPLEMENTED: 501,
+	BAD_GATEWAY: 502,
+	SERVICE_UNAVAILABLE: 503,
+	GATEWAY_TIMEOUT: 504,
+	HTTP_VERSION_NOT_SUPPORTED: 505,
+	VARIANT_ALSO_NEGOTIATES: 506,
+	INSUFFICIENT_STORAGE: 507,
+	LOOP_DETECTED: 508,
+	NOT_EXTENDED: 510,
+	NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+var InternalAPIError = class extends Error {
+	constructor(status = "INTERNAL_SERVER_ERROR", body = void 0, headers = {}, statusCode = typeof status === "number" ? status : statusCodes[status]) {
+		super(body?.message, body?.cause ? { cause: body.cause } : void 0);
+		this.status = status;
+		this.body = body;
+		this.headers = headers;
+		this.statusCode = statusCode;
+		this.name = "APIError";
+		this.status = status;
+		this.headers = headers;
+		this.statusCode = statusCode;
+		this.body = body;
+	}
+};
+var ValidationError = class extends InternalAPIError {
+	constructor(message, issues) {
+		super(400, {
+			message,
+			code: "VALIDATION_ERROR"
+		});
+		this.message = message;
+		this.issues = issues;
+		this.issues = issues;
+	}
+};
+var BetterCallError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "BetterCallError";
+	}
+};
+const kAPIErrorHeaderSymbol = Symbol.for("better-call:api-error-headers");
+const APIError = makeErrorForHideStackFrame(InternalAPIError, Error);
+
+//#endregion
+export { APIError, BetterCallError, ValidationError, hideInternalStackFrames, kAPIErrorHeaderSymbol, makeErrorForHideStackFrame, statusCodes };
+//# sourceMappingURL=error.mjs.map

package/.output/server/node_modules/better-call/dist/index.mjs

@@ -0,0 +1,10 @@
+import { APIError, BetterCallError, ValidationError, hideInternalStackFrames, kAPIErrorHeaderSymbol, makeErrorForHideStackFrame, statusCodes } from "./error.mjs";
+import { toResponse } from "./to-response.mjs";
+import { getCookieKey, parseCookies, serializeCookie, serializeSignedCookie } from "./cookies.mjs";
+import { createInternalContext } from "./context.mjs";
+import { createEndpoint } from "./endpoint.mjs";
+import { createMiddleware } from "./middleware.mjs";
+import { generator, getHTML } from "./openapi.mjs";
+import { createRouter } from "./router.mjs";
+
+export { APIError, BetterCallError, ValidationError, createEndpoint, createInternalContext, createMiddleware, createRouter, generator, getCookieKey, getHTML, hideInternalStackFrames, kAPIErrorHeaderSymbol, makeErrorForHideStackFrame, parseCookies, serializeCookie, serializeSignedCookie, statusCodes, toResponse };

package/.output/server/node_modules/better-call/dist/middleware.mjs

@@ -0,0 +1,52 @@
+import { kAPIErrorHeaderSymbol } from "./error.mjs";
+import { isAPIError } from "./utils.mjs";
+import { createInternalContext } from "./context.mjs";
+import "./endpoint.mjs";
+
+//#region src/middleware.ts
+function createMiddleware(optionsOrHandler, handler) {
+	const internalHandler = async (inputCtx) => {
+		const context = inputCtx;
+		const _handler = typeof optionsOrHandler === "function" ? optionsOrHandler : handler;
+		const internalContext = await createInternalContext(context, {
+			options: typeof optionsOrHandler === "function" ? {} : optionsOrHandler,
+			path: "/"
+		});
+		if (!_handler) throw new Error("handler must be defined");
+		try {
+			const response = await _handler(internalContext);
+			const headers = internalContext.responseHeaders;
+			return context.returnHeaders ? {
+				headers,
+				response
+			} : response;
+		} catch (e) {
+			if (isAPIError(e)) Object.defineProperty(e, kAPIErrorHeaderSymbol, {
+				enumerable: false,
+				configurable: false,
+				get() {
+					return internalContext.responseHeaders;
+				}
+			});
+			throw e;
+		}
+	};
+	internalHandler.options = typeof optionsOrHandler === "function" ? {} : optionsOrHandler;
+	return internalHandler;
+}
+createMiddleware.create = (opts) => {
+	function fn(optionsOrHandler, handler) {
+		if (typeof optionsOrHandler === "function") return createMiddleware({ use: opts?.use }, optionsOrHandler);
+		if (!handler) throw new Error("Middleware handler is required");
+		return createMiddleware({
+			...optionsOrHandler,
+			method: "*",
+			use: [...opts?.use || [], ...optionsOrHandler.use || []]
+		}, handler);
+	}
+	return fn;
+};
+
+//#endregion
+export { createMiddleware };
+//# sourceMappingURL=middleware.mjs.map

package/.output/server/node_modules/better-call/dist/openapi.mjs

@@ -0,0 +1,189 @@
+import { ZodObject, ZodOptional } from "zod";
+
+//#region src/openapi.ts
+const paths = {};
+function getTypeFromZodType(zodType) {
+	switch (zodType.constructor.name) {
+		case "ZodString": return "string";
+		case "ZodNumber": return "number";
+		case "ZodBoolean": return "boolean";
+		case "ZodObject": return "object";
+		case "ZodArray": return "array";
+		default: return "string";
+	}
+}
+function getParameters(options) {
+	const parameters = [];
+	if (options.metadata?.openapi?.parameters) {
+		parameters.push(...options.metadata.openapi.parameters);
+		return parameters;
+	}
+	if (options.query instanceof ZodObject) Object.entries(options.query.shape).forEach(([key, value]) => {
+		if (value instanceof ZodObject) parameters.push({
+			name: key,
+			in: "query",
+			schema: {
+				type: getTypeFromZodType(value),
+				..."minLength" in value && value.minLength ? { minLength: value.minLength } : {},
+				description: value.description
+			}
+		});
+	});
+	return parameters;
+}
+function getRequestBody(options) {
+	if (options.metadata?.openapi?.requestBody) return options.metadata.openapi.requestBody;
+	if (!options.body) return void 0;
+	if (options.body instanceof ZodObject || options.body instanceof ZodOptional) {
+		const shape = options.body.shape;
+		if (!shape) return void 0;
+		const properties = {};
+		const required = [];
+		Object.entries(shape).forEach(([key, value]) => {
+			if (value instanceof ZodObject) {
+				properties[key] = {
+					type: getTypeFromZodType(value),
+					description: value.description
+				};
+				if (!(value instanceof ZodOptional)) required.push(key);
+			}
+		});
+		return {
+			required: options.body instanceof ZodOptional ? false : options.body ? true : false,
+			content: { "application/json": { schema: {
+				type: "object",
+				properties,
+				required
+			} } }
+		};
+	}
+}
+function getResponse(responses) {
+	return {
+		"400": {
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { message: { type: "string" } },
+				required: ["message"]
+			} } },
+			description: "Bad Request. Usually due to missing parameters, or invalid parameters."
+		},
+		"401": {
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { message: { type: "string" } },
+				required: ["message"]
+			} } },
+			description: "Unauthorized. Due to missing or invalid authentication."
+		},
+		"403": {
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { message: { type: "string" } }
+			} } },
+			description: "Forbidden. You do not have permission to access this resource or to perform this action."
+		},
+		"404": {
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { message: { type: "string" } }
+			} } },
+			description: "Not Found. The requested resource was not found."
+		},
+		"429": {
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { message: { type: "string" } }
+			} } },
+			description: "Too Many Requests. You have exceeded the rate limit. Try again later."
+		},
+		"500": {
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { message: { type: "string" } }
+			} } },
+			description: "Internal Server Error. This is a problem with the server that you cannot fix."
+		},
+		...responses
+	};
+}
+async function generator(endpoints, config) {
+	const components = { schemas: {} };
+	Object.entries(endpoints).forEach(([_, value]) => {
+		const options = value.options;
+		if (!value.path || options.metadata?.SERVER_ONLY) return;
+		if (options.method === "GET") paths[value.path] = { get: {
+			tags: ["Default", ...options.metadata?.openapi?.tags || []],
+			description: options.metadata?.openapi?.description,
+			operationId: options.metadata?.openapi?.operationId,
+			security: [{ bearerAuth: [] }],
+			parameters: getParameters(options),
+			responses: getResponse(options.metadata?.openapi?.responses)
+		} };
+		if (options.method === "POST") {
+			const body = getRequestBody(options);
+			paths[value.path] = { post: {
+				tags: ["Default", ...options.metadata?.openapi?.tags || []],
+				description: options.metadata?.openapi?.description,
+				operationId: options.metadata?.openapi?.operationId,
+				security: [{ bearerAuth: [] }],
+				parameters: getParameters(options),
+				...body ? { requestBody: body } : { requestBody: { content: { "application/json": { schema: {
+					type: "object",
+					properties: {}
+				} } } } },
+				responses: getResponse(options.metadata?.openapi?.responses)
+			} };
+		}
+	});
+	return {
+		openapi: "3.1.1",
+		info: {
+			title: "Better Auth",
+			description: "API Reference for your Better Auth Instance",
+			version: "1.1.0"
+		},
+		components,
+		security: [{ apiKeyCookie: [] }],
+		servers: [{ url: config?.url }],
+		tags: [{
+			name: "Default",
+			description: "Default endpoints that are included with Better Auth by default. These endpoints are not part of any plugin."
+		}],
+		paths
+	};
+}
+const getHTML = (apiReference, config) => `<!doctype html>
+<html>
+  <head>
+    <title>Scalar API Reference</title>
+    <meta charset="utf-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <script
+      id="api-reference"
+      type="application/json">
+    ${JSON.stringify(apiReference)}
+    <\/script>
+	 <script>
+      var configuration = {
+	  	favicon: ${config?.logo ? `data:image/svg+xml;utf8,${encodeURIComponent(config.logo)}` : void 0} ,
+	   	theme: ${config?.theme || "saturn"},
+        metaData: {
+			title: ${config?.title || "Open API Reference"},
+			description: ${config?.description || "Better Call Open API"},
+		}
+      }
+      document.getElementById('api-reference').dataset.configuration =
+        JSON.stringify(configuration)
+    <\/script>
+	  <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
+  </body>
+</html>`;
+
+//#endregion
+export { generator, getHTML };
+//# sourceMappingURL=openapi.mjs.map