@caplets/core 0.17.0 → 0.18.0

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export { DEFAULT_AUTH_DIR, DEFAULT_CONFIG_PATH, PROJECT_CONFIG_FILE, resolveCapletsRoot, resolveConfigPath, resolveProjectCapletsRoot, resolveProjectConfigPath, } from "./config/paths";
+export { DEFAULT_AUTH_DIR, DEFAULT_COMPLETION_CACHE_DIR, DEFAULT_CONFIG_PATH, PROJECT_CONFIG_FILE, defaultCacheBaseDir, defaultCompletionCacheDir, resolveCapletsRoot, resolveConfigPath, resolveProjectCapletsRoot, resolveProjectConfigPath, } from "./config/paths";
 export type RemoteAuthConfig = {
     type: "none";
 } | {
@@ -181,6 +181,13 @@ export type CapletConfig = CapletServerConfig | OpenApiEndpointConfig | GraphQlE
 export type CapletsOptions = {
     defaultSearchLimit: number;
     maxSearchLimit: number;
+    completion: CompletionConfig;
+};
+export type CompletionConfig = {
+    discoveryTimeoutMs: number;
+    overallTimeoutMs: number;
+    cacheTtlMs: number;
+    negativeCacheTtlMs: number;
 };
 export type CapletsConfig = {
     version: 1;
@@ -207,6 +214,12 @@ export declare const configFileSchema: z.ZodObject<{
     version: z.ZodDefault<z.ZodLiteral<1>>;
     defaultSearchLimit: z.ZodDefault<z.ZodNumber>;
     maxSearchLimit: z.ZodDefault<z.ZodNumber>;
+    completion: z.ZodDefault<z.ZodObject<{
+        discoveryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        overallTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        cacheTtlMs: z.ZodDefault<z.ZodNumber>;
+        negativeCacheTtlMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
     mcpServers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
     openapiEndpoints: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
     graphqlEndpoints: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;

package/dist/downstream.d.ts

@@ -1,4 +1,4 @@
-import { type CompatibilityCallToolResult, type Tool } from "@modelcontextprotocol/sdk/types.js";
+import { type Prompt, type Resource, type ResourceTemplate as McpResourceTemplate, type CompatibilityCallToolResult, type Tool } from "@modelcontextprotocol/sdk/types.js";
 import type { CapletServerConfig } from "./config";
 import type { ServerRegistry } from "./registry";
 export type CompactTool = {
@@ -8,6 +8,29 @@ export type CompactTool = {
     hasInputSchema: boolean;
     hasOutputSchema: boolean;
 };
+export type CompactResource = {
+    id: string;
+    kind: "resource";
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+};
+export type CompactResourceTemplate = {
+    id: string;
+    kind: "resourceTemplate";
+    uriTemplate: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+};
+export type CompactPrompt = {
+    id: string;
+    prompt: string;
+    description?: string;
+    arguments?: Prompt["arguments"];
+};
 export declare class DownstreamManager {
     private registry;
     private readonly options;
@@ -30,8 +53,153 @@ export declare class DownstreamManager {
     listTools(server: CapletServerConfig): Promise<Tool[]>;
     getTool(server: CapletServerConfig, toolName: string): Promise<Tool>;
     callTool(server: CapletServerConfig, toolName: string, args: Record<string, unknown>): Promise<CompatibilityCallToolResult>;
+    listResources(server: CapletServerConfig, force?: boolean): Promise<Resource[]>;
+    listResourceTemplates(server: CapletServerConfig, force?: boolean): Promise<McpResourceTemplate[]>;
+    readResource(server: CapletServerConfig, uri: string): Promise<{
+        [x: string]: unknown;
+        contents: ({
+            uri: string;
+            text: string;
+            mimeType?: string | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            uri: string;
+            blob: string;
+            mimeType?: string | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    listPrompts(server: CapletServerConfig, force?: boolean): Promise<Prompt[]>;
+    getPrompt(server: CapletServerConfig, promptName: string, args: Record<string, unknown>): Promise<{
+        [x: string]: unknown;
+        messages: {
+            role: "user" | "assistant";
+            content: {
+                type: "text";
+                text: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "image";
+                data: string;
+                mimeType: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "audio";
+                data: string;
+                mimeType: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "resource";
+                resource: {
+                    uri: string;
+                    text: string;
+                    mimeType?: string | undefined;
+                    _meta?: Record<string, unknown> | undefined;
+                } | {
+                    uri: string;
+                    blob: string;
+                    mimeType?: string | undefined;
+                    _meta?: Record<string, unknown> | undefined;
+                };
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                name: string;
+                type: "resource_link";
+                description?: string | undefined;
+                mimeType?: string | undefined;
+                size?: number | undefined;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                icons?: {
+                    src: string;
+                    mimeType?: string | undefined;
+                    sizes?: string[] | undefined;
+                    theme?: "light" | "dark" | undefined;
+                }[] | undefined;
+                title?: string | undefined;
+            };
+        }[];
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        description?: string | undefined;
+    }>;
+    complete(server: CapletServerConfig, request: {
+        ref: {
+            type: "prompt";
+            name: string;
+        } | {
+            type: "resourceTemplate";
+            uri: string;
+        };
+        argument: {
+            name: string;
+            value: string;
+        };
+    }): Promise<{
+        [x: string]: unknown;
+        completion: {
+            [x: string]: unknown;
+            values: string[];
+            total?: number | undefined;
+            hasMore?: boolean | undefined;
+        };
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
     compact(server: CapletServerConfig, tool: Tool): CompactTool;
+    compactResource(server: CapletServerConfig, resource: Resource): CompactResource;
+    compactResourceTemplate(server: CapletServerConfig, template: McpResourceTemplate): CompactResourceTemplate;
+    compactPrompt(server: CapletServerConfig, prompt: Prompt): CompactPrompt;
+    searchResources(server: CapletServerConfig, resources: Resource[], query: string, limit: number): CompactResource[];
+    searchResourceTemplates(server: CapletServerConfig, templates: McpResourceTemplate[], query: string, limit: number): CompactResourceTemplate[];
+    searchPrompts(server: CapletServerConfig, prompts: Prompt[], query: string, limit: number): CompactPrompt[];
     search(server: CapletServerConfig, tools: Tool[], query: string, limit: number): CompactTool[];
+    private assertCapability;
+    private isCacheFresh;
     private refreshTools;
     private connect;
     private createTransport;

package/dist/engine.d.ts

@@ -39,7 +39,9 @@ export declare class CapletsEngine {
     scheduleReload(): void;
     reload(): Promise<boolean>;
     execute(serverId: string, request: unknown): Promise<unknown>;
+    completeCliWords(words: string[]): Promise<string[]>;
     close(): Promise<void>;
+    private listCompletionTools;
     private reloadOnce;
     private reloadUntilSettled;
     private emitReload;

package/dist/errors.d.ts

@@ -1,4 +1,4 @@
-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 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_OPERATION", "UNSUPPORTED_CAPABILITY", "PROMPT_NOT_FOUND", "DOWNSTREAM_RESOURCE_ERROR", "DOWNSTREAM_PROMPT_ERROR", "DOWNSTREAM_COMPLETION_ERROR", "UNSUPPORTED_TRANSPORT", "INTERNAL_ERROR"];
 export type CapletsErrorCode = (typeof CAPLETS_ERROR_CODES)[number];
 export type SafeErrorSummary = {
     code: CapletsErrorCode;