@caplets/core 0.21.1 → 0.23.0

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;

package/dist/index.js

@@ -1,9 +1,9 @@
-import { $ as loadGlobalConfig, $t as ListRootsResultSchema, A as codeModeRunParamsSchema, At as assertToolsCallTaskCapability, B as generateCodeModeRunToolDescription, Bt as CreateTaskResultSchema, C as nativeCapletPromptGuidance, Ct as resolveCapletsRoot, D as nativeCodeModeToolId, Dt as ReadBuffer, Et as resolveProjectConfigPath, F as listCodeModeCallableCaplets, Ft as CallToolRequestSchema, G as directResourceUriMatchesTemplate, Gt as GetPromptRequestSchema, H as CapletsEngine, Ht as ElicitResultSchema, I as CodeModeLogStore, It as CallToolResultSchema, J as handleServerTool, Jt as JSONRPCMessageSchema, K as findProjectRoot, Kt as InitializeRequestSchema, L as redactCodeModeLogText, Lt as CompleteRequestSchema, M as QuickJsCodeModeSandbox, Mt as Protocol, N as diagnoseCodeModeTypeScript, Nt as mergeCapabilities, Ot as serializeMessage, P as createCodeModeCapletsApi, Pt as toJsonSchemaCompat, Q as loadConfigWithSources, Qt as ListResourcesRequestSchema, R as codeModeDeclarationHash, Rt as CreateMessageResultSchema, S as resolveCapletsServer, St as defaultStateBaseDir, T as nativeCapletToolName, Tt as resolveProjectCapletsRoot, U as resolveExposure, Ut as EmptyResultSchema, V as minifyCodeModeDeclarationText, W as decodeDirectResourceUri, Wt as ErrorCode, X as capabilityDescription, Xt as ListPromptsRequestSchema, Y as ServerRegistry, Yt as LATEST_PROTOCOL_VERSION, Z as loadConfig, Zt as ListResourceTemplatesRequestSchema, _ as resolveHostedCloudRemote, _n as isZ4Schema, a as projectBindingError, an as SetLevelRequestSchema, at as loadCapletFilesFromMap, b as parseServerBaseUrl, bn as safeParse, bt as defaultCacheBaseDir, c as cloudAuthPath, cn as isInitializeRequest, ct as markdownStructuredContent, d as CloudAuthClient, dn as isJSONRPCResultResponse, dt as runOAuthFlow, en as ListToolsRequestSchema, et as loadLocalOverlayConfigWithSources, fn as getLiteralValue, ft as startGenericOAuthFlow, g as resolveCapletsRemote, gn as isSchemaOptional, gt as readTokenBundle, hn as getSchemaDescription, ht as isTokenBundleExpired, i as ProjectBindingError, in as SUPPORTED_PROTOCOL_VERSIONS, it as validateCapletFile, j as runCodeMode, jt as AjvJsonSchemaValidator, k as codeModeRunInputSchema, kt as assertClientRequestTaskCapability, l as migrateCredentials, ln as isJSONRPCErrorResponse, lt as refreshOAuthTokenBundle, m as buildProjectSyncManifest, mn as getParseErrorMessage, mt as deleteTokenBundle, n as resolveRemoteSelection, nn as McpError, nt as parseConfig, o as projectBindingRecovery, on as assertCompleteRequestPrompt, ot as hasRenderableStructuredContent, p as createSdkRemoteCapletsClient, pn as getObjectShape, pt as startOAuthFlow, q as fingerprintProjectRoot, qt as InitializedNotificationSchema, r as PROJECT_BINDING_ERROR_CODES, rn as ReadResourceRequestSchema, rt as discoverCapletFiles, s as CloudAuthStore, sn as assertCompleteRequestResourceTemplate, st as markdownCallToolResultContent, t as createNativeCapletsService, tn as LoggingLevelSchema, tt as loadProjectConfig, u as redactedCloudAuthStatus, un as isJSONRPCRequest, ut as runGenericOAuthFlow, v as resolveRemoteMode, vn as normalizeObjectSchema, w as nativeCapletToolDescription, wt as resolveConfigPath, x as resolveCapletsMode, xn as safeParseAsync, xt as defaultConfigBaseDir, y as controlUrlForBase, yn as objectFromShape, yt as DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR, z as generateCodeModeDeclarations, zt as CreateMessageResultWithToolsSchema } from "./service-lkrQheFA.js";
+import { $ as loadConfigWithSources, $t as ListResourcesRequestSchema, A as codeModeRunParamsSchema, At as assertClientRequestTaskCapability, B as generateCodeModeRunToolDescription, Bt as CreateMessageResultWithToolsSchema, C as nativeCapletPromptGuidance, Ct as defaultStateBaseDir, D as nativeCodeModeToolId, Dt as resolveProjectConfigPath, Et as resolveProjectCapletsRoot, F as listCodeModeCallableCaplets, Ft as toJsonSchemaCompat, G as directResourceUriMatchesTemplate, Gt as ErrorCode, H as CapletsEngine, I as CodeModeLogStore, It as CallToolRequestSchema, J as handleServerTool, Jt as InitializedNotificationSchema, K as findProjectRoot, Kt as GetPromptRequestSchema, L as redactCodeModeLogText, Lt as CallToolResultSchema, M as QuickJsCodeModeSandbox, Mt as AjvJsonSchemaValidator, N as diagnoseCodeModeTypeScript, Nt as Protocol, Ot as ReadBuffer, P as createCodeModeCapletsApi, Pt as mergeCapabilities, Q as loadConfig, Qt as ListResourceTemplatesRequestSchema, R as codeModeDeclarationHash, Rt as CompleteRequestSchema, S as resolveCapletsServer, Sn as safeParseAsync, St as defaultConfigBaseDir, T as nativeCapletToolName, Tt as resolveConfigPath, U as resolveExposure, Ut as ElicitResultSchema, V as minifyCodeModeDeclarationText, Vt as CreateTaskResultSchema, W as decodeDirectResourceUri, Wt as EmptyResultSchema, X as capabilityDescription, Xt as LATEST_PROTOCOL_VERSION, Y as ServerRegistry, Yt as JSONRPCMessageSchema, Z as GoogleDiscoveryManager, Zt as ListPromptsRequestSchema, _ as resolveHostedCloudRemote, _n as isSchemaOptional, _t as readTokenBundle, a as projectBindingError, an as SUPPORTED_PROTOCOL_VERSIONS, at as validateCapletFile, b as parseServerBaseUrl, bn as objectFromShape, bt as DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR, c as cloudAuthPath, cn as assertCompleteRequestResourceTemplate, ct as markdownCallToolResultContent, d as CloudAuthClient, dn as isJSONRPCRequest, dt as runGenericOAuthFlow, en as ListRootsResultSchema, et as loadGlobalConfig, fn as isJSONRPCResultResponse, ft as runOAuthFlow, g as resolveCapletsRemote, gn as getSchemaDescription, gt as isTokenBundleExpired, hn as getParseErrorMessage, ht as deleteTokenBundle, i as ProjectBindingError, in as ReadResourceRequestSchema, it as discoverCapletFiles, j as runCodeMode, jt as assertToolsCallTaskCapability, k as codeModeRunInputSchema, kt as serializeMessage, l as migrateCredentials, ln as isInitializeRequest, lt as markdownStructuredContent, m as buildProjectSyncManifest, mn as getObjectShape, mt as startOAuthFlow, n as resolveRemoteSelection, nn as LoggingLevelSchema, nt as loadProjectConfig, o as projectBindingRecovery, on as SetLevelRequestSchema, ot as loadCapletFilesFromMap, p as createSdkRemoteCapletsClient, pn as getLiteralValue, pt as startGenericOAuthFlow, q as fingerprintProjectRoot, qt as InitializeRequestSchema, r as PROJECT_BINDING_ERROR_CODES, rn as McpError, rt as parseConfig, s as CloudAuthStore, sn as assertCompleteRequestPrompt, st as hasRenderableStructuredContent, t as createNativeCapletsService, tn as ListToolsRequestSchema, tt as loadLocalOverlayConfigWithSources, u as redactedCloudAuthStatus, un as isJSONRPCErrorResponse, ut as refreshOAuthTokenBundle, v as resolveRemoteMode, vn as isZ4Schema, w as nativeCapletToolDescription, wt as resolveCapletsRoot, x as resolveCapletsMode, xn as safeParse, xt as defaultCacheBaseDir, y as controlUrlForBase, yn as normalizeObjectSchema, z as generateCodeModeDeclarations, zt as CreateMessageResultSchema } from "./service-CSRCJfpA.js";
 import { _ as record, b as unknown, d as literal, m as object, n as ZodOptional, o as array, p as number, r as _enum, s as boolean, v as string, x as url } from "./schemas-C0PNPwjS.js";
 import { f as redactSecrets, i as SERVER_ID_PATTERN, l as CAPLETS_ERROR_CODES, p as toSafeError, u as CapletsError } from "./validation-DgxCzt-A.js";
 import { generatedToolInputJsonSchemaForCaplet, generatedToolInputSchema, generatedToolInputSchemaForCaplet } from "./generated-tool-input-schema.js";
-import { f as observedOutputShapeKey, g as stableJsonStringify, h as schemaHash, i as observeOutputShape, u as FileObservedOutputShapeStore } from "./observed-output-shapes-CL5MFXwM.js";
-import { a as formatCapletList, c as resolveCliConfigPaths, l as cliCommands$1, n as completionScript, o as formatConfigPaths, s as listCaplets, t as completeCliWords, u as completionShells } from "./completion-Cb-pshjL.js";
+import { f as observedOutputShapeKey, g as stableJsonStringify, h as schemaHash, i as observeOutputShape, u as FileObservedOutputShapeStore } from "./observed-output-shapes-D2k2-q8K.js";
+import { a as formatCapletList, c as resolveCliConfigPaths, l as cliCommands$1, n as completionScript, o as formatConfigPaths, s as listCaplets, t as completeCliWords, u as completionShells } from "./completion-BC4BNWo0.js";
 import { n as normalizeCapletSourcePath, t as FilesystemCapletSource } from "./filesystem-Kkg32TOJ.js";
 import { parseConfig as parseConfig$1 } from "./config-runtime.js";
 import fs, { accessSync, chmodSync, closeSync, constants, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
@@ -1553,7 +1553,7 @@ const EMPTY_COMPLETION_RESULT = { completion: {
 } };
 //#endregion
 //#region package.json
-var version = "0.21.1";
+var version = "0.23.0";
 //#endregion
 //#region src/serve/session.ts
 var CapletsMcpSession = class {
@@ -1895,6 +1895,8 @@ function engineOptions(options) {
 	if (options.configPath !== void 0) engineOptions.configPath = options.configPath;
 	if (options.projectConfigPath !== void 0) engineOptions.projectConfigPath = options.projectConfigPath;
 	if (options.authDir !== void 0) engineOptions.authDir = options.authDir;
+	if (options.artifactDir !== void 0) engineOptions.artifactDir = options.artifactDir;
+	if (options.exposeLocalArtifactPaths !== void 0) engineOptions.exposeLocalArtifactPaths = options.exposeLocalArtifactPaths;
 	if (options.watchDebounceMs !== void 0) engineOptions.watchDebounceMs = options.watchDebounceMs;
 	if (options.writeErr !== void 0) engineOptions.writeErr = options.writeErr;
 	return engineOptions;
@@ -4994,7 +4996,7 @@ function isPackageCommand(command) {
 function renderCaplet(input) {
 	const lines = [
 		"---",
-		"$schema: https://caplets.dev/caplet-frontmatter.schema.json",
+		"# yaml-language-server: $schema=https://caplets.dev/caplet.schema.json",
 		`name: ${yamlString$1(input.name)}`,
 		`description: ${yamlString$1(input.description)}`,
 		"tags:",
@@ -5081,6 +5083,15 @@ function addOpenApiCaplet(id, options) {
 		["auth", authFromTokenEnv(options.tokenEnv) ?? { type: "none" }]
 	], options);
 }
+function addGoogleDiscoveryCaplet(id, options) {
+	const discovery = options.discovery ?? options.discoveryUrl;
+	if (!discovery) throw new CapletsError("REQUEST_INVALID", "Google Discovery Caplet requires --discovery or --discovery-url");
+	return writeGeneratedCaplet(id, "Google Discovery", "googleDiscoveryApi", [
+		[options.discoveryUrl ? "discoveryUrl" : isUrlLike(discovery) ? "discoveryUrl" : "discoveryPath", discovery],
+		["baseUrl", options.baseUrl],
+		["auth", authFromTokenEnv(options.tokenEnv) ?? { type: "none" }]
+	], options);
+}
 function addGraphqlCaplet(id, options) {
 	if (!options.endpointUrl) throw new CapletsError("REQUEST_INVALID", "GraphQL Caplet requires --endpoint-url");
 	if (Boolean(options.schema) === Boolean(options.introspection)) throw new CapletsError("REQUEST_INVALID", "GraphQL Caplet requires exactly one of --schema or --introspection");
@@ -5183,7 +5194,7 @@ function resolvePrintOutputPath(id, options) {
 }
 function renderLocalPaths(fields, outputDir) {
 	return fields.map(([key, value]) => {
-		if (key !== "specPath" && key !== "schemaPath" || typeof value !== "string") return [key, value];
+		if (key !== "specPath" && key !== "schemaPath" && key !== "discoveryPath" || typeof value !== "string") return [key, value];
 		return [key, localPathRelativeToOutput(value, outputDir)];
 	});
 }
@@ -5234,7 +5245,7 @@ function renderBackendCaplet(id, label, backend, fields) {
 	const description = `${label} backend Caplet generated by caplets add.`;
 	const lines = [
 		"---",
-		"$schema: https://caplets.dev/caplet-frontmatter.schema.json",
+		"$schema: https://caplets.dev/caplet.schema.json",
 		`name: ${yamlString(name)}`,
 		`description: ${yamlString(description)}`,
 		"tags:",
@@ -5343,7 +5354,7 @@ function collectFiles(root) {
 //#endregion
 //#region src/cli/auth.ts
 async function loginAuth(serverId, options) {
-	const server = findAuthTarget(serverId, options.config ?? loadConfig(options.configPath));
+	const server = await resolveAuthTarget$1(serverId, options.config ?? loadConfig(options.configPath), options.authDir);
 	assertLoginTarget(server, serverId);
 	try {
 		const flowOptions = {
@@ -5376,7 +5387,7 @@ async function refreshAuth(serverId, options) {
 	options.writeOut(`Refreshed OAuth credentials for \`${serverId}\`.\n`);
 }
 async function refreshAuthResult(serverId, options) {
-	const target = findAuthTarget(serverId, options.config ?? loadConfig(options.configPath));
+	const target = await resolveAuthTarget$1(serverId, options.config ?? loadConfig(options.configPath), options.authDir);
 	assertLoginTarget(target, serverId);
 	await refreshOAuthTokenBundle(target, options.authDir);
 	return { server: serverId };
@@ -5450,14 +5461,35 @@ function formatAuthRows(rows, format) {
 function findAuthTarget(serverId, config = loadConfig()) {
 	return authTargets(config).find((server) => server.server === serverId);
 }
+async function resolveAuthTarget$1(serverId, config, authDir) {
+	const target = findAuthTarget(serverId, config);
+	if (target?.backend !== "googleDiscovery") return target;
+	const api = config.googleDiscoveryApis[serverId];
+	if (!api || api.auth.type !== "oauth2" && api.auth.type !== "oidc") return target;
+	const manager = new GoogleDiscoveryManager(new ServerRegistry(config), authDir ? { authDir } : {});
+	const baseUrl = api.baseUrl ?? await manager.resolveBaseUrl(api).catch(() => void 0) ?? api.discoveryUrl;
+	return {
+		...target,
+		...baseUrl ? { baseUrl } : {},
+		...api.auth.scopes?.length ? {} : { resolvedScopes: await manager.resolveAuthScopes(api) }
+	};
+}
 function authTargets(config) {
 	return [
 		...Object.values(config.mcpServers).filter((server) => server.transport !== "stdio" && (server.auth?.type === "oauth2" || server.auth?.type === "oidc")),
 		...Object.values(config.openapiEndpoints).filter((endpoint) => endpoint.auth?.type === "oauth2" || endpoint.auth?.type === "oidc"),
+		...Object.values(config.googleDiscoveryApis).filter((api) => api.auth?.type === "oauth2" || api.auth?.type === "oidc").map(googleDiscoveryAuthTarget),
 		...Object.values(config.graphqlEndpoints).filter((endpoint) => endpoint.auth?.type === "oauth2" || endpoint.auth?.type === "oidc").map(graphQlAuthTarget),
 		...Object.values(config.httpApis).filter((api) => api.auth?.type === "oauth2" || api.auth?.type === "oidc").map(httpAuthTarget)
 	];
 }
+function googleDiscoveryAuthTarget(api) {
+	const baseUrl = api.baseUrl ?? api.discoveryUrl;
+	return {
+		...api,
+		...baseUrl ? { baseUrl } : {}
+	};
+}
 function graphQlAuthTarget(endpoint) {
 	return {
 		...endpoint,
@@ -6090,6 +6122,7 @@ function allCaplets(config) {
 	return [
 		...Object.values(typed.mcpServers ?? {}),
 		...Object.values(typed.openapiEndpoints ?? {}),
+		...Object.values(typed.googleDiscoveryApis ?? {}),
 		...Object.values(typed.graphqlEndpoints ?? {}),
 		...Object.values(typed.httpApis ?? {}),
 		...Object.values(typed.cliTools ?? {}),
@@ -6690,6 +6723,7 @@ async function runCapletSetupCli(capletId, options = {}) {
 	const caplet = Object.values({
 		...config.mcpServers,
 		...config.openapiEndpoints,
+		...config.googleDiscoveryApis,
 		...config.graphqlEndpoints,
 		...config.httpApis,
 		...config.cliTools,
@@ -6815,6 +6849,8 @@ async function runSetup(integration, options = {}) {
 	if (!setupIntegrationIds.includes(integration)) return await runCapletSetupCli(integration, {
 		...options.yes === void 0 ? {} : { yes: options.yes },
 		target: resolveSetupTargetKind(options),
+		...options.env?.CAPLETS_CONFIG ? { configPath: options.env.CAPLETS_CONFIG } : {},
+		...options.env?.CAPLETS_PROJECT_CONFIG ? { projectConfigPath: options.env.CAPLETS_PROJECT_CONFIG } : {},
 		...options.remote === void 0 && !isRemoteSetup(options) ? {} : { remote: isRemoteSetup(options) }
 	});
 	const result = await executeSetup(integration, options);
@@ -10666,7 +10702,7 @@ function progressiveCapletExport(entry) {
 		inputSchema,
 		schemaHash: schemaHash(inputSchema),
 		capletId: entry.caplet.server,
-		shadowing: "forbid"
+		shadowing: shadowingPolicy(entry.caplet)
 	};
 }
 function codeModeCapletExport(entry) {
@@ -10678,7 +10714,7 @@ function codeModeCapletExport(entry) {
 		description: entry.caplet.description,
 		schemaHash: null,
 		capletId: entry.caplet.server,
-		shadowing: "forbid"
+		shadowing: shadowingPolicy(entry.caplet)
 	};
 }
 function toolExport(entry) {
@@ -10697,7 +10733,7 @@ function toolExport(entry) {
 			output: entry.tool.outputSchema
 		}),
 		capletId: entry.caplet.server,
-		shadowing: "forbid"
+		shadowing: shadowingPolicy(entry.caplet)
 	};
 }
 function resourceExport(entry) {
@@ -10712,7 +10748,7 @@ function resourceExport(entry) {
 		...typeof entry.resource.size === "number" ? { size: entry.resource.size } : {},
 		schemaHash: null,
 		capletId: entry.caplet.server,
-		shadowing: "forbid"
+		shadowing: shadowingPolicy(entry.caplet)
 	};
 }
 function resourceTemplateExport(entry) {
@@ -10726,7 +10762,7 @@ function resourceTemplateExport(entry) {
 		...entry.resourceTemplate.mimeType ? { mimeType: entry.resourceTemplate.mimeType } : {},
 		schemaHash: null,
 		capletId: entry.caplet.server,
-		shadowing: "forbid"
+		shadowing: shadowingPolicy(entry.caplet)
 	};
 }
 function promptExport(entry) {
@@ -10741,11 +10777,11 @@ function promptExport(entry) {
 		inputSchema,
 		schemaHash: schemaHash(inputSchema),
 		capletId: entry.caplet.server,
-		shadowing: "forbid"
+		shadowing: shadowingPolicy(entry.caplet)
 	};
 }
 function completionExports(snapshot) {
-	return [...new Set([...snapshot.directPrompts.map((entry) => entry.caplet.server), ...snapshot.directResourceTemplates.map((entry) => entry.caplet.server)])].sort().map((capletId) => ({
+	return [...new Map([...snapshot.directPrompts, ...snapshot.directResourceTemplates].map((entry) => [entry.caplet.server, entry.caplet])).entries()].sort(([left], [right]) => left.localeCompare(right)).map(([capletId, caplet]) => ({
 		stableId: `completion:${capletId}`,
 		kind: "completion",
 		name: `${capletId}:complete`,
@@ -10753,9 +10789,12 @@ function completionExports(snapshot) {
 		description: `MCP completion for ${capletId}.`,
 		schemaHash: null,
 		capletId,
-		shadowing: "forbid"
+		shadowing: shadowingPolicy(caplet)
 	}));
 }
+function shadowingPolicy(caplet) {
+	return caplet.shadowing ?? "forbid";
+}
 function sortAttachProjectionInput(partial) {
 	return {
 		caplets: sortByStableId(partial.caplets),
@@ -10971,7 +11010,7 @@ async function dispatch(request, context) {
 async function startRemoteAuthLogin(serverId, context) {
 	if (!context.authFlowStore || !context.controlCallbackBaseUrl) throw new CapletsError("REQUEST_INVALID", "Remote auth login is not available on this server");
 	const config = loadConfigWithSources(context.configPath, context.projectConfigPath).config;
-	const target = findAuthTarget(serverId, config);
+	const target = await resolveAuthTarget$1(serverId, config, context.authDir);
 	assertLoginTarget(target, serverId);
 	const flowId = randomUUID();
 	const baseUrl = context.controlCallbackBaseUrl.endsWith("/") ? context.controlCallbackBaseUrl : `${context.controlCallbackBaseUrl}/`;
@@ -11040,6 +11079,16 @@ function dispatchAdd(args, context) {
 				print: false
 			})
 		};
+		case "google-discovery":
+		case "googleDiscovery": return {
+			remote: true,
+			label: "Google Discovery",
+			...addGoogleDiscoveryCaplet(id, {
+				...options,
+				destinationRoot: context.projectCapletsRoot,
+				print: false
+			})
+		};
 		case "graphql": return {
 			remote: true,
 			label: "GraphQL",
@@ -11058,7 +11107,7 @@ function dispatchAdd(args, context) {
 				print: false
 			})
 		};
-		default: throw new CapletsError("REQUEST_INVALID", "add.kind must be cli, mcp, openapi, graphql, or http");
+		default: throw new CapletsError("REQUEST_INVALID", "add.kind must be cli, mcp, openapi, google-discovery, googleDiscovery, graphql, or http");
 	}
 }
 function optionalProp(key, value) {
@@ -11115,6 +11164,14 @@ function remoteAddOptions$1(kind, options) {
 			tokenEnv: "string",
 			force: "boolean"
 		});
+		case "google-discovery":
+		case "googleDiscovery": return pickOptions(options, {
+			discovery: "string",
+			discoveryUrl: "string",
+			baseUrl: "string",
+			tokenEnv: "string",
+			force: "boolean"
+		});
 		case "graphql": return pickOptions(options, {
 			endpointUrl: "string",
 			schema: "string",
@@ -11455,12 +11512,16 @@ function attachEventsResponse(engine, activeStreams) {
 	} });
 }
 async function serveHttp(options, engineOptions = {}, writeErr = (value) => process.stderr.write(value)) {
-	const engine = new CapletsEngine(engineOptions);
+	const resolvedEngineOptions = {
+		exposeLocalArtifactPaths: false,
+		...engineOptions
+	};
+	const engine = new CapletsEngine(resolvedEngineOptions);
 	const app = createHttpServeApp(options, engine, {
 		writeErr,
 		control: {
-			...engineOptions,
-			projectCapletsRoot: projectCapletsRootForEngineOptions(engineOptions)
+			...resolvedEngineOptions,
+			projectCapletsRoot: projectCapletsRootForEngineOptions(resolvedEngineOptions)
 		}
 	});
 	const paths = servicePaths(options.path);
@@ -11480,12 +11541,16 @@ async function serveHttp(options, engineOptions = {}, writeErr = (value) => proc
 	}), app, engine, writeErr);
 }
 async function serveHttpWithSessionFactory(options, createSession, writeErr = (value) => process.stderr.write(value)) {
-	const engine = new CapletsEngine({});
+	const resolvedEngineOptions = { exposeLocalArtifactPaths: false };
+	const engine = new CapletsEngine(resolvedEngineOptions);
 	const app = createHttpServeApp(options, engine, {
 		writeErr,
 		exposeAttach: false,
 		sessionFactory: createSession,
-		control: { projectCapletsRoot: resolveProjectCapletsRoot() }
+		control: {
+			...resolvedEngineOptions,
+			projectCapletsRoot: resolveProjectCapletsRoot()
+		}
 	});
 	const paths = servicePaths(options.path);
 	const origin = `http://${formatHost(options.host)}:${options.port}`;
@@ -11746,6 +11811,7 @@ function createAttachNativeService(options, io) {
 			url: options.selection.remote.attachUrl,
 			...options.selection.remote.fetch ? { fetch: options.selection.remote.fetch } : {}
 		}),
+		exposeLocalArtifactPaths: false,
 		...io.writeErr ? { writeErr: io.writeErr } : {}
 	});
 }
@@ -13311,6 +13377,22 @@ function createProgram(io = {}) {
 		});
 		writeAddResult(writeOut, `${localMutationTargetLabel(target, io)}OpenAPI`, result);
 	});
+	add.command("google-discovery").description("Add a Google Discovery API backend Caplet.").argument("<id>", "Caplet ID/display seed").option("--discovery <path-or-url>", "Google Discovery document path or URL").option("--discovery-url <url>", "remote Google Discovery document URL").option("--base-url <url>", "request base URL override").option("--token-env <ENV>", "bearer token environment variable reference").option("--project", "write to the project Caplets root").option("-g, --global", "write to the user Caplets root").option("--remote", "add through remote control").option("--print", "print generated Caplet text without writing a file").option("--output <path>", "output path").option("--force", "overwrite an existing destination file").action(async (id, options) => {
+		const target = parseMutationTarget(options);
+		if (target === "remote") {
+			writeAddResult(writeOut, "Google Discovery", await requireRemoteClientForTarget(io).request("add", {
+				kind: "googleDiscovery",
+				id,
+				options: remoteAddOptions(options)
+			}));
+			return;
+		}
+		const result = addGoogleDiscoveryCaplet(id, {
+			...options,
+			destinationRoot: addDestinationRoot(target, currentConfigPath(), env)
+		});
+		writeAddResult(writeOut, `${localMutationTargetLabel(target, io)}Google Discovery`, result);
+	});
 	add.command("graphql").description("Add a GraphQL backend Caplet.").argument("<id>", "Caplet ID/display seed").option("--endpoint-url <url>", "GraphQL endpoint URL").option("--schema <path-or-url>", "GraphQL schema path or URL").option("--introspection", "load schema through endpoint introspection").option("--token-env <ENV>", "bearer token environment variable reference").option("--project", "write to the project Caplets root").option("-g, --global", "write to the user Caplets root").option("--remote", "add through remote control").option("--print", "print generated Caplet text without writing a file").option("--output <path>", "output path").option("--force", "overwrite an existing destination file").action(async (id, options) => {
 		const target = parseMutationTarget(options);
 		if (target === "remote") {
@@ -13951,6 +14033,7 @@ function mergePartialLocalOverlays(globalOverlay, projectOverlay) {
 const capletConfigKinds = [
 	"mcpServers",
 	"openapiEndpoints",
+	"googleDiscoveryApis",
 	"graphqlEndpoints",
 	"httpApis",
 	"cliTools",
@@ -13993,7 +14076,7 @@ function formatOverlaySource(kind) {
 	return kind;
 }
 function hasEnabledCaplet(config, id) {
-	const caplet = config.mcpServers[id] ?? config.openapiEndpoints[id] ?? config.graphqlEndpoints[id] ?? config.httpApis[id] ?? config.cliTools[id] ?? config.capletSets[id];
+	const caplet = config.mcpServers[id] ?? config.openapiEndpoints[id] ?? config.googleDiscoveryApis[id] ?? config.graphqlEndpoints[id] ?? config.httpApis[id] ?? config.cliTools[id] ?? config.capletSets[id];
 	return Boolean(caplet && !caplet.disabled);
 }
 async function executeLocalOperation(caplet, request, io, config) {
@@ -14628,7 +14711,7 @@ function classifyCapletRuntimeRoute(caplet) {
 	if (caplet.setup) return "process";
 	if (caplet.backend === "cli") return "process";
 	if (caplet.backend === "mcp") return caplet.transport === "stdio" || Boolean(caplet.command) ? "process" : "worker_safe";
-	if (caplet.backend === "openapi" || caplet.backend === "graphql" || caplet.backend === "http") return "worker_safe";
+	if (caplet.backend === "openapi" || caplet.backend === "googleDiscovery" || caplet.backend === "graphql" || caplet.backend === "http") return "worker_safe";
 	if (caplet.backend === "caplets") return "worker_safe";
 	return "local_only";
 }
@@ -14737,6 +14820,7 @@ function capletsFromConfig(config) {
 	return [
 		...Object.values(config.mcpServers),
 		...Object.values(config.openapiEndpoints),
+		...Object.values(config.googleDiscoveryApis ?? {}),
 		...Object.values(config.graphqlEndpoints),
 		...Object.values(config.httpApis),
 		...Object.values(config.cliTools),
@@ -14745,6 +14829,7 @@ function capletsFromConfig(config) {
 }
 function localReferencePaths(caplet) {
 	if (caplet.backend === "openapi") return filterLocalReferences([caplet.specPath]);
+	if (caplet.backend === "googleDiscovery") return filterLocalReferences([caplet.discoveryPath]);
 	if (caplet.backend === "graphql") return filterLocalReferences([caplet.schemaPath, ...Object.values(caplet.operations ?? {}).map((operation) => operation.documentPath)]);
 	if (caplet.backend === "caplets") return filterLocalReferences([caplet.configPath]);
 	return [];

package/dist/media/artifacts.d.ts

@@ -0,0 +1,24 @@
+export type MediaArtifact = {
+    uri: string;
+    path?: string;
+    filename: string;
+    mimeType?: string;
+    byteLength: number;
+    sha256: string;
+};
+export type WriteMediaArtifactInput = {
+    rootDir?: string;
+    capletId: string;
+    callId?: string;
+    suggestedFilename?: string;
+    outputPath?: string;
+    mimeType?: string;
+    bytes: Uint8Array | Buffer;
+    exposeLocalPath?: boolean;
+};
+export declare function artifactUri(capletId: string, callId: string, filename: string): string;
+export declare function writeMediaArtifact(input: WriteMediaArtifactInput): Promise<MediaArtifact>;
+export declare function resolveMediaArtifact(uri: string, options?: {
+    artifactRoot?: string;
+    maxBytes?: number;
+}): MediaArtifact;

package/dist/media/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./artifacts";
+export * from "./input";

package/dist/media/input.d.ts

@@ -0,0 +1,29 @@
+export type MediaInput = {
+    path: string;
+    artifact?: never;
+    dataUrl?: never;
+    filename?: string;
+    mimeType?: string;
+} | {
+    artifact: string;
+    path?: never;
+    dataUrl?: never;
+    filename?: string;
+    mimeType?: string;
+} | {
+    dataUrl: string;
+    path?: never;
+    artifact?: never;
+    filename?: string;
+    mimeType?: string;
+};
+export type ResolvedMediaInput = {
+    bytes: Buffer;
+    filename: string;
+    mimeType?: string;
+};
+export declare function readMediaInput(input: unknown, options?: {
+    artifactRoot?: string;
+    maxBytes?: number;
+    allowLocalPaths?: boolean;
+}): Promise<ResolvedMediaInput>;

package/dist/native/remote.d.ts

@@ -5,6 +5,7 @@ export type RemoteCapletsTool = {
     name: string;
     capletId?: string | undefined;
     sourceCapletId?: string | undefined;
+    shadowing?: "forbid" | "allow" | undefined;
     title?: string | undefined;
     description?: string | undefined;
     inputSchema?: unknown;

package/dist/native/service.d.ts

@@ -8,6 +8,7 @@ export type NativeCapletsServiceOptions = NativeCapletsServiceResolutionInput &
     configPath?: string;
     projectConfigPath?: string;
     authDir?: string;
+    exposeLocalArtifactPaths?: boolean;
     watchDebounceMs?: number;
     watch?: boolean;
     writeErr?: (value: string) => void;
@@ -17,6 +18,7 @@ export type NativeCapletsServiceOptions = NativeCapletsServiceResolutionInput &
 export type NativeCapletTool = {
     caplet: string;
     sourceCaplet?: string;
+    shadowing?: "forbid" | "allow";
     toolName: string;
     title: string;
     description: string;

package/dist/native.js

@@ -1,4 +1,4 @@
-import { C as nativeCapletPromptGuidance, D as nativeCodeModeToolId, E as nativeCapletsSystemGuidance, O as nativeCodeModeToolName, T as nativeCapletToolName, f as RemoteNativeCapletsService, h as resolveNativeCapletsServiceOptions, p as createSdkRemoteCapletsClient, t as createNativeCapletsService, w as nativeCapletToolDescription } from "./service-lkrQheFA.js";
+import { C as nativeCapletPromptGuidance, D as nativeCodeModeToolId, E as nativeCapletsSystemGuidance, O as nativeCodeModeToolName, T as nativeCapletToolName, f as RemoteNativeCapletsService, h as resolveNativeCapletsServiceOptions, p as createSdkRemoteCapletsClient, t as createNativeCapletsService, w as nativeCapletToolDescription } from "./service-CSRCJfpA.js";
 import { generatedToolInputJsonSchema, generatedToolInputSchema } from "./generated-tool-input-schema.js";
 //#region src/native/process-cleanup.ts
 function registerNativeCapletsProcessCleanup(service, options = {}) {

package/dist/{observed-output-shapes-CL5MFXwM.js → observed-output-shapes-D2k2-q8K.js}

@@ -89,6 +89,15 @@ function nonSecretBackendIdentity(caplet) {
 			specUrl: caplet.specUrl,
 			baseUrl: caplet.baseUrl
 		};
+		case "googleDiscovery": return {
+			backend: caplet.backend,
+			server: caplet.server,
+			discoveryPath: caplet.discoveryPath,
+			discoveryUrl: caplet.discoveryUrl,
+			baseUrl: caplet.baseUrl,
+			includeOperations: caplet.includeOperations,
+			excludeOperations: caplet.excludeOperations
+		};
 		case "graphql": return {
 			backend: caplet.backend,
 			server: caplet.server,

package/dist/observed-output-shapes.js

@@ -1,2 +1,2 @@
-import { _ as OBSERVED_OUTPUT_SHAPE_LIMITS, a as parseShapeableJsonText, c as shapeType, d as backendFingerprint, f as observedOutputShapeKey, i as observeOutputShape, l as mergeJsonShapes, m as stableHash, n as extractJsonShape, o as hasTruncatedShape, p as observedOutputShapeStorageKey, r as normalizedObservableValue, s as shapeToTypeScript, t as usefulOutputSchema, u as FileObservedOutputShapeStore, v as OBSERVED_OUTPUT_SHAPE_VERSION } from "./observed-output-shapes-CL5MFXwM.js";
+import { _ as OBSERVED_OUTPUT_SHAPE_LIMITS, a as parseShapeableJsonText, c as shapeType, d as backendFingerprint, f as observedOutputShapeKey, i as observeOutputShape, l as mergeJsonShapes, m as stableHash, n as extractJsonShape, o as hasTruncatedShape, p as observedOutputShapeStorageKey, r as normalizedObservableValue, s as shapeToTypeScript, t as usefulOutputSchema, u as FileObservedOutputShapeStore, v as OBSERVED_OUTPUT_SHAPE_VERSION } from "./observed-output-shapes-D2k2-q8K.js";
 export { FileObservedOutputShapeStore, OBSERVED_OUTPUT_SHAPE_LIMITS, OBSERVED_OUTPUT_SHAPE_VERSION, backendFingerprint, extractJsonShape, hasTruncatedShape, mergeJsonShapes, normalizedObservableValue, observeOutputShape, observedOutputShapeKey, observedOutputShapeStorageKey, parseShapeableJsonText, shapeToTypeScript, shapeType, stableHash, usefulOutputSchema };