@caplets/core 0.11.0

package/dist/native.js

@@ -0,0 +1,92 @@
+import { E as errorResult, S as resolveProjectConfigPath, a as OpenApiManager, b as resolveConfigPath, c as DownstreamManager, h as loadConfig, i as capabilityDescription, m as CliToolsManager, n as handleServerTool, o as HttpActionManager, r as ServerRegistry, s as GraphQLManager, t as generatedToolInputSchema } from "./tools-BlFF20vE.js";
+import { generatedToolInputJsonSchema } from "./generated-tool-input-schema.js";
+//#region src/native/tools.ts
+function nativeCapletToolName(capletId) {
+	return `caplets_${capletId.replace(/_/g, "__").replace(/-/g, "_dash_")}`;
+}
+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 {
+	config;
+	registry;
+	downstream;
+	openapi;
+	graphql;
+	http;
+	cli;
+	constructor(options) {
+		const configPath = resolveConfigPath(options.configPath);
+		const projectConfigPath = options.projectConfigPath ?? resolveProjectConfigPath();
+		this.config = loadConfig(configPath, projectConfigPath);
+		this.registry = new ServerRegistry(this.config);
+		const authOptions = options.authDir ? { authDir: options.authDir } : void 0;
+		this.downstream = new DownstreamManager(this.registry, authOptions);
+		this.openapi = new OpenApiManager(this.registry, authOptions);
+		this.graphql = new GraphQLManager(this.registry, authOptions);
+		this.http = new HttpActionManager(this.registry, authOptions);
+		this.cli = new CliToolsManager(this.registry);
+	}
+	listTools() {
+		return this.registry.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) {
+		try {
+			return await handleServerTool(this.registry.require(capletId), request, this.registry, this.downstream, this.openapi, this.graphql, this.http, this.cli);
+		} catch (error) {
+			return errorResult(error);
+		}
+	}
+	async close() {
+		await this.downstream.close();
+	}
+};
+//#endregion
+export { createNativeCapletsService, generatedToolInputJsonSchema, generatedToolInputSchema, nativeCapletPromptGuidance, nativeCapletToolDescription, nativeCapletToolName, nativeCapletsSystemGuidance };