@caplets/core 0.19.0 → 0.20.1

package/dist/index.js

@@ -1,18 +1,19 @@
-import { $ as ElicitResultSchema, $t as markdownStructuredContent, A as capabilityDescription, At as objectFromShape, B as assertClientRequestTaskCapability, C as migrateCredentials, Ct as getLiteralValue, D as CapletsEngine, Dt as isSchemaOptional, E as fingerprintProjectRoot, Et as getSchemaDescription, F as deleteTokenBundle, Ft as loadGlobalConfig, G as toJsonSchemaCompat, Gt as resolveConfigPath, H as AjvJsonSchemaValidator, Ht as defaultConfigBaseDir, I as isTokenBundleExpired, It as loadLocalOverlayConfigWithSources, J as CompleteRequestSchema, Jt as discoverCapletFiles, K as CallToolRequestSchema, Kt as resolveProjectCapletsRoot, L as readTokenBundle, Lt as loadProjectConfig, M as runOAuthFlow, Mt as safeParseAsync, N as startGenericOAuthFlow, Nt as loadConfig, O as handleServerTool, Ot as isZ4Schema, P as startOAuthFlow, Pt as loadConfigWithSources, Qt as markdownCallToolResultContent, R as ReadBuffer, Rt as parseConfig, S as cloudAuthPath, St as isJSONRPCResultResponse, T as findProjectRoot, Tt as getParseErrorMessage, U as Protocol, Ut as defaultStateBaseDir, V as assertToolsCallTaskCapability, Vt as defaultCacheBaseDir, W as mergeCapabilities, Wt as resolveCapletsRoot, X as CreateMessageResultWithToolsSchema, Xt as loadCapletFilesFromMap, Y as CreateMessageResultSchema, Yt as validateCapletFile, Z as CreateTaskResultSchema, Zt as hasRenderableStructuredContent, _ as controlUrlForBase, _t as assertCompleteRequestPrompt, a as createSdkRemoteCapletsClient, at as JSONRPCMessageSchema, b as resolveCapletsServer, bt as isJSONRPCErrorResponse, ct as ListResourceTemplatesRequestSchema, d as PROJECT_BINDING_ERROR_CODES, dt as ListToolsRequestSchema, et as EmptyResultSchema, f as ProjectBindingError, ft as LoggingLevelSchema, g as resolveCapletsRemote, gt as SetLevelRequestSchema, h as CloudAuthClient, ht as SUPPORTED_PROTOCOL_VERSIONS, it as InitializedNotificationSchema, j as runGenericOAuthFlow, jt as safeParse, k as ServerRegistry, kt as normalizeObjectSchema, lt as ListResourcesRequestSchema, m as projectBindingRecovery, mt as ReadResourceRequestSchema, n as buildProjectSyncManifest, nt as GetPromptRequestSchema, ot as LATEST_PROTOCOL_VERSION, p as projectBindingError, pt as McpError, q as CallToolResultSchema, qt as resolveProjectConfigPath, rt as InitializeRequestSchema, st as ListPromptsRequestSchema, t as createNativeCapletsService, tt as ErrorCode, u as resolveRemoteSelection, ut as ListRootsResultSchema, v as parseServerBaseUrl, vt as assertCompleteRequestResourceTemplate, w as redactedCloudAuthStatus, wt as getObjectShape, x as CloudAuthStore, xt as isJSONRPCRequest, y as resolveCapletsMode, yt as isInitializeRequest, z as serializeMessage } from "./service-BXcE4Rv8.js";
-import { f as redactSecrets, i as SERVER_ID_PATTERN, l as CAPLETS_ERROR_CODES, p as toSafeError, u as CapletsError } from "./validation-BBG4skZf.js";
+import { $ as parseConfig, $t as ReadResourceRequestSchema, A as QuickJsCodeModeSandbox, At as toJsonSchemaCompat, B as CapletsEngine, Bt as ErrorCode, C as nativeCapletToolName, Ct as ReadBuffer, D as codeModeRunInputSchema, Dt as AjvJsonSchemaValidator, Et as assertToolsCallTaskCapability, F as redactCodeModeLogText, Ft as CreateMessageResultWithToolsSchema, G as handleServerTool, Gt as LATEST_PROTOCOL_VERSION, H as decodeDirectResourceUri, Ht as InitializeRequestSchema, I as codeModeDeclarationHash, It as CreateTaskResultSchema, J as loadConfig, Jt as ListResourcesRequestSchema, K as ServerRegistry, Kt as ListPromptsRequestSchema, L as generateCodeModeDeclarations, M as createCodeModeCapletsApi, Mt as CallToolResultSchema, N as listCodeModeCallableCaplets, Nt as CompleteRequestSchema, O as codeModeRunParamsSchema, Ot as Protocol, P as CodeModeLogStore, Pt as CreateMessageResultSchema, Q as loadProjectConfig, Qt as McpError, R as generateCodeModeRunToolDescription, Rt as ElicitResultSchema, S as nativeCapletToolDescription, St as resolveProjectConfigPath, T as nativeCodeModeToolId, Tt as assertClientRequestTaskCapability, U as findProjectRoot, Ut as InitializedNotificationSchema, V as resolveExposure, Vt as GetPromptRequestSchema, W as fingerprintProjectRoot, Wt as JSONRPCMessageSchema, X as loadGlobalConfig, Xt as ListToolsRequestSchema, Y as loadConfigWithSources, Yt as ListRootsResultSchema, Z as loadLocalOverlayConfigWithSources, Zt as LoggingLevelSchema, _ as controlUrlForBase, _n as safeParseAsync, _t as defaultConfigBaseDir, a as projectBindingError, an as isJSONRPCErrorResponse, at as markdownStructuredContent, b as resolveCapletsServer, bt as resolveConfigPath, c as cloudAuthPath, cn as getLiteralValue, ct as startGenericOAuthFlow, d as CloudAuthClient, dn as getSchemaDescription, dt as isTokenBundleExpired, en as SUPPORTED_PROTOCOL_VERSIONS, et as discoverCapletFiles, fn as isSchemaOptional, ft as readTokenBundle, g as resolveCapletsRemote, gn as safeParse, gt as defaultCacheBaseDir, hn as objectFromShape, ht as DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR, i as ProjectBindingError, in as isInitializeRequest, it as markdownCallToolResultContent, j as diagnoseCodeModeTypeScript, jt as CallToolRequestSchema, k as runCodeMode, kt as mergeCapabilities, l as migrateCredentials, ln as getObjectShape, lt as startOAuthFlow, m as buildProjectSyncManifest, mn as normalizeObjectSchema, n as resolveRemoteSelection, nn as assertCompleteRequestPrompt, nt as loadCapletFilesFromMap, o as projectBindingRecovery, on as isJSONRPCRequest, ot as runGenericOAuthFlow, p as createSdkRemoteCapletsClient, pn as isZ4Schema, q as capabilityDescription, qt as ListResourceTemplatesRequestSchema, r as PROJECT_BINDING_ERROR_CODES, rn as assertCompleteRequestResourceTemplate, rt as hasRenderableStructuredContent, s as CloudAuthStore, sn as isJSONRPCResultResponse, st as runOAuthFlow, t as createNativeCapletsService, tn as SetLevelRequestSchema, tt as validateCapletFile, u as redactedCloudAuthStatus, un as getParseErrorMessage, ut as deleteTokenBundle, v as parseServerBaseUrl, vt as defaultStateBaseDir, wt as serializeMessage, x as nativeCapletPromptGuidance, xt as resolveProjectCapletsRoot, y as resolveCapletsMode, yt as resolveCapletsRoot, z as minifyCodeModeDeclarationText, zt as EmptyResultSchema } from "./service-Bsq7R0mt.js";
 import { _ as record, b as unknown, d as literal, m as object, n as ZodOptional, o as array, p as number, r as _enum, s as boolean, v as string, x as url } from "./schemas-BZ6BBrh7.js";
+import { f as redactSecrets, i as SERVER_ID_PATTERN, l as CAPLETS_ERROR_CODES, p as toSafeError, u as CapletsError } from "./validation-CdqbI2zN.js";
 import { generatedToolInputSchema, generatedToolInputSchemaForCaplet } from "./generated-tool-input-schema.js";
-import { a as formatCapletList, c as resolveCliConfigPaths, l as cliCommands$1, n as completionScript, o as formatConfigPaths, s as listCaplets, t as completeCliWords, u as completionShells } from "./completion-brgziz4L.js";
+import { f as observedOutputShapeKey, i as observeOutputShape, u as FileObservedOutputShapeStore } from "./observed-output-shapes-uzAMQPhg.js";
+import { a as formatCapletList, c as resolveCliConfigPaths, l as cliCommands$1, n as completionScript, o as formatConfigPaths, s as listCaplets, t as completeCliWords, u as completionShells } from "./completion-D-kuyArL.js";
 import { n as normalizeCapletSourcePath, t as FilesystemCapletSource } from "./filesystem-Kkg32TOJ.js";
 import { parseConfig as parseConfig$1 } from "./config-runtime.js";
 import fs, { accessSync, chmodSync, closeSync, constants, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import path, { basename, dirname, isAbsolute, join, parse, posix, relative, resolve, sep, win32 } from "node:path";
 import childProcess, { execFile, execFileSync, spawn } from "node:child_process";
-import { homedir, tmpdir } from "node:os";
 import process$1, { stdin, stdout } from "node:process";
 import { Readable } from "node:stream";
 import { STATUS_CODES, createServer } from "node:http";
 import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { homedir, tmpdir } from "node:os";
 import { EventEmitter } from "node:events";
 import { promisify, stripVTControlCharacters } from "node:util";
 import { createInterface } from "node:readline/promises";
@@ -598,6 +599,203 @@ var McpZodTypeKind;
 	McpZodTypeKind["Completable"] = "McpCompletable";
 })(McpZodTypeKind || (McpZodTypeKind = {}));
 //#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/uriTemplate.js
+const MAX_TEMPLATE_LENGTH = 1e6;
+const MAX_VARIABLE_LENGTH = 1e6;
+const MAX_TEMPLATE_EXPRESSIONS = 1e4;
+const MAX_REGEX_LENGTH = 1e6;
+var UriTemplate = class UriTemplate {
+	/**
+	* Returns true if the given string contains any URI template expressions.
+	* A template expression is a sequence of characters enclosed in curly braces,
+	* like {foo} or {?bar}.
+	*/
+	static isTemplate(str) {
+		return /\{[^}\s]+\}/.test(str);
+	}
+	static validateLength(str, max, context) {
+		if (str.length > max) throw new Error(`${context} exceeds maximum length of ${max} characters (got ${str.length})`);
+	}
+	get variableNames() {
+		return this.parts.flatMap((part) => typeof part === "string" ? [] : part.names);
+	}
+	constructor(template) {
+		UriTemplate.validateLength(template, MAX_TEMPLATE_LENGTH, "Template");
+		this.template = template;
+		this.parts = this.parse(template);
+	}
+	toString() {
+		return this.template;
+	}
+	parse(template) {
+		const parts = [];
+		let currentText = "";
+		let i = 0;
+		let expressionCount = 0;
+		while (i < template.length) if (template[i] === "{") {
+			if (currentText) {
+				parts.push(currentText);
+				currentText = "";
+			}
+			const end = template.indexOf("}", i);
+			if (end === -1) throw new Error("Unclosed template expression");
+			expressionCount++;
+			if (expressionCount > MAX_TEMPLATE_EXPRESSIONS) throw new Error(`Template contains too many expressions (max ${MAX_TEMPLATE_EXPRESSIONS})`);
+			const expr = template.slice(i + 1, end);
+			const operator = this.getOperator(expr);
+			const exploded = expr.includes("*");
+			const names = this.getNames(expr);
+			const name = names[0];
+			for (const name of names) UriTemplate.validateLength(name, MAX_VARIABLE_LENGTH, "Variable name");
+			parts.push({
+				name,
+				operator,
+				names,
+				exploded
+			});
+			i = end + 1;
+		} else {
+			currentText += template[i];
+			i++;
+		}
+		if (currentText) parts.push(currentText);
+		return parts;
+	}
+	getOperator(expr) {
+		return [
+			"+",
+			"#",
+			".",
+			"/",
+			"?",
+			"&"
+		].find((op) => expr.startsWith(op)) || "";
+	}
+	getNames(expr) {
+		const operator = this.getOperator(expr);
+		return expr.slice(operator.length).split(",").map((name) => name.replace("*", "").trim()).filter((name) => name.length > 0);
+	}
+	encodeValue(value, operator) {
+		UriTemplate.validateLength(value, MAX_VARIABLE_LENGTH, "Variable value");
+		if (operator === "+" || operator === "#") return encodeURI(value);
+		return encodeURIComponent(value);
+	}
+	expandPart(part, variables) {
+		if (part.operator === "?" || part.operator === "&") {
+			const pairs = part.names.map((name) => {
+				const value = variables[name];
+				if (value === void 0) return "";
+				return `${name}=${Array.isArray(value) ? value.map((v) => this.encodeValue(v, part.operator)).join(",") : this.encodeValue(value.toString(), part.operator)}`;
+			}).filter((pair) => pair.length > 0);
+			if (pairs.length === 0) return "";
+			return (part.operator === "?" ? "?" : "&") + pairs.join("&");
+		}
+		if (part.names.length > 1) {
+			const values = part.names.map((name) => variables[name]).filter((v) => v !== void 0);
+			if (values.length === 0) return "";
+			return values.map((v) => Array.isArray(v) ? v[0] : v).join(",");
+		}
+		const value = variables[part.name];
+		if (value === void 0) return "";
+		const encoded = (Array.isArray(value) ? value : [value]).map((v) => this.encodeValue(v, part.operator));
+		switch (part.operator) {
+			case "": return encoded.join(",");
+			case "+": return encoded.join(",");
+			case "#": return "#" + encoded.join(",");
+			case ".": return "." + encoded.join(".");
+			case "/": return "/" + encoded.join("/");
+			default: return encoded.join(",");
+		}
+	}
+	expand(variables) {
+		let result = "";
+		let hasQueryParam = false;
+		for (const part of this.parts) {
+			if (typeof part === "string") {
+				result += part;
+				continue;
+			}
+			const expanded = this.expandPart(part, variables);
+			if (!expanded) continue;
+			if ((part.operator === "?" || part.operator === "&") && hasQueryParam) result += expanded.replace("?", "&");
+			else result += expanded;
+			if (part.operator === "?" || part.operator === "&") hasQueryParam = true;
+		}
+		return result;
+	}
+	escapeRegExp(str) {
+		return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}
+	partToRegExp(part) {
+		const patterns = [];
+		for (const name of part.names) UriTemplate.validateLength(name, MAX_VARIABLE_LENGTH, "Variable name");
+		if (part.operator === "?" || part.operator === "&") {
+			for (let i = 0; i < part.names.length; i++) {
+				const name = part.names[i];
+				const prefix = i === 0 ? "\\" + part.operator : "&";
+				patterns.push({
+					pattern: prefix + this.escapeRegExp(name) + "=([^&]+)",
+					name
+				});
+			}
+			return patterns;
+		}
+		let pattern;
+		const name = part.name;
+		switch (part.operator) {
+			case "":
+				pattern = part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)";
+				break;
+			case "+":
+			case "#":
+				pattern = "(.+)";
+				break;
+			case ".":
+				pattern = "\\.([^/,]+)";
+				break;
+			case "/":
+				pattern = "/" + (part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)");
+				break;
+			default: pattern = "([^/]+)";
+		}
+		patterns.push({
+			pattern,
+			name
+		});
+		return patterns;
+	}
+	match(uri) {
+		UriTemplate.validateLength(uri, MAX_TEMPLATE_LENGTH, "URI");
+		let pattern = "^";
+		const names = [];
+		for (const part of this.parts) if (typeof part === "string") pattern += this.escapeRegExp(part);
+		else {
+			const patterns = this.partToRegExp(part);
+			for (const { pattern: partPattern, name } of patterns) {
+				pattern += partPattern;
+				names.push({
+					name,
+					exploded: part.exploded
+				});
+			}
+		}
+		pattern += "$";
+		UriTemplate.validateLength(pattern, MAX_REGEX_LENGTH, "Generated regex pattern");
+		const regex = new RegExp(pattern);
+		const match = uri.match(regex);
+		if (!match) return null;
+		const result = {};
+		for (let i = 0; i < names.length; i++) {
+			const { name, exploded } = names[i];
+			const value = match[i + 1];
+			const cleanName = name.replace("*", "");
+			if (exploded && value.includes(",")) result[cleanName] = value.split(",");
+			else result[cleanName] = value;
+		}
+		return result;
+	}
+};
+//#endregion
 //#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
 /**
 * Tool name validation utilities according to SEP: Specify Format for Tool Names
@@ -1250,6 +1448,34 @@ var McpServer = class {
 		if (this.isConnected()) this.server.sendPromptListChanged();
 	}
 };
+/**
+* A resource template combines a URI pattern with optional functionality to enumerate
+* all resources matching that pattern.
+*/
+var ResourceTemplate = class {
+	constructor(uriTemplate, _callbacks) {
+		this._callbacks = _callbacks;
+		this._uriTemplate = typeof uriTemplate === "string" ? new UriTemplate(uriTemplate) : uriTemplate;
+	}
+	/**
+	* Gets the URI template pattern.
+	*/
+	get uriTemplate() {
+		return this._uriTemplate;
+	}
+	/**
+	* Gets the list callback, if one was provided.
+	*/
+	get listCallback() {
+		return this._callbacks.list;
+	}
+	/**
+	* Gets the callback for completing a specific URI template variable, if one was provided.
+	*/
+	completeCallback(variable) {
+		return this._callbacks.complete?.[variable];
+	}
+};
 const EMPTY_OBJECT_JSON_SCHEMA = {
 	type: "object",
 	properties: {}
@@ -1327,13 +1553,16 @@ const EMPTY_COMPLETION_RESULT = { completion: {
 } };
 //#endregion
 //#region package.json
-var version = "0.19.0";
+var version = "0.20.1";
 //#endregion
 //#region src/serve/session.ts
 var CapletsMcpSession = class {
 	engine;
 	server;
 	tools = /* @__PURE__ */ new Map();
+	resources = /* @__PURE__ */ new Map();
+	prompts = /* @__PURE__ */ new Map();
+	codeModeTool;
 	unsubscribeReload;
 	closed = false;
 	constructor(engine, options = {}) {
@@ -1342,71 +1571,284 @@ var CapletsMcpSession = class {
 			name: "caplets",
 			version
 		});
-		this.unsubscribeReload = this.engine.onReload(({ previous, next }) => this.reconcileTools(previous, next));
-		this.reconcileTools(void 0, this.engine.currentConfig());
+		this.unsubscribeReload = this.engine.onReload(({ previous, next }) => {
+			this.reconcileFromSnapshot(staticExposureSnapshot(next, this.engine.enabledServers()));
+			this.refreshExposure(previous, next);
+		});
+		this.reconcileFromSnapshot(staticExposureSnapshot(this.engine.currentConfig(), this.engine.enabledServers()));
 	}
 	async connect(transport) {
+		await this.refreshExposure(void 0, this.engine.currentConfig());
 		await this.server.connect(transport);
 	}
 	registeredToolIds() {
 		return [...this.tools.keys()].sort();
 	}
+	async refreshExposure(_previous = void 0, _next = this.engine.currentConfig()) {
+		if (this.closed) return;
+		this.reconcileFromSnapshot(await this.engine.exposureSnapshot());
+	}
 	async close() {
 		if (this.closed) return;
 		this.closed = true;
 		this.unsubscribeReload();
-		this.tools.clear();
+		this.clearRegistrations();
 		await this.server.close();
 	}
-	reconcileTools(previous, next) {
-		const enabled = new Map(nextEnabledServers(next).map((server) => [server.server, server]));
-		for (const [serverId, tool] of this.tools) {
-			const caplet = enabled.get(serverId);
-			if (!caplet) {
+	reconcileFromSnapshot(snapshot) {
+		if (snapshot.codeModeCaplets.length > 0) if (this.codeModeTool) this.codeModeTool.update({
+			title: "Code Mode",
+			description: codeModeRunToolDescription(snapshot.codeModeCaplets),
+			paramsSchema: codeModeRunParamsSchema,
+			callback: async (request) => this.handleCodeModeRunTool(request),
+			enabled: true
+		});
+		else this.codeModeTool = this.registerCodeModeTool(snapshot);
+		else if (this.codeModeTool) {
+			this.codeModeTool.remove();
+			this.codeModeTool = void 0;
+		}
+		const desiredTools = /* @__PURE__ */ new Map();
+		for (const entry of snapshot.progressiveCaplets) desiredTools.set(entry.caplet.server, {
+			register: () => this.registerCapletTool(entry.caplet),
+			update: (tool) => tool.update({
+				title: entry.caplet.name,
+				description: capabilityDescription(entry.caplet),
+				paramsSchema: generatedToolInputSchemaForCaplet(entry.caplet).shape,
+				callback: async (request) => this.engine.execute(entry.caplet.server, request),
+				enabled: true
+			})
+		});
+		for (const entry of snapshot.directTools) desiredTools.set(entry.name, {
+			register: () => this.registerDirectTool(entry),
+			update: (tool) => tool.update({
+				title: entry.tool.name,
+				description: entry.tool.description,
+				paramsSchema: entry.tool.inputSchema,
+				outputSchema: entry.tool.outputSchema,
+				annotations: entry.tool.annotations,
+				_meta: { caplets: {
+					capletId: entry.caplet.server,
+					downstreamName: entry.downstreamName,
+					exposure: "direct"
+				} },
+				callback: async (request) => this.engine.executeDirectTool(entry.caplet.server, entry.downstreamName, isRecord$3(request) ? request : {}),
+				enabled: true
+			})
+		});
+		for (const [name, tool] of this.tools) {
+			const plan = desiredTools.get(name);
+			if (!plan) {
 				tool.remove();
-				this.tools.delete(serverId);
-				continue;
+				this.tools.delete(name);
+			} else plan.update(tool);
+		}
+		for (const [name, plan] of desiredTools) if (!this.tools.has(name)) this.tools.set(name, plan.register());
+		for (const resource of this.resources.values()) resource.remove();
+		for (const prompt of this.prompts.values()) prompt.remove();
+		this.resources.clear();
+		this.prompts.clear();
+		for (const entry of snapshot.directResources) this.resources.set(entry.uri, this.registerDirectResource(entry));
+		for (const entry of snapshot.directResourceTemplates) this.resources.set(entry.uriTemplate, this.registerDirectResourceTemplate(entry));
+		for (const entry of snapshot.directPrompts) this.prompts.set(entry.name, this.registerDirectPrompt(entry));
+	}
+	clearRegistrations() {
+		this.codeModeTool?.remove();
+		this.codeModeTool = void 0;
+		for (const tool of this.tools.values()) tool.remove();
+		for (const resource of this.resources.values()) resource.remove();
+		for (const prompt of this.prompts.values()) prompt.remove();
+		this.tools.clear();
+		this.resources.clear();
+		this.prompts.clear();
+	}
+	registerCodeModeTool(snapshot) {
+		return this.server.registerTool("code_mode", {
+			title: "Code Mode",
+			description: codeModeRunToolDescription(snapshot.codeModeCaplets),
+			inputSchema: codeModeRunParamsSchema
+		}, async (request) => this.handleCodeModeRunTool(request));
+	}
+	async handleCodeModeRunTool(request) {
+		const parsed = codeModeRunInputSchema.safeParse(request);
+		const envelope = parsed.success ? await runCodeMode({
+			code: parsed.data.code,
+			service: new EngineNativeCapletsService(this.engine),
+			...parsed.data.timeoutMs === void 0 ? {} : { timeoutMs: parsed.data.timeoutMs },
+			logStore: new CodeModeLogStore()
+		}) : {
+			ok: false,
+			error: {
+				code: "REQUEST_INVALID",
+				message: "Code Mode run input is invalid.",
+				details: parsed.error.issues
+			},
+			diagnostics: [],
+			logs: {
+				entries: [],
+				truncated: false,
+				stored: false
+			},
+			meta: {
+				runId: "",
+				traceId: "",
+				declarationHash: "",
+				durationMs: 0,
+				timeoutMs: 0,
+				maxTimeoutMs: 0
 			}
-			const previousCaplet = previous ? capletById(previous, serverId) : void 0;
-			if (!previousCaplet || serializeCaplet(previousCaplet) !== serializeCaplet(caplet)) tool.update({
-				title: caplet.name,
-				description: capabilityDescription(caplet),
-				paramsSchema: generatedToolInputSchemaForCaplet(caplet).shape,
-				callback: async (request) => this.handleTool(serverId, request),
-				enabled: true
-			});
-		}
-		for (const caplet of enabled.values()) {
-			if (this.tools.has(caplet.server)) continue;
-			this.tools.set(caplet.server, this.registerCapletTool(caplet));
-		}
+		};
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(envelope, null, 2)
+			}],
+			structuredContent: envelope,
+			isError: !envelope.ok
+		};
 	}
 	registerCapletTool(caplet) {
 		return this.server.registerTool(caplet.server, {
 			title: caplet.name,
 			description: capabilityDescription(caplet),
 			inputSchema: generatedToolInputSchemaForCaplet(caplet).shape
-		}, async (request) => this.handleTool(caplet.server, request));
+		}, async (request) => this.engine.execute(caplet.server, request));
+	}
+	registerDirectTool(entry) {
+		return this.server.registerTool(entry.name, {
+			title: entry.tool.name,
+			...entry.tool.description ? { description: entry.tool.description } : {},
+			...entry.tool.inputSchema ? { inputSchema: entry.tool.inputSchema } : {},
+			...entry.tool.outputSchema ? { outputSchema: entry.tool.outputSchema } : {},
+			...entry.tool.annotations ? { annotations: entry.tool.annotations } : {},
+			_meta: { caplets: {
+				capletId: entry.caplet.server,
+				downstreamName: entry.downstreamName,
+				exposure: "direct"
+			} }
+		}, async (request) => this.engine.executeDirectTool(entry.caplet.server, entry.downstreamName, isRecord$3(request) ? request : {}));
+	}
+	registerDirectResource(entry) {
+		if (!this.server.registerResource) throw new Error("MCP server does not support resource registration");
+		return this.server.registerResource(entry.resource.name ?? entry.uri, entry.uri, resourceMetadata(entry.resource), async () => this.directResourceResult(entry.caplet.server, entry.downstreamUri));
+	}
+	registerDirectResourceTemplate(entry) {
+		if (!this.server.registerResource) throw new Error("MCP server does not support resource registration");
+		return this.server.registerResource(`${entry.caplet.server}:${entry.resourceTemplate.name ?? entry.downstreamUriTemplate}`, new ResourceTemplate(entry.uriTemplate, { list: void 0 }), resourceTemplateMetadata(entry.resourceTemplate), async (uri) => {
+			const decoded = decodeDirectResourceUri(uri.toString());
+			return this.directResourceResult(decoded.capletId, decoded.downstreamUri);
+		});
+	}
+	registerDirectPrompt(entry) {
+		if (!this.server.registerPrompt) throw new Error("MCP server does not support prompt registration");
+		return this.server.registerPrompt(entry.name, {
+			title: entry.prompt.name,
+			...entry.prompt.description ? { description: entry.prompt.description } : {},
+			argsSchema: promptArgsSchema(entry.prompt.arguments)
+		}, async (args) => await this.engine.getDirectPrompt(entry.caplet.server, entry.downstreamName, isRecord$3(args) ? stringifyRecord(args) : {}));
+	}
+	async directResourceResult(serverId, downstreamUri) {
+		const result = await this.engine.readDirectResource(serverId, downstreamUri);
+		if (isRecord$3(result) && "contents" in result) return result;
+		return { contents: [{
+			uri: downstreamUri,
+			mimeType: "application/json",
+			text: JSON.stringify(result, null, 2)
+		}] };
 	}
-	async handleTool(serverId, request) {
-		return await this.engine.execute(serverId, request);
+};
+function codeModeRunToolDescription(caplets) {
+	return generateCodeModeRunToolDescription(generateCodeModeDeclarations({ caplets: caplets.map((entry) => ({
+		id: entry.caplet.server,
+		name: entry.caplet.name,
+		description: capabilityDescription(entry.caplet),
+		...entry.caplet.useWhen ? { useWhen: entry.caplet.useWhen } : {},
+		...entry.caplet.avoidWhen ? { avoidWhen: entry.caplet.avoidWhen } : {}
+	})) }));
+}
+var EngineNativeCapletsService = class {
+	engine;
+	constructor(engine) {
+		this.engine = engine;
 	}
+	listTools() {
+		return (this.engine.currentExposureSnapshot()?.codeModeCaplets.map((entry) => entry.caplet) ?? this.engine.enabledServers()).map((caplet) => {
+			const toolName = nativeCapletToolName(caplet.server);
+			return {
+				caplet: caplet.server,
+				toolName,
+				title: caplet.name,
+				description: nativeCapletToolDescription(toolName, caplet),
+				promptGuidance: nativeCapletPromptGuidance(toolName, caplet)
+			};
+		});
+	}
+	async execute(capletId, request) {
+		return await this.engine.execute(capletId, request);
+	}
+	async reload() {
+		return await this.engine.reload();
+	}
+	onToolsChanged(listener) {
+		return this.engine.onReload(() => listener(this.listTools()));
+	}
+	async close() {}
 };
-function nextEnabledServers(config) {
-	return [
-		...Object.values(config.mcpServers),
-		...Object.values(config.openapiEndpoints),
-		...Object.values(config.graphqlEndpoints),
-		...Object.values(config.httpApis),
-		...Object.values(config.cliTools),
-		...Object.values(config.capletSets)
-	].filter((server) => !server.disabled);
+function resourceMetadata(resource) {
+	return {
+		...resource.description ? { description: resource.description } : {},
+		...resource.mimeType ? { mimeType: resource.mimeType } : {},
+		...typeof resource.size === "number" ? { size: resource.size } : {},
+		_meta: { caplets: {
+			downstreamUri: resource.uri,
+			exposure: "direct"
+		} }
+	};
 }
-function capletById(config, serverId) {
-	return config.mcpServers[serverId] ?? config.openapiEndpoints[serverId] ?? config.graphqlEndpoints[serverId] ?? config.httpApis[serverId] ?? config.cliTools[serverId] ?? config.capletSets[serverId];
+function resourceTemplateMetadata(resourceTemplate) {
+	return {
+		...resourceTemplate.description ? { description: resourceTemplate.description } : {},
+		...resourceTemplate.mimeType ? { mimeType: resourceTemplate.mimeType } : {},
+		_meta: { caplets: {
+			downstreamUriTemplate: resourceTemplate.uriTemplate,
+			exposure: "direct"
+		} }
+	};
 }
-function serializeCaplet(caplet) {
-	return JSON.stringify(caplet ?? null);
+function promptArgsSchema(args) {
+	const shape = {};
+	for (const arg of args ?? []) shape[arg.name] = string().optional();
+	return shape;
+}
+function stringifyRecord(value) {
+	return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, nested === void 0 ? "" : String(nested)]));
+}
+function isRecord$3(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function staticExposureSnapshot(config, caplets) {
+	const callableCaplets = caplets.filter((caplet) => !caplet.disabled && !caplet.setup && !caplet.projectBinding?.required).map((caplet) => ({
+		caplet,
+		exposure: resolveExposure(caplet.exposure, config.options.exposure),
+		tools: [],
+		resources: [],
+		resourceTemplates: [],
+		prompts: [],
+		discoveredAt: Date.now()
+	}));
+	return {
+		callableCaplets,
+		progressiveCaplets: callableCaplets.filter((entry) => entry.exposure.progressive),
+		codeModeCaplets: callableCaplets.filter((entry) => entry.exposure.codeMode),
+		directTools: [],
+		directResources: [],
+		directResourceTemplates: [],
+		directPrompts: [],
+		hiddenCaplets: caplets.filter((caplet) => caplet.disabled || caplet.setup || caplet.projectBinding?.required).map((caplet) => ({
+			capletId: caplet.server,
+			reason: caplet.disabled ? "disabled" : caplet.setup ? "setup_required" : "project_binding_required"
+		}))
+	};
 }
 //#endregion
 //#region src/runtime.ts
@@ -4863,6 +5305,42 @@ function isUrlLike(value) {
 	return /^https?:\/\//i.test(value);
 }
 //#endregion
+//#region src/cli/cloud-add.ts
+const MAX_CLOUD_CAPLET_BUNDLE_BYTES = 2 * 1024 * 1024;
+const SKIPPED_DIRECTORY_NAMES = new Set([
+	".git",
+	"node_modules",
+	"auth"
+]);
+function buildCloudCapletBundle(rootInput) {
+	const root = resolve(rootInput);
+	if (!existsSync(root)) throw new CapletsError("CONFIG_INVALID", `Caplet path does not exist: ${rootInput}`);
+	if (!statSync(root).isDirectory()) throw new CapletsError("CONFIG_INVALID", `Caplet path must be a directory: ${rootInput}`);
+	const files = collectFiles(root).map((filePath) => ({
+		path: relative(root, filePath).split(sep).join("/"),
+		content: readFileSync(filePath, "utf8")
+	})).filter((file) => file.path !== "config.json").sort((left, right) => left.path.localeCompare(right.path));
+	const totalBytes = files.reduce((total, file) => total + Buffer.byteLength(file.content), 0);
+	if (totalBytes > MAX_CLOUD_CAPLET_BUNDLE_BYTES) throw new CapletsError("CONFIG_INVALID", `Caplet bundle is too large for Cloud upload (${totalBytes} bytes).`);
+	if (!files.some((file) => file.path.endsWith(".md") || file.path.endsWith("/CAPLET.md"))) throw new CapletsError("CONFIG_INVALID", `No Caplet files found under ${rootInput}`);
+	return { files };
+}
+function collectFiles(root) {
+	const entries = readdirSync(root, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+	const files = [];
+	for (const entry of entries) {
+		if (entry.isSymbolicLink()) continue;
+		const path = resolve(root, entry.name);
+		if (entry.isDirectory()) {
+			if (SKIPPED_DIRECTORY_NAMES.has(entry.name)) continue;
+			files.push(...collectFiles(path));
+			continue;
+		}
+		if (entry.isFile()) files.push(path);
+	}
+	return files;
+}
+//#endregion
 //#region src/cli/auth.ts
 async function loginAuth(serverId, options) {
 	const server = findAuthTarget(serverId, options.config ?? loadConfig(options.configPath));
@@ -4996,6 +5474,86 @@ async function maybeReadManualInput() {
 	}
 }
 //#endregion
+//#region src/cli/code-mode.ts
+async function runCodeModeCli(options) {
+	const service = createNativeCapletsService({
+		mode: "local",
+		...options.configPath ? { configPath: options.configPath } : {},
+		...options.projectConfigPath ? { projectConfigPath: options.projectConfigPath } : {},
+		...options.authDir ? { authDir: options.authDir } : {}
+	});
+	try {
+		const code = await readCodeModeCliCode(options);
+		const result = await service.execute(nativeCodeModeToolId, {
+			code,
+			...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+		});
+		if (options.json) options.writeOut(`${JSON.stringify(result, null, 2)}\n`);
+		else if (result.ok) options.writeOut(`${formatHumanValue(result.value)}\n`);
+		else {
+			options.writeOut(`${result.error.code}: ${result.error.message}\n`);
+			if (result.diagnostics.length > 0) options.writeOut(`${result.diagnostics.map((diagnostic) => `- ${diagnostic.message}`).join("\n")}\n`);
+		}
+		if (!result.ok) options.setExitCode(1);
+	} finally {
+		await service.close();
+	}
+}
+async function codeModeTypesCli(options) {
+	const engine = new CapletsEngine({
+		...options.configPath ? { configPath: options.configPath } : {},
+		...options.projectConfigPath ? { projectConfigPath: options.projectConfigPath } : {},
+		...options.authDir ? { authDir: options.authDir } : {}
+	});
+	try {
+		const caplets = listCodeModeCallableCaplets$1(engine);
+		const declaration = generateCodeModeDeclarations({ caplets });
+		if (!options.json) {
+			options.writeOut(declaration);
+			return;
+		}
+		const output = {
+			declaration,
+			declarationHash: codeModeDeclarationHash(declaration),
+			callableCount: caplets.length,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			runtimeScope: runtimeScope(options.env)
+		};
+		options.writeOut(`${JSON.stringify(output, null, 2)}\n`);
+	} finally {
+		await engine.close();
+	}
+}
+async function readCodeModeCliCode(options) {
+	if (options.inlineCode !== void 0) return options.inlineCode;
+	if (options.file !== void 0) return readFileSync(resolve(process.cwd(), options.file), "utf8");
+	return await (options.readStdin ?? readProcessStdin)();
+}
+async function readProcessStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+	return Buffer.concat(chunks).toString("utf8");
+}
+function formatHumanValue(value) {
+	return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+function runtimeScope(env = process.env) {
+	return env.CAPLETS_MODE?.trim() || "local";
+}
+function listCodeModeCallableCaplets$1(engine) {
+	const defaultExposure = engine.currentConfig().options.exposure;
+	return engine.enabledServers().filter((caplet) => {
+		if (caplet.setup || caplet.projectBinding?.required) return false;
+		return resolveExposure(caplet.exposure, defaultExposure).codeMode;
+	}).map((caplet) => ({
+		id: caplet.server,
+		name: caplet.name,
+		description: caplet.description,
+		...caplet.useWhen ? { useWhen: caplet.useWhen } : {},
+		...caplet.avoidWhen ? { avoidWhen: caplet.avoidWhen } : {}
+	})).sort((left, right) => left.id.localeCompare(right.id));
+}
+//#endregion
 //#region src/cli/init.ts
 function initConfig(options = {}) {
 	const path = resolveConfigPath(options.path);
@@ -5257,7 +5815,9 @@ async function doctorJsonReport(options = {}) {
 			configured: false,
 			running: false
 		},
-		cloudAuth: redactedCloudAuthStatus(credentials)
+		cloudAuth: redactedCloudAuthStatus(credentials),
+		exposure: await resolveExposureSection(env),
+		codeMode: await resolveCodeModeSection(options, env)
 	};
 }
 async function formatDoctorReport(options = {}) {
@@ -5298,9 +5858,68 @@ async function formatDoctorReport(options = {}) {
 		"Cloud Auth",
 		`  Authenticated: ${yesNo(Boolean(report.cloudAuth.authenticated))}`,
 		...report.cloudAuth.cloudUrl ? [`  Cloud URL: ${report.cloudAuth.cloudUrl}`] : [],
-		...report.cloudAuth.workspaceSlug || report.cloudAuth.workspaceId ? [`  Selected Workspace: ${report.cloudAuth.workspaceSlug ?? report.cloudAuth.workspaceId}`] : []
+		...report.cloudAuth.workspaceSlug || report.cloudAuth.workspaceId ? [`  Selected Workspace: ${report.cloudAuth.workspaceSlug ?? report.cloudAuth.workspaceId}`] : [],
+		"",
+		"Exposure",
+		`  Default: ${report.exposure.default ?? "unknown"}`,
+		`  Discovery timeout: ${report.exposure.discoveryTimeoutMs ?? "unknown"}ms`,
+		`  Discovery concurrency: ${report.exposure.discoveryConcurrency ?? "unknown"}`,
+		`  Callable native tools: ${report.exposure.callableNativeToolCount ?? 0}`,
+		...Array.isArray(report.exposure.caplets) ? report.exposure.caplets.map((caplet) => `  ${caplet.id}: ${caplet.exposure} (${caplet.callable ? "callable" : `hidden: ${caplet.hiddenReason}`})`) : [],
+		"",
+		"Code Mode",
+		`  Types generation: ${doctorOk(report.codeMode.typesGeneration)}`,
+		`  Diagnostics: ${doctorOk(report.codeMode.diagnostics)}`,
+		`  Sandbox smoke: ${doctorOk(report.codeMode.sandboxSmoke)}`,
+		`  Log storage: ${doctorOk(report.codeMode.logStorage)}`,
+		`  Callable index: ${doctorOk(report.codeMode.callableIndex)}`,
+		`  Observed output shapes: ${doctorOk(report.codeMode.observedOutputShapes)}`,
+		...observedOutputShapePath(report.codeMode.observedOutputShapes) ? [`  Observed output shape cache: ${observedOutputShapePath(report.codeMode.observedOutputShapes)}`] : []
 	].join("\n")}\n`;
 }
+async function resolveExposureSection(env) {
+	const configPath = env.CAPLETS_CONFIG?.trim() ? env.CAPLETS_CONFIG.trim() : resolveConfigPath();
+	const projectConfigPath = env.CAPLETS_PROJECT_CONFIG?.trim() ? env.CAPLETS_PROJECT_CONFIG.trim() : resolveProjectConfigPath();
+	try {
+		const config = loadConfig(configPath, projectConfigPath);
+		const service = createNativeCapletsService({
+			mode: "local",
+			configPath,
+			projectConfigPath,
+			watch: false,
+			writeErr: () => void 0
+		});
+		try {
+			const nativeTools = service.listTools();
+			const callableIds = new Set(nativeTools.map((tool) => tool.caplet));
+			return {
+				ok: true,
+				default: config.options.exposure,
+				discoveryTimeoutMs: config.options.exposureDiscoveryTimeoutMs,
+				discoveryConcurrency: config.options.exposureDiscoveryConcurrency,
+				callableNativeToolCount: nativeTools.length,
+				caplets: allCaplets(config).map((caplet) => {
+					const exposure = resolveExposure(caplet.exposure, config.options.exposure);
+					const callable = callableIds.has(caplet.server) || [...callableIds].some((id) => id.startsWith(`${caplet.server}__`));
+					return {
+						id: caplet.server,
+						exposure: exposure.value,
+						callable,
+						...callable ? {} : { hiddenReason: hiddenReasonFor(caplet) }
+					};
+				})
+			};
+		} finally {
+			await service.close();
+		}
+	} catch (error) {
+		return {
+			ok: true,
+			configLoaded: false,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
 function resolveServerSection(env) {
 	try {
 		const server = resolveCapletsServer({}, env);
@@ -5337,6 +5956,134 @@ function resolveRemoteSection(env) {
 function yesNo(value) {
 	return value ? "yes" : "no";
 }
+async function resolveCodeModeSection(options, env) {
+	const emptyDeclaration = generateCodeModeDeclarations({ caplets: [] });
+	const diagnostics = diagnoseCodeModeTypeScript({
+		declaration: emptyDeclaration,
+		code: "return 1;"
+	});
+	const tempDir = mkdtempSync(join(tmpdir(), "caplets-code-mode-doctor-"));
+	try {
+		const logStore = new CodeModeLogStore({ stateDir: tempDir });
+		const stored = await logStore.store([{
+			level: "log",
+			message: "doctor smoke",
+			timestamp: (/* @__PURE__ */ new Date(0)).toISOString()
+		}]);
+		const read = await logStore.read({ logRef: stored.logRef });
+		const sandboxSmoke = await runCodeMode({
+			code: "return 1;",
+			service: emptyCodeModeDoctorService(),
+			logStore
+		});
+		return {
+			typesGeneration: { ok: emptyDeclaration.includes("declare const caplets") },
+			diagnostics: { ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error") },
+			sandboxSmoke: { ok: sandboxSmoke.ok },
+			logStorage: { ok: read.entries.length === 1 },
+			callableIndex: await resolveCallableIndexDoctor(env),
+			observedOutputShapes: await resolveObservedOutputShapesDoctor(options)
+		};
+	} catch (error) {
+		return {
+			typesGeneration: { ok: true },
+			diagnostics: { ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error") },
+			sandboxSmoke: {
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			},
+			logStorage: {
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			},
+			callableIndex: {
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			},
+			observedOutputShapes: await resolveObservedOutputShapesDoctor(options)
+		};
+	} finally {
+		rmSync(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function resolveObservedOutputShapesDoctor(options) {
+	const store = new FileObservedOutputShapeStore(options.observedOutputShapeCacheDir ?? DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR);
+	if (!store.health) return {
+		ok: false,
+		error: "store health unavailable"
+	};
+	const health = await store.health();
+	return {
+		ok: health.readable && health.writable,
+		path: health.path,
+		readable: health.readable,
+		writable: health.writable,
+		entryCount: health.entryCount ?? null,
+		prune: health.prune ?? null,
+		...health.error ? { error: health.error } : {}
+	};
+}
+async function resolveCallableIndexDoctor(env) {
+	try {
+		const service = createNativeCapletsService({
+			mode: "local",
+			...env.CAPLETS_CONFIG?.trim() ? { configPath: env.CAPLETS_CONFIG.trim() } : {},
+			...env.CAPLETS_PROJECT_CONFIG?.trim() ? { projectConfigPath: env.CAPLETS_PROJECT_CONFIG.trim() } : {},
+			watch: false,
+			writeErr: () => void 0
+		});
+		try {
+			return {
+				ok: true,
+				callableCount: listCodeModeCallableCaplets(service).length
+			};
+		} finally {
+			await service.close();
+		}
+	} catch (error) {
+		return {
+			ok: true,
+			callableCount: 0,
+			configLoaded: false,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function emptyCodeModeDoctorService() {
+	return {
+		listTools: () => [],
+		execute: async () => void 0,
+		reload: async () => true,
+		onToolsChanged: () => () => void 0,
+		close: async () => void 0
+	};
+}
+function doctorOk(value) {
+	return value && typeof value === "object" && value.ok === true ? "ok" : "failed";
+}
+function observedOutputShapePath(value) {
+	return value && typeof value === "object" && typeof value.path === "string" ? value.path : void 0;
+}
+function allCaplets(config) {
+	const typed = config;
+	return [
+		...Object.values(typed.mcpServers ?? {}),
+		...Object.values(typed.openapiEndpoints ?? {}),
+		...Object.values(typed.graphqlEndpoints ?? {}),
+		...Object.values(typed.httpApis ?? {}),
+		...Object.values(typed.cliTools ?? {}),
+		...Object.values(typed.capletSets ?? {})
+	];
+}
+function hiddenReasonFor(caplet) {
+	if (caplet.disabled) return "disabled";
+	if (caplet.setup) return "setup_required";
+	if (caplet.projectBinding?.required) return "project_binding_required";
+	return "not_exposed";
+}
 //#endregion
 //#region src/cloud-auth/open-url.ts
 async function openBrowserUrl(url, options = {}) {
@@ -6002,27 +6749,55 @@ const localMcpConfig = `{
 `;
 function formatSetupMenu() {
 	return [
-		"Usage: caplets setup <integration>",
+		"Usage: caplets setup [integration]",
 		"",
 		"Supported integrations:",
-		"  codex        Run Codex plugin marketplace and plugin install commands",
-		"  claude-code  Run Claude Code plugin marketplace and plugin install commands",
+		"  codex        Add Caplets to Codex MCP config",
+		"  claude-code  Add Caplets to Claude Code MCP config",
 		"  opencode     Run OpenCode native plugin install",
 		"  pi           Run Pi extension install",
 		"  mcp-client   Write a generic MCP client config with --output",
 		"",
 		"Examples:",
+		"  caplets setup",
 		"  caplets setup codex",
 		"  caplets setup opencode --dry-run",
 		"  caplets setup mcp-client --output ./caplets.mcp.json",
 		""
 	].join("\n");
 }
+function formatSetupPrompt() {
+	return [
+		"Select integrations to set up:",
+		"  1. Codex",
+		"  2. Claude Code",
+		"  3. OpenCode",
+		"  4. Pi",
+		"  5. Any MCP client",
+		"",
+		"Enter numbers, ids, or all, separated by commas (default: codex): "
+	].join("\n");
+}
+async function runInteractiveSetup(options) {
+	if (options.format === "json") throw new CapletsError("REQUEST_INVALID", "interactive caplets setup only supports plain output; pass an integration with --format json");
+	const selected = parseInteractiveSetupSelection(await options.readPrompt(formatSetupPrompt()));
+	const chunks = [];
+	for (const integration of selected) {
+		const setupOptions = { ...options };
+		if (integration === "mcp-client" && !setupOptions.output) {
+			const output = nonEmpty$1(await options.readPrompt("Path to write generic MCP config (--output): "));
+			if (!output) throw new CapletsError("REQUEST_INVALID", "mcp-client setup requires an output path");
+			setupOptions.output = output;
+		}
+		chunks.push(await runSetup(integration, setupOptions));
+	}
+	return chunks.join("\n");
+}
 async function runSetup(integration, options = {}) {
 	if (!setupIntegrationIds.includes(integration)) return await runCapletSetupCli(integration, {
 		...options.yes === void 0 ? {} : { yes: options.yes },
 		target: resolveSetupTargetKind(options),
-		...options.remote === void 0 ? {} : { remote: options.remote }
+		...options.remote === void 0 && !isRemoteSetup(options) ? {} : { remote: isRemoteSetup(options) }
 	});
 	const result = await executeSetup(integration, options);
 	if (options.format === "json") return `${JSON.stringify(result, null, 2)}\n`;
@@ -6066,7 +6841,7 @@ async function executeSetup(integration, options) {
 	return {
 		integration: id,
 		name: definition.name,
-		mode: options.remote ? "remote" : "local",
+		mode: isRemoteSetup(options) ? "remote" : "local",
 		targetKind: resolveSetupTargetKind(options),
 		dryRun: Boolean(options.dryRun),
 		actions,
@@ -6074,55 +6849,31 @@ async function executeSetup(integration, options) {
 	};
 }
 function setupDefinition(id, options) {
-	if (options.remote) return remoteSetupDefinition(id, options);
+	if (isRemoteSetup(options)) return remoteSetupDefinition(id, options);
 	switch (id) {
 		case "codex": return {
 			name: "Codex",
 			actions: [{
 				type: "command",
-				label: "Add Caplets marketplace to Codex",
+				label: "Add Caplets MCP server to Codex",
 				command: "codex",
-				args: [
-					"plugin",
-					"marketplace",
-					"add",
-					"spiritledsoftware/caplets"
-				]
-			}, {
-				type: "command",
-				label: "Install Caplets Codex plugin",
-				command: "codex",
-				args: [
-					"plugin",
-					"add",
-					"caplets@caplets"
-				]
+				args: codexMcpAddArgs(["serve"])
 			}],
-			nextSteps: ["Try a premade Caplet: caplets install spiritledsoftware/caplets github", "Ask Codex: codex \"try using the github caplet\""]
+			nextSteps: [
+				"In Codex, run /mcp to confirm the caplets server is connected.",
+				"Try a premade Caplet: caplets install spiritledsoftware/caplets github",
+				"Ask Codex: codex \"try using the github caplet\""
+			]
 		};
 		case "claude-code": return {
 			name: "Claude Code",
 			actions: [{
 				type: "command",
-				label: "Add Caplets marketplace to Claude Code",
-				command: "claude",
-				args: [
-					"plugin",
-					"marketplace",
-					"add",
-					"spiritledsoftware/caplets"
-				]
-			}, {
-				type: "command",
-				label: "Install Caplets Claude Code plugin",
+				label: "Add Caplets MCP server to Claude Code",
 				command: "claude",
-				args: [
-					"plugin",
-					"install",
-					"caplets@caplets"
-				]
+				args: claudeMcpAddArgs(["serve"])
 			}],
-			nextSteps: ["Restart Claude Code if it was already running.", "Try a premade Caplet: caplets install spiritledsoftware/caplets github"]
+			nextSteps: ["In Claude Code, run /mcp to confirm the caplets server is connected.", "Try a premade Caplet: caplets install spiritledsoftware/caplets github"]
 		};
 		case "opencode": return {
 			name: "OpenCode",
@@ -6163,7 +6914,7 @@ function setupDefinition(id, options) {
 	}
 }
 function remoteSetupDefinition(id, options) {
-	const serverUrl = nonEmpty$1(options.serverUrl) ?? nonEmpty$1(options.env?.CAPLETS_SERVER_URL) ?? "https://caplets.example.com/caplets";
+	const serverUrl = nonEmpty$1(options.remoteUrl) ?? nonEmpty$1(options.serverUrl) ?? nonEmpty$1(options.env?.CAPLETS_REMOTE_URL) ?? nonEmpty$1(options.env?.CAPLETS_SERVER_URL) ?? "https://caplets.example.com/caplets";
 	if (id === "opencode") return {
 		name: "OpenCode",
 		actions: [{
@@ -6188,9 +6939,37 @@ function remoteSetupDefinition(id, options) {
 		}],
 		nextSteps: [`Start Pi with CAPLETS_MODE=remote and CAPLETS_SERVER_URL=${serverUrl}.`, "Keep CAPLETS_SERVER_PASSWORD in your shell or secret manager."]
 	};
+	if (id === "codex") return {
+		name: "Codex",
+		actions: [{
+			type: "command",
+			label: "Add remote-backed Caplets MCP server to Codex",
+			command: "codex",
+			args: codexMcpAddArgs([
+				"attach",
+				"--remote-url",
+				serverUrl
+			])
+		}],
+		nextSteps: ["In Codex, run /mcp to confirm the caplets server is connected.", "Keep remote credentials in your shell or secret manager; do not hardcode them in config."]
+	};
+	if (id === "claude-code") return {
+		name: "Claude Code",
+		actions: [{
+			type: "command",
+			label: "Add remote-backed Caplets MCP server to Claude Code",
+			command: "claude",
+			args: claudeMcpAddArgs([
+				"attach",
+				"--remote-url",
+				serverUrl
+			])
+		}],
+		nextSteps: ["In Claude Code, run /mcp to confirm the caplets server is connected.", "Keep remote credentials in your shell or secret manager; do not hardcode them in config."]
+	};
 	if (!options.output) throw new CapletsError("REQUEST_INVALID", "remote MCP-backed setup requires --output <path> so Caplets can write a client config without guessing your agent's secret storage");
 	return {
-		name: id === "codex" ? "Codex" : id === "claude-code" ? "Claude Code" : "Any MCP client",
+		name: "Any MCP client",
 		actions: [{
 			type: "writeFile",
 			label: "Write remote MCP config",
@@ -6204,6 +6983,23 @@ function parseSetupIntegrationId(value) {
 	if (setupIntegrationIds.includes(value)) return value;
 	throw new CapletsError("REQUEST_INVALID", `setup integration must be one of: ${setupIntegrationIds.join(", ")}`);
 }
+function parseInteractiveSetupSelection(value) {
+	const rawSelections = value.split(",").map((part) => part.trim()).filter(Boolean);
+	const ids = (rawSelections.length > 0 ? rawSelections : ["codex"]).flatMap((selection) => normalizedInteractiveSetupToken(selection) === "all" ? setupIntegrationIds : [parseInteractiveSetupToken(selection)]);
+	return [...new Set(ids)];
+}
+function parseInteractiveSetupToken(value) {
+	const normalized = normalizedInteractiveSetupToken(value);
+	if (normalized === "1" || normalized === "codex") return "codex";
+	if (normalized === "2" || normalized === "claude" || normalized === "claude-code" || normalized === "claudecode") return "claude-code";
+	if (normalized === "3" || normalized === "opencode" || normalized === "open-code") return "opencode";
+	if (normalized === "4" || normalized === "pi") return "pi";
+	if (normalized === "5" || normalized === "mcp" || normalized === "mcp-client" || normalized === "any-mcp-client" || normalized === "generic" || normalized === "generic-mcp") return "mcp-client";
+	throw new CapletsError("REQUEST_INVALID", `unknown setup integration selection: ${value}`);
+}
+function normalizedInteractiveSetupToken(value) {
+	return value.trim().toLowerCase().replace(/[\s_]+/gu, "-");
+}
 async function defaultSetupCommandRunner(command, args) {
 	const { stdout, stderr } = await execFileAsync(command, args, {
 		encoding: "utf8",
@@ -6230,10 +7026,37 @@ function formatSetupResult(result) {
 function formatCommand(command, args) {
 	return [command, ...args].join(" ");
 }
+function codexMcpAddArgs(capletsArgs) {
+	return [
+		"mcp",
+		"add",
+		"caplets",
+		"--",
+		"caplets",
+		...capletsArgs
+	];
+}
+function claudeMcpAddArgs(capletsArgs) {
+	return [
+		"mcp",
+		"add",
+		"--transport",
+		"stdio",
+		"--scope",
+		"user",
+		"caplets",
+		"--",
+		"caplets",
+		...capletsArgs
+	];
+}
 function nonEmpty$1(value) {
 	const trimmed = value?.trim();
 	return trimmed ? trimmed : void 0;
 }
+function isRemoteSetup(options) {
+	return Boolean(options.remote ?? nonEmpty$1(options.remoteUrl) ?? nonEmpty$1(options.serverUrl));
+}
 function resolveSetupTargetKind(options) {
 	if (options.target !== void 0) {
 		if (isSetupTargetKind(options.target)) return options.target;
@@ -6242,7 +7065,7 @@ function resolveSetupTargetKind(options) {
 		if (options.target === "cloud" || options.target === "hosted_worker") return "hosted_sandbox";
 		throw new CapletsError("REQUEST_INVALID", "setup target must be one of: local_host, remote_host, hosted_sandbox");
 	}
-	return options.remote ? "remote_host" : "local_host";
+	return isRemoteSetup(options) ? "remote_host" : "local_host";
 }
 //#endregion
 //#region src/serve/options.ts
@@ -9747,16 +10570,16 @@ var logger = (fn = console.log) => {
 //#region src/remote-control/dispatch.ts
 const ENGINE_COMMANDS = new Set([
 	"inspect",
-	"check_backend",
-	"list_tools",
+	"check",
+	"tools",
 	"search_tools",
-	"get_tool",
+	"describe_tool",
 	"call_tool",
-	"list_resources",
+	"resources",
 	"search_resources",
-	"list_resource_templates",
+	"resource_templates",
 	"read_resource",
-	"list_prompts",
+	"prompts",
 	"search_prompts",
 	"get_prompt",
 	"complete"
@@ -11013,8 +11836,17 @@ async function serveStdio(options = {}) {
 		process.once("SIGINT", sigintHandler);
 		process.once("SIGTERM", sigtermHandler);
 	}
+	const transport = new StdioServerTransport();
+	const transportClosed = new Promise((resolve) => {
+		const previousOnClose = transport.onclose;
+		transport.onclose = () => {
+			previousOnClose?.();
+			resolve();
+		};
+	});
 	try {
-		await session.connect(new StdioServerTransport());
+		await session.connect(transport);
+		await transportClosed;
 	} finally {
 		if (sigintHandler) process.off("SIGINT", sigintHandler);
 		if (sigtermHandler) process.off("SIGTERM", sigtermHandler);
@@ -11460,6 +12292,16 @@ function cloudAuthStore(env) {
 function cloudAuthStatus(credentials) {
 	return redactedCloudAuthStatus(credentials);
 }
+function compactCloudCaplet(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const record = value;
+	return {
+		...typeof record.id === "string" ? { id: record.id } : {},
+		...typeof record.name === "string" ? { name: record.name } : {},
+		...typeof record.description === "string" ? { description: record.description } : {},
+		...typeof record.readinessState === "string" ? { readinessState: record.readinessState } : {}
+	};
+}
 function isProjectBindingWebSocketUnavailable(error) {
 	return error instanceof CapletsError && error.code === "SERVER_UNAVAILABLE" && error.message.includes("Project Binding WebSocket unavailable");
 }
@@ -11497,6 +12339,32 @@ function numberEnv(value, fallback) {
 	const parsed = Number(value);
 	return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
 }
+function createSetupPromptHandle(io, writeOut) {
+	if (io.readStdin) {
+		const readStdin = io.readStdin;
+		let input;
+		let lines;
+		let lineIndex = 0;
+		return {
+			readPrompt: async (prompt) => {
+				writeOut(prompt);
+				input ??= readStdin();
+				lines ??= (await input).split(/\r?\n/u);
+				return lines[lineIndex++] ?? "";
+			},
+			close: () => {}
+		};
+	}
+	if (io.writeOut || io.writeErr || !process.stdin.isTTY || !process.stdout.isTTY) return;
+	const readline = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	return {
+		readPrompt: (prompt) => readline.question(prompt),
+		close: () => readline.close()
+	};
+}
 async function sleep(ms) {
 	if (ms <= 0) return;
 	await new Promise((resolve) => setTimeout(resolve, ms));
@@ -11552,6 +12420,31 @@ function createProgram(io = {}) {
 		}
 		if (suggestions.length > 0) writeOut(`${suggestions.join("\n")}\n`);
 	});
+	program.command(cliCommands$1.codeMode).description("Run, inspect, and debug Caplets Code Mode.").argument("[code]", "inline TypeScript code to run").option("--file <path>", "read TypeScript code from a file relative to the current directory").option("--timeout-ms <ms>", "execution timeout in milliseconds", parsePositiveInteger).option("--json", "print the structured run envelope").action(async (code, options) => {
+		await runCodeModeCli({
+			env,
+			...currentConfigPath() ? { configPath: currentConfigPath() } : {},
+			projectConfigPath: envProjectConfigPath(env),
+			...io.authDir ? { authDir: io.authDir } : {},
+			...code === void 0 ? {} : { inlineCode: code },
+			...options.file === void 0 ? {} : { file: options.file },
+			...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+			...options.json === void 0 ? {} : { json: options.json },
+			...io.readStdin ? { readStdin: io.readStdin } : {},
+			writeOut,
+			setExitCode
+		});
+	}).command("types").description("Print the generated Code Mode TypeScript declarations.").option("--json", "print declaration metadata as JSON").action(async (options, command) => {
+		const parentOptions = command.parent?.opts() ?? {};
+		await codeModeTypesCli({
+			env,
+			...currentConfigPath() ? { configPath: currentConfigPath() } : {},
+			projectConfigPath: envProjectConfigPath(env),
+			...io.authDir ? { authDir: io.authDir } : {},
+			...options.json === void 0 && parentOptions.json === void 0 ? {} : { json: options.json ?? parentOptions.json },
+			writeOut
+		});
+	});
 	const serve = program.command(cliCommands$1.serve).description("Serve configured Caplets as an MCP server.").option("--transport <transport>", "server transport: stdio or http").option("--host <host>", "HTTP bind host").option("--port <port>", "HTTP bind port").option("--path <path>", "HTTP service base path").option("--user <user>", "HTTP Basic Auth username").option("--password <password>", "HTTP Basic Auth password").option("--allow-unauthenticated-http", "allow unauthenticated HTTP serving on non-loopback hosts").option("--trust-proxy", "trust X-Forwarded-* headers from a reverse proxy").action(async (options) => {
 		const resolved = resolveServeOptions(options);
 		const configPath = currentConfigPath();
@@ -11667,7 +12560,8 @@ function createProgram(io = {}) {
 			throw error;
 		}
 	});
-	const cloudAuth = program.command(cliCommands$1.cloud).description("Manage hosted Caplets Cloud.").command("auth").description("Authenticate this Caplets client to hosted Caplets Cloud.");
+	const cloud = program.command(cliCommands$1.cloud).description("Manage hosted Caplets Cloud.");
+	const cloudAuth = cloud.command("auth").description("Authenticate this Caplets client to hosted Caplets Cloud.");
 	cloudAuth.command("login").description("Log in to hosted Caplets Cloud.").option("--cloud-url <url>", "hosted Caplets Cloud URL").option("--workspace <workspace>", "workspace ID or slug to select").option("--device-name <name>", "device label for this Cloud Auth credential").option("--no-open", "print the login URL without opening a browser").option("--json", "print JSON output").action(async (options) => {
 		const client = new CloudAuthClient({
 			cloudUrl: options.cloudUrl ?? env.CAPLETS_CLOUD_URL ?? "https://cloud.caplets.dev",
@@ -11786,6 +12680,29 @@ function createProgram(io = {}) {
 		}
 		writeOut(`Selected workspace ${next.workspaceSlug ?? next.workspaceId}.\n`);
 	});
+	cloud.command("add").description("Upload local caplet-files to the selected hosted Caplets Cloud workspace.").argument("[path]", "directory containing caplet-files", ".").option("--cloud-url <url>", "hosted Caplets Cloud URL").option("--workspace <workspace>", "workspace ID or slug").option("--json", "print JSON output").action(async (pathInput, options) => {
+		const credentials = await cloudAuthStore(env).load();
+		if (!credentials) throw new CapletsError("AUTH_REQUIRED", "Run caplets cloud auth login first.");
+		const cloudUrl = options.cloudUrl ?? credentials.cloudUrl;
+		const workspace = options.workspace ?? credentials.workspaceSlug ?? credentials.workspaceId;
+		const bundle = buildCloudCapletBundle(pathInput);
+		const caplets = (await new CloudAuthClient({
+			cloudUrl,
+			...io.fetch ? { fetch: io.fetch } : {}
+		}).addCaplets({
+			accessToken: credentials.accessToken,
+			workspace,
+			bundle
+		})).caplets.map(compactCloudCaplet);
+		if (options.json) {
+			writeOut(`${JSON.stringify({
+				caplets,
+				workspace
+			}, null, 2)}\n`);
+			return;
+		}
+		for (const caplet of caplets) writeOut(`Added ${caplet.name ?? caplet.id ?? "Caplet"} to ${workspace}.\n`);
+	});
 	program.command(cliCommands$1.init).description("Create a starter Caplets config file.").option("--project", "create the project Caplets config").option("-g, --global", "create the user Caplets config").option("--remote", "create the remote Caplets config").option("--force", "overwrite an existing config file").action(async (options) => {
 		const target = parseMutationTarget(options);
 		if (target === "remote") {
@@ -11798,16 +12715,28 @@ function createProgram(io = {}) {
 		});
 		writeOut(`Created ${localMutationTargetLabel(target, io)}Caplets config at ${path}\n`);
 	});
-	program.command(cliCommands$1.setup).description("Install or configure an agent integration for Caplets.").argument("[integration]", "integration: codex, claude-code, opencode, pi, or mcp-client").option("--remote", "configure for a remote Caplets server").option("--server-url <url>", "remote Caplets service base URL").option("--output <path>", "config path to write for generic MCP setup").option("--dry-run", "print actions without running commands or writing files").option("--yes", "approve Caplet setup commands for the exact current content hash").option("--target <target>", "Caplet setup target: local, remote, or cloud", parseSetupTarget).option("--format <format>", "output format: plain or json", parseSetupFormat).action(async (integration, options) => {
-		if (!integration) {
-			writeOut(formatSetupMenu());
-			return;
-		}
+	program.command(cliCommands$1.setup).description("Install or configure an agent integration for Caplets.").argument("[integration]", "integration: codex, claude-code, opencode, pi, or mcp-client").option("--remote", "configure for a remote Caplets server").option("--remote-url <url>", "remote Caplets service base URL").option("--server-url <url>", "remote Caplets service base URL").option("--output <path>", "config path to write for generic MCP setup").option("--dry-run", "print actions without running commands or writing files").option("--yes", "approve Caplet setup commands for the exact current content hash").option("--target <target>", "Caplet setup target: local, remote, or cloud", parseSetupTarget).option("--format <format>", "output format: plain or json", parseSetupFormat).action(async (integration, options) => {
 		const setupOptions = {
 			...options,
 			env
 		};
 		if (io.runSetupCommand) setupOptions.runCommand = io.runSetupCommand;
+		if (!integration) {
+			const promptHandle = createSetupPromptHandle(io, writeOut);
+			if (!promptHandle) {
+				writeOut(formatSetupMenu());
+				return;
+			}
+			try {
+				writeOut(await runInteractiveSetup({
+					...setupOptions,
+					readPrompt: promptHandle.readPrompt
+				}));
+			} finally {
+				promptHandle.close();
+			}
+			return;
+		}
 		writeOut(await runSetup(integration, setupOptions));
 	});
 	program.command(cliCommands$1.doctor).description("Diagnose Caplets local, remote, and project-sync configuration.").option("--json", "print JSON output").action(async (options) => {
@@ -11954,7 +12883,7 @@ function createProgram(io = {}) {
 		});
 	});
 	program.command(cliCommands$1.checkBackend).description("Check backend availability for a configured Caplet.").argument("<caplet>", "configured Caplet ID").option("--format <format>", "output format: markdown, md, plain, or json", parseOutputFormat).action(async (caplet, options) => {
-		await executeOperation(caplet, { operation: "check_backend" }, {
+		await executeOperation(caplet, { operation: "check" }, {
 			writeOut,
 			writeErr,
 			setExitCode,
@@ -11965,7 +12894,7 @@ function createProgram(io = {}) {
 		});
 	});
 	program.command(cliCommands$1.listTools).description("List downstream tools for a configured Caplet.").argument("<caplet>", "configured Caplet ID").option("--format <format>", "output format: markdown, md, plain, or json", parseOutputFormat).action(async (caplet, options) => {
-		await executeOperation(caplet, { operation: "list_tools" }, {
+		await executeOperation(caplet, { operation: "tools" }, {
 			writeOut,
 			writeErr,
 			setExitCode,
@@ -11996,8 +12925,8 @@ function createProgram(io = {}) {
 	program.command(cliCommands$1.getTool).description("Print one downstream tool schema.").argument("<caplet-or-target>", "Caplet ID or qualified <caplet.tool> target").argument("[tool]", "downstream tool name when caplet is provided separately").option("--format <format>", "output format: markdown, md, plain, or json", parseOutputFormat).action(async (capletOrTarget, toolArgument, options) => {
 		const { caplet, tool } = parseQualifiedTarget(capletOrTarget, toolArgument);
 		await executeOperation(caplet, {
-			operation: "get_tool",
-			tool
+			operation: "describe_tool",
+			name: tool
 		}, {
 			writeOut,
 			writeErr,
@@ -12012,8 +12941,8 @@ function createProgram(io = {}) {
 		const { caplet, tool } = parseQualifiedTarget(capletOrTarget, toolArgument);
 		await executeOperation(caplet, {
 			operation: "call_tool",
-			tool,
-			arguments: parseCallToolArgs(options.args),
+			name: tool,
+			args: parseCallToolArgs(options.args),
 			...options.field && options.field.length > 0 ? { fields: options.field } : {}
 		}, {
 			writeOut,
@@ -12025,8 +12954,8 @@ function createProgram(io = {}) {
 			format: options.format
 		});
 	});
-	program.command(cliCommands$1.listResources).description("List MCP resources for a configured MCP Caplet.").argument("<caplet>").option("--limit <n>", "maximum number of resources to return", parsePositiveInteger).option("--format <format>", "output format: markdown, md, plain, or json", parseOutputFormat).action(async (caplet, options) => executeOperation(caplet, options.limit === void 0 ? { operation: "list_resources" } : {
-		operation: "list_resources",
+	program.command(cliCommands$1.listResources).description("List MCP resources for a configured MCP Caplet.").argument("<caplet>").option("--limit <n>", "maximum number of resources to return", parsePositiveInteger).option("--format <format>", "output format: markdown, md, plain, or json", parseOutputFormat).action(async (caplet, options) => executeOperation(caplet, options.limit === void 0 ? { operation: "resources" } : {
+		operation: "resources",
 		limit: options.limit
 	}, {
 		writeOut,
@@ -12053,8 +12982,8 @@ function createProgram(io = {}) {
 		remote: remoteClientForCli(io),
 		format: options.format
 	}));
-	program.command(cliCommands$1.listResourceTemplates).description("List MCP resource templates for a configured MCP Caplet.").argument("<caplet>").option("--limit <n>", "maximum number of templates to return", parsePositiveInteger).option("--format <format>", "output format: markdown, md, plain, or json", parseOutputFormat).action(async (caplet, options) => executeOperation(caplet, options.limit === void 0 ? { operation: "list_resource_templates" } : {
-		operation: "list_resource_templates",
+	program.command(cliCommands$1.listResourceTemplates).description("List MCP resource templates for a configured MCP Caplet.").argument("<caplet>").option("--limit <n>", "maximum number of templates to return", parsePositiveInteger).option("--format <format>", "output format: markdown, md, plain, or json", parseOutputFormat).action(async (caplet, options) => executeOperation(caplet, options.limit === void 0 ? { operation: "resource_templates" } : {
+		operation: "resource_templates",
 		limit: options.limit
 	}, {
 		writeOut,
@@ -12077,8 +13006,8 @@ function createProgram(io = {}) {
 		remote: remoteClientForCli(io),
 		format: options.format
 	}));
-	program.command(cliCommands$1.listPrompts).description("List MCP prompts for a configured MCP Caplet.").argument("<caplet>").option("--limit <n>", "maximum number of prompts to return", parsePositiveInteger).option("--format <format>", "output format: markdown, md, plain, or json", parseOutputFormat).action(async (caplet, options) => executeOperation(caplet, options.limit === void 0 ? { operation: "list_prompts" } : {
-		operation: "list_prompts",
+	program.command(cliCommands$1.listPrompts).description("List MCP prompts for a configured MCP Caplet.").argument("<caplet>").option("--limit <n>", "maximum number of prompts to return", parsePositiveInteger).option("--format <format>", "output format: markdown, md, plain, or json", parseOutputFormat).action(async (caplet, options) => executeOperation(caplet, options.limit === void 0 ? { operation: "prompts" } : {
+		operation: "prompts",
 		limit: options.limit
 	}, {
 		writeOut,
@@ -12109,8 +13038,8 @@ function createProgram(io = {}) {
 		const { caplet, tool: prompt } = parseQualifiedTarget(capletOrTarget, promptArgument);
 		await executeOperation(caplet, {
 			operation: "get_prompt",
-			prompt,
-			arguments: parseJsonObjectOption(options.args, "get-prompt --args")
+			name: prompt,
+			args: parseJsonObjectOption(options.args, "get-prompt --args")
 		}, {
 			writeOut,
 			writeErr,
@@ -12229,16 +13158,16 @@ async function openBrowser(url) {
 function remoteCommandForOperation(operation) {
 	switch (operation) {
 		case "inspect":
-		case "check_backend":
-		case "list_tools":
+		case "check":
+		case "tools":
 		case "search_tools":
-		case "get_tool":
+		case "describe_tool":
 		case "call_tool":
-		case "list_resources":
+		case "resources":
 		case "search_resources":
-		case "list_resource_templates":
+		case "resource_templates":
 		case "read_resource":
-		case "list_prompts":
+		case "prompts":
 		case "search_prompts":
 		case "get_prompt":
 		case "complete": return operation;
@@ -12623,7 +13552,7 @@ function markdownSummaryForOperation(result, request) {
 			`- List tools: \`caplets list-tools ${id}\``,
 			`- Search tools: \`caplets search-tools ${id} <query>\``
 		].filter((line) => line !== void 0).join("\n");
-		case "check_backend": return [
+		case "check": return [
 			`## Backend \`${id}\``,
 			"",
 			`- Status: ${String(payload.status ?? "unknown")}`,
@@ -12633,8 +13562,8 @@ function markdownSummaryForOperation(result, request) {
 			"Next:",
 			`- List tools: \`caplets list-tools ${id}\``
 		].filter((line) => line !== void 0).join("\n");
-		case "list_tools": {
-			const tools = Array.isArray(payload.tools) ? payload.tools : [];
+		case "tools": {
+			const tools = pageItemsFromPayload(payload);
 			return [
 				`## Tools for \`${id}\``,
 				"",
@@ -12649,7 +13578,7 @@ function markdownSummaryForOperation(result, request) {
 			].join("\n");
 		}
 		case "search_tools": {
-			const tools = Array.isArray(payload.tools) ? payload.tools : [];
+			const tools = pageItemsFromPayload(payload);
 			return [
 				`## Matches for ${JSON.stringify(String(payload.query ?? ""))} in \`${id}\``,
 				"",
@@ -12661,7 +13590,7 @@ function markdownSummaryForOperation(result, request) {
 				tools.length > 0 ? `- Inspect the first match: \`caplets get-tool ${id}.${firstToolName(tools) ?? "<tool>"}\`` : `- Try a broader query or list tools: \`caplets list-tools ${id}\``
 			].join("\n");
 		}
-		case "get_tool": {
+		case "describe_tool": {
 			const tool = isPlainObject(payload.tool) ? payload.tool : {};
 			const target = `${id}.${String(tool.name ?? "<tool>")}`;
 			return [
@@ -12681,7 +13610,7 @@ function markdownSummaryForOperation(result, request) {
 			].filter((line) => line !== void 0).join("\n");
 		}
 		case "call_tool": return [
-			`## Call \`${`${String(request.caplet ?? "<caplet>")}.${String(request.tool ?? "unknown")}`}\``,
+			`## Call \`${`${String(request.caplet ?? "<caplet>")}.${String(request.name ?? "unknown")}`}\``,
 			"",
 			`- Status: ${payload.isError === true ? "failed" : "succeeded"}`,
 			callStatusLine(payload) ? `- ${callStatusLine(payload)}` : void 0,
@@ -12689,11 +13618,9 @@ function markdownSummaryForOperation(result, request) {
 			"",
 			"Use `--format json` to inspect the full structured result."
 		].filter((line) => line !== void 0).join("\n");
-		case "list_resources":
+		case "resources":
 		case "search_resources": {
-			const resources = Array.isArray(payload.resources) ? payload.resources : [];
-			const templates = Array.isArray(payload.resourceTemplates) ? payload.resourceTemplates : [];
-			const matches = Array.isArray(payload.matches) ? payload.matches : [...resources, ...templates];
+			const matches = pageItemsFromPayload(payload);
 			return [
 				`## MCP resources for \`${id}\``,
 				"",
@@ -12702,8 +13629,8 @@ function markdownSummaryForOperation(result, request) {
 				...formatResourceLines(matches, "markdown")
 			].join("\n");
 		}
-		case "list_resource_templates": {
-			const templates = Array.isArray(payload.resourceTemplates) ? payload.resourceTemplates : [];
+		case "resource_templates": {
+			const templates = pageItemsFromPayload(payload);
 			return [
 				`## MCP resource templates for \`${id}\``,
 				"",
@@ -12717,9 +13644,9 @@ function markdownSummaryForOperation(result, request) {
 			"",
 			"Use `--format json` to inspect all contents."
 		].join("\n");
-		case "list_prompts":
+		case "prompts":
 		case "search_prompts": {
-			const prompts = Array.isArray(payload.prompts) ? payload.prompts : [];
+			const prompts = pageItemsFromPayload(payload);
 			return [
 				`## MCP prompts for \`${id}\``,
 				"",
@@ -12727,7 +13654,7 @@ function markdownSummaryForOperation(result, request) {
 			].join("\n");
 		}
 		case "get_prompt": return [
-			`## Prompt \`${String(request.caplet)}.${String(request.prompt)}\``,
+			`## Prompt \`${String(request.caplet)}.${String(request.name)}\``,
 			"",
 			summarizePromptResult(payload),
 			"",
@@ -12754,14 +13681,14 @@ function plainSummaryForOperation(result, request) {
 			payload.backend ? `Backend: ${backendType(payload.backend)}` : void 0,
 			`Next: caplets list-tools ${id} or caplets search-tools ${id} <query>`
 		].filter((line) => Boolean(line)).join("\n");
-		case "check_backend": return [
+		case "check": return [
 			`Backend: ${id} is ${String(payload.status ?? "unknown")}`,
 			typeof payload.toolCount === "number" ? `Tools: ${payload.toolCount}` : void 0,
 			typeof payload.elapsedMs === "number" ? `Elapsed: ${payload.elapsedMs}ms` : void 0,
 			`Next: caplets list-tools ${id}`
 		].filter((line) => Boolean(line)).join("\n");
-		case "list_tools": {
-			const tools = Array.isArray(payload.tools) ? payload.tools : [];
+		case "tools": {
+			const tools = pageItemsFromPayload(payload);
 			return [
 				`Tools for ${id} (${tools.length}):`,
 				...formatToolLines(tools, "plain"),
@@ -12769,14 +13696,14 @@ function plainSummaryForOperation(result, request) {
 			].join("\n");
 		}
 		case "search_tools": {
-			const tools = Array.isArray(payload.tools) ? payload.tools : [];
+			const tools = pageItemsFromPayload(payload);
 			return [
 				`Matches for ${JSON.stringify(String(payload.query ?? ""))} in ${id} (${tools.length}):`,
 				...formatToolLines(tools, "plain"),
 				tools.length > 0 ? `Next: caplets get-tool ${id}.${firstToolName(tools) ?? "<tool>"}` : `Next: try caplets list-tools ${id} or a broader query.`
 			].join("\n");
 		}
-		case "get_tool": {
+		case "describe_tool": {
 			const tool = isPlainObject(payload.tool) ? payload.tool : {};
 			const target = `${id}.${String(tool.name ?? "<tool>")}`;
 			return [
@@ -12789,20 +13716,18 @@ function plainSummaryForOperation(result, request) {
 			].filter((line) => Boolean(line)).join("\n");
 		}
 		case "call_tool": return [
-			`Call ${`${String(request.caplet ?? "<caplet>")}.${String(request.tool ?? "unknown")}`} ${payload.isError === true ? "failed" : "succeeded"}.`,
+			`Call ${`${String(request.caplet ?? "<caplet>")}.${String(request.name ?? "unknown")}`} ${payload.isError === true ? "failed" : "succeeded"}.`,
 			callStatusLine(payload),
 			`Result: ${summarizeCallResult(payload)}`,
 			"Use --format json to inspect the full structured result."
 		].filter((line) => Boolean(line)).join("\n");
-		case "list_resources":
+		case "resources":
 		case "search_resources": {
-			const resources = Array.isArray(payload.resources) ? payload.resources : [];
-			const templates = Array.isArray(payload.resourceTemplates) ? payload.resourceTemplates : [];
-			const matches = Array.isArray(payload.matches) ? payload.matches : [...resources, ...templates];
+			const matches = pageItemsFromPayload(payload);
 			return [`MCP resources for ${id} (${matches.length}):`, ...formatResourceLines(matches, "plain")].join("\n");
 		}
-		case "list_resource_templates": {
-			const templates = Array.isArray(payload.resourceTemplates) ? payload.resourceTemplates : [];
+		case "resource_templates": {
+			const templates = pageItemsFromPayload(payload);
 			return [`MCP resource templates for ${id}:`, ...formatResourceLines(templates, "plain")].join("\n");
 		}
 		case "read_resource": return [
@@ -12810,13 +13735,13 @@ function plainSummaryForOperation(result, request) {
 			summarizeResourceRead(payload),
 			"Use --format json to inspect all contents."
 		].join("\n");
-		case "list_prompts":
+		case "prompts":
 		case "search_prompts": {
-			const prompts = Array.isArray(payload.prompts) ? payload.prompts : [];
+			const prompts = pageItemsFromPayload(payload);
 			return [`MCP prompts for ${id}:`, ...formatPromptLines(prompts, "plain")].join("\n");
 		}
 		case "get_prompt": return [
-			`Prompt ${String(request.caplet)}.${String(request.prompt)}`,
+			`Prompt ${String(request.caplet)}.${String(request.name)}`,
 			summarizePromptResult(payload),
 			"Use --format json to inspect all messages."
 		].join("\n");
@@ -12827,6 +13752,17 @@ function plainSummaryForOperation(result, request) {
 function payloadId(payload) {
 	return String(payload.id ?? payload.caplet ?? payload.server ?? "<caplet>");
 }
+function pageItemsFromPayload(payload) {
+	if (Array.isArray(payload.items)) return payload.items;
+	for (const key of [
+		"tools",
+		"resources",
+		"resourceTemplates",
+		"prompts",
+		"matches"
+	]) if (Array.isArray(payload[key])) return payload[key];
+	return [];
+}
 function formatToolLines(tools, format) {
 	if (tools.length === 0) return ["- none"];
 	return tools.map((tool) => {
@@ -13116,6 +14052,12 @@ const rank = {
 	large: 2,
 	heavy: 3
 };
+function resourceClassRank(value) {
+	return rank[value] ?? 0;
+}
+function isRuntimeResourceClassAllowed(requested, maximum) {
+	return resourceClassRank(requested) <= resourceClassRank(maximum);
+}
 function resolveRuntimeResources(inputOrCaplet, features, policy) {
 	const caplet = inputOrCaplet;
 	const input = features === void 0 ? inputOrCaplet : {
@@ -13150,7 +14092,7 @@ function explicitResourceClass$1(caplet) {
 }
 function capClass(requested, maxClass) {
 	if (!maxClass) return requested;
-	return (rank[requested] ?? 0) > (rank[maxClass] ?? 0) ? maxClass : requested;
+	return isRuntimeResourceClassAllowed(requested, maxClass) ? requested : maxClass;
 }
 //#endregion
 //#region src/runtime-plan/planner.ts
@@ -13673,4 +14615,4 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null;
 }
 //#endregion
-export { BundleCapletSource, CapletsRuntime, CloudAuthClient, CloudAuthStore, DEFAULT_SYNC_LIMITS, FilesystemCapletSource, LocalSetupStore, ManagedMutagenProjectSync, PROJECT_BINDINGS_CONTROL_PATH, PROJECT_BINDING_CONNECT_PATH, PROJECT_BINDING_ERROR_CODES, PROJECT_BINDING_STATES, PROJECT_BINDING_SYNC_STATES, ProjectBindingError, ProjectBindingWorkspaceStore, ServerRegistry, attachProjectOnce, attachProjectSession, buildProjectSyncManifest, capabilityDescription, capletSetupContentHash, classifyCapletRuntimeRoute, cloudAuthPath, createProgram, defaultProjectBindingWebSocketFactory, enforceProjectSyncSizeLimits, generatedToolInputSchema, handleServerTool, hasRenderableStructuredContent, loadConfig, markdownCallToolResultContent, markdownStructuredContent, migrateCredentials, mutagenProjectSyncDoctorData, mutagenSyncName, openBrowserUrl, parseCapletSource, parseConfig, parseMutagenVersionOutput as parseManagedMutagenVersionOutput, planCapletRuntimeRoute, planCapletRuntimeRoutes, planMutagenSyncCreateCommand, planMutagenSyncListCommand, planMutagenSyncTerminateCommand, planMutagenVersionCommand, projectBindingConnectPath, projectBindingConnectUrl, projectBindingError, projectBindingRecovery, projectBindingStatusPath, projectBindingStatusUrl, projectBindingWorkspacePaths, projectBindingWorkspaceRoot, redactedCloudAuthStatus, resolveAttachOptions, runCapletSetup, runCli, runProjectBindingSession, serveCaplets, serveHttp, serveResolvedCaplets, serveStdio, stableJson };
+export { BundleCapletSource, CapletsRuntime, CloudAuthClient, CloudAuthStore, CodeModeLogStore, DEFAULT_SYNC_LIMITS, FileObservedOutputShapeStore, FilesystemCapletSource, LocalSetupStore, ManagedMutagenProjectSync, PROJECT_BINDINGS_CONTROL_PATH, PROJECT_BINDING_CONNECT_PATH, PROJECT_BINDING_ERROR_CODES, PROJECT_BINDING_STATES, PROJECT_BINDING_SYNC_STATES, ProjectBindingError, ProjectBindingWorkspaceStore, QuickJsCodeModeSandbox, ServerRegistry, attachProjectOnce, attachProjectSession, buildProjectSyncManifest, capabilityDescription, capletSetupContentHash, classifyCapletRuntimeRoute, cloudAuthPath, codeModeDeclarationHash, createCodeModeCapletsApi, createProgram, defaultProjectBindingWebSocketFactory, diagnoseCodeModeTypeScript, enforceProjectSyncSizeLimits, generateCodeModeDeclarations, generateCodeModeRunToolDescription, generatedToolInputSchema, handleServerTool, hasRenderableStructuredContent, listCodeModeCallableCaplets, loadConfig, markdownCallToolResultContent, markdownStructuredContent, migrateCredentials, minifyCodeModeDeclarationText, mutagenProjectSyncDoctorData, mutagenSyncName, observeOutputShape, observedOutputShapeKey, openBrowserUrl, parseCapletSource, parseConfig, parseMutagenVersionOutput as parseManagedMutagenVersionOutput, planCapletRuntimeRoute, planCapletRuntimeRoutes, planMutagenSyncCreateCommand, planMutagenSyncListCommand, planMutagenSyncTerminateCommand, planMutagenVersionCommand, projectBindingConnectPath, projectBindingConnectUrl, projectBindingError, projectBindingRecovery, projectBindingStatusPath, projectBindingStatusUrl, projectBindingWorkspacePaths, projectBindingWorkspaceRoot, redactCodeModeLogText, redactedCloudAuthStatus, resolveAttachOptions, runCapletSetup, runCli, runCodeMode, runProjectBindingSession, serveCaplets, serveHttp, serveResolvedCaplets, serveStdio, stableJson };