@caplets/core 0.13.0 → 0.14.0

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

@@ -1,64 +0,0 @@
-//#region src/generated-tool-input-schema.mjs
-const operations = [
-	"get_caplet",
-	"check_backend",
-	"check_mcp_server",
-	"list_tools",
-	"search_tools",
-	"get_tool",
-	"call_tool"
-];
-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, 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.",
-	limit: "Optional only for search_tools; defaults to the configured search limit. For downstream result limits, use call_tool.arguments with the downstream schema field name.",
-	tool: "Exact downstream tool name for get_tool or call_tool. Example: {\"operation\":\"get_tool\",\"tool\":\"web_search_exa\"} before calling it.",
-	arguments: "Required JSON object only for call_tool. Put every downstream tool input inside this object. Example: {\"operation\":\"call_tool\",\"tool\":\"web_search_exa\",\"arguments\":{\"query\":\"latest MCP docs\",\"numResults\":3}}. Do not send downstream inputs as top-level query, limit, url, path, or other fields.",
-	fields: "Optional for call_tool after get_tool shows outputSchema on a non-GraphQL tool. Example: fields: [\"path.to.field\"]."
-};
-function generatedToolInputJsonSchema() {
-	return {
-		type: "object",
-		properties: {
-			operation: {
-				type: "string",
-				enum: operations,
-				description: generatedToolInputDescriptions.operation
-			},
-			query: {
-				type: "string",
-				description: generatedToolInputDescriptions.query
-			},
-			limit: {
-				type: "integer",
-				minimum: 1,
-				description: generatedToolInputDescriptions.limit
-			},
-			tool: {
-				type: "string",
-				description: generatedToolInputDescriptions.tool
-			},
-			arguments: {
-				type: "object",
-				description: generatedToolInputDescriptions.arguments
-			},
-			fields: {
-				type: "array",
-				items: {
-					type: "string",
-					minLength: 1
-				},
-				minItems: 1,
-				description: generatedToolInputDescriptions.fields
-			}
-		},
-		required: ["operation"],
-		additionalProperties: false
-	};
-}
-//#endregion
-export { generatedToolInputDescriptions, generatedToolInputJsonSchema, operations };

package/dist/native.js

@@ -1,105 +0,0 @@
-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) {
-	return `caplets_${capletId.replace(/_/g, "__").replace(/-/g, "_")}`;
-}
-function nativeCapletsSystemGuidance(toolNames) {
-	return [
-		"## Caplets Native Tools",
-		"",
-		"Caplets tools are native wrappers around configured Caplet backends. Each tool is named `caplets_<id>` and represents one capability domain.",
-		"",
-		"Available Caplets native tools:",
-		toolNames.length > 0 ? toolNames.map((tool) => `- ${tool}`).join("\n") : "- none",
-		"",
-		"Recommended flow:",
-		"1. Call the relevant `caplets_<id>` tool with `operation: \"get_caplet\"` to read the full Caplet card.",
-		"2. Call `check_backend` or `check_mcp_server` only when availability is uncertain.",
-		"3. Use `search_tools` or `list_tools` to discover the selected Caplet's downstream operations.",
-		"4. Use `get_tool` before `call_tool` when argument or output schema is unclear.",
-		"5. For `call_tool`, put downstream inputs only inside the top-level `arguments` object.",
-		"6. Do not invent downstream tool names; execute only exact names returned by `list_tools`, `search_tools`, or `get_tool`."
-	].join("\n");
-}
-function nativeCapletPromptGuidance(toolName, caplet) {
-	const checkOperation = caplet.backend === "mcp" ? "check_mcp_server" : "check_backend";
-	return [
-		`Use ${toolName} for the ${caplet.name} Caplet capability domain.`,
-		`Call ${toolName} with operation get_caplet before using unfamiliar downstream tools.`,
-		`Call ${toolName} with operation ${checkOperation} only when backend availability is uncertain.`,
-		`Call ${toolName} with operation search_tools or list_tools to discover exact downstream tool names.`,
-		`Call ${toolName} with operation call_tool only with exact downstream tool names and put downstream inputs in arguments.`
-	];
-}
-function nativeCapletToolDescription(toolName, caplet) {
-	return [
-		capabilityDescription(caplet),
-		"",
-		`Native tool name: ${toolName}`,
-		`Original Caplet ID: ${caplet.server}`
-	].join("\n");
-}
-//#endregion
-//#region src/native/service.ts
-function createNativeCapletsService(options = {}) {
-	return new DefaultNativeCapletsService(options);
-}
-var DefaultNativeCapletsService = class {
-	engine;
-	constructor(options) {
-		this.engine = new CapletsEngine(options);
-	}
-	listTools() {
-		return 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() {
-		await this.engine.close();
-	}
-};
-//#endregion
-//#region src/native/process-cleanup.ts
-function registerNativeCapletsProcessCleanup(service) {
-	let closed = false;
-	const close = async () => {
-		if (closed) return;
-		closed = true;
-		try {
-			await service.close();
-		} catch (error) {
-			console.error("Failed to close Caplets service:", error);
-			process.exitCode = 1;
-		}
-	};
-	const closeBeforeExit = () => {
-		close();
-	};
-	const closeAndExit = () => {
-		close().finally(() => {
-			process.exit(process.exitCode ?? 0);
-		});
-	};
-	process.once("beforeExit", closeBeforeExit);
-	process.once("SIGINT", closeAndExit);
-	process.once("SIGTERM", closeAndExit);
-}
-//#endregion
-export { createNativeCapletsService, generatedToolInputJsonSchema, generatedToolInputSchema, nativeCapletPromptGuidance, nativeCapletToolDescription, nativeCapletToolName, nativeCapletsSystemGuidance, registerNativeCapletsProcessCleanup };