@caplets/core 0.22.0 → 0.24.0

package/dist/config-runtime.js

@@ -89,6 +89,18 @@ const openApiEndpointSchema = object({
 	requestTimeoutMs: number().int().positive().default(6e4),
 	operationCacheTtlMs: number().int().nonnegative().default(3e4)
 }).strict();
+const operationFilterSchema = array(string().trim().min(1).max(160));
+const googleDiscoveryApiSchema = object({
+	...commonSchema,
+	discoveryPath: string().min(1).optional(),
+	discoveryUrl: string().min(1).optional(),
+	baseUrl: string().min(1).optional(),
+	includeOperations: operationFilterSchema.optional(),
+	excludeOperations: operationFilterSchema.optional(),
+	auth: authSchema,
+	requestTimeoutMs: number().int().positive().default(6e4),
+	operationCacheTtlMs: number().int().nonnegative().default(3e4)
+}).strict();
 const graphQlOperationSchema = object({
 	document: string().min(1).optional(),
 	documentPath: string().min(1).optional(),
@@ -202,6 +214,7 @@ const configSchema = object({
 	}),
 	mcpServers: record(string().regex(SERVER_ID_PATTERN), mcpServerSchema).default({}),
 	openapiEndpoints: record(string().regex(SERVER_ID_PATTERN), openApiEndpointSchema).default({}),
+	googleDiscoveryApis: record(string().regex(SERVER_ID_PATTERN), googleDiscoveryApiSchema).default({}),
 	graphqlEndpoints: record(string().regex(SERVER_ID_PATTERN), graphQlEndpointSchema).default({}),
 	httpApis: record(string().regex(SERVER_ID_PATTERN), httpApiSchema).default({}),
 	cliTools: record(string().regex(SERVER_ID_PATTERN), cliToolsSchema).default({}),
@@ -237,6 +250,7 @@ function parseConfig(input) {
 			};
 		}),
 		openapiEndpoints: mapBackend(config.openapiEndpoints, "openapi"),
+		googleDiscoveryApis: mapBackend(config.googleDiscoveryApis, "googleDiscovery"),
 		graphqlEndpoints: mapBackend(config.graphqlEndpoints, "graphql"),
 		httpApis: mapBackend(config.httpApis, "http"),
 		cliTools: mapBackend(config.cliTools, "cli"),
@@ -330,6 +344,36 @@ function validateBackends(config, ctx) {
 			"auth"
 		]);
 	}
+	for (const [server, raw] of Object.entries(config.googleDiscoveryApis)) {
+		if (Boolean(raw.discoveryPath) === Boolean(raw.discoveryUrl)) ctx.addIssue({
+			code: "custom",
+			path: ["googleDiscoveryApis", server],
+			message: "Google Discovery API must define exactly one discovery source"
+		});
+		if (raw.discoveryUrl && !hasEnvReference(raw.discoveryUrl) && !isAllowedRemoteUrl(raw.discoveryUrl)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"googleDiscoveryApis",
+				server,
+				"discoveryUrl"
+			],
+			message: "Google Discovery API discoveryUrl must use https except loopback development urls"
+		});
+		if (raw.baseUrl && !hasEnvReference(raw.baseUrl) && !isAllowedHttpBaseUrl(raw.baseUrl)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"googleDiscoveryApis",
+				server,
+				"baseUrl"
+			],
+			message: "Google Discovery API baseUrl must use https except loopback development urls and must not include credentials, query, or fragment"
+		});
+		validateAuthHeaders(raw.auth, ctx, [
+			"googleDiscoveryApis",
+			server,
+			"auth"
+		]);
+	}
 	for (const [server, raw] of Object.entries(config.graphqlEndpoints)) {
 		if (Number(Boolean(raw.schemaPath)) + Number(Boolean(raw.schemaUrl)) + Number(raw.introspection === true) !== 1) ctx.addIssue({
 			code: "custom",

package/dist/config.d.ts

@@ -178,6 +178,28 @@ export type HttpApiConfig = AgentSelectionHintsConfig & {
     projectBinding?: ProjectBindingConfig | undefined;
     runtime?: RuntimeRequirementsConfig | undefined;
 };
+export type GoogleDiscoveryApiConfig = AgentSelectionHintsConfig & {
+    server: string;
+    backend: "googleDiscovery";
+    name: string;
+    description: string;
+    exposure?: CapletExposure | undefined;
+    shadowing?: CapletShadowingPolicy | undefined;
+    tags?: string[] | undefined;
+    body?: string | undefined;
+    discoveryPath?: string | undefined;
+    discoveryUrl?: string | undefined;
+    baseUrl?: string | undefined;
+    includeOperations?: string[] | undefined;
+    excludeOperations?: string[] | undefined;
+    auth: OpenApiAuthConfig;
+    requestTimeoutMs: number;
+    operationCacheTtlMs: number;
+    disabled: boolean;
+    setup?: CapletSetupConfig | undefined;
+    projectBinding?: ProjectBindingConfig | undefined;
+    runtime?: RuntimeRequirementsConfig | undefined;
+};
 export type CliToolOutputConfig = {
     type: "text" | "json";
 };
@@ -237,7 +259,7 @@ export type CapletSetConfig = AgentSelectionHintsConfig & {
     projectBinding?: ProjectBindingConfig | undefined;
     runtime?: RuntimeRequirementsConfig | undefined;
 };
-export type CapletConfig = CapletServerConfig | OpenApiEndpointConfig | GraphQlEndpointConfig | HttpApiConfig | CliToolsConfig | CapletSetConfig;
+export type CapletConfig = CapletServerConfig | OpenApiEndpointConfig | GoogleDiscoveryApiConfig | GraphQlEndpointConfig | HttpApiConfig | CliToolsConfig | CapletSetConfig;
 export type CapletsOptions = {
     defaultSearchLimit: number;
     maxSearchLimit: number;
@@ -257,6 +279,7 @@ export type CapletsConfig = {
     options: CapletsOptions;
     mcpServers: Record<string, CapletServerConfig>;
     openapiEndpoints: Record<string, OpenApiEndpointConfig>;
+    googleDiscoveryApis: Record<string, GoogleDiscoveryApiConfig>;
     graphqlEndpoints: Record<string, GraphQlEndpointConfig>;
     httpApis: Record<string, HttpApiConfig>;
     cliTools: Record<string, CliToolsConfig>;
@@ -304,6 +327,7 @@ export declare const configFileSchema: z.ZodObject<{
     }, 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>>>>;
+    googleDiscoveryApis: 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>>>>;
     httpApis: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
     cliTools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;

package/dist/engine.d.ts

@@ -5,6 +5,8 @@ export type CapletsEngineOptions = {
     configPath?: string;
     projectConfigPath?: string;
     authDir?: string;
+    artifactDir?: string;
+    exposeLocalArtifactPaths?: boolean;
     watchDebounceMs?: number;
     watch?: boolean;
     writeErr?: (value: string) => void;
@@ -23,6 +25,7 @@ export declare class CapletsEngine {
     private registry;
     private readonly downstream;
     private readonly openapi;
+    private readonly googleDiscovery;
     private readonly graphql;
     private readonly http;
     private readonly cli;

package/dist/google-discovery/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./schema";
+export * from "./operations";
+export * from "./request";
+export * from "./manager";

package/dist/google-discovery/manager.d.ts

@@ -0,0 +1,37 @@
+import type { CompatibilityCallToolResult, Tool } from "@modelcontextprotocol/sdk/types";
+import type { GoogleDiscoveryApiConfig } from "../config";
+import { type CompactTool } from "../downstream";
+import type { ServerRegistry } from "../registry";
+export declare class GoogleDiscoveryManager {
+    private registry;
+    private readonly options;
+    private readonly cache;
+    constructor(registry: ServerRegistry, options?: {
+        authDir?: string;
+        artifactDir?: string;
+        exposeLocalArtifactPaths?: boolean;
+    });
+    updateRegistry(registry: ServerRegistry): void;
+    invalidate(serverId: string): void;
+    checkApi(api: GoogleDiscoveryApiConfig): Promise<{
+        id: string;
+        status: string;
+        toolCount?: number;
+        elapsedMs: number;
+        error?: unknown;
+    }>;
+    listTools(api: GoogleDiscoveryApiConfig): Promise<Tool[]>;
+    getTool(api: GoogleDiscoveryApiConfig, toolName: string): Promise<Tool>;
+    callTool(api: GoogleDiscoveryApiConfig, toolName: string, args: Record<string, unknown>): Promise<CompatibilityCallToolResult>;
+    private callMediaUpload;
+    private callSingleUpload;
+    private callResumableUpload;
+    compact(_api: GoogleDiscoveryApiConfig, tool: Tool): CompactTool;
+    search(api: GoogleDiscoveryApiConfig, tools: Tool[], query: string, limit: number): CompactTool[];
+    resolveAuthScopes(api: GoogleDiscoveryApiConfig): Promise<string[]>;
+    private getOperation;
+    private refreshOperations;
+    private toTool;
+    resolveBaseUrl(api: GoogleDiscoveryApiConfig): Promise<string | undefined>;
+    private resolveRequestApi;
+}

package/dist/google-discovery/operations.d.ts

@@ -0,0 +1,32 @@
+type GoogleDiscoveryHttpMethod = "get" | "put" | "post" | "delete" | "patch" | "head";
+export type GoogleDiscoveryOperation = {
+    name: string;
+    method: GoogleDiscoveryHttpMethod;
+    path: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+    scopes: string[];
+    supportsMediaUpload: boolean;
+    supportsMediaDownload: boolean;
+    mediaUpload?: {
+        accept?: string[];
+        maxSize?: string;
+    };
+    mediaUploadProtocols: Record<string, {
+        path?: string;
+        multipart?: boolean;
+    }>;
+    parameterOrder: string[];
+};
+export type DiscoveryOperationsOptions = {
+    server: string;
+    document: unknown;
+    includeOperations?: string[];
+    excludeOperations?: string[];
+};
+export declare function discoveryOperations(options: DiscoveryOperationsOptions): GoogleDiscoveryOperation[];
+export declare function googleDiscoveryScopesForOperations(operations: GoogleDiscoveryOperation[]): string[];
+export {};

package/dist/google-discovery/request.d.ts

@@ -0,0 +1,5 @@
+import type { GoogleDiscoveryApiConfig } from "../config";
+import type { GoogleDiscoveryOperation } from "./operations";
+export declare function buildGoogleDiscoveryUrl(api: GoogleDiscoveryApiConfig, operation: GoogleDiscoveryOperation, args: Record<string, unknown>): URL;
+export declare function buildGoogleDiscoveryUploadUrl(api: GoogleDiscoveryApiConfig, operation: GoogleDiscoveryOperation, uploadPath: string, uploadType: "media" | "multipart" | "resumable", args: Record<string, unknown>): URL;
+export declare function buildJsonRequestInit(operation: GoogleDiscoveryOperation, args: Record<string, unknown>, headers: Headers): RequestInit;

package/dist/google-discovery/schema.d.ts

@@ -0,0 +1,2 @@
+import type { GoogleDiscoverySchema } from "./types";
+export declare function googleDiscoverySchemaToJsonSchema(value: GoogleDiscoverySchema | undefined, schemas?: Record<string, GoogleDiscoverySchema>, seen?: Set<string>): Record<string, unknown>;

package/dist/google-discovery/types.d.ts

@@ -0,0 +1,70 @@
+export type GoogleDiscoveryDocument = {
+    kind?: string;
+    id?: string;
+    name?: string;
+    version?: string;
+    title?: string;
+    rootUrl?: string;
+    servicePath?: string;
+    baseUrl?: string;
+    auth?: {
+        oauth2?: {
+            scopes?: Record<string, {
+                description?: string;
+            }>;
+        };
+    };
+    parameters?: Record<string, GoogleDiscoveryParameter>;
+    schemas?: Record<string, GoogleDiscoverySchema>;
+    methods?: Record<string, GoogleDiscoveryMethod>;
+    resources?: Record<string, GoogleDiscoveryResource>;
+};
+export type GoogleDiscoveryResource = {
+    methods?: Record<string, GoogleDiscoveryMethod>;
+    resources?: Record<string, GoogleDiscoveryResource>;
+};
+export type GoogleDiscoveryMethod = {
+    id?: string;
+    path?: string;
+    flatPath?: string;
+    httpMethod?: string;
+    description?: string;
+    parameters?: Record<string, GoogleDiscoveryParameter>;
+    parameterOrder?: string[];
+    request?: {
+        $ref?: string;
+    };
+    response?: {
+        $ref?: string;
+    };
+    scopes?: string[];
+    supportsMediaUpload?: boolean;
+    supportsMediaDownload?: boolean;
+    mediaUpload?: {
+        accept?: string[];
+        maxSize?: string;
+        protocols?: Record<string, {
+            path?: string;
+            multipart?: boolean;
+        }>;
+    };
+};
+export type GoogleDiscoveryParameter = GoogleDiscoverySchema & {
+    location?: "path" | "query" | "header" | "body" | "media";
+    required?: boolean;
+    repeated?: boolean;
+    deprecated?: boolean;
+};
+export type GoogleDiscoverySchema = {
+    id?: string;
+    $ref?: string;
+    type?: string;
+    format?: string;
+    description?: string;
+    default?: unknown;
+    enum?: string[];
+    repeated?: boolean;
+    properties?: Record<string, GoogleDiscoverySchema>;
+    items?: GoogleDiscoverySchema;
+    additionalProperties?: GoogleDiscoverySchema | boolean;
+};

package/dist/http/response.d.ts

@@ -0,0 +1,14 @@
+import type { MediaArtifact } from "../media";
+export type ReadHttpLikeResponseOptions = {
+    capletId: string;
+    method?: string;
+    artifactDir?: string;
+    outputPath?: string;
+    filename?: string;
+    maxInlineBytes?: number;
+    maxBytes?: number;
+    forceArtifact?: boolean;
+    exposeLocalPath?: boolean;
+};
+export declare function readHttpLikeResponse(response: Response, options: ReadHttpLikeResponseOptions): Promise<Record<string, unknown>>;
+export type { MediaArtifact };

package/dist/http-actions.d.ts

@@ -7,6 +7,9 @@ export declare class HttpActionManager {
     private readonly options;
     constructor(registry: ServerRegistry, options?: {
         authDir?: string;
+        artifactDir?: string;
+        exposeLocalArtifactPaths?: boolean;
+        maxInlineBytes?: number;
     });
     updateRegistry(registry: ServerRegistry): void;
     invalidate(_serverId: string): void;