@caplets/core 0.13.1 → 0.15.0

package/dist/engine.d.ts

@@ -0,0 +1,52 @@
+import { type CapletConfig, type CapletsConfig } from "./config";
+export type CapletsEngineOptions = {
+    configPath?: string;
+    projectConfigPath?: string;
+    authDir?: string;
+    watchDebounceMs?: number;
+    watch?: boolean;
+    writeErr?: (value: string) => void;
+};
+export type CapletsEngineReloadEvent = {
+    previous: CapletsConfig;
+    next: CapletsConfig;
+    invalidated: boolean;
+};
+export declare class CapletsEngine {
+    private registry;
+    private readonly downstream;
+    private readonly openapi;
+    private readonly graphql;
+    private readonly http;
+    private readonly cli;
+    private readonly capletSets;
+    private readonly paths;
+    private readonly watchDebounceMs;
+    private readonly watchEnabled;
+    private readonly writeErr;
+    private readonly reloadListeners;
+    private watchers;
+    private reloadTimer;
+    private watcherRefreshTimer;
+    private reloading;
+    private pendingReload;
+    private closed;
+    constructor(options?: CapletsEngineOptions);
+    currentConfig(): CapletsConfig;
+    enabledServers(): CapletConfig[];
+    watchedPaths(): string[];
+    onReload(listener: (event: CapletsEngineReloadEvent) => void): () => void;
+    scheduleReload(): void;
+    reload(): Promise<boolean>;
+    execute(serverId: string, request: unknown): Promise<unknown>;
+    close(): Promise<void>;
+    private reloadOnce;
+    private reloadUntilSettled;
+    private emitReload;
+    private invalidateChangedBackends;
+    private resetWatchers;
+    private closeWatchers;
+    private watchEntry;
+    private watchDirectoryTree;
+    private scheduleWatcherRefresh;
+}

package/dist/errors.d.ts

@@ -0,0 +1,24 @@
+export declare const CAPLETS_ERROR_CODES: readonly ["CONFIG_NOT_FOUND", "CONFIG_EXISTS", "CONFIG_INVALID", "REQUEST_INVALID", "SERVER_NOT_FOUND", "SERVER_UNAVAILABLE", "SERVER_START_TIMEOUT", "UNKNOWN_OPERATION", "TOOL_NOT_FOUND", "TOOL_CALL_TIMEOUT", "AUTH_REQUIRED", "AUTH_FAILED", "AUTH_REFRESH_FAILED", "DOWNSTREAM_PROTOCOL_ERROR", "DOWNSTREAM_TOOL_ERROR", "UNSUPPORTED_TRANSPORT", "INTERNAL_ERROR"];
+export type CapletsErrorCode = (typeof CAPLETS_ERROR_CODES)[number];
+export type SafeErrorSummary = {
+    code: CapletsErrorCode;
+    message: string;
+    details?: unknown;
+};
+export declare class CapletsError extends Error {
+    readonly code: CapletsErrorCode;
+    readonly details?: unknown;
+    constructor(code: CapletsErrorCode, message: string, details?: unknown);
+}
+export declare function redactSecrets(value: unknown): unknown;
+export declare function toSafeError(error: unknown, fallback?: CapletsErrorCode): SafeErrorSummary;
+export declare function errorResult(error: unknown, fallback?: CapletsErrorCode): {
+    isError: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        error: SafeErrorSummary;
+    };
+};

package/dist/field-selection.d.ts

@@ -0,0 +1,4 @@
+type JsonObject = Record<string, unknown>;
+export declare function projectStructuredContent(value: unknown, outputSchema: unknown, fields: string[]): JsonObject;
+export declare function validateFieldSelection(outputSchema: unknown, fields: string[]): void;
+export {};

package/dist/generated-tool-input-schema.d.ts

@@ -0,0 +1,47 @@
+export declare const operations: readonly ["get_caplet", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"];
+export declare const generatedToolInputDescriptions: {
+    readonly operation: "Wrapper operation: get_caplet, check_backend, list_tools, search_tools, get_tool, or call_tool.";
+    readonly query: "Required for search_tools only.";
+    readonly limit: "Optional search_tools result limit.";
+    readonly tool: "Exact downstream tool name for get_tool or call_tool.";
+    readonly arguments: "Required JSON object for call_tool arguments/downstream inputs.";
+    readonly fields: "Optional call_tool structured output paths when outputSchema allows it.";
+};
+export declare function generatedToolInputJsonSchema(): {
+    readonly type: "object";
+    readonly properties: {
+        readonly operation: {
+            readonly type: "string";
+            readonly enum: readonly ["get_caplet", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"];
+            readonly description: "Wrapper operation: get_caplet, check_backend, list_tools, search_tools, get_tool, or call_tool.";
+        };
+        readonly query: {
+            readonly type: "string";
+            readonly description: "Required for search_tools only.";
+        };
+        readonly limit: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly description: "Optional search_tools result limit.";
+        };
+        readonly tool: {
+            readonly type: "string";
+            readonly description: "Exact downstream tool name for get_tool or call_tool.";
+        };
+        readonly arguments: {
+            readonly type: "object";
+            readonly description: "Required JSON object for call_tool arguments/downstream inputs.";
+        };
+        readonly fields: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly minItems: 1;
+            readonly description: "Optional call_tool structured output paths when outputSchema allows it.";
+        };
+    };
+    readonly required: readonly ["operation"];
+    readonly additionalProperties: false;
+};

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

@@ -0,0 +1,59 @@
+//#region src/generated-tool-input-schema.ts
+const operations = [
+	"get_caplet",
+	"check_backend",
+	"list_tools",
+	"search_tools",
+	"get_tool",
+	"call_tool"
+];
+const generatedToolInputDescriptions = {
+	operation: "Wrapper operation: get_caplet, check_backend, list_tools, search_tools, get_tool, or call_tool.",
+	query: "Required for search_tools only.",
+	limit: "Optional search_tools result limit.",
+	tool: "Exact downstream tool name for get_tool or call_tool.",
+	arguments: "Required JSON object for call_tool arguments/downstream inputs.",
+	fields: "Optional call_tool structured output paths when outputSchema allows it."
+};
+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/graphql.d.ts

@@ -0,0 +1,30 @@
+import type { CompatibilityCallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { GraphQlEndpointConfig } from "./config";
+import type { CompactTool } from "./downstream";
+import type { ServerRegistry } from "./registry";
+export type { GraphQlEndpointConfig as GraphqlEndpointConfig } from "./config";
+export declare class GraphQLManager {
+    private registry;
+    private readonly options;
+    private readonly cache;
+    constructor(registry: ServerRegistry, options?: {
+        authDir?: string;
+    });
+    updateRegistry(registry: ServerRegistry): void;
+    invalidate(serverId: string): void;
+    checkEndpoint(endpoint: GraphQlEndpointConfig): Promise<{
+        id: string;
+        status: string;
+        toolCount?: number;
+        elapsedMs: number;
+        error?: unknown;
+    }>;
+    listTools(endpoint: GraphQlEndpointConfig): Promise<Tool[]>;
+    getTool(endpoint: GraphQlEndpointConfig, toolName: string): Promise<Tool>;
+    callTool(endpoint: GraphQlEndpointConfig, toolName: string, args: Record<string, unknown>): Promise<CompatibilityCallToolResult>;
+    compact(endpoint: GraphQlEndpointConfig, tool: Tool): CompactTool;
+    search(endpoint: GraphQlEndpointConfig, tools: Tool[], query: string, limit: number): CompactTool[];
+    private getOperation;
+    private refreshOperations;
+    private toTool;
+}

package/dist/http/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_MAX_RESPONSE_BYTES: number;
+export declare function parseHttpBody(contentType: string, text: string): unknown;
+export declare function readLimitedText(response: Response, options: {
+    maxBytes?: number;
+    errorMessage: string;
+}): Promise<string>;
+export declare function isAbortError(error: unknown): boolean;

package/dist/http-actions.d.ts

@@ -0,0 +1,26 @@
+import type { CompatibilityCallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { HttpApiConfig } from "./config";
+import type { CompactTool } from "./downstream";
+import type { ServerRegistry } from "./registry";
+export declare class HttpActionManager {
+    private registry;
+    private readonly options;
+    constructor(registry: ServerRegistry, options?: {
+        authDir?: string;
+    });
+    updateRegistry(registry: ServerRegistry): void;
+    invalidate(_serverId: string): void;
+    checkApi(api: HttpApiConfig): Promise<{
+        id: string;
+        status: string;
+        toolCount?: number;
+        elapsedMs: number;
+        error?: unknown;
+    }>;
+    listTools(api: HttpApiConfig): Promise<Tool[]>;
+    getTool(api: HttpApiConfig, toolName: string): Promise<Tool>;
+    callTool(api: HttpApiConfig, toolName: string, args: Record<string, unknown>): Promise<CompatibilityCallToolResult>;
+    compact(api: HttpApiConfig, tool: Tool): CompactTool;
+    search(api: HttpApiConfig, tools: Tool[], query: string, limit: number): CompactTool[];
+    private toTool;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { CapletsRuntime } from "./runtime";
+export { runCli, createProgram } from "./cli";
+export { parseConfig, loadConfig } from "./config";
+export { capabilityDescription, ServerRegistry } from "./registry";
+export { generatedToolInputSchema, handleServerTool } from "./tools";