@caplets/core 0.17.0 → 0.18.1

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,5 +1,5 @@
-import { $ as ToolListChangedNotificationSchema, Nt as CapletsError, a as resolveCapletsServer, i as resolveCapletsMode, n as mcpUrlForBase, o as CapletsEngine, s as generatedToolInputSchema, u as capabilityDescription, v as StreamableHTTPClientTransport, x as Client } from "./options-CJEOqS87.js";
-import { generatedToolInputJsonSchema } from "./generated-tool-input-schema.js";
+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-BqibJVxq.js";
+import { a as generatedToolInputJsonSchemaForCaplet, i as generatedToolInputJsonSchema, l as operations, o as generatedToolInputSchema } from "./generated-tool-input-schema-BYoyY-l-.js";
 //#region src/native/options.ts
 const DEFAULT_POLL_INTERVAL_MS = 3e4;
 function resolveNativeCapletsServiceOptions(input = {}, env = process.env) {
@@ -42,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 [
@@ -80,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) {
@@ -221,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,
@@ -231,9 +233,21 @@ 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);
 }
@@ -272,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]
 			};
 		});
 	}