@caplets/core 0.12.2 → 0.13.0

package/dist/{engine-BzekyZ5r.js → engine-D_zyCvXx.js}

@@ -1,4 +1,4 @@
-import { generatedToolInputDescriptions, operations } from "./generated-tool-input-schema.js";
+import { generatedToolInputDescriptions, generatedToolInputJsonSchema, operations } from "./generated-tool-input-schema.js";
 import { createRequire } from "node:module";
 import { accessSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import minpath, { basename, delimiter, dirname, extname, isAbsolute, join, parse, posix, relative, resolve, win32 } from "node:path";
@@ -26433,6 +26433,24 @@ const capletCliToolsSchema = object({
 	maxOutputBytes: number$1().int().positive().optional(),
 	disabled: boolean().optional().describe("When true, omit this Caplet from discovery.")
 }).strict();
+const capletSetSchema = object({
+	configPath: string().min(1).optional().describe("Child Caplets config.json path."),
+	capletsRoot: string().min(1).optional().describe("Child Markdown Caplets root directory."),
+	defaultSearchLimit: number$1().int().positive().optional(),
+	maxSearchLimit: number$1().int().positive().max(50).optional(),
+	toolCacheTtlMs: number$1().int().nonnegative().optional(),
+	disabled: boolean().optional().describe("When true, omit this Caplet from discovery.")
+}).strict().superRefine((set, ctx) => {
+	if (!set.configPath && !set.capletsRoot) ctx.addIssue({
+		code: "custom",
+		message: "capletSet must define at least one source: configPath or capletsRoot"
+	});
+	if (set.defaultSearchLimit !== void 0 && set.maxSearchLimit !== void 0 && set.defaultSearchLimit > set.maxSearchLimit) ctx.addIssue({
+		code: "custom",
+		path: ["defaultSearchLimit"],
+		message: "defaultSearchLimit must be <= maxSearchLimit"
+	});
+});
 const capletFileSchema = object({
 	$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."),
@@ -26442,13 +26460,17 @@ const capletFileSchema = object({
 	openapiEndpoint: capletOpenApiEndpointSchema.describe("OpenAPI 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(),
-	cliTools: capletCliToolsSchema.describe("CLI tools backend configuration for this Caplet.").optional()
+	cliTools: capletCliToolsSchema.describe("CLI tools backend configuration for this Caplet.").optional(),
+	capletSet: capletSetSchema.describe("Nested Caplet collection backend configuration for this Caplet.").optional()
 }).strict().superRefine((frontmatter, ctx) => {
-	if (Number(Boolean(frontmatter.mcpServer)) + Number(Boolean(frontmatter.openapiEndpoint)) + Number(Boolean(frontmatter.graphqlEndpoint)) + Number(Boolean(frontmatter.httpApi)) + Number(Boolean(frontmatter.cliTools)) !== 1) ctx.addIssue({
+	if (Number(Boolean(frontmatter.mcpServer)) + Number(Boolean(frontmatter.openapiEndpoint)) + Number(Boolean(frontmatter.graphqlEndpoint)) + Number(Boolean(frontmatter.httpApi)) + Number(Boolean(frontmatter.cliTools)) + Number(Boolean(frontmatter.capletSet)) !== 1) ctx.addIssue({
 		code: "custom",
-		message: "Caplet file must define exactly one backend: mcpServer, openapiEndpoint, graphqlEndpoint, httpApi, or cliTools"
+		message: "Caplet file must define exactly one backend: mcpServer, openapiEndpoint, graphqlEndpoint, httpApi, cliTools, or capletSet"
 	});
 });
+function loadCapletFiles(root) {
+	return loadCapletFilesWithPaths(root)?.config;
+}
 function loadCapletFilesWithPaths(root) {
 	if (!existsSync(root)) return;
 	const servers = {};
@@ -26456,9 +26478,10 @@ function loadCapletFilesWithPaths(root) {
 	const graphqlEndpoints = {};
 	const httpApis = {};
 	const cliTools = {};
+	const capletSets = {};
 	const paths = {};
 	for (const candidate of discoverCapletFiles(root)) {
-		if (servers[candidate.id] || openapiEndpoints[candidate.id] || graphqlEndpoints[candidate.id] || httpApis[candidate.id] || cliTools[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] || cliTools[candidate.id] || capletSets[candidate.id]) throw new CapletsError("CONFIG_INVALID", `Duplicate Caplet ID ${candidate.id} under ${root}`);
 		paths[candidate.id] = candidate.path;
 		const config = readCapletFile(candidate.path);
 		if (isPlainObject$5(config) && config.backend === "openapi") {
@@ -26473,6 +26496,9 @@ function loadCapletFilesWithPaths(root) {
 		} else if (isPlainObject$5(config) && config.backend === "cli") {
 			const { backend: _backend, ...endpoint } = config;
 			cliTools[candidate.id] = endpoint;
+		} else if (isPlainObject$5(config) && config.backend === "caplets") {
+			const { backend: _backend, ...endpoint } = config;
+			capletSets[candidate.id] = endpoint;
 		} else servers[candidate.id] = config;
 	}
 	const hasServers = Object.keys(servers).length > 0;
@@ -26480,13 +26506,15 @@ function loadCapletFilesWithPaths(root) {
 	const hasGraphQl = Object.keys(graphqlEndpoints).length > 0;
 	const hasHttpApis = Object.keys(httpApis).length > 0;
 	const hasCliTools = Object.keys(cliTools).length > 0;
-	return hasServers || hasOpenApi || hasGraphQl || hasHttpApis || hasCliTools ? {
+	const hasCapletSets = Object.keys(capletSets).length > 0;
+	return hasServers || hasOpenApi || hasGraphQl || hasHttpApis || hasCliTools || hasCapletSets ? {
 		config: {
 			...hasServers ? { mcpServers: servers } : {},
 			...hasOpenApi ? { openapiEndpoints } : {},
 			...hasGraphQl ? { graphqlEndpoints } : {},
 			...hasHttpApis ? { httpApis } : {},
-			...hasCliTools ? { cliTools } : {}
+			...hasCliTools ? { cliTools } : {},
+			...hasCapletSets ? { capletSets } : {}
 		},
 		paths
 	} : void 0;
@@ -26564,6 +26592,16 @@ function capletToServerConfig(frontmatter, body, baseDir) {
 		...frontmatter.tags ? { tags: frontmatter.tags } : {},
 		body
 	};
+	if (frontmatter.capletSet) return {
+		...frontmatter.capletSet,
+		configPath: normalizeLocalPath$1(frontmatter.capletSet.configPath, baseDir),
+		capletsRoot: normalizeLocalPath$1(frontmatter.capletSet.capletsRoot, baseDir),
+		backend: "caplets",
+		name: frontmatter.name,
+		description: frontmatter.description,
+		...frontmatter.tags ? { tags: frontmatter.tags } : {},
+		body
+	};
 	return {
 		...frontmatter.mcpServer,
 		name: frontmatter.name,
@@ -26884,7 +26922,29 @@ const publicCliToolsSchema = object({
 	disabled: boolean().default(false).describe("When true, omit this CLI tools Caplet.")
 }).strict();
 const normalizedCliToolsSchema = publicCliToolsSchema.extend({ body: string().optional() });
-function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, graphQlEndpointValueSchema, httpApiValueSchema, cliToolsValueSchema) {
+const publicCapletSetSchema = object({
+	name: string().trim().min(1).max(80).describe("Human-readable Caplet set display name."),
+	description: string().describe("Capability description shown before child Caplets 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"),
+	configPath: string().min(1).optional().describe("Child Caplets config.json path."),
+	capletsRoot: string().min(1).optional().describe("Child Markdown Caplets root directory."),
+	defaultSearchLimit: number$1().int().positive().default(20).describe("Default maximum number of child Caplet search results."),
+	maxSearchLimit: number$1().int().positive().max(50).default(50).describe("Maximum accepted child Caplet search result limit."),
+	toolCacheTtlMs: number$1().int().nonnegative().default(3e4).describe("Milliseconds child Caplet metadata stays fresh. Set 0 to refresh every time."),
+	tags: array(string().trim().min(1).max(80)).optional(),
+	disabled: boolean().default(false).describe("When true, omit this Caplet set.")
+}).strict().superRefine((set, ctx) => {
+	if (!set.configPath && !set.capletsRoot) ctx.addIssue({
+		code: "custom",
+		message: "Caplet set must define at least one source: configPath or capletsRoot"
+	});
+	if (set.defaultSearchLimit > set.maxSearchLimit) ctx.addIssue({
+		code: "custom",
+		path: ["defaultSearchLimit"],
+		message: "defaultSearchLimit must be <= maxSearchLimit"
+	});
+});
+const normalizedCapletSetSchema = publicCapletSetSchema.extend({ body: string().optional() });
+function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, graphQlEndpointValueSchema, httpApiValueSchema, cliToolsValueSchema, capletSetValueSchema) {
 	return object({
 		$schema: string().url().optional().describe("Optional JSON Schema URL for editor validation."),
 		version: literal(1).default(1).describe("Caplets config schema version."),
@@ -26894,7 +26954,8 @@ function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, graphQlE
 		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."),
 		httpApis: record(string().regex(SERVER_ID_PATTERN), httpApiValueSchema).default({}).describe("HTTP APIs keyed by stable Caplet ID."),
-		cliTools: record(string().regex(SERVER_ID_PATTERN), cliToolsValueSchema).default({}).describe("CLI tools keyed by stable Caplet ID.")
+		cliTools: record(string().regex(SERVER_ID_PATTERN), cliToolsValueSchema).default({}).describe("CLI tools keyed by stable Caplet ID."),
+		capletSets: record(string().regex(SERVER_ID_PATTERN), capletSetValueSchema).default({}).describe("Nested Caplet collections keyed by stable Caplet ID.")
 	}).strict().superRefine((config, ctx) => {
 		if (config.defaultSearchLimit > config.maxSearchLimit) ctx.addIssue({
 			code: "custom",
@@ -27107,10 +27168,29 @@ function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, graphQlE
 				message: "CLI action ID must match ^[a-zA-Z0-9_-]{1,64}$"
 			});
 		}
+		for (const [server, rawValue] of Object.entries(config.capletSets)) {
+			const raw = rawValue;
+			const duplicateBackend = config.mcpServers[server] ? "mcpServers" : config.openapiEndpoints[server] ? "openapiEndpoints" : config.graphqlEndpoints[server] ? "graphqlEndpoints" : config.httpApis[server] ? "httpApis" : config.cliTools[server] ? "cliTools" : void 0;
+			if (duplicateBackend) ctx.addIssue({
+				code: "custom",
+				path: ["capletSets", server],
+				message: `Caplet ID ${server} is already used by ${duplicateBackend}`
+			});
+			if (!SERVER_ID_PATTERN.test(server)) ctx.addIssue({
+				code: "custom",
+				path: ["capletSets", server],
+				message: "Caplet set ID must match ^[a-zA-Z0-9_-]{1,64}$"
+			});
+			if (!raw.configPath && !raw.capletsRoot) ctx.addIssue({
+				code: "custom",
+				path: ["capletSets", server],
+				message: "Caplet set must define at least one source: configPath or capletsRoot"
+			});
+		}
 	});
 }
-const configFileSchema = configSchemaFor(publicServerSchema, publicOpenApiEndpointSchema, publicGraphQlEndpointSchema, publicHttpApiSchema, publicCliToolsSchema);
-const normalizedConfigFileSchema = configSchemaFor(normalizedServerSchema, normalizedOpenApiEndpointSchema, normalizedGraphQlEndpointSchema, normalizedHttpApiSchema, normalizedCliToolsSchema);
+const configFileSchema = configSchemaFor(publicServerSchema, publicOpenApiEndpointSchema, publicGraphQlEndpointSchema, publicHttpApiSchema, publicCliToolsSchema, publicCapletSetSchema);
+const normalizedConfigFileSchema = configSchemaFor(normalizedServerSchema, normalizedOpenApiEndpointSchema, normalizedGraphQlEndpointSchema, normalizedHttpApiSchema, normalizedCliToolsSchema, normalizedCapletSetSchema);
 function loadConfig(path = resolveConfigPath(), projectPath = resolveProjectConfigPath()) {
 	return loadConfigWithSources(path, projectPath).config;
 }
@@ -27150,7 +27230,7 @@ function loadConfigWithSources(path = resolveConfigPath(), projectPath = resolve
 			}
 		} : void 0);
 		const config = parseConfig(input);
-		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 && Object.keys(config.cliTools).length === 0) throw new CapletsError("CONFIG_INVALID", "Caplets config must define at least one MCP server, OpenAPI endpoint, GraphQL endpoint, HTTP API, or CLI tools backend");
+		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 && Object.keys(config.cliTools).length === 0 && Object.keys(config.capletSets).length === 0) throw new CapletsError("CONFIG_INVALID", "Caplets config must define at least one MCP server, OpenAPI endpoint, GraphQL endpoint, HTTP API, CLI tools backend, or Caplet set");
 		return {
 			config,
 			sources,
@@ -27161,6 +27241,19 @@ function loadConfigWithSources(path = resolveConfigPath(), projectPath = resolve
 		throw new CapletsError("CONFIG_INVALID", "Caplets config is not valid JSON", redactSecrets(error));
 	}
 }
+function loadIsolatedConfig(options) {
+	if (!options.configPath && !options.capletsRoot) throw new CapletsError("CONFIG_INVALID", "Nested Caplet set must define at least one source: configPath or capletsRoot");
+	const configInput = options.configPath ? readPublicConfigInput(options.configPath) : void 0;
+	const capletInput = options.capletsRoot ? loadCapletFiles(options.capletsRoot) : void 0;
+	if (!configInput && !capletInput) throw new CapletsError("CONFIG_NOT_FOUND", `Nested Caplet set sources not found: ${[options.configPath, options.capletsRoot].filter(Boolean).join(", ")}`);
+	const config = parseConfig(mergeConfigInputs(configInput, capletInput, {
+		version: 1,
+		defaultSearchLimit: options.defaultSearchLimit,
+		maxSearchLimit: options.maxSearchLimit
+	}));
+	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 && Object.keys(config.cliTools).length === 0 && Object.keys(config.capletSets).length === 0) throw new CapletsError("CONFIG_INVALID", "Nested Caplet set must define at least one Caplet");
+	return config;
+}
 function resolveProjectCapletsRootForConfigPath(projectPath) {
 	const root = dirname(projectPath);
 	return basename(root) === ".caplets" && basename(projectPath) === "config.json" ? root : void 0;
@@ -27181,7 +27274,8 @@ function normalizeLocalPaths(input, baseDir) {
 		...input,
 		openapiEndpoints: normalizeEndpointPaths(input.openapiEndpoints, baseDir, normalizeOpenApiPath),
 		graphqlEndpoints: normalizeEndpointPaths(input.graphqlEndpoints, baseDir, normalizeGraphQlPath),
-		cliTools: normalizeEndpointPaths(input.cliTools, baseDir, normalizeCliToolsPaths)
+		cliTools: normalizeEndpointPaths(input.cliTools, baseDir, normalizeCliToolsPaths),
+		capletSets: normalizeEndpointPaths(input.capletSets, baseDir, normalizeCapletSetPaths)
 	});
 }
 function normalizeEndpointPaths(endpoints, baseDir, normalize) {
@@ -27216,6 +27310,13 @@ function normalizeCliToolsPaths(endpoint, baseDir) {
 		actions
 	};
 }
+function normalizeCapletSetPaths(endpoint, baseDir) {
+	return {
+		...endpoint,
+		configPath: normalizeLocalPath(endpoint.configPath, baseDir),
+		capletsRoot: normalizeLocalPath(endpoint.capletsRoot, baseDir)
+	};
+}
 function normalizeLocalPath(value, baseDir) {
 	if (typeof value !== "string" || !value || isAbsolute(value) || hasEnvReference(value)) return value;
 	return join(baseDir, value);
@@ -27225,6 +27326,7 @@ function rejectProjectConfigExecutableBackendMaps(input, path) {
 	if (input.graphqlEndpoints && Object.keys(input.graphqlEndpoints).length > 0) throw new CapletsError("CONFIG_INVALID", `Project config at ${path} cannot define executable backend map graphqlEndpoints; use project Markdown Caplet files or user config instead`);
 	if (input.httpApis && Object.keys(input.httpApis).length > 0) throw new CapletsError("CONFIG_INVALID", `Project config at ${path} cannot define executable backend map httpApis; use project Markdown Caplet files or user config instead`);
 	if (input.cliTools && Object.keys(input.cliTools).length > 0) throw new CapletsError("CONFIG_INVALID", `Project config at ${path} cannot define executable backend map cliTools; use project Markdown Caplet files or user config instead`);
+	if (input.capletSets && Object.keys(input.capletSets).length > 0) throw new CapletsError("CONFIG_INVALID", `Project config at ${path} cannot define executable backend map capletSets; use project Markdown Caplet files or user config instead`);
 	return input;
 }
 function mergeConfigInputs(...inputs) {
@@ -27253,6 +27355,10 @@ function mergeConfigInputs(...inputs) {
 			cliTools: {
 				...merged?.cliTools,
 				...input.cliTools
+			},
+			capletSets: {
+				...merged?.capletSets,
+				...input.capletSets
 			}
 		};
 	}
@@ -27284,13 +27390,15 @@ function removeCapletId(input, id) {
 	const { [id]: _graphqlEndpoint, ...graphqlEndpoints } = input.graphqlEndpoints ?? {};
 	const { [id]: _httpApi, ...httpApis } = input.httpApis ?? {};
 	const { [id]: _cliTools, ...cliTools } = input.cliTools ?? {};
+	const { [id]: _capletSet, ...capletSets } = input.capletSets ?? {};
 	return {
 		...input,
 		mcpServers,
 		openapiEndpoints,
 		graphqlEndpoints,
 		httpApis,
-		cliTools
+		cliTools,
+		capletSets
 	};
 }
 function capletIds(input) {
@@ -27299,7 +27407,8 @@ function capletIds(input) {
 		...Object.keys(input.openapiEndpoints ?? {}),
 		...Object.keys(input.graphqlEndpoints ?? {}),
 		...Object.keys(input.httpApis ?? {}),
-		...Object.keys(input.cliTools ?? {})
+		...Object.keys(input.cliTools ?? {}),
+		...Object.keys(input.capletSets ?? {})
 	];
 }
 function sourceForId(source, id) {
@@ -27345,6 +27454,12 @@ function parseConfig(input) {
 		server,
 		backend: "cli"
 	});
+	const capletSets = {};
+	for (const [server, raw] of Object.entries(parsed.data.capletSets)) capletSets[server] = stripUndefined$1({
+		...raw,
+		server,
+		backend: "caplets"
+	});
 	return {
 		version: parsed.data.version,
 		options: {
@@ -27355,7 +27470,8 @@ function parseConfig(input) {
 		openapiEndpoints,
 		graphqlEndpoints,
 		httpApis,
-		cliTools
+		cliTools,
+		capletSets
 	};
 }
 function validateEndpointAuthHeaders(auth, ctx, path) {
@@ -27384,7 +27500,7 @@ function interpolateConfig(value, path = []) {
 	return value;
 }
 function isPublicMetadataPath(path) {
-	if (path.length < 3 || path[0] !== "mcpServers" && path[0] !== "openapiEndpoints" && path[0] !== "graphqlEndpoints" && path[0] !== "httpApis" && path[0] !== "cliTools") return false;
+	if (path.length < 3 || path[0] !== "mcpServers" && path[0] !== "openapiEndpoints" && path[0] !== "graphqlEndpoints" && path[0] !== "httpApis" && path[0] !== "cliTools" && path[0] !== "capletSets") return false;
 	return NON_INTERPOLATED_SERVER_FIELDS.has(path[2] ?? "");
 }
 function isPlainObject$4(value) {
@@ -56973,7 +57089,7 @@ function openApiCacheKey(endpoint) {
 //#endregion
 //#region src/capability-description.mjs
 function capabilityDescription(server) {
-	const backendName = server.backend === "mcp" ? "MCP server" : server.backend === "openapi" ? "OpenAPI endpoint" : server.backend === "graphql" ? "GraphQL endpoint" : server.backend === "http" ? "HTTP API" : "CLI tools";
+	const backendName = server.backend === "mcp" ? "MCP server" : server.backend === "openapi" ? "OpenAPI endpoint" : server.backend === "graphql" ? "GraphQL endpoint" : server.backend === "http" ? "HTTP API" : server.backend === "cli" ? "CLI tools" : server.backend === "caplets" ? "nested Caplets" : "backend";
 	const checkOperation = server.backend === "mcp" ? "check_mcp_server" : "check_backend";
 	const hint = [
 		`Use this Caplet to inspect and call tools from its ${backendName} backend.`,
@@ -57003,7 +57119,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] ?? this.config.httpApis[serverId] ?? this.config.cliTools[serverId];
+		const server = this.config.mcpServers[serverId] ?? this.config.openapiEndpoints[serverId] ?? this.config.graphqlEndpoints[serverId] ?? this.config.httpApis[serverId] ?? this.config.cliTools[serverId] ?? this.config.capletSets[serverId];
 		return server?.disabled ? void 0 : server;
 	}
 	require(serverId) {
@@ -57055,7 +57171,8 @@ var ServerRegistry = class {
 			...Object.values(this.config.openapiEndpoints),
 			...Object.values(this.config.graphqlEndpoints),
 			...Object.values(this.config.httpApis),
-			...Object.values(this.config.cliTools)
+			...Object.values(this.config.cliTools),
+			...Object.values(this.config.capletSets)
 		];
 	}
 };
@@ -57088,6 +57205,12 @@ function backendDetail(server) {
 		maxOutputBytes: server.maxOutputBytes,
 		configuredActions: Object.keys(server.actions).length
 	};
+	if (server.backend === "caplets") return {
+		type: "caplets",
+		disabled: server.disabled,
+		source: capletSetSource(server),
+		toolCacheTtlMs: server.toolCacheTtlMs
+	};
 	return {
 		type: "mcp",
 		transport: server.transport,
@@ -57097,6 +57220,9 @@ function backendDetail(server) {
 		toolCacheTtlMs: server.toolCacheTtlMs
 	};
 }
+function capletSetSource(server) {
+	return server.configPath && server.capletsRoot ? "both" : server.configPath ? "configPath" : "capletsRoot";
+}
 function graphQlSource(server) {
 	if (server.schemaPath) return "schemaPath";
 	if (server.schemaUrl) return "schemaUrl";
@@ -57213,16 +57339,16 @@ const generatedToolInputSchema = object({
 	arguments: record(string(), unknown()).optional().describe(generatedToolInputDescriptions.arguments),
 	fields: array(string().min(1)).min(1).optional().describe(generatedToolInputDescriptions.fields)
 }).strict();
-async function handleServerTool(server, request, registry, downstream, openapi, graphql, http, cli) {
+async function handleServerTool(server, request, registry, downstream, openapi, graphql, http, cli, caplets) {
 	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, http, cli).check(server));
+		case "check_backend": return jsonResult(await backendFor(server, downstream, openapi, graphql, http, cli, caplets).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, http, cli);
+			const backend = backendFor(server, downstream, openapi, graphql, http, cli, caplets);
 			const tools = await backend.listTools(server);
 			return jsonResult({
 				server: server.server,
@@ -57230,7 +57356,7 @@ async function handleServerTool(server, request, registry, downstream, openapi,
 			});
 		}
 		case "search_tools": {
-			const backend = backendFor(server, downstream, openapi, graphql, http, cli);
+			const backend = backendFor(server, downstream, openapi, graphql, http, cli, caplets);
 			const tools = await backend.listTools(server);
 			const limit = parsed.limit ?? registry.config.options.defaultSearchLimit;
 			return jsonResult({
@@ -57240,14 +57366,14 @@ async function handleServerTool(server, request, registry, downstream, openapi,
 			});
 		}
 		case "get_tool": {
-			const tool = await backendFor(server, downstream, openapi, graphql, http, cli).getTool(server, parsed.tool);
+			const tool = await backendFor(server, downstream, openapi, graphql, http, cli, caplets).getTool(server, parsed.tool);
 			return jsonResult({
 				server: server.server,
 				tool
 			});
 		}
 		case "call_tool": {
-			const backend = backendFor(server, downstream, openapi, graphql, http, cli);
+			const backend = backendFor(server, downstream, openapi, graphql, http, cli, caplets);
 			if (parsed.fields === void 0) return backend.callTool(server, parsed.tool, parsed.arguments);
 			if (server.backend === "graphql") throw new CapletsError("REQUEST_INVALID", "call_tool.fields is not supported for GraphQL-backed Caplets; select fields in the GraphQL operation document instead");
 			const tool = await backend.getTool(server, parsed.tool);
@@ -57340,7 +57466,7 @@ function projectCallToolResult(result, outputSchema, fields) {
 function isPlainObject(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function backendFor(server, downstream, openapi, graphql, http, cli) {
+function backendFor(server, downstream, openapi, graphql, http, cli, caplets) {
 	if (server.backend === "mcp") return {
 		check: (...args) => downstream.checkServer(...args),
 		listTools: (...args) => downstream.listTools(...args),
@@ -57382,6 +57508,17 @@ function backendFor(server, downstream, openapi, graphql, http, cli) {
 			search: (...args) => cli.search(...args)
 		};
 	}
+	if (server.backend === "caplets") {
+		if (!caplets) throw new CapletsError("INTERNAL_ERROR", "Caplet set manager is not configured");
+		return {
+			check: (...args) => caplets.checkSet(...args),
+			listTools: (...args) => caplets.listTools(...args),
+			getTool: (...args) => caplets.getTool(...args),
+			callTool: (...args) => caplets.callTool(...args),
+			compact: (...args) => caplets.compact(...args),
+			search: (...args) => caplets.search(...args)
+		};
+	}
 	if (!openapi) throw new CapletsError("INTERNAL_ERROR", "OpenAPI manager is not configured");
 	return {
 		check: (...args) => openapi.checkEndpoint(...args),
@@ -57393,6 +57530,174 @@ function backendFor(server, downstream, openapi, graphql, http, cli) {
 	};
 }
 //#endregion
+//#region src/caplet-sets.ts
+var CapletSetManager = class CapletSetManager {
+	registry;
+	options;
+	children = /* @__PURE__ */ new Map();
+	childRefreshLocks = /* @__PURE__ */ new Map();
+	constructor(registry, options = {}) {
+		this.registry = registry;
+		this.options = options;
+	}
+	updateRegistry(registry) {
+		this.registry = registry;
+	}
+	invalidate(serverId) {
+		const pending = this.childRefreshLocks.get(serverId);
+		if (pending) {
+			pending.then(() => this.closeChild(serverId), () => this.closeChild(serverId));
+			return;
+		}
+		this.closeChild(serverId);
+	}
+	async close() {
+		await Promise.allSettled(this.childRefreshLocks.values());
+		await Promise.allSettled([...this.children.keys()].map((serverId) => this.closeChild(serverId)));
+	}
+	async checkSet(config) {
+		const startedAt = Date.now();
+		try {
+			const childCaplets = (await this.childRuntime(config, true)).registry.enabledServers();
+			this.registry.setStatus(config.server, "available");
+			return {
+				server: config.server,
+				status: "available",
+				toolCount: childCaplets.length,
+				elapsedMs: Date.now() - startedAt
+			};
+		} catch (error) {
+			const safe = toSafeError(error, "SERVER_UNAVAILABLE");
+			this.registry.setStatus(config.server, "unavailable", safe);
+			return {
+				server: config.server,
+				status: "unavailable",
+				elapsedMs: Date.now() - startedAt,
+				error: safe
+			};
+		}
+	}
+	async listTools(config) {
+		return (await this.childRuntime(config, false)).registry.enabledServers().map((caplet) => this.toTool(caplet));
+	}
+	async getTool(config, toolName) {
+		const child = await this.childRuntime(config, false);
+		const caplet = child.registry.get(toolName);
+		if (!caplet) throw new CapletsError("TOOL_NOT_FOUND", `Tool ${toolName} was not found on ${config.server}`, {
+			server: config.server,
+			tool: toolName,
+			suggestions: nearbyCapletNames(child.registry.enabledServers(), toolName)
+		});
+		return this.toTool(caplet);
+	}
+	async callTool(config, toolName, args) {
+		const child = await this.childRuntime(config, false);
+		const caplet = child.registry.get(toolName);
+		if (!caplet) throw new CapletsError("TOOL_NOT_FOUND", `Tool ${toolName} was not found on ${config.server}`, {
+			server: config.server,
+			tool: toolName,
+			suggestions: nearbyCapletNames(child.registry.enabledServers(), toolName)
+		});
+		try {
+			return await handleServerTool(caplet, args, child.registry, child.downstream, child.openapi, child.graphql, child.http, child.cli, child.capletSets);
+		} catch (error) {
+			return errorResult(error);
+		}
+	}
+	compact(config, tool) {
+		return {
+			server: config.server,
+			tool: tool.name,
+			...tool.description ? { description: tool.description } : {},
+			...tool.annotations ? { annotations: tool.annotations } : {},
+			hasInputSchema: Boolean(tool.inputSchema),
+			hasOutputSchema: Boolean(tool.outputSchema)
+		};
+	}
+	search(config, 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(config, tool));
+	}
+	async childRuntime(config, force) {
+		const pending = this.childRefreshLocks.get(config.server);
+		if (pending) return pending;
+		const refresh = this.loadChildRuntime(config, force).finally(() => {
+			this.childRefreshLocks.delete(config.server);
+		});
+		this.childRefreshLocks.set(config.server, refresh);
+		return await refresh;
+	}
+	async loadChildRuntime(config, force) {
+		const cacheKey = sourceKey(config);
+		const existing = this.children.get(config.server);
+		const now = Date.now();
+		const isFresh = existing && existing.cacheKey === cacheKey && existing.configFingerprint === JSON.stringify(config) && config.toolCacheTtlMs > 0 && now - existing.loadedAt <= config.toolCacheTtlMs;
+		if (existing && !force && isFresh) return existing;
+		const ancestry = this.options.ancestry ?? /* @__PURE__ */ new Set();
+		if (ancestry.has(cacheKey)) throw new CapletsError("CONFIG_INVALID", "Nested Caplet set cycle detected", {
+			server: config.server,
+			source: cacheKey,
+			ancestry: [...ancestry]
+		});
+		let child;
+		try {
+			const registry = new ServerRegistry(loadIsolatedConfig({
+				...config.configPath ? { configPath: config.configPath } : {},
+				...config.capletsRoot ? { capletsRoot: config.capletsRoot } : {},
+				defaultSearchLimit: config.defaultSearchLimit,
+				maxSearchLimit: config.maxSearchLimit
+			}));
+			const authOptions = this.options.authDir ? { authDir: this.options.authDir } : {};
+			const childAncestry = new Set([...ancestry, cacheKey]);
+			child = {
+				registry,
+				downstream: new DownstreamManager(registry, authOptions),
+				openapi: new OpenApiManager(registry, authOptions),
+				graphql: new GraphQLManager(registry, authOptions),
+				http: new HttpActionManager(registry, authOptions),
+				cli: new CliToolsManager(registry),
+				capletSets: new CapletSetManager(registry, {
+					...authOptions,
+					ancestry: childAncestry
+				}),
+				cacheKey,
+				configFingerprint: JSON.stringify(config),
+				loadedAt: now
+			};
+		} catch (error) {
+			if (existing) return existing;
+			throw error;
+		}
+		if (existing) await this.closeChild(config.server);
+		this.children.set(config.server, child);
+		this.registry.setStatus(config.server, "available");
+		return child;
+	}
+	async closeChild(serverId) {
+		const child = this.children.get(serverId);
+		this.children.delete(serverId);
+		if (!child) return;
+		await Promise.allSettled([child.downstream.close(), child.capletSets.close()]);
+	}
+	toTool(caplet) {
+		return {
+			name: caplet.server,
+			description: capabilityDescription(caplet),
+			inputSchema: generatedToolInputJsonSchema()
+		};
+	}
+};
+function sourceKey(config) {
+	return JSON.stringify({
+		configPath: config.configPath ? resolve(config.configPath) : void 0,
+		capletsRoot: config.capletsRoot ? resolve(config.capletsRoot) : void 0
+	});
+}
+function nearbyCapletNames(caplets, needle) {
+	const lower = needle.toLocaleLowerCase();
+	return caplets.map((caplet) => caplet.server).filter((name) => name.toLocaleLowerCase().includes(lower[0] ?? "")).sort().slice(0, 5);
+}
+//#endregion
 //#region src/engine.ts
 var CapletsEngine = class {
 	registry;
@@ -57401,6 +57706,7 @@ var CapletsEngine = class {
 	graphql;
 	http;
 	cli;
+	capletSets;
 	paths;
 	watchDebounceMs;
 	watchEnabled;
@@ -57424,6 +57730,7 @@ var CapletsEngine = class {
 		this.graphql = new GraphQLManager(this.registry, selectAuthOptions(options.authDir));
 		this.http = new HttpActionManager(this.registry, selectAuthOptions(options.authDir));
 		this.cli = new CliToolsManager(this.registry);
+		this.capletSets = new CapletSetManager(this.registry, selectAuthOptions(options.authDir));
 		this.watchDebounceMs = options.watchDebounceMs ?? 250;
 		this.watchEnabled = options.watch ?? true;
 		this.writeErr = options.writeErr ?? ((value) => process.stderr.write(value));
@@ -57465,7 +57772,7 @@ var CapletsEngine = class {
 	}
 	async execute(serverId, request) {
 		try {
-			return await handleServerTool(this.registry.require(serverId), request, this.registry, this.downstream, this.openapi, this.graphql, this.http, this.cli);
+			return await handleServerTool(this.registry.require(serverId), request, this.registry, this.downstream, this.openapi, this.graphql, this.http, this.cli, this.capletSets);
 		} catch (error) {
 			return errorResult(error);
 		}
@@ -57485,6 +57792,7 @@ var CapletsEngine = class {
 		} finally {
 			this.closeWatchers();
 			await this.downstream.close();
+			await this.capletSets.close();
 			this.reloadListeners.clear();
 		}
 	}
@@ -57507,6 +57815,7 @@ var CapletsEngine = class {
 		this.graphql.updateRegistry(nextRegistry);
 		this.http.updateRegistry(nextRegistry);
 		this.cli.updateRegistry(nextRegistry);
+		this.capletSets.updateRegistry(nextRegistry);
 		let invalidated = true;
 		try {
 			await this.invalidateChangedBackends(previousConfig, nextConfig);
@@ -57559,6 +57868,7 @@ var CapletsEngine = class {
 			if (before?.backend === "graphql" || after?.backend === "graphql" || !after) this.graphql.invalidate(serverId);
 			if (before?.backend === "http" || after?.backend === "http" || !after) this.http.invalidate(serverId);
 			if (before?.backend === "cli" || after?.backend === "cli" || !after) this.cli.invalidate(serverId);
+			if (before?.backend === "caplets" || after?.backend === "caplets" || !after) this.capletSets.invalidate(serverId);
 		}
 	}
 	resetWatchers() {
@@ -57651,7 +57961,8 @@ function allCaplets(config) {
 		...Object.values(config.openapiEndpoints),
 		...Object.values(config.graphqlEndpoints),
 		...Object.values(config.httpApis),
-		...Object.values(config.cliTools)
+		...Object.values(config.cliTools),
+		...Object.values(config.capletSets)
 	];
 }
 function nextEnabledServers(config) {

package/dist/generated-tool-input-schema.js

@@ -11,7 +11,7 @@ const operations = [
 const generatedToolInputDescriptions = {
 	operation: [
 		"Caplets wrapper operation to perform for this configured Caplet backend.",
-		"Use get_caplet to read the full Caplet card, check_backend to check any backend, check_mcp_server to check an MCP backend, list_tools or search_tools to discover downstream tools, get_tool to read a downstream input schema, and call_tool to run one downstream tool, operation, action, or CLI command.",
+		"Use get_caplet to read the full Caplet card, check_backend to check any backend, check_mcp_server to check an MCP backend, list_tools or search_tools to discover downstream tools, get_tool to read a downstream input schema, and call_tool to run one downstream tool, operation, action, CLI command, or child Caplet.",
 		"For call_tool, pass downstream inputs only inside the top-level \"arguments\" object."
 	].join(" "),
 	query: "Required only for search_tools. Example: {\"operation\":\"search_tools\",\"query\":\"web search\",\"limit\":5}. Do not use query for call_tool; put downstream query values under arguments.query.",

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $ as assertCompleteRequestPrompt, A as CallToolRequestSchema, B as InitializeRequestSchema, C as SERVER_ID_PATTERN, D as Protocol, E as AjvJsonSchemaValidator, F as CreateTaskResultSchema, G as ListResourcesRequestSchema, H as LATEST_PROTOCOL_VERSION, I as ElicitResultSchema, J as LoggingLevelSchema, K as ListRootsResultSchema, L as EmptyResultSchema, M as CompleteRequestSchema, N as CreateMessageResultSchema, O as mergeCapabilities, P as CreateMessageResultWithToolsSchema, Q as SetLevelRequestSchema, R as ErrorCode, S as toSafeError, T as assertToolsCallTaskCapability, U as ListPromptsRequestSchema, V as InitializedNotificationSchema, W as ListResourceTemplatesRequestSchema, X as ReadResourceRequestSchema, Y as McpError, Z as SUPPORTED_PROTOCOL_VERSIONS, _ as resolveProjectCapletsRoot, a as capabilityDescription, at as getSchemaDescription, b as validateCapletFile, c as deleteTokenBundle, ct as normalizeObjectSchema, d as loadConfig, dt as safeParseAsync, et as assertCompleteRequestResourceTemplate, f as loadConfigWithSources, ft as __commonJSMin, g as resolveConfigPath, h as resolveCapletsRoot, i as ServerRegistry, it as getParseErrorMessage, j as CallToolResultSchema, k as toJsonSchemaCompat, l as isTokenBundleExpired, lt as objectFromShape, m as DEFAULT_AUTH_DIR, mt as __toESM, n as generatedToolInputSchema, nt as getLiteralValue, o as runGenericOAuthFlow, ot as isSchemaOptional, p as parseConfig, pt as __require, q as ListToolsRequestSchema, r as handleServerTool, rt as getObjectShape, s as runOAuthFlow, st as isZ4Schema, t as CapletsEngine, tt as ZodOptional, u as readTokenBundle, ut as safeParse, v as resolveProjectConfigPath, w as assertClientRequestTaskCapability, x as CapletsError, y as discoverCapletFiles, z as GetPromptRequestSchema } from "./engine-BzekyZ5r.js";
+import { $ as assertCompleteRequestPrompt, A as CallToolRequestSchema, B as InitializeRequestSchema, C as SERVER_ID_PATTERN, D as Protocol, E as AjvJsonSchemaValidator, F as CreateTaskResultSchema, G as ListResourcesRequestSchema, H as LATEST_PROTOCOL_VERSION, I as ElicitResultSchema, J as LoggingLevelSchema, K as ListRootsResultSchema, L as EmptyResultSchema, M as CompleteRequestSchema, N as CreateMessageResultSchema, O as mergeCapabilities, P as CreateMessageResultWithToolsSchema, Q as SetLevelRequestSchema, R as ErrorCode, S as toSafeError, T as assertToolsCallTaskCapability, U as ListPromptsRequestSchema, V as InitializedNotificationSchema, W as ListResourceTemplatesRequestSchema, X as ReadResourceRequestSchema, Y as McpError, Z as SUPPORTED_PROTOCOL_VERSIONS, _ as resolveProjectCapletsRoot, a as capabilityDescription, at as getSchemaDescription, b as validateCapletFile, c as deleteTokenBundle, ct as normalizeObjectSchema, d as loadConfig, dt as safeParseAsync, et as assertCompleteRequestResourceTemplate, f as loadConfigWithSources, ft as __commonJSMin, g as resolveConfigPath, h as resolveCapletsRoot, i as ServerRegistry, it as getParseErrorMessage, j as CallToolResultSchema, k as toJsonSchemaCompat, l as isTokenBundleExpired, lt as objectFromShape, m as DEFAULT_AUTH_DIR, mt as __toESM, n as generatedToolInputSchema, nt as getLiteralValue, o as runGenericOAuthFlow, ot as isSchemaOptional, p as parseConfig, pt as __require, q as ListToolsRequestSchema, r as handleServerTool, rt as getObjectShape, s as runOAuthFlow, st as isZ4Schema, t as CapletsEngine, tt as ZodOptional, u as readTokenBundle, ut as safeParse, v as resolveProjectConfigPath, w as assertClientRequestTaskCapability, x as CapletsError, y as discoverCapletFiles, z as GetPromptRequestSchema } from "./engine-D_zyCvXx.js";
 import { accessSync, chmodSync, closeSync, constants, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import { basename, dirname, join, parse, relative, resolve } from "node:path";
 import { stdin, stdout } from "node:process";
@@ -1314,7 +1314,7 @@ const EMPTY_COMPLETION_RESULT = { completion: {
 } };
 //#endregion
 //#region package.json
-var version = "0.12.2";
+var version = "0.13.0";
 //#endregion
 //#region src/runtime.ts
 var CapletsRuntime = class {
@@ -1396,11 +1396,12 @@ function nextEnabledServers(config) {
 		...Object.values(config.openapiEndpoints),
 		...Object.values(config.graphqlEndpoints),
 		...Object.values(config.httpApis),
-		...Object.values(config.cliTools)
+		...Object.values(config.cliTools),
+		...Object.values(config.capletSets)
 	].filter((server) => !server.disabled);
 }
 function capletById(config, serverId) {
-	return config.mcpServers[serverId] ?? config.openapiEndpoints[serverId] ?? config.graphqlEndpoints[serverId] ?? config.httpApis[serverId] ?? config.cliTools[serverId];
+	return config.mcpServers[serverId] ?? config.openapiEndpoints[serverId] ?? config.graphqlEndpoints[serverId] ?? config.httpApis[serverId] ?? config.cliTools[serverId] ?? config.capletSets[serverId];
 }
 function serializeCaplet(caplet) {
 	return JSON.stringify(caplet ?? null);

package/dist/native.js

@@ -1,4 +1,4 @@
-import { a as capabilityDescription, n as generatedToolInputSchema, t as CapletsEngine } from "./engine-BzekyZ5r.js";
+import { a as capabilityDescription, n as generatedToolInputSchema, t as CapletsEngine } from "./engine-D_zyCvXx.js";
 import { generatedToolInputJsonSchema } from "./generated-tool-input-schema.js";
 //#region src/native/tools.ts
 function nativeCapletToolName(capletId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caplets/core",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "Core runtime library for Caplets progressive disclosure gateways.",
   "keywords": [
     "caplets",