caplets 0.7.0 → 0.9.0

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from "node:module";
 import minproc, { stdin, stdout, default as process$1 } from "node:process";
 import { execFileSync } from "node:child_process";
-import minpath, { basename, dirname, extname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+import minpath, { basename, dirname, extname, isAbsolute, join, parse, posix, relative, resolve, win32 } from "node:path";
 import { accessSync, chmodSync, constants, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { createServer } from "node:http";
@@ -180,7 +180,7 @@ const allowsEval = /* @__PURE__ */ cached(() => {
 		return false;
 	}
 });
-function isPlainObject$4(o) {
+function isPlainObject$5(o) {
 	if (isObject(o) === false) return false;
 	const ctor = o.constructor;
 	if (ctor === void 0) return true;
@@ -191,7 +191,7 @@ function isPlainObject$4(o) {
 	return true;
 }
 function shallowClone(o) {
-	if (isPlainObject$4(o)) return { ...o };
+	if (isPlainObject$5(o)) return { ...o };
 	if (Array.isArray(o)) return [...o];
 	if (o instanceof Map) return new Map(o);
 	if (o instanceof Set) return new Set(o);
@@ -274,7 +274,7 @@ function omit(schema, mask) {
 	}));
 }
 function extend(schema, shape) {
-	if (!isPlainObject$4(shape)) throw new Error("Invalid input to extend: expected a plain object");
+	if (!isPlainObject$5(shape)) throw new Error("Invalid input to extend: expected a plain object");
 	const checks = schema._zod.def.checks;
 	if (checks && checks.length > 0) {
 		const existingShape = schema._zod.def.shape;
@@ -290,7 +290,7 @@ function extend(schema, shape) {
 	} }));
 }
 function safeExtend(schema, shape) {
-	if (!isPlainObject$4(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
+	if (!isPlainObject$5(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
 	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
 		const _shape = {
 			...schema._zod.def.shape,
@@ -1904,7 +1904,7 @@ function mergeValues$1(a, b) {
 		valid: true,
 		data: a
 	};
-	if (isPlainObject$4(a) && isPlainObject$4(b)) {
+	if (isPlainObject$5(a) && isPlainObject$5(b)) {
 		const bKeys = Object.keys(b);
 		const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
 		const newObj = {
@@ -1980,7 +1980,7 @@ const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
 		const input = payload.value;
-		if (!isPlainObject$4(input)) {
+		if (!isPlainObject$5(input)) {
 			payload.issues.push({
 				expected: "record",
 				code: "invalid_type",
@@ -9619,7 +9619,7 @@ const { program, createCommand, createArgument, createOption, CommanderError, In
 })))(), 1)).default;
 //#endregion
 //#region package.json
-var version = "0.7.0";
+var version = "0.9.0";
 //#endregion
 //#region node_modules/.pnpm/pkce-challenge@5.0.1/node_modules/pkce-challenge/dist/index.node.js
 let crypto;
@@ -10658,6 +10658,41 @@ async function registerClient(authorizationServerUrl, { metadata, clientMetadata
 	return OAuthClientInformationFullSchema.parse(await response.json());
 }
 //#endregion
+//#region src/config/paths.ts
+function defaultConfigBaseDir(env = process.env, home = homedir(), platform = process.platform) {
+	if (platform === "win32") return env.APPDATA && win32.isAbsolute(env.APPDATA) ? env.APPDATA : win32.join(home, "AppData", "Roaming");
+	return env.XDG_CONFIG_HOME && posix.isAbsolute(env.XDG_CONFIG_HOME) ? env.XDG_CONFIG_HOME : posix.join(home, ".config");
+}
+function defaultStateBaseDir(env = process.env, home = homedir(), platform = process.platform) {
+	if (platform === "win32") return env.LOCALAPPDATA && win32.isAbsolute(env.LOCALAPPDATA) ? env.LOCALAPPDATA : win32.join(home, "AppData", "Local");
+	return env.XDG_STATE_HOME && posix.isAbsolute(env.XDG_STATE_HOME) ? env.XDG_STATE_HOME : posix.join(home, ".local", "state");
+}
+function defaultConfigPath(env = process.env, home = homedir(), platform = process.platform) {
+	return (platform === "win32" ? win32.join : posix.join)(defaultConfigBaseDir(env, home, platform), "caplets", "config.json");
+}
+function defaultAuthDir(env = process.env, home = homedir(), platform = process.platform) {
+	return (platform === "win32" ? win32.join : posix.join)(defaultStateBaseDir(env, home, platform), "caplets", "auth");
+}
+const DEFAULT_CONFIG_PATH = defaultConfigPath();
+const DEFAULT_AUTH_DIR = defaultAuthDir();
+const PROJECT_CONFIG_FILE = join(".caplets", "config.json");
+const TRUST_PROJECT_CAPLETS_ENV = "CAPLETS_TRUST_PROJECT_CAPLETS";
+function resolveConfigPath(path) {
+	return path ?? DEFAULT_CONFIG_PATH;
+}
+function resolveProjectConfigPath(cwd = process.cwd()) {
+	return join(cwd, PROJECT_CONFIG_FILE);
+}
+function resolveCapletsRoot(configPath = resolveConfigPath()) {
+	return dirname(configPath);
+}
+function resolveProjectCapletsRoot(cwd = process.cwd()) {
+	return join(cwd, ".caplets");
+}
+function isTrustedEnvEnabled(value) {
+	return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
+}
+//#endregion
 //#region src/errors.ts
 var CapletsError = class extends Error {
 	code;
@@ -10708,11 +10743,12 @@ function errorResult(error, fallback) {
 }
 //#endregion
 //#region src/auth/store.ts
-function authStorePath(server, authDir = join(homedir(), ".caplets", "auth")) {
+function authStorePath(server, authDir = DEFAULT_AUTH_DIR) {
 	if (!server || server.includes("/") || server.includes("\\") || server.includes("..")) throw new CapletsError("REQUEST_INVALID", `Invalid auth store server name ${server}`);
 	const authRoot = resolve(authDir);
 	const candidate = resolve(authRoot, `${server}.json`);
-	if (candidate !== authRoot && candidate.startsWith(`${authRoot}${sep}`)) return candidate;
+	const relativePath = relative(authRoot, candidate);
+	if (relativePath && !relativePath.startsWith("..") && !isAbsolute(relativePath)) return candidate;
 	throw new CapletsError("REQUEST_INVALID", `Invalid auth store server name ${server}`);
 }
 function readTokenBundle(server, authDir) {
@@ -10780,11 +10816,13 @@ var FileOAuthProvider = class {
 	verifier = base64url(randomBytes(32));
 	stateValue = base64url(randomBytes(24));
 	clientInfo;
+	clientMetadataUrl;
 	constructor(server, redirectUrl, onRedirect, authDir) {
 		this.server = server;
 		this.redirectUrl = redirectUrl;
 		this.onRedirect = onRedirect;
 		this.authDir = authDir;
+		if ((this.server.auth?.type === "oauth2" || this.server.auth?.type === "oidc") && this.server.auth.clientMetadataUrl) this.clientMetadataUrl = this.server.auth.clientMetadataUrl;
 	}
 	get clientMetadata() {
 		return {
@@ -10884,10 +10922,19 @@ async function runOAuthFlow(server, options = {}) {
 			authorizationCode: completion.code,
 			...scope ? { scope } : {}
 		});
+	} catch (error) {
+		throw normalizeMcpOAuthError(server, error);
 	} finally {
 		await callback.close();
 	}
 }
+function normalizeMcpOAuthError(server, error) {
+	if ((server.auth?.type === "oauth2" || server.auth?.type === "oidc") && !server.auth.clientId && !server.auth.clientMetadataUrl && error instanceof Error && error.message.includes("does not support dynamic client registration")) return new CapletsError("AUTH_FAILED", "OAuth is not available for this server without a host-specific OAuth app or PAT auth", {
+		server: server.server,
+		nextAction: "configure_bearer_auth_or_host_oauth_app"
+	});
+	return error;
+}
 async function runGenericOAuthFlow(target, options = {}) {
 	if (target.auth?.type !== "oauth2" && target.auth?.type !== "oidc") throw new CapletsError("REQUEST_INVALID", `${target.server} is not configured for OAuth`);
 	const authConfig = target.auth;
@@ -11057,6 +11104,11 @@ async function resolveGenericClient(target, authConfig, metadata, redirectUri, a
 		...authConfig.clientSecret ? { clientSecret: authConfig.clientSecret } : {},
 		dynamic: false
 	};
+	if (authConfig.clientMetadataUrl) return {
+		clientId: authConfig.clientMetadataUrl,
+		...authConfig.clientSecret ? { clientSecret: authConfig.clientSecret } : {},
+		dynamic: false
+	};
 	if (!metadata.registration_endpoint) throw new CapletsError("AUTH_FAILED", "OAuth clientId is required without dynamic registration", { server: target.server });
 	const response = await fetchJson(metadata.registration_endpoint, target.requestTimeoutMs, {
 		method: "POST",
@@ -11125,8 +11177,9 @@ function assertAllowedAuthUrl(value, label, allowLoopbackHttp = false) {
 	throw new CapletsError("AUTH_FAILED", `${label} must use https except loopback development URLs`);
 }
 function assertTokenBundleMatchesTarget(bundle, target, authConfig) {
+	const configuredClientId = authConfig.clientId ?? authConfig.clientMetadataUrl;
 	const expectedOrigin = protectedResourceOrigin(target, authConfig);
-	if (bundle.authType !== authConfig.type || expectedOrigin && bundle.protectedResourceOrigin !== expectedOrigin || authConfig.clientId && bundle.clientId !== authConfig.clientId || authConfig.issuer && bundle.issuer !== authConfig.issuer) throw new CapletsError("AUTH_REQUIRED", `OAuth credentials for ${target.server} do not match the configured backend`, {
+	if (bundle.authType !== authConfig.type || expectedOrigin && bundle.protectedResourceOrigin !== expectedOrigin || configuredClientId && bundle.clientId !== configuredClientId || authConfig.issuer && bundle.issuer !== authConfig.issuer) throw new CapletsError("AUTH_REQUIRED", `OAuth credentials for ${target.server} do not match the configured backend`, {
 		server: target.server,
 		backend: target.backend,
 		authType: authConfig.type,
@@ -18680,6 +18733,7 @@ function matter(file, options) {
 //#region src/config/validation.ts
 const SERVER_ID_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
 const HEADER_NAME_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const HTTP_BASE_URL_PATTERN = /^(?![a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^/?#]*@)[^?#]*$/;
 const FORBIDDEN_HEADERS = new Set([
 	"accept",
 	"authorization",
@@ -18697,6 +18751,16 @@ const FORBIDDEN_HEADERS = new Set([
 	"transfer-encoding",
 	"upgrade"
 ]);
+function validateHttpActionHeaders(headers, ctx, path) {
+	for (const headerName of Object.keys(headers)) {
+		const normalized = headerName.toLowerCase();
+		if (!HEADER_NAME_PATTERN.test(headerName) || FORBIDDEN_HEADERS.has(normalized)) ctx.addIssue({
+			code: "custom",
+			path: [...path, headerName],
+			message: `header ${headerName} is not allowed`
+		});
+	}
+}
 function isAllowedRemoteUrl(value) {
 	let url;
 	try {
@@ -18712,6 +18776,23 @@ function isAllowedRemoteUrl(value) {
 		"::1"
 	].includes(url.hostname);
 }
+function isAllowedHttpBaseUrl(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return false;
+	}
+	return isAllowedRemoteUrl(value) && !url.username && !url.password && !url.search && !url.hash;
+}
+function isUrl(value) {
+	try {
+		new URL(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
 //#endregion
 //#region src/caplet-files.ts
 const MAX_CAPLET_FILE_BYTES = 128 * 1024;
@@ -18734,6 +18815,7 @@ const capletRemoteAuthSchema = discriminatedUnion("type", [
 		resourceMetadataUrl: string().min(1).optional(),
 		authorizationServerMetadataUrl: string().min(1).optional(),
 		openidConfigurationUrl: string().min(1).optional(),
+		clientMetadataUrl: string().min(1).optional(),
 		clientId: string().min(1).optional(),
 		clientSecret: string().min(1).optional(),
 		scopes: array(string().min(1)).optional(),
@@ -18747,6 +18829,7 @@ const capletRemoteAuthSchema = discriminatedUnion("type", [
 		resourceMetadataUrl: string().min(1).optional(),
 		authorizationServerMetadataUrl: string().min(1).optional(),
 		openidConfigurationUrl: string().min(1).optional(),
+		clientMetadataUrl: string().min(1).optional(),
 		clientId: string().min(1).optional(),
 		clientSecret: string().min(1).optional(),
 		scopes: array(string().min(1)).optional(),
@@ -18771,6 +18854,7 @@ const capletEndpointAuthSchema = discriminatedUnion("type", [
 		resourceMetadataUrl: string().min(1).optional(),
 		authorizationServerMetadataUrl: string().min(1).optional(),
 		openidConfigurationUrl: string().min(1).optional(),
+		clientMetadataUrl: string().min(1).optional(),
 		clientId: string().min(1).optional(),
 		clientSecret: string().min(1).optional(),
 		scopes: array(string().min(1)).optional(),
@@ -18784,6 +18868,7 @@ const capletEndpointAuthSchema = discriminatedUnion("type", [
 		resourceMetadataUrl: string().min(1).optional(),
 		authorizationServerMetadataUrl: string().min(1).optional(),
 		openidConfigurationUrl: string().min(1).optional(),
+		clientMetadataUrl: string().min(1).optional(),
 		clientId: string().min(1).optional(),
 		clientSecret: string().min(1).optional(),
 		scopes: array(string().min(1)).optional(),
@@ -18827,10 +18912,11 @@ const capletMcpServerSchema = object$1({
 		path: ["url"],
 		message: "remote url must use https except loopback development urls"
 	});
-	if (server.auth?.type === "oauth2") for (const field of [
+	if (server.auth?.type === "oauth2" || server.auth?.type === "oidc") for (const field of [
 		"authorizationUrl",
 		"tokenUrl",
 		"issuer",
+		"clientMetadataUrl",
 		"redirectUri"
 	]) {
 		const value = server.auth[field];
@@ -18917,6 +19003,52 @@ const capletGraphQlEndpointSchema = object$1({
 	});
 	validateEndpointAuthHeaders$1(endpoint.auth, ctx);
 });
+const httpScalarMappingSchema$1 = record(string(), union([
+	string(),
+	number$1(),
+	boolean()
+]));
+const capletHttpActionSchema = object$1({
+	method: _enum([
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE"
+	]).describe("HTTP method used for this action."),
+	path: string().min(1).regex(/^\//, "HTTP action path must start with /").describe("URL path appended to the HTTP API baseUrl.").refine((value) => !value.startsWith("//"), "HTTP action path must not start with //").refine((value) => !isUrl(value), "HTTP action path must be a URL path, not a URL"),
+	description: string().min(1).optional().describe("Action capability description."),
+	inputSchema: record(string(), unknown()).optional().describe("JSON Schema for call_tool arguments."),
+	query: httpScalarMappingSchema$1.optional().describe("Query parameter mapping."),
+	headers: httpScalarMappingSchema$1.optional().describe("Request header mapping."),
+	jsonBody: unknown().optional().describe("JSON request body mapping.")
+}).strict().superRefine((action, ctx) => {
+	if (action.method === "GET" && action.jsonBody !== void 0) ctx.addIssue({
+		code: "custom",
+		path: ["jsonBody"],
+		message: "HTTP GET actions must not define jsonBody"
+	});
+});
+const capletHttpApiSchema = object$1({
+	baseUrl: string().min(1).regex(HTTP_BASE_URL_PATTERN, "HTTP API baseUrl must not include credentials, query, or fragment").describe("Base URL for HTTP action requests."),
+	auth: capletEndpointAuthSchema.describe("Explicit HTTP API request auth config. Use {\"type\":\"none\"} for public APIs."),
+	actions: record(string().regex(SERVER_ID_PATTERN), capletHttpActionSchema).refine((actions) => Object.keys(actions).length > 0, "HTTP API must define at least one action").describe("Configured HTTP actions keyed by stable tool name."),
+	requestTimeoutMs: number$1().int().positive().optional().describe("Timeout in milliseconds for HTTP action requests."),
+	maxResponseBytes: number$1().int().positive().optional().describe("Maximum HTTP action response body bytes to read."),
+	disabled: boolean().optional().describe("When true, omit this Caplet from discovery.")
+}).strict().superRefine((api, ctx) => {
+	if (api.baseUrl && !hasEnvReference$1(api.baseUrl) && !isAllowedHttpBaseUrl(api.baseUrl)) ctx.addIssue({
+		code: "custom",
+		path: ["baseUrl"],
+		message: "HTTP API baseUrl must use https except loopback development urls and must not include credentials, query, or fragment"
+	});
+	validateEndpointAuthHeaders$1(api.auth, ctx);
+	for (const [actionName, action] of Object.entries(api.actions)) if (action.headers) validateHttpActionHeaders(action.headers, ctx, [
+		"actions",
+		actionName,
+		"headers"
+	]);
+});
 const capletFileSchema = object$1({
 	$schema: string().url().optional().describe("Optional JSON Schema URL for editor validation."),
 	name: string().trim().min(1).max(80).describe("Human-readable Caplet display name."),
@@ -18924,11 +19056,12 @@ const capletFileSchema = object$1({
 	tags: array(string().trim().min(1).max(80)).optional().describe("Optional tags for grouping or searching Caplets."),
 	mcpServer: capletMcpServerSchema.describe("MCP server backend configuration for this Caplet.").optional(),
 	openapiEndpoint: capletOpenApiEndpointSchema.describe("OpenAPI endpoint backend configuration for this Caplet.").optional(),
-	graphqlEndpoint: capletGraphQlEndpointSchema.describe("GraphQL endpoint backend configuration for this Caplet.").optional()
+	graphqlEndpoint: capletGraphQlEndpointSchema.describe("GraphQL endpoint backend configuration for this Caplet.").optional(),
+	httpApi: capletHttpApiSchema.describe("HTTP API backend configuration for this Caplet.").optional()
 }).strict().superRefine((frontmatter, ctx) => {
-	if (Number(Boolean(frontmatter.mcpServer)) + Number(Boolean(frontmatter.openapiEndpoint)) + Number(Boolean(frontmatter.graphqlEndpoint)) !== 1) ctx.addIssue({
+	if (Number(Boolean(frontmatter.mcpServer)) + Number(Boolean(frontmatter.openapiEndpoint)) + Number(Boolean(frontmatter.graphqlEndpoint)) + Number(Boolean(frontmatter.httpApi)) !== 1) ctx.addIssue({
 		code: "custom",
-		message: "Caplet file must define exactly one backend: mcpServer, openapiEndpoint, or graphqlEndpoint"
+		message: "Caplet file must define exactly one backend: mcpServer, openapiEndpoint, graphqlEndpoint, or httpApi"
 	});
 });
 function loadCapletFiles(root) {
@@ -18936,24 +19069,30 @@ function loadCapletFiles(root) {
 	const servers = {};
 	const openapiEndpoints = {};
 	const graphqlEndpoints = {};
+	const httpApis = {};
 	for (const candidate of discoverCapletFiles(root)) {
-		if (servers[candidate.id] || openapiEndpoints[candidate.id] || graphqlEndpoints[candidate.id]) throw new CapletsError("CONFIG_INVALID", `Duplicate Caplet ID ${candidate.id} under ${root}`);
+		if (servers[candidate.id] || openapiEndpoints[candidate.id] || graphqlEndpoints[candidate.id] || httpApis[candidate.id]) throw new CapletsError("CONFIG_INVALID", `Duplicate Caplet ID ${candidate.id} under ${root}`);
 		const config = readCapletFile(candidate.path);
-		if (isPlainObject$3(config) && config.backend === "openapi") {
+		if (isPlainObject$4(config) && config.backend === "openapi") {
 			const { backend: _backend, ...endpoint } = config;
 			openapiEndpoints[candidate.id] = endpoint;
-		} else if (isPlainObject$3(config) && config.backend === "graphql") {
+		} else if (isPlainObject$4(config) && config.backend === "graphql") {
 			const { backend: _backend, ...endpoint } = config;
 			graphqlEndpoints[candidate.id] = endpoint;
+		} else if (isPlainObject$4(config) && config.backend === "http") {
+			const { backend: _backend, ...endpoint } = config;
+			httpApis[candidate.id] = endpoint;
 		} else servers[candidate.id] = config;
 	}
 	const hasServers = Object.keys(servers).length > 0;
 	const hasOpenApi = Object.keys(openapiEndpoints).length > 0;
 	const hasGraphQl = Object.keys(graphqlEndpoints).length > 0;
-	return hasServers || hasOpenApi || hasGraphQl ? {
+	const hasHttpApis = Object.keys(httpApis).length > 0;
+	return hasServers || hasOpenApi || hasGraphQl || hasHttpApis ? {
 		...hasServers ? { mcpServers: servers } : {},
 		...hasOpenApi ? { openapiEndpoints } : {},
-		...hasGraphQl ? { graphqlEndpoints } : {}
+		...hasGraphQl ? { graphqlEndpoints } : {},
+		...hasHttpApis ? { httpApis } : {}
 	} : void 0;
 }
 function discoverCapletFiles(root) {
@@ -19011,6 +19150,14 @@ function capletToServerConfig(frontmatter, body, baseDir) {
 		...frontmatter.tags ? { tags: frontmatter.tags } : {},
 		body
 	};
+	if (frontmatter.httpApi) return {
+		...frontmatter.httpApi,
+		backend: "http",
+		name: frontmatter.name,
+		description: frontmatter.description,
+		...frontmatter.tags ? { tags: frontmatter.tags } : {},
+		body
+	};
 	return {
 		...frontmatter.mcpServer,
 		name: frontmatter.name,
@@ -19053,7 +19200,7 @@ function parseFrontmatter(text, path) {
 			value: text
 		});
 		matter(file, { strip: true });
-		if (!isPlainObject$3(file.data.matter) || Object.keys(file.data.matter).length === 0) throw new Error("empty frontmatter");
+		if (!isPlainObject$4(file.data.matter) || Object.keys(file.data.matter).length === 0) throw new Error("empty frontmatter");
 		return {
 			frontmatter: file.data.matter,
 			body: String(file)
@@ -19062,7 +19209,7 @@ function parseFrontmatter(text, path) {
 		throw new CapletsError("CONFIG_INVALID", `Caplet file at ${path} has invalid YAML frontmatter`, redactSecrets(error));
 	}
 }
-function isPlainObject$3(value) {
+function isPlainObject$4(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function validateCapletId(id, path) {
@@ -19071,35 +19218,6 @@ function validateCapletId(id, path) {
 function hasEnvReference$1(value) {
 	return /\$\{[A-Za-z_][A-Za-z0-9_]*\}|\$env:[A-Za-z_][A-Za-z0-9_]*/.test(value);
 }
-function isUrl(value) {
-	try {
-		new URL(value);
-		return true;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/config/paths.ts
-const DEFAULT_CONFIG_PATH = join(homedir(), ".caplets", "config.json");
-const DEFAULT_AUTH_DIR = join(homedir(), ".caplets", "auth");
-const PROJECT_CONFIG_FILE = join(".caplets", "config.json");
-const TRUST_PROJECT_CAPLETS_ENV = "CAPLETS_TRUST_PROJECT_CAPLETS";
-function resolveConfigPath(path) {
-	return path ?? DEFAULT_CONFIG_PATH;
-}
-function resolveProjectConfigPath(cwd = process.cwd()) {
-	return join(cwd, PROJECT_CONFIG_FILE);
-}
-function resolveCapletsRoot(configPath = resolveConfigPath()) {
-	return dirname(configPath);
-}
-function resolveProjectCapletsRoot(cwd = process.cwd()) {
-	return join(cwd, ".caplets");
-}
-function isTrustedEnvEnabled(value) {
-	return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
-}
 //#endregion
 //#region src/config.ts
 const NON_INTERPOLATED_SERVER_FIELDS = new Set([
@@ -19126,6 +19244,7 @@ const remoteAuthSchema = discriminatedUnion("type", [
 		resourceMetadataUrl: string().url().optional(),
 		authorizationServerMetadataUrl: string().url().optional(),
 		openidConfigurationUrl: string().url().optional(),
+		clientMetadataUrl: string().url().optional(),
 		clientId: string().min(1).optional(),
 		clientSecret: string().min(1).optional(),
 		scopes: array(string().min(1)).optional(),
@@ -19139,6 +19258,7 @@ const remoteAuthSchema = discriminatedUnion("type", [
 		resourceMetadataUrl: string().url().optional(),
 		authorizationServerMetadataUrl: string().url().optional(),
 		openidConfigurationUrl: string().url().optional(),
+		clientMetadataUrl: string().url().optional(),
 		clientId: string().min(1).optional(),
 		clientSecret: string().min(1).optional(),
 		scopes: array(string().min(1)).optional(),
@@ -19153,6 +19273,7 @@ const oauthLikeAuthSchema = union([object$1({
 	resourceMetadataUrl: string().url().optional(),
 	authorizationServerMetadataUrl: string().url().optional(),
 	openidConfigurationUrl: string().url().optional(),
+	clientMetadataUrl: string().url().optional(),
 	clientId: string().min(1).optional(),
 	clientSecret: string().min(1).optional(),
 	scopes: array(string().min(1)).optional(),
@@ -19165,6 +19286,7 @@ const oauthLikeAuthSchema = union([object$1({
 	resourceMetadataUrl: string().url().optional(),
 	authorizationServerMetadataUrl: string().url().optional(),
 	openidConfigurationUrl: string().url().optional(),
+	clientMetadataUrl: string().url().optional(),
 	clientId: string().min(1).optional(),
 	clientSecret: string().min(1).optional(),
 	scopes: array(string().min(1)).optional(),
@@ -19248,7 +19370,45 @@ const publicGraphQlEndpointSchema = object$1({
 	});
 });
 const normalizedGraphQlEndpointSchema = publicGraphQlEndpointSchema.extend({ body: string().optional() });
-function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, graphQlEndpointValueSchema) {
+const httpScalarMappingSchema = record(string(), union([
+	string(),
+	number$1(),
+	boolean()
+]));
+const httpActionSchema = object$1({
+	method: _enum([
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE"
+	]).describe("HTTP method used for this action."),
+	path: string().min(1).regex(/^\//, "HTTP action path must start with /").describe("URL path appended to the HTTP API baseUrl.").refine((value) => !value.startsWith("//"), "HTTP action path must not start with //").refine((value) => !isUrl(value), "HTTP action path must be a URL path, not a URL"),
+	description: string().min(1).optional().describe("Action capability description."),
+	inputSchema: record(string(), unknown()).optional().describe("JSON Schema for call_tool arguments."),
+	query: httpScalarMappingSchema.optional().describe("Query parameter mapping."),
+	headers: httpScalarMappingSchema.optional().describe("Request header mapping."),
+	jsonBody: unknown().optional().describe("JSON request body mapping.")
+}).strict().superRefine((action, ctx) => {
+	if (action.method === "GET" && action.jsonBody !== void 0) ctx.addIssue({
+		code: "custom",
+		path: ["jsonBody"],
+		message: "HTTP GET actions must not define jsonBody"
+	});
+});
+const publicHttpApiSchema = object$1({
+	name: string().trim().min(1).max(80).describe("Human-readable HTTP API display name."),
+	description: string().describe("Capability description shown to agents before HTTP actions are disclosed.").refine((value) => value.trim().length >= 10, "description must contain at least 10 non-whitespace characters").refine((value) => value.length <= 1500, "description must be at most 1500 characters"),
+	baseUrl: string().url().regex(HTTP_BASE_URL_PATTERN, "HTTP API baseUrl must not include credentials, query, or fragment").describe("Base URL for HTTP action requests."),
+	auth: openApiAuthSchema.describe("Explicit HTTP API request auth config. Use {\"type\":\"none\"} for public APIs."),
+	actions: record(string().regex(SERVER_ID_PATTERN), httpActionSchema).refine((actions) => Object.keys(actions).length > 0, "HTTP API must define at least one action").describe("Configured HTTP actions keyed by stable tool name."),
+	tags: array(string().trim().min(1).max(80)).optional(),
+	requestTimeoutMs: number$1().int().positive().default(6e4).describe("Timeout in milliseconds for HTTP action requests."),
+	maxResponseBytes: number$1().int().positive().default(1e6).describe("Maximum HTTP action response body bytes to read."),
+	disabled: boolean().default(false).describe("When true, omit this HTTP API Caplet.")
+}).strict();
+const normalizedHttpApiSchema = publicHttpApiSchema.extend({ body: string().optional() });
+function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, graphQlEndpointValueSchema, httpApiValueSchema) {
 	return object$1({
 		$schema: string().url().optional().describe("Optional JSON Schema URL for editor validation."),
 		version: literal(1).default(1).describe("Caplets config schema version."),
@@ -19256,7 +19416,8 @@ function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, graphQlE
 		maxSearchLimit: number$1().int().positive().max(50).default(50).describe("Maximum accepted search_tools limit."),
 		mcpServers: record(string().regex(SERVER_ID_PATTERN), serverValueSchema).default({}).describe("Downstream MCP servers keyed by stable server ID."),
 		openapiEndpoints: record(string().regex(SERVER_ID_PATTERN), openApiEndpointValueSchema).default({}).describe("OpenAPI endpoints keyed by stable Caplet ID."),
-		graphqlEndpoints: record(string().regex(SERVER_ID_PATTERN), graphQlEndpointValueSchema).default({}).describe("GraphQL endpoints keyed by stable Caplet ID.")
+		graphqlEndpoints: record(string().regex(SERVER_ID_PATTERN), graphQlEndpointValueSchema).default({}).describe("GraphQL endpoints keyed by stable Caplet ID."),
+		httpApis: record(string().regex(SERVER_ID_PATTERN), httpApiValueSchema).default({}).describe("HTTP APIs keyed by stable Caplet ID.")
 	}).strict().superRefine((config, ctx) => {
 		if (config.defaultSearchLimit > config.maxSearchLimit) ctx.addIssue({
 			code: "custom",
@@ -19410,10 +19571,45 @@ function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, graphQlE
 				"auth"
 			]);
 		}
+		for (const [endpoint, rawValue] of Object.entries(config.httpApis)) {
+			const raw = rawValue;
+			const duplicateBackend = config.mcpServers[endpoint] ? "mcpServers" : config.openapiEndpoints[endpoint] ? "openapiEndpoints" : config.graphqlEndpoints[endpoint] ? "graphqlEndpoints" : void 0;
+			if (duplicateBackend) ctx.addIssue({
+				code: "custom",
+				path: ["httpApis", endpoint],
+				message: `Caplet ID ${endpoint} is already used by ${duplicateBackend}`
+			});
+			if (!SERVER_ID_PATTERN.test(endpoint)) ctx.addIssue({
+				code: "custom",
+				path: ["httpApis", endpoint],
+				message: "HTTP API ID must match ^[a-zA-Z0-9_-]{1,64}$"
+			});
+			if (raw.baseUrl && !isAllowedHttpBaseUrl(raw.baseUrl)) ctx.addIssue({
+				code: "custom",
+				path: [
+					"httpApis",
+					endpoint,
+					"baseUrl"
+				],
+				message: "HTTP API baseUrl must use https except loopback development urls and must not include credentials, query, or fragment"
+			});
+			validateEndpointAuthHeaders(raw.auth, ctx, [
+				"httpApis",
+				endpoint,
+				"auth"
+			]);
+			for (const [actionName, action] of Object.entries(raw.actions)) if (action.headers) validateHttpActionHeaders(action.headers, ctx, [
+				"httpApis",
+				endpoint,
+				"actions",
+				actionName,
+				"headers"
+			]);
+		}
 	});
 }
-const configFileSchema = configSchemaFor(publicServerSchema, publicOpenApiEndpointSchema, publicGraphQlEndpointSchema);
-const normalizedConfigFileSchema = configSchemaFor(normalizedServerSchema, normalizedOpenApiEndpointSchema, normalizedGraphQlEndpointSchema);
+const configFileSchema = configSchemaFor(publicServerSchema, publicOpenApiEndpointSchema, publicGraphQlEndpointSchema, publicHttpApiSchema);
+const normalizedConfigFileSchema = configSchemaFor(normalizedServerSchema, normalizedOpenApiEndpointSchema, normalizedGraphQlEndpointSchema, normalizedHttpApiSchema);
 function loadConfig(path = resolveConfigPath(), projectPath = resolveProjectConfigPath()) {
 	const hasUserConfig = existsSync(path);
 	const hasProjectConfig = existsSync(projectPath);
@@ -19424,7 +19620,7 @@ function loadConfig(path = resolveConfigPath(), projectPath = resolveProjectConf
 	if (!hasUserConfig && !hasProjectConfig && !userCaplets && !projectCaplets) throw new CapletsError("CONFIG_NOT_FOUND", `Caplets config not found at ${path} or ${projectPath}`);
 	try {
 		const config = parseConfig(mergeConfigInputs(userConfig, userCaplets, projectConfig, projectCaplets));
-		if (Object.keys(config.mcpServers).length === 0 && Object.keys(config.openapiEndpoints).length === 0 && Object.keys(config.graphqlEndpoints).length === 0) throw new CapletsError("CONFIG_INVALID", "Caplets config must define at least one MCP server, OpenAPI endpoint, or GraphQL endpoint");
+		if (Object.keys(config.mcpServers).length === 0 && Object.keys(config.openapiEndpoints).length === 0 && Object.keys(config.graphqlEndpoints).length === 0 && Object.keys(config.httpApis).length === 0) throw new CapletsError("CONFIG_INVALID", "Caplets config must define at least one MCP server, OpenAPI endpoint, GraphQL endpoint, or HTTP API");
 		return config;
 	} catch (error) {
 		if (error instanceof CapletsError) throw error;
@@ -19454,7 +19650,7 @@ function normalizeLocalPaths(input, baseDir) {
 }
 function normalizeEndpointPaths(endpoints, baseDir, normalize) {
 	if (!endpoints) return;
-	return Object.fromEntries(Object.entries(endpoints).map(([id, endpoint]) => [id, isPlainObject$2(endpoint) ? normalize(endpoint, baseDir) : endpoint]));
+	return Object.fromEntries(Object.entries(endpoints).map(([id, endpoint]) => [id, isPlainObject$3(endpoint) ? normalize(endpoint, baseDir) : endpoint]));
 }
 function normalizeOpenApiPath(endpoint, baseDir) {
 	return {
@@ -19463,7 +19659,7 @@ function normalizeOpenApiPath(endpoint, baseDir) {
 	};
 }
 function normalizeGraphQlPath(endpoint, baseDir) {
-	const operations = isPlainObject$2(endpoint.operations) ? Object.fromEntries(Object.entries(endpoint.operations).map(([name, operation]) => [name, isPlainObject$2(operation) ? {
+	const operations = isPlainObject$3(endpoint.operations) ? Object.fromEntries(Object.entries(endpoint.operations).map(([name, operation]) => [name, isPlainObject$3(operation) ? {
 		...operation,
 		documentPath: normalizeLocalPath(operation.documentPath, baseDir)
 	} : operation])) : endpoint.operations;
@@ -19480,6 +19676,7 @@ function normalizeLocalPath(value, baseDir) {
 function rejectUntrustedProjectExecutableBackends(input, path) {
 	if (input.openapiEndpoints && Object.keys(input.openapiEndpoints).length > 0) throw new CapletsError("CONFIG_INVALID", `Project config at ${path} cannot define openapiEndpoints; use trusted project Caplet files or user config`);
 	if (input.graphqlEndpoints && Object.keys(input.graphqlEndpoints).length > 0) throw new CapletsError("CONFIG_INVALID", `Project config at ${path} cannot define graphqlEndpoints; use trusted project Caplet files or user config`);
+	if (input.httpApis && Object.keys(input.httpApis).length > 0) throw new CapletsError("CONFIG_INVALID", `Project config at ${path} cannot define httpApis; use trusted project Caplet files or user config`);
 	return input;
 }
 function mergeConfigInputs(...inputs) {
@@ -19500,6 +19697,10 @@ function mergeConfigInputs(...inputs) {
 			graphqlEndpoints: {
 				...merged?.graphqlEndpoints,
 				...input.graphqlEndpoints
+			},
+			httpApis: {
+				...merged?.httpApis,
+				...input.httpApis
 			}
 		};
 	}
@@ -19530,6 +19731,12 @@ function parseConfig(input) {
 		server,
 		backend: "graphql"
 	});
+	const httpApis = {};
+	for (const [server, raw] of Object.entries(parsed.data.httpApis)) httpApis[server] = stripUndefined({
+		...raw,
+		server,
+		backend: "http"
+	});
 	return {
 		version: parsed.data.version,
 		options: {
@@ -19538,7 +19745,8 @@ function parseConfig(input) {
 		},
 		mcpServers: servers,
 		openapiEndpoints,
-		graphqlEndpoints
+		graphqlEndpoints,
+		httpApis
 	};
 }
 function validateEndpointAuthHeaders(auth, ctx, path) {
@@ -19567,10 +19775,10 @@ function interpolateConfig(value, path = []) {
 	return value;
 }
 function isPublicMetadataPath(path) {
-	if (path.length < 3 || path[0] !== "mcpServers" && path[0] !== "openapiEndpoints" && path[0] !== "graphqlEndpoints") return false;
+	if (path.length < 3 || path[0] !== "mcpServers" && path[0] !== "openapiEndpoints" && path[0] !== "graphqlEndpoints" && path[0] !== "httpApis") return false;
 	return NON_INTERPOLATED_SERVER_FIELDS.has(path[2] ?? "");
 }
-function isPlainObject$2(value) {
+function isPlainObject$3(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function hasEnvReference(value) {
@@ -19629,7 +19837,8 @@ function authTargets(config) {
 	return [
 		...Object.values(config.mcpServers).filter((server) => server.transport !== "stdio" && (server.auth?.type === "oauth2" || server.auth?.type === "oidc")),
 		...Object.values(config.openapiEndpoints).filter((endpoint) => endpoint.auth?.type === "oauth2" || endpoint.auth?.type === "oidc"),
-		...Object.values(config.graphqlEndpoints).filter((endpoint) => endpoint.auth?.type === "oauth2" || endpoint.auth?.type === "oidc").map(graphQlAuthTarget)
+		...Object.values(config.graphqlEndpoints).filter((endpoint) => endpoint.auth?.type === "oauth2" || endpoint.auth?.type === "oidc").map(graphQlAuthTarget),
+		...Object.values(config.httpApis).filter((api) => api.auth?.type === "oauth2" || api.auth?.type === "oidc").map(httpAuthTarget)
 	];
 }
 function graphQlAuthTarget(endpoint) {
@@ -19638,6 +19847,9 @@ function graphQlAuthTarget(endpoint) {
 		url: endpoint.endpointUrl
 	};
 }
+function httpAuthTarget(api) {
+	return { ...api };
+}
 function assertLoginTarget(target, serverId) {
 	if (!target) throw new CapletsError("SERVER_NOT_FOUND", `Server ${serverId} is not configured for OAuth`);
 	if ("disabled" in target && target.disabled) throw new CapletsError("SERVER_UNAVAILABLE", `Server ${serverId} is disabled`);
@@ -19725,12 +19937,14 @@ function formatCapletList(rows) {
 }
 function resolveCliConfigPaths(envConfigPath, authDir) {
 	const configPath = resolveConfigPath(envConfigPath);
+	const effectiveAuthDir = authDir ?? DEFAULT_AUTH_DIR;
 	return {
 		userConfig: configPath,
 		projectConfig: resolveProjectConfigPath(),
 		userRoot: resolveCapletsRoot(configPath),
+		stateRoot: dirname(effectiveAuthDir),
 		projectRoot: resolveProjectCapletsRoot(),
-		authDir: authDir ?? DEFAULT_AUTH_DIR,
+		authDir: effectiveAuthDir,
 		envConfig: envConfigPath ?? null,
 		projectCapletsTrusted: isTrustedProjectCapletsEnabled()
 	};
@@ -19740,6 +19954,7 @@ function formatConfigPaths(paths) {
 		`userConfig: ${paths.userConfig}`,
 		`projectConfig: ${paths.projectConfig}`,
 		`userRoot: ${paths.userRoot}`,
+		`stateRoot: ${paths.stateRoot}`,
 		`projectRoot: ${paths.projectRoot}`,
 		`authDir: ${paths.authDir}`,
 		`envConfig: ${paths.envConfig ?? "unset"}`,
@@ -25649,7 +25864,7 @@ var Protocol = class {
 		};
 	}
 };
-function isPlainObject$1(value) {
+function isPlainObject$2(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function mergeCapabilities(base, additional) {
@@ -25659,7 +25874,7 @@ function mergeCapabilities(base, additional) {
 		const addValue = additional[k];
 		if (addValue === void 0) continue;
 		const baseValue = result[k];
-		if (isPlainObject$1(baseValue) && isPlainObject$1(addValue)) result[k] = {
+		if (isPlainObject$2(baseValue) && isPlainObject$2(addValue)) result[k] = {
 			...baseValue,
 			...addValue
 		};
@@ -50843,6 +51058,279 @@ function graphQlCacheKey(endpoint) {
 	});
 }
 //#endregion
+//#region src/http-actions.ts
+const DEFAULT_INPUT_SCHEMA = {
+	type: "object",
+	additionalProperties: true
+};
+var HttpActionManager = class {
+	registry;
+	options;
+	constructor(registry, options = {}) {
+		this.registry = registry;
+		this.options = options;
+	}
+	updateRegistry(registry) {
+		this.registry = registry;
+	}
+	invalidate(_serverId) {}
+	async checkApi(api) {
+		const startedAt = Date.now();
+		try {
+			const operations = operationsFor(api);
+			validateBaseUrl(api);
+			authHeaders$1(api, this.options.authDir);
+			for (const operation of operations) validateAction(api, operation);
+			this.registry.setStatus(api.server, "available");
+			return {
+				server: api.server,
+				status: "available",
+				toolCount: operations.length,
+				elapsedMs: Date.now() - startedAt
+			};
+		} catch (error) {
+			const safe = toSafeError(error, "SERVER_UNAVAILABLE");
+			this.registry.setStatus(api.server, "unavailable", safe);
+			return {
+				server: api.server,
+				status: "unavailable",
+				elapsedMs: Date.now() - startedAt,
+				error: safe
+			};
+		}
+	}
+	async listTools(api) {
+		return operationsFor(api).map((operation) => this.toTool(operation));
+	}
+	async getTool(api, toolName) {
+		return this.toTool(getOperation(api, toolName));
+	}
+	async callTool(api, toolName, args) {
+		const operation = getOperation(api, toolName);
+		const startedAt = Date.now();
+		const request = buildRequest$1(api, operation, args, this.options.authDir);
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), api.requestTimeoutMs);
+		try {
+			const response = await fetch(request.url, {
+				method: operation.method,
+				headers: request.headers,
+				redirect: "manual",
+				signal: controller.signal,
+				...request.body === void 0 ? {} : { body: request.body }
+			});
+			if (response.status >= 300 && response.status < 400) throw new CapletsError("DOWNSTREAM_PROTOCOL_ERROR", "HTTP action request returned a redirect", {
+				server: api.server,
+				status: response.status,
+				location: response.headers.get("location") ? "[REDACTED]" : void 0
+			});
+			const parsed = await readResponse$1(response, api, Date.now() - startedAt);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(parsed, null, 2)
+				}],
+				structuredContent: parsed,
+				isError: !response.ok
+			};
+		} catch (error) {
+			if (isAbortError(error)) throw new CapletsError("TOOL_CALL_TIMEOUT", `HTTP action request timed out for ${api.server}/${toolName}`);
+			if (error instanceof CapletsError) throw error;
+			throw new CapletsError("DOWNSTREAM_TOOL_ERROR", `HTTP action request failed for ${api.server}/${toolName}`, toSafeError(error));
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+	compact(api, tool) {
+		return {
+			server: api.server,
+			tool: tool.name,
+			...tool.description ? { description: tool.description } : {},
+			...tool.annotations ? { annotations: tool.annotations } : {},
+			hasInputSchema: Boolean(tool.inputSchema)
+		};
+	}
+	search(api, tools, query, limit) {
+		const needle = query.toLocaleLowerCase();
+		return tools.filter((tool) => `${tool.name}\n${tool.description ?? ""}`.toLocaleLowerCase().includes(needle)).sort((left, right) => left.name.localeCompare(right.name)).slice(0, limit).map((tool) => this.compact(api, tool));
+	}
+	toTool(operation) {
+		return {
+			name: operation.name,
+			...operation.description ? { description: operation.description } : {},
+			inputSchema: operation.inputSchema ?? DEFAULT_INPUT_SCHEMA,
+			annotations: {
+				readOnlyHint: operation.method === "GET",
+				destructiveHint: operation.method === "DELETE"
+			}
+		};
+	}
+};
+function operationsFor(api) {
+	return Object.entries(api.actions).map(([name, action]) => ({
+		name,
+		...action
+	})).sort((left, right) => left.name.localeCompare(right.name));
+}
+function getOperation(api, toolName) {
+	const operations = operationsFor(api);
+	const operation = operations.find((candidate) => candidate.name === toolName);
+	if (!operation) throw new CapletsError("TOOL_NOT_FOUND", `Tool ${toolName} was not found on ${api.server}`, {
+		server: api.server,
+		tool: toolName,
+		suggestions: operations.map((candidate) => candidate.name).filter((name) => name.toLocaleLowerCase().includes(toolName.toLocaleLowerCase()[0] ?? "")).slice(0, 5)
+	});
+	return operation;
+}
+function buildRequest$1(api, operation, args, authDir) {
+	validateBaseUrl(api);
+	validateAction(api, operation);
+	const url = buildActionUrl(api.baseUrl, substitutePath$1(operation.path, args, operation), { allowEncodedSlash: true });
+	const query = resolveMappingToRecord(operation.query, args, "query");
+	for (const [key, value] of Object.entries(query)) if (value !== void 0 && value !== null) url.searchParams.append(key, serializeHttpValue$1("query", key, value));
+	const headers = new Headers();
+	applyAuth$1(headers, api, authDir);
+	const resolvedHeaders = resolveMappingToRecord(operation.headers, args, "headers");
+	for (const [key, value] of Object.entries(resolvedHeaders)) if (value !== void 0 && value !== null) {
+		validateResolvedHeader(api, operation, key);
+		headers.set(key, serializeHttpValue$1("header", key, value));
+	}
+	const bodyValue = resolveMapping(operation.jsonBody, args);
+	if (operation.jsonBody !== void 0) {
+		if (bodyValue === void 0) throw new CapletsError("REQUEST_INVALID", "HTTP action jsonBody must not resolve to undefined");
+		headers.set("content-type", "application/json");
+		return {
+			url,
+			headers,
+			body: JSON.stringify(bodyValue)
+		};
+	}
+	return {
+		url,
+		headers
+	};
+}
+function substitutePath$1(path, args, operation) {
+	return path.replace(/\{([^}]+)\}/g, (_match, name) => {
+		const value = args[name];
+		if (value === void 0 || value === null || value === "") throw new CapletsError("REQUEST_INVALID", `Missing required path parameter ${name}`, { tool: operation.name });
+		return encodeURIComponent(serializeHttpValue$1("path", name, value));
+	});
+}
+function resolveMapping(mapping, input) {
+	if (typeof mapping === "string") {
+		if (mapping === "$input") return input;
+		if (mapping.startsWith("$input.")) return valueAtPath(input, mapping.slice(7));
+		return mapping;
+	}
+	if (Array.isArray(mapping)) return mapping.map((item) => resolveMapping(item, input));
+	if (mapping && typeof mapping === "object") return Object.fromEntries(Object.entries(mapping).map(([key, value]) => [key, resolveMapping(value, input)]));
+	return mapping;
+}
+function resolveMappingToRecord(mapping, input, name) {
+	if (mapping === void 0) return {};
+	const resolved = resolveMapping(mapping, input);
+	if (!isPlainObject$1(resolved)) throw new CapletsError("REQUEST_INVALID", `HTTP action ${name} mapping must resolve to an object`);
+	return resolved;
+}
+function valueAtPath(input, path) {
+	let current = input;
+	for (const segment of path.split(".")) {
+		if (!current || typeof current !== "object" || Array.isArray(current)) return;
+		current = current[segment];
+	}
+	return current;
+}
+function validateAction(api, operation) {
+	buildActionUrl(api.baseUrl, operation.path);
+	validateConfiguredHeaders(api, operation);
+}
+function validateConfiguredHeaders(api, operation) {
+	const configured = asRecord$1(operation.headers);
+	for (const key of Object.keys(configured)) validateResolvedHeader(api, operation, key);
+}
+function validateResolvedHeader(api, operation, key) {
+	const authHeaderNames = api.auth.type === "headers" ? new Set(Object.keys(api.auth.headers).map((header) => header.toLowerCase())) : /* @__PURE__ */ new Set();
+	const normalized = key.toLowerCase();
+	if (FORBIDDEN_HEADERS.has(normalized) || authHeaderNames.has(normalized)) throw new CapletsError("CONFIG_INVALID", `HTTP action header ${key} is not allowed`, {
+		server: api.server,
+		tool: operation.name
+	});
+}
+function serializeHttpValue$1(location, name, value) {
+	switch (typeof value) {
+		case "string":
+		case "number":
+		case "boolean": return String(value);
+		default: throw new CapletsError("REQUEST_INVALID", `HTTP action ${location} parameter ${name} must be a string, number, or boolean`);
+	}
+}
+function applyAuth$1(headers, api, authDir) {
+	for (const [key, value] of Object.entries(authHeaders$1(api, authDir))) headers.set(key, value);
+}
+function authHeaders$1(api, authDir) {
+	switch (api.auth.type) {
+		case "none": return {};
+		case "bearer": return { authorization: `Bearer ${api.auth.token}` };
+		case "headers": return api.auth.headers;
+		case "oauth2":
+		case "oidc": return genericOAuthHeaders({
+			server: api.server,
+			backend: "http",
+			baseUrl: api.baseUrl,
+			auth: api.auth,
+			requestTimeoutMs: api.requestTimeoutMs
+		}, authDir);
+	}
+}
+async function readResponse$1(response, api, elapsedMs) {
+	const contentType = response.headers.get("content-type") ?? "";
+	const body = parseHttpBody(contentType, await readLimitedText(response, {
+		maxBytes: maxResponseBytes(api),
+		errorMessage: "HTTP action response exceeded byte limit"
+	}));
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers: { "content-type": contentType },
+		...body === void 0 ? {} : { body },
+		elapsedMs
+	};
+}
+function maxResponseBytes(api) {
+	return api.maxResponseBytes;
+}
+function validateBaseUrl(api) {
+	if (!isAllowedRemoteUrl(api.baseUrl)) throw new CapletsError("CONFIG_INVALID", `${api.server} HTTP API baseUrl is not allowed`);
+	const url = new URL(api.baseUrl);
+	if (url.username || url.password || url.search || url.hash) throw new CapletsError("CONFIG_INVALID", `${api.server} HTTP API baseUrl must not include credentials, query, or fragment`);
+}
+function buildActionUrl(base, actionPath, options = {}) {
+	if (/^[a-z][a-z0-9+.-]*:/i.test(actionPath) || actionPath.startsWith("//")) throw new CapletsError("CONFIG_INVALID", "HTTP action path cannot change origin");
+	for (const rawSegment of actionPath.split("/")) {
+		let segment;
+		try {
+			segment = decodeURIComponent(rawSegment);
+		} catch {
+			throw new CapletsError("CONFIG_INVALID", "HTTP action path contains invalid encoding");
+		}
+		if (segment === "." || segment === ".." || !options.allowEncodedSlash && segment.includes("/")) throw new CapletsError("CONFIG_INVALID", "HTTP action path cannot contain dot segments");
+	}
+	const baseUrl = new URL(base);
+	const originalOrigin = baseUrl.origin;
+	const basePath = baseUrl.pathname.replace(/\/+$/, "");
+	baseUrl.pathname = [basePath, actionPath.replace(/^\/+/, "")].filter(Boolean).join("/");
+	if (baseUrl.origin !== originalOrigin) throw new CapletsError("CONFIG_INVALID", "HTTP action path cannot change origin");
+	if (basePath && baseUrl.pathname !== basePath && !baseUrl.pathname.startsWith(`${basePath}/`)) throw new CapletsError("CONFIG_INVALID", "HTTP action path cannot escape baseUrl path");
+	return baseUrl;
+}
+function asRecord$1(value) {
+	return isPlainObject$1(value) ? value : {};
+}
+function isPlainObject$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
 //#region node_modules/.pnpm/@apidevtools+swagger-parser@12.1.0_openapi-types@12.1.3/node_modules/@apidevtools/swagger-parser/lib/util.js
 var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const util = __require("util");
@@ -60731,7 +61219,7 @@ var ServerRegistry = class {
 		return this.allCaplets().filter((server) => !server.disabled);
 	}
 	get(serverId) {
-		const server = this.config.mcpServers[serverId] ?? this.config.openapiEndpoints[serverId] ?? this.config.graphqlEndpoints[serverId];
+		const server = this.config.mcpServers[serverId] ?? this.config.openapiEndpoints[serverId] ?? this.config.graphqlEndpoints[serverId] ?? this.config.httpApis[serverId];
 		return server?.disabled ? void 0 : server;
 	}
 	require(serverId) {
@@ -60781,12 +61269,13 @@ var ServerRegistry = class {
 		return [
 			...Object.values(this.config.mcpServers),
 			...Object.values(this.config.openapiEndpoints),
-			...Object.values(this.config.graphqlEndpoints)
+			...Object.values(this.config.graphqlEndpoints),
+			...Object.values(this.config.httpApis)
 		];
 	}
 };
 function capabilityDescription(server) {
-	const backendName = server.backend === "mcp" ? "MCP server" : server.backend === "openapi" ? "OpenAPI endpoint" : "GraphQL endpoint";
+	const backendName = server.backend === "mcp" ? "MCP server" : server.backend === "openapi" ? "OpenAPI endpoint" : server.backend === "graphql" ? "GraphQL endpoint" : "HTTP API";
 	const checkOperation = server.backend === "mcp" ? "check_mcp_server" : "check_backend";
 	const hint = [
 		`Use this Caplet to inspect and call tools from its ${backendName} backend.`,
@@ -60818,6 +61307,12 @@ function backendDetail(server) {
 		source: graphQlSource(server),
 		configuredOperations: Boolean(server.operations && Object.keys(server.operations).length > 0)
 	};
+	if (server.backend === "http") return {
+		type: "http",
+		disabled: server.disabled,
+		requestTimeoutMs: server.requestTimeoutMs,
+		configuredActions: Object.keys(server.actions).length
+	};
 	return {
 		type: "mcp",
 		transport: server.transport,
@@ -60854,16 +61349,16 @@ const generatedToolInputSchema = object$1({
 	tool: string().optional().describe("Exact downstream tool name for get_tool or call_tool. Example: {\"operation\":\"get_tool\",\"tool\":\"web_search_exa\"} before calling it."),
 	arguments: record(string(), unknown()).optional().describe("Required JSON object only for call_tool. Put every downstream tool input inside this object. Example: {\"operation\":\"call_tool\",\"tool\":\"web_search_exa\",\"arguments\":{\"query\":\"latest MCP docs\",\"numResults\":3}}. Do not send downstream inputs as top-level query, limit, url, path, or other fields.")
 }).strict();
-async function handleServerTool(server, request, registry, downstream, openapi, graphql) {
+async function handleServerTool(server, request, registry, downstream, openapi, graphql, http) {
 	const parsed = validateOperationRequest(request, registry.config.options.maxSearchLimit);
 	switch (parsed.operation) {
 		case "get_caplet": return jsonResult(registry.detail(server));
-		case "check_backend": return jsonResult(await backendFor(server, downstream, openapi, graphql).check(server));
+		case "check_backend": return jsonResult(await backendFor(server, downstream, openapi, graphql, http).check(server));
 		case "check_mcp_server":
 			if (server.backend !== "mcp") throw new CapletsError("REQUEST_INVALID", "check_mcp_server is only valid for MCP-backed Caplets; use check_backend");
 			return jsonResult(await downstream.checkServer(server));
 		case "list_tools": {
-			const backend = backendFor(server, downstream, openapi, graphql);
+			const backend = backendFor(server, downstream, openapi, graphql, http);
 			const tools = await backend.listTools(server);
 			return jsonResult({
 				server: server.server,
@@ -60871,7 +61366,7 @@ async function handleServerTool(server, request, registry, downstream, openapi,
 			});
 		}
 		case "search_tools": {
-			const backend = backendFor(server, downstream, openapi, graphql);
+			const backend = backendFor(server, downstream, openapi, graphql, http);
 			const tools = await backend.listTools(server);
 			const limit = parsed.limit ?? registry.config.options.defaultSearchLimit;
 			return jsonResult({
@@ -60881,13 +61376,13 @@ async function handleServerTool(server, request, registry, downstream, openapi,
 			});
 		}
 		case "get_tool": {
-			const tool = await backendFor(server, downstream, openapi, graphql).getTool(server, parsed.tool);
+			const tool = await backendFor(server, downstream, openapi, graphql, http).getTool(server, parsed.tool);
 			return jsonResult({
 				server: server.server,
 				tool
 			});
 		}
-		case "call_tool": return backendFor(server, downstream, openapi, graphql).callTool(server, parsed.tool, parsed.arguments);
+		case "call_tool": return backendFor(server, downstream, openapi, graphql, http).callTool(server, parsed.tool, parsed.arguments);
 	}
 }
 function validateOperationRequest(request, maxSearchLimit) {
@@ -60950,7 +61445,7 @@ function jsonResult(value) {
 function isPlainObject(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function backendFor(server, downstream, openapi, graphql) {
+function backendFor(server, downstream, openapi, graphql, http) {
 	if (server.backend === "mcp") return {
 		check: (...args) => downstream.checkServer(...args),
 		listTools: (...args) => downstream.listTools(...args),
@@ -60970,6 +61465,17 @@ function backendFor(server, downstream, openapi, graphql) {
 			search: (...args) => graphql.search(...args)
 		};
 	}
+	if (server.backend === "http") {
+		if (!http) throw new CapletsError("INTERNAL_ERROR", "HTTP action manager is not configured");
+		return {
+			check: (...args) => http.checkApi(...args),
+			listTools: (...args) => http.listTools(...args),
+			getTool: (...args) => http.getTool(...args),
+			callTool: (...args) => http.callTool(...args),
+			compact: (...args) => http.compact(...args),
+			search: (...args) => http.search(...args)
+		};
+	}
 	if (!openapi) throw new CapletsError("INTERNAL_ERROR", "OpenAPI manager is not configured");
 	return {
 		check: (...args) => openapi.checkEndpoint(...args),
@@ -60988,6 +61494,7 @@ var CapletsRuntime = class {
 	downstream;
 	openapi;
 	graphql;
+	http;
 	tools = /* @__PURE__ */ new Map();
 	paths;
 	watchDebounceMs;
@@ -61008,6 +61515,7 @@ var CapletsRuntime = class {
 		this.downstream = new DownstreamManager(this.registry, selectAuthOptions(options.authDir));
 		this.openapi = new OpenApiManager(this.registry, selectAuthOptions(options.authDir));
 		this.graphql = new GraphQLManager(this.registry, selectAuthOptions(options.authDir));
+		this.http = new HttpActionManager(this.registry, selectAuthOptions(options.authDir));
 		this.server = options.server ?? new McpServer({
 			name: "caplets",
 			version
@@ -61083,6 +61591,7 @@ var CapletsRuntime = class {
 		this.downstream.updateRegistry(nextRegistry);
 		this.openapi.updateRegistry(nextRegistry);
 		this.graphql.updateRegistry(nextRegistry);
+		this.http.updateRegistry(nextRegistry);
 		let invalidated = true;
 		try {
 			await this.invalidateChangedBackends(previousConfig, nextConfig);
@@ -61141,7 +61650,7 @@ var CapletsRuntime = class {
 	}
 	async handleTool(serverId, request) {
 		try {
-			return await handleServerTool(this.registry.require(serverId), request, this.registry, this.downstream, this.openapi, this.graphql);
+			return await handleServerTool(this.registry.require(serverId), request, this.registry, this.downstream, this.openapi, this.graphql, this.http);
 		} catch (error) {
 			return errorResult(error);
 		}
@@ -61157,6 +61666,7 @@ var CapletsRuntime = class {
 			if (before?.backend === "mcp") await this.downstream.closeServer(serverId);
 			if (before?.backend === "openapi" || after?.backend === "openapi" || !after) this.openapi.invalidate(serverId);
 			if (before?.backend === "graphql" || after?.backend === "graphql" || !after) this.graphql.invalidate(serverId);
+			if (before?.backend === "http" || after?.backend === "http" || !after) this.http.invalidate(serverId);
 		}
 	}
 	resetWatchers() {
@@ -61248,14 +61758,15 @@ function allCaplets(config) {
 	return [
 		...Object.values(config.mcpServers),
 		...Object.values(config.openapiEndpoints),
-		...Object.values(config.graphqlEndpoints)
+		...Object.values(config.graphqlEndpoints),
+		...Object.values(config.httpApis)
 	];
 }
 function nextEnabledServers(config) {
 	return allCaplets(config).filter((server) => !server.disabled);
 }
 function capletById(config, serverId) {
-	return config.mcpServers[serverId] ?? config.openapiEndpoints[serverId] ?? config.graphqlEndpoints[serverId];
+	return config.mcpServers[serverId] ?? config.openapiEndpoints[serverId] ?? config.graphqlEndpoints[serverId] ?? config.httpApis[serverId];
 }
 function serializeCaplet(caplet) {
 	return JSON.stringify(caplet ?? null);