@caplets/core 0.22.0 → 0.23.0

package/dist/code-mode.js

@@ -41,7 +41,7 @@ function capletHintText(caplet) {
 	].filter((value) => Boolean(value)).join(" ");
 }
 function minifyCodeModeDeclarationText(value) {
-	return value.replace(/^\s*export\s*\{\s*\}\s*;?\s*/u, "").replace(/\r\n?/gu, "\n").split("\n").map((line) => line.trim()).filter(Boolean).join(" ").replace(/\s+/gu, " ").replace(/\s*([{}()[\]:;,|&=])\s*/gu, "$1").replace(/\s*<\s*/gu, "<").replace(/\s*>\s*/gu, ">").replace(/\?\s*:/gu, "?:").trim();
+	return value.replace(/^\s*export\s*\{\s*\}\s*;?\s*/u, "").replace(/\s*export\s*\{\s*\}\s*;?\s*$/u, "").replace(/\r\n?/gu, "\n").split("\n").map((line) => line.trim()).filter(Boolean).join(" ").replace(/\s+/gu, " ").replace(/\s*([{}()[\]:;,|&=])\s*/gu, "$1").replace(/\s*<\s*/gu, "<").replace(/\s*>\s*/gu, ">").replace(/\?\s*:/gu, "?:").trim();
 }
 function codeModeDeclarationHash(declaration) {
 	return [
@@ -12678,7 +12678,7 @@ const PARSER_OPTIONS = {
 	]
 };
 function hasDirectFetchCall(code) {
-	return hasMatchingAstNode(code, (node) => isCallExpression(node) && isFetchCallee(node.callee));
+	return hasMatchingAstNode(code, isDirectFetchCallNode);
 }
 function hasExecutableImport(code) {
 	return hasMatchingAstNode(code, isExecutableImportNode);
@@ -12687,9 +12687,9 @@ function hasMatchingAstNode(code, predicate) {
 	const ast = parseCode(code);
 	if (!ast) return false;
 	let found = false;
-	visitAst(ast, (node) => {
+	visitAst(ast, (node, parent) => {
 		if (found) return;
-		found = predicate(node);
+		found = predicate(node, parent);
 	});
 	return found;
 }
@@ -12707,11 +12707,10 @@ function isExecutableImportNode(node) {
 function isCallExpression(node) {
 	return (node.type === "CallExpression" || node.type === "OptionalCallExpression") && "callee" in node;
 }
-function isFetchCallee(value) {
-	if (!isNode(value)) return false;
-	if (value.type === "Identifier") return value.name === "fetch";
-	if (value.type === "MemberExpression" || value.type === "OptionalMemberExpression") return isGlobalFetchMember(value);
-	return false;
+function isDirectFetchCallNode(node) {
+	if (!isCallExpression(node) || !isNode(node.callee)) return false;
+	if (isIdentifierNamed(node.callee, "fetch")) return true;
+	return (node.callee.type === "MemberExpression" || node.callee.type === "OptionalMemberExpression") && isGlobalFetchMember(node.callee);
 }
 function isGlobalFetchMember(node) {
 	if (!isIdentifierNamed(node.object, "globalThis", "window", "self")) return false;
@@ -12721,16 +12720,22 @@ function isGlobalFetchMember(node) {
 function isExportDeclaration(node) {
 	return node.type === "ExportAllDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration";
 }
-function visitAst(value, visit) {
+function visitAst(value, visit, parent) {
 	if (!isNode(value)) return;
-	visit(value);
+	visit(value, parent);
 	for (const [key, child] of Object.entries(value)) {
 		if (key === "loc" || key === "start" || key === "end" || key === "extra") continue;
 		if (Array.isArray(child)) {
-			for (const item of child) visitAst(item, visit);
+			for (const item of child) visitAst(item, visit, {
+				node: value,
+				key
+			});
 			continue;
 		}
-		visitAst(child, visit);
+		visitAst(child, visit, {
+			node: value,
+			key
+		});
 	}
 }
 function isNode(value) {

package/dist/{completion-DnQujlrc.js → completion-BC4BNWo0.js}

@@ -1,4 +1,4 @@
-import { Ct as resolveCapletsRoot, Et as resolveProjectConfigPath, Q as loadConfigWithSources, Sn as __exportAll, _t as DEFAULT_AUTH_DIR, vt as DEFAULT_COMPLETION_CACHE_DIR, wt as resolveConfigPath } from "./service-4_chB2wu.js";
+import { $ as loadConfigWithSources, Cn as __exportAll, Dt as resolveProjectConfigPath, Tt as resolveConfigPath, vt as DEFAULT_AUTH_DIR, wt as resolveCapletsRoot, yt as DEFAULT_COMPLETION_CACHE_DIR } from "./service-CSRCJfpA.js";
 import { u as CapletsError } from "./validation-DgxCzt-A.js";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -75,6 +75,7 @@ const cliSubcommands = {
 		"cli",
 		"mcp",
 		"openapi",
+		"google-discovery",
 		"graphql",
 		"http"
 	],
@@ -142,6 +143,7 @@ function allCaplets(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),
@@ -383,6 +385,16 @@ function secretFreeServerShape(server) {
 			authType: server.auth.type,
 			requestTimeoutMs: server.requestTimeoutMs
 		};
+		case "googleDiscovery": return {
+			...base,
+			discoveryPath: server.discoveryPath,
+			discoveryUrl: server.discoveryUrl,
+			baseUrl: server.baseUrl,
+			includeOperations: server.includeOperations,
+			excludeOperations: server.excludeOperations,
+			authType: server.auth.type,
+			requestTimeoutMs: server.requestTimeoutMs
+		};
 		case "graphql": return {
 			...base,
 			endpointUrl: server.endpointUrl,
@@ -441,7 +453,7 @@ async function withTimeout(promise, timeoutMs) {
 	}
 }
 function enabledServer(serverId, config) {
-	const server = config.mcpServers[serverId] ?? config.openapiEndpoints[serverId] ?? config.graphqlEndpoints[serverId] ?? config.httpApis[serverId] ?? config.cliTools[serverId] ?? config.capletSets[serverId];
+	const server = config.mcpServers[serverId] ?? config.openapiEndpoints[serverId] ?? config.googleDiscoveryApis[serverId] ?? config.graphqlEndpoints[serverId] ?? config.httpApis[serverId] ?? config.cliTools[serverId] ?? config.capletSets[serverId];
 	return server && !server.disabled ? server : void 0;
 }
 function dedupeCandidates(candidates) {

package/dist/config/paths.d.ts

@@ -5,10 +5,12 @@ export declare function defaultStateBaseDir(env?: PathEnv, home?: string, platfo
 export declare function defaultCacheBaseDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultConfigPath(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultAuthDir(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultArtifactDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultCompletionCacheDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultObservedOutputShapeCacheDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare const DEFAULT_CONFIG_PATH: string;
 export declare const DEFAULT_AUTH_DIR: string;
+export declare const DEFAULT_ARTIFACT_DIR: string;
 export declare const DEFAULT_COMPLETION_CACHE_DIR: string;
 export declare const DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR: string;
 export declare const PROJECT_CONFIG_FILE: string;

package/dist/config-runtime.d.ts

@@ -73,6 +73,17 @@ export type OpenApiEndpointConfig = CommonCapletConfig & {
     requestTimeoutMs: number;
     operationCacheTtlMs: number;
 };
+export type GoogleDiscoveryApiConfig = CommonCapletConfig & {
+    backend: "googleDiscovery";
+    discoveryPath?: string | undefined;
+    discoveryUrl?: string | undefined;
+    baseUrl?: string | undefined;
+    includeOperations?: string[] | undefined;
+    excludeOperations?: string[] | undefined;
+    auth: OpenApiAuthConfig;
+    requestTimeoutMs: number;
+    operationCacheTtlMs: number;
+};
 export type GraphQlOperationConfig = AgentSelectionHintsConfig & {
     document?: string | undefined;
     documentPath?: string | undefined;
@@ -145,7 +156,7 @@ export type CapletSetConfig = CommonCapletConfig & {
     maxSearchLimit: number;
     toolCacheTtlMs: number;
 };
-export type CapletConfig = CapletServerConfig | OpenApiEndpointConfig | GraphQlEndpointConfig | HttpApiConfig | CliToolsConfig | CapletSetConfig;
+export type CapletConfig = CapletServerConfig | OpenApiEndpointConfig | GoogleDiscoveryApiConfig | GraphQlEndpointConfig | HttpApiConfig | CliToolsConfig | CapletSetConfig;
 export type CapletsConfig = {
     version: 1;
     options: {
@@ -163,6 +174,7 @@ export type CapletsConfig = {
     };
     mcpServers: Record<string, CapletServerConfig>;
     openapiEndpoints: Record<string, OpenApiEndpointConfig>;
+    googleDiscoveryApis: Record<string, GoogleDiscoveryApiConfig>;
     graphqlEndpoints: Record<string, GraphQlEndpointConfig>;
     httpApis: Record<string, HttpApiConfig>;
     cliTools: Record<string, CliToolsConfig>;

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;