@caplets/core 0.16.0 → 0.18.0

package/dist/native/options.d.ts

@@ -1,16 +1,15 @@
-export type NativeCapletsMode = "auto" | "local" | "remote";
+import { type CapletsMode, type CapletsServerEnv, type CapletsServerInput } from "../server/options";
+export type NativeCapletsMode = CapletsMode;
 export type NativeRemoteCapletsOptions = {
-    url?: string;
-    user?: string;
-    password?: string;
     pollIntervalMs?: number;
     fetch?: typeof fetch;
 };
 export type NativeCapletsServiceResolutionInput = {
     mode?: NativeCapletsMode;
+    server?: CapletsServerInput;
     remote?: NativeRemoteCapletsOptions;
 };
-export type NativeCapletsEnv = Partial<Record<"CAPLETS_NATIVE_MODE" | "CAPLETS_REMOTE_URL" | "CAPLETS_REMOTE_USER" | "CAPLETS_REMOTE_PASSWORD", string>>;
+export type NativeCapletsEnv = CapletsServerEnv;
 export type NativeRemoteAuthOptions = {
     enabled: false;
     user: string;

package/dist/native/remote.d.ts

@@ -4,6 +4,7 @@ export type RemoteCapletsTool = {
     name: string;
     title?: string | undefined;
     description?: string | undefined;
+    inputSchema?: unknown;
 };
 export type RemoteCapletsClient = {
     listTools(): Promise<RemoteCapletsTool[]>;

package/dist/native/service.d.ts

@@ -1,6 +1,7 @@
 import type { NativeCapletsServiceResolutionInput } from "./options";
 import { resolveNativeCapletsServiceOptions } from "./options";
 import { type RemoteCapletsClient } from "./remote";
+import { generatedToolInputJsonSchemaForCaplet } from "../generated-tool-input-schema";
 export type NativeCapletsServiceOptions = NativeCapletsServiceResolutionInput & {
     configPath?: string;
     projectConfigPath?: string;
@@ -18,6 +19,8 @@ export type NativeCapletTool = {
     title: string;
     description: string;
     promptGuidance: string[];
+    inputSchema?: ReturnType<typeof generatedToolInputJsonSchemaForCaplet> | Record<string, unknown>;
+    operationNames?: string[];
 };
 export type NativeCapletsToolsChangedListener = (tools: NativeCapletTool[]) => void;
 export type NativeCapletsService = {

package/dist/native.js

@@ -1,76 +1,33 @@
-import { K as ToolListChangedNotificationSchema, Tt as CapletsError, a as capabilityDescription, d as StreamableHTTPClientTransport, m as Client, n as generatedToolInputSchema, t as CapletsEngine } from "./engine-Brwid_mq.js";
-import { generatedToolInputJsonSchema } from "./generated-tool-input-schema.js";
-import { Buffer } from "node:buffer";
+import { Ot as CapletsError, Q as ToolListChangedNotificationSchema, _ as StreamableHTTPClientTransport, a as resolveCapletsServer, b as Client, i as resolveCapletsMode, l as capabilityDescription, n as mcpUrlForBase, o as CapletsEngine } from "./options-DM1cMRcp.js";
+import { a as generatedToolInputJsonSchemaForCaplet, i as generatedToolInputJsonSchema, l as operations, o as generatedToolInputSchema } from "./generated-tool-input-schema-B6rce396.js";
 //#region src/native/options.ts
-const DEFAULT_REMOTE_USER = "caplets";
 const DEFAULT_POLL_INTERVAL_MS = 3e4;
 function resolveNativeCapletsServiceOptions(input = {}, env = process.env) {
-	const mode = parseMode(input.mode ?? env.CAPLETS_NATIVE_MODE ?? "auto");
-	if (mode === "local") return { mode: "local" };
-	const rawUrl = nonEmpty(input.remote?.url, "remote.url") ?? nonEmpty(env.CAPLETS_REMOTE_URL, "CAPLETS_REMOTE_URL");
-	if (mode === "remote" && rawUrl === void 0) throw new CapletsError("REQUEST_INVALID", "CAPLETS_NATIVE_MODE=remote requires CAPLETS_REMOTE_URL or remote.url.");
-	if (rawUrl === void 0) return { mode: "local" };
-	const url = parseRemoteUrl(rawUrl);
-	const userWasExplicit = input.remote?.user !== void 0 || hasEnv(env.CAPLETS_REMOTE_USER);
-	const user = nonEmpty(input.remote?.user, "remote.user") ?? nonEmpty(env.CAPLETS_REMOTE_USER, "CAPLETS_REMOTE_USER") ?? DEFAULT_REMOTE_USER;
-	const password = nonEmpty(input.remote?.password, "remote.password") ?? nonEmpty(env.CAPLETS_REMOTE_PASSWORD, "CAPLETS_REMOTE_PASSWORD");
-	if (userWasExplicit && password === void 0) throw new CapletsError("REQUEST_INVALID", "Remote Caplets Basic Auth requires a password; set CAPLETS_REMOTE_PASSWORD or remote.password.");
-	const auth = password === void 0 ? {
-		enabled: false,
-		user
-	} : {
-		enabled: true,
-		user,
-		password
-	};
-	const requestInit = auth.enabled ? { headers: { Authorization: basicAuthHeader(auth.user, auth.password) } } : {};
+	if (resolveCapletsMode({
+		...input.mode ? { mode: input.mode } : {},
+		...input.server?.url ? { serverUrl: input.server.url } : {}
+	}, env).mode === "local") return { mode: "local" };
+	const serverFetch = input.remote?.fetch ?? input.server?.fetch;
+	const server = resolveCapletsServer({
+		...input.server,
+		...serverFetch ? { fetch: serverFetch } : {}
+	}, env);
 	return {
 		mode: "remote",
 		remote: {
-			url,
-			auth,
+			url: mcpUrlForBase(server.baseUrl),
+			auth: server.auth,
 			pollIntervalMs: parsePollInterval(input.remote?.pollIntervalMs),
-			requestInit,
-			...input.remote?.fetch ? { fetch: input.remote.fetch } : {}
+			requestInit: server.requestInit,
+			...server.fetch ? { fetch: server.fetch } : {}
 		}
 	};
 }
-function parseMode(value) {
-	if (value === "auto" || value === "local" || value === "remote") return value;
-	throw new CapletsError("REQUEST_INVALID", `Expected CAPLETS_NATIVE_MODE to be auto, local, or remote, got ${value}`);
-}
-function parseRemoteUrl(value) {
-	let url;
-	try {
-		url = new URL(value);
-	} catch {
-		throw new CapletsError("REQUEST_INVALID", "Invalid remote Caplets URL.");
-	}
-	if (url.username !== "" || url.password !== "") throw new CapletsError("REQUEST_INVALID", "Remote Caplets URL must not include username or password; use CAPLETS_REMOTE_USER/CAPLETS_REMOTE_PASSWORD or remote.user/remote.password instead.");
-	if (url.protocol === "https:") return url;
-	if (url.protocol === "http:" && isLoopbackHost(url.hostname)) return url;
-	throw new CapletsError("REQUEST_INVALID", "Remote Caplets URL must use https except loopback development URLs.");
-}
-function isLoopbackHost(host) {
-	return host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1";
-}
 function parsePollInterval(value) {
 	if (value === void 0) return DEFAULT_POLL_INTERVAL_MS;
 	if (!Number.isInteger(value) || value < 1e3) throw new CapletsError("REQUEST_INVALID", "remote.pollIntervalMs must be an integer >= 1000.");
 	return value;
 }
-function basicAuthHeader(user, password) {
-	return `Basic ${Buffer.from(`${user}:${password}`).toString("base64")}`;
-}
-function nonEmpty(value, label) {
-	if (value === void 0) return;
-	const trimmed = value.trim();
-	if (!trimmed) throw new CapletsError("REQUEST_INVALID", `${label} must not be empty`);
-	return trimmed;
-}
-function hasEnv(value) {
-	return value !== void 0 && value.trim() !== "";
-}
 //#endregion
 //#region src/native/tools.ts
 function nativeCapletToolName(capletId) {
@@ -85,12 +42,12 @@ function nativeCapletsSystemGuidance(toolNames) {
 		"Available Caplets native tools:",
 		toolNames.length > 0 ? toolNames.map((tool) => `- ${tool}`).join("\n") : "- none",
 		"",
-		"Flow: get_caplet when the domain is unfamiliar; search_tools or list_tools to find exact downstream names; get_tool only when schemas are unclear; call_tool with downstream inputs inside arguments.",
+		"Flow: get_caplet when the domain is unfamiliar; use search_tools/list_tools for actions; MCP-backed Caplets may also expose resources, prompts, and completions in their tool schema.",
 		"Use fields on call_tool when a non-GraphQL downstream outputSchema allows selecting only needed structured paths."
 	].join("\n");
 }
 function nativeCapletPromptGuidance(toolName, caplet) {
-	return [`Use ${toolName} for the ${caplet.name} Caplet capability domain.`];
+	return caplet.backend === "mcp" ? [`Use ${toolName} for the ${caplet.name} Caplet capability domain.`, "Prefer resources for readable context, prompts for reusable workflows, and tools for actions."] : [`Use ${toolName} for the ${caplet.name} Caplet capability domain.`];
 }
 function nativeCapletToolDescription(toolName, caplet) {
 	return [
@@ -123,7 +80,8 @@ function createSdkRemoteCapletsClient(options) {
 			return ((await client.listTools()).tools ?? []).map((tool) => ({
 				name: tool.name,
 				...tool.title ? { title: tool.title } : {},
-				...tool.description ? { description: tool.description } : {}
+				...tool.description ? { description: tool.description } : {},
+				...tool.inputSchema ? { inputSchema: tool.inputSchema } : {}
 			}));
 		},
 		async callTool(name, args) {
@@ -264,6 +222,7 @@ var RemoteNativeCapletsService = class {
 };
 function remoteToolToNativeTool(tool) {
 	const toolName = nativeCapletToolName(tool.name);
+	const inputSchema = isPlainObject(tool.inputSchema) ? tool.inputSchema : generatedToolInputJsonSchemaForCaplet({ backend: "tool" });
 	return {
 		caplet: tool.name,
 		toolName,
@@ -274,14 +233,26 @@ function remoteToolToNativeTool(tool) {
 			`Native tool name: ${toolName}`,
 			`Remote Caplet ID: ${tool.name}`
 		].join("\n"),
-		promptGuidance: [`Use ${toolName} through the remote Caplets service.`]
+		promptGuidance: [`Use ${toolName} through the remote Caplets service.`],
+		inputSchema,
+		operationNames: operationNamesFromSchema(inputSchema)
 	};
 }
+function operationNamesFromSchema(schema) {
+	const properties = schema.properties;
+	if (!isPlainObject(properties)) return [...operations];
+	const operation = properties.operation;
+	if (!isPlainObject(operation) || !Array.isArray(operation.enum)) return [...operations];
+	return operation.enum.filter((value) => typeof value === "string");
+}
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function remoteAuthError() {
-	return new CapletsError("AUTH_FAILED", "Remote Caplets authentication failed; check CAPLETS_REMOTE_USER and CAPLETS_REMOTE_PASSWORD.");
+	return new CapletsError("AUTH_FAILED", "Remote Caplets authentication failed; check CAPLETS_SERVER_USER and CAPLETS_SERVER_PASSWORD.");
 }
 function isSessionFailure(error) {
 	const message = errorMessage(error).toLowerCase();
@@ -315,12 +286,15 @@ var DefaultNativeCapletsService = class {
 	listTools() {
 		return this.engine.enabledServers().map((caplet) => {
 			const toolName = nativeCapletToolName(caplet.server);
+			const inputSchema = generatedToolInputJsonSchemaForCaplet(caplet);
 			return {
 				caplet: caplet.server,
 				toolName,
 				title: caplet.name,
 				description: nativeCapletToolDescription(toolName, caplet),
-				promptGuidance: nativeCapletPromptGuidance(toolName, caplet)
+				promptGuidance: nativeCapletPromptGuidance(toolName, caplet),
+				inputSchema,
+				operationNames: [...inputSchema.properties.operation.enum]
 			};
 		});
 	}