@caplets/core 0.22.0 → 0.24.0

package/dist/auth.d.ts

@@ -20,10 +20,11 @@ type OAuthLikeAuthConfig = {
 };
 export type GenericAuthTarget = {
     server: string;
-    backend: "openapi" | "graphql" | "http";
+    backend: "openapi" | "googleDiscovery" | "graphql" | "http";
     url?: string | undefined;
     baseUrl?: string | undefined;
     specUrl?: string | undefined;
+    resolvedScopes?: string[] | undefined;
     auth?: OAuthLikeAuthConfig | {
         type: string;
     } | undefined;

package/dist/caplet-files-bundle.d.ts

@@ -162,6 +162,67 @@ export declare const capletFileSchema: z.ZodObject<{
             }, z.core.$strict>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    googleDiscoveryApi: z.ZodOptional<z.ZodObject<{
+        discoveryPath: z.ZodOptional<z.ZodString>;
+        discoveryUrl: z.ZodOptional<z.ZodString>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        auth: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"none">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"bearer">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"headers">;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oauth2">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oidc">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">;
+        requestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        operationCacheTtlMs: z.ZodOptional<z.ZodNumber>;
+        includeOperations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        excludeOperations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+        projectBinding: z.ZodOptional<z.ZodObject<{
+            required: z.ZodLiteral<true>;
+        }, z.core.$strict>>;
+        runtime: z.ZodOptional<z.ZodObject<{
+            features: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                docker: "docker";
+                browser: "browser";
+            }>>>;
+            resources: z.ZodOptional<z.ZodObject<{
+                class: z.ZodOptional<z.ZodEnum<{
+                    standard: "standard";
+                    large: "large";
+                    heavy: "heavy";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     graphqlEndpoint: z.ZodOptional<z.ZodObject<{
         endpointUrl: z.ZodString;
         schemaPath: z.ZodOptional<z.ZodString>;
@@ -399,6 +460,7 @@ export declare function capletJsonSchema(): unknown;
 export type CapletFileConfig = {
     mcpServers?: Record<string, unknown>;
     openapiEndpoints?: Record<string, unknown>;
+    googleDiscoveryApis?: Record<string, unknown>;
     graphqlEndpoints?: Record<string, unknown>;
     httpApis?: Record<string, unknown>;
     cliTools?: Record<string, unknown>;

package/dist/caplet-sets.d.ts

@@ -9,6 +9,8 @@ export declare class CapletSetManager {
     private readonly childRefreshLocks;
     constructor(registry: ServerRegistry, options?: {
         authDir?: string;
+        artifactDir?: string;
+        exposeLocalArtifactPaths?: boolean;
         ancestry?: Set<string>;
     });
     updateRegistry(registry: ServerRegistry): void;

package/dist/caplet-source.js

@@ -10299,6 +10299,36 @@ const capletOpenApiEndpointSchema = object({
 	});
 	validateEndpointAuthHeaders(endpoint.auth, ctx);
 });
+const capletGoogleDiscoveryOperationFilterSchema = array(string().trim().min(1).max(160));
+const capletGoogleDiscoveryApiSchema = object({
+	discoveryPath: string().min(1).optional().describe("Local Google Discovery document path."),
+	discoveryUrl: string().min(1).optional().describe("Remote Google Discovery document URL."),
+	baseUrl: string().min(1).optional().describe("Override base URL for Google API requests."),
+	auth: capletEndpointAuthSchema.describe("Explicit Google API request auth config. Use {\"type\":\"none\"} for public APIs."),
+	requestTimeoutMs: number().int().positive().optional().describe("Timeout in milliseconds for Google API HTTP requests."),
+	operationCacheTtlMs: number().int().nonnegative().optional().describe("Milliseconds Google Discovery operation metadata stays fresh. Set 0 to refresh every time."),
+	includeOperations: capletGoogleDiscoveryOperationFilterSchema.optional(),
+	excludeOperations: capletGoogleDiscoveryOperationFilterSchema.optional(),
+	disabled: boolean().optional().describe("When true, omit this Caplet from discovery."),
+	projectBinding: capletProjectBindingSchema.optional(),
+	runtime: capletRuntimeRequirementsSchema.optional()
+}).strict().superRefine((api, ctx) => {
+	if (Boolean(api.discoveryPath) === Boolean(api.discoveryUrl)) ctx.addIssue({
+		code: "custom",
+		message: "googleDiscoveryApi must define exactly one discovery source: discoveryPath or discoveryUrl"
+	});
+	if (api.discoveryUrl && !hasEnvReference$2(api.discoveryUrl) && !isAllowedRemoteUrl(api.discoveryUrl)) ctx.addIssue({
+		code: "custom",
+		path: ["discoveryUrl"],
+		message: "Google Discovery discoveryUrl must use https except loopback development urls"
+	});
+	if (api.baseUrl && !hasEnvReference$2(api.baseUrl) && !isAllowedHttpBaseUrl(api.baseUrl)) ctx.addIssue({
+		code: "custom",
+		path: ["baseUrl"],
+		message: "Google Discovery baseUrl must use https except loopback development urls and must not include credentials, query, or fragment"
+	});
+	validateEndpointAuthHeaders(api.auth, ctx);
+});
 const capletGraphQlOperationSchema = object({
 	document: string().min(1).optional().describe("Inline GraphQL operation document."),
 	documentPath: string().min(1).optional().describe("Path to a GraphQL operation document."),
@@ -10442,7 +10472,7 @@ const capletSetSchema$1 = object({
 	});
 });
 const capletFileSchema = object({
-	$schema: string().url().optional().describe("Optional JSON Schema URL for editor validation."),
+	$schema: string().optional().describe("Optional JSON Schema for editor validation."),
 	name: string().trim().min(1).max(80).describe("Human-readable Caplet display name."),
 	description: string().describe("Compact capability description shown before the full Caplet card is disclosed.").refine((value) => value.trim().length >= 10, "description must contain at least 10 non-whitespace characters").refine((value) => value.length <= 1500, "description must be at most 1500 characters"),
 	tags: array(string().trim().min(1).max(80)).optional().describe("Optional tags for grouping or searching Caplets."),
@@ -10454,14 +10484,15 @@ const capletFileSchema = object({
 	runtime: capletRuntimeRequirementsSchema.optional(),
 	mcpServer: capletMcpServerSchema.describe("MCP server backend configuration for this Caplet.").optional(),
 	openapiEndpoint: capletOpenApiEndpointSchema.describe("OpenAPI endpoint backend configuration for this Caplet.").optional(),
+	googleDiscoveryApi: capletGoogleDiscoveryApiSchema.describe("Google Discovery API backend configuration for this Caplet.").optional(),
 	graphqlEndpoint: capletGraphQlEndpointSchema.describe("GraphQL endpoint backend configuration for this Caplet.").optional(),
 	httpApi: capletHttpApiSchema.describe("HTTP API backend configuration for this Caplet.").optional(),
 	cliTools: capletCliToolsSchema.describe("CLI tools backend configuration for this Caplet.").optional(),
 	capletSet: capletSetSchema$1.describe("Nested Caplet collection backend configuration for this Caplet.").optional()
 }).strict().superRefine((frontmatter, ctx) => {
-	if (Number(Boolean(frontmatter.mcpServer)) + Number(Boolean(frontmatter.openapiEndpoint)) + Number(Boolean(frontmatter.graphqlEndpoint)) + Number(Boolean(frontmatter.httpApi)) + Number(Boolean(frontmatter.cliTools)) + Number(Boolean(frontmatter.capletSet)) !== 1) ctx.addIssue({
+	if (Number(Boolean(frontmatter.mcpServer)) + Number(Boolean(frontmatter.openapiEndpoint)) + Number(Boolean(frontmatter.googleDiscoveryApi)) + Number(Boolean(frontmatter.graphqlEndpoint)) + Number(Boolean(frontmatter.httpApi)) + Number(Boolean(frontmatter.cliTools)) + Number(Boolean(frontmatter.capletSet)) !== 1) ctx.addIssue({
 		code: "custom",
-		message: "Caplet file must define exactly one backend: mcpServer, openapiEndpoint, graphqlEndpoint, httpApi, cliTools, or capletSet"
+		message: "Caplet file must define exactly one backend: mcpServer, openapiEndpoint, googleDiscoveryApi, graphqlEndpoint, httpApi, cliTools, or capletSet"
 	});
 });
 function loadCapletFilesFromMap(input) {
@@ -10480,13 +10511,14 @@ function loadCapletFilesFromMap(input) {
 function buildCapletFileLoadResultFromEntries(root, candidates, readConfig, warnings) {
 	const servers = {};
 	const openapiEndpoints = {};
+	const googleDiscoveryApis = {};
 	const graphqlEndpoints = {};
 	const httpApis = {};
 	const cliTools = {};
 	const capletSets = {};
 	const paths = {};
 	function hasId(id) {
-		return Boolean(servers[id] || openapiEndpoints[id] || graphqlEndpoints[id] || httpApis[id] || cliTools[id] || capletSets[id]);
+		return Boolean(servers[id] || openapiEndpoints[id] || googleDiscoveryApis[id] || graphqlEndpoints[id] || httpApis[id] || cliTools[id] || capletSets[id]);
 	}
 	for (const candidate of candidates) {
 		if (hasId(candidate.id)) {
@@ -10513,6 +10545,9 @@ function buildCapletFileLoadResultFromEntries(root, candidates, readConfig, warn
 		if (isPlainObject(config) && config.backend === "openapi") {
 			const { backend: _backend, ...endpoint } = config;
 			openapiEndpoints[candidate.id] = endpoint;
+		} else if (isPlainObject(config) && config.backend === "googleDiscovery") {
+			const { backend: _backend, ...api } = config;
+			googleDiscoveryApis[candidate.id] = api;
 		} else if (isPlainObject(config) && config.backend === "graphql") {
 			const { backend: _backend, ...endpoint } = config;
 			graphqlEndpoints[candidate.id] = endpoint;
@@ -10529,6 +10564,7 @@ function buildCapletFileLoadResultFromEntries(root, candidates, readConfig, warn
 	}
 	const hasServers = Object.keys(servers).length > 0;
 	const hasOpenApi = Object.keys(openapiEndpoints).length > 0;
+	const hasGoogleDiscovery = Object.keys(googleDiscoveryApis).length > 0;
 	const hasGraphQl = Object.keys(graphqlEndpoints).length > 0;
 	const hasHttpApis = Object.keys(httpApis).length > 0;
 	const hasCliTools = Object.keys(cliTools).length > 0;
@@ -10536,6 +10572,7 @@ function buildCapletFileLoadResultFromEntries(root, candidates, readConfig, warn
 	const config = {
 		...hasServers ? { mcpServers: servers } : {},
 		...hasOpenApi ? { openapiEndpoints } : {},
+		...hasGoogleDiscovery ? { googleDiscoveryApis } : {},
 		...hasGraphQl ? { graphqlEndpoints } : {},
 		...hasHttpApis ? { httpApis } : {},
 		...hasCliTools ? { cliTools } : {},
@@ -10595,6 +10632,15 @@ function capletToServerConfig(frontmatter, body, baseDir, normalizePath) {
 		...sharedCapletFields(frontmatter),
 		body
 	};
+	if (frontmatter.googleDiscoveryApi) return {
+		...frontmatter.googleDiscoveryApi,
+		discoveryPath: normalizePath(frontmatter.googleDiscoveryApi.discoveryPath, baseDir),
+		backend: "googleDiscovery",
+		name: frontmatter.name,
+		description: frontmatter.description,
+		...sharedCapletFields(frontmatter),
+		body
+	};
 	if (frontmatter.graphqlEndpoint) return {
 		...frontmatter.graphqlEndpoint,
 		schemaPath: normalizePath(frontmatter.graphqlEndpoint.schemaPath, baseDir),
@@ -10840,6 +10886,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(),
@@ -10953,6 +11011,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({}),
@@ -10988,6 +11047,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"),
@@ -11081,6 +11141,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$1(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$1(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",
@@ -11256,6 +11346,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),
@@ -11264,6 +11355,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/cli/add.d.ts

@@ -27,6 +27,12 @@ type AddOpenApiOptions = AddDestinationOptions & {
     baseUrl?: string;
     tokenEnv?: string;
 };
+type AddGoogleDiscoveryOptions = AddDestinationOptions & {
+    discovery?: string;
+    discoveryUrl?: string;
+    baseUrl?: string;
+    tokenEnv?: string;
+};
 type AddGraphqlOptions = AddDestinationOptions & {
     endpointUrl?: string;
     schema?: string;
@@ -50,6 +56,10 @@ export declare function addOpenApiCaplet(id: string, options: AddOpenApiOptions)
     path?: string;
     text: string;
 };
+export declare function addGoogleDiscoveryCaplet(id: string, options: AddGoogleDiscoveryOptions): {
+    path?: string;
+    text: string;
+};
 export declare function addGraphqlCaplet(id: string, options: AddGraphqlOptions): {
     path?: string;
     text: string;

package/dist/cli/auth.d.ts

@@ -76,7 +76,29 @@ export declare function localAuthConfigForTarget(options: {
 }): CapletsConfig;
 export declare function formatAuthRows(rows: AuthStatusRow[], format: Exclude<AuthListFormat, "json">): string;
 export declare function findAuthTarget(serverId: string, config?: CapletsConfig): AuthTarget | undefined;
+export declare function resolveAuthTarget(serverId: string, config: CapletsConfig, authDir?: string): Promise<AuthTarget | undefined>;
 declare function authTargets(config: ReturnType<typeof loadConfig>): (import("../config").CapletServerConfig | import("../config").OpenApiEndpointConfig | (import("../config").AgentSelectionHintsConfig & {
+    server: string;
+    backend: "googleDiscovery";
+    name: string;
+    description: string;
+    exposure?: import("../config").CapletExposure | undefined;
+    shadowing?: import("../config").CapletShadowingPolicy | undefined;
+    tags?: string[] | undefined;
+    body?: string | undefined;
+    discoveryPath?: string | undefined;
+    discoveryUrl?: string | undefined;
+    baseUrl?: string | undefined;
+    includeOperations?: string[] | undefined;
+    excludeOperations?: string[] | undefined;
+    auth: import("../config").OpenApiAuthConfig;
+    requestTimeoutMs: number;
+    operationCacheTtlMs: number;
+    disabled: boolean;
+    setup?: import("..").CapletSetupConfig | undefined;
+    projectBinding?: import("../config").ProjectBindingConfig | undefined;
+    runtime?: import("../config").RuntimeRequirementsConfig | undefined;
+} & GenericAuthTarget) | (import("../config").AgentSelectionHintsConfig & {
     server: string;
     backend: "graphql";
     name: string;

package/dist/cli/code-mode.d.ts

@@ -6,11 +6,14 @@ export type CodeModeCliOptions = {
     inlineCode?: string | undefined;
     file?: string | undefined;
     timeoutMs?: number | undefined;
+    sessionId?: string | undefined;
+    recoveryRef?: string | undefined;
     json?: boolean | undefined;
     readStdin?: (() => Promise<string>) | undefined;
     writeOut: (value: string) => void;
     setExitCode: (code: number) => void;
 };
 export declare function runCodeModeCli(options: CodeModeCliOptions): Promise<void>;
+export declare function runCodeModeReplCli(options: Pick<CodeModeCliOptions, "env" | "configPath" | "projectConfigPath" | "authDir" | "sessionId" | "recoveryRef" | "json" | "writeOut" | "setExitCode">): Promise<void>;
 export declare function codeModeTypesCli(options: Pick<CodeModeCliOptions, "env" | "configPath" | "projectConfigPath" | "authDir" | "json" | "writeOut">): Promise<void>;
 export declare function readCodeModeCliCode(options: Pick<CodeModeCliOptions, "inlineCode" | "file" | "readStdin">): Promise<string>;

package/dist/cli/commands.d.ts

@@ -32,7 +32,7 @@ export declare const cliCommands: {
 };
 export declare const topLevelCommandNames: readonly ["serve", "code-mode", "attach", "cloud", "init", "setup", "doctor", "list", "install", "add", "inspect", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "completion"];
 export declare const cliSubcommands: {
-    readonly add: readonly ["cli", "mcp", "openapi", "graphql", "http"];
+    readonly add: readonly ["cli", "mcp", "openapi", "google-discovery", "graphql", "http"];
     readonly auth: readonly ["login", "logout", "list", "refresh"];
     readonly cloud: readonly ["auth"];
     readonly "code-mode": readonly ["types"];

package/dist/cli.d.ts

@@ -5,7 +5,7 @@ import type { ProjectBindingWebSocketFactory } from "./project-binding/transport
 import { type ServeDaemonOperationOptions, type ServeOptions } from "./serve";
 export { initConfig, starterConfig } from "./cli/init";
 export { installCaplets, normalizeGitRepo } from "./cli/install";
-export { addCliCaplet, addGraphqlCaplet, addHttpCaplet, addMcpCaplet, addOpenApiCaplet, } from "./cli/add";
+export { addCliCaplet, addGoogleDiscoveryCaplet, addGraphqlCaplet, addHttpCaplet, addMcpCaplet, addOpenApiCaplet, } from "./cli/add";
 type CliIO = {
     writeOut?: (value: string) => void;
     writeErr?: (value: string) => void;

package/dist/code-mode/api.d.ts

@@ -1,5 +1,5 @@
 import type { NativeCapletsService } from "../native/service";
-import type { CapletsResult, CodeModeCallableCaplet, Page, PageInput, ReadLogsInput, ReadLogsResult, ToolCallResult } from "./types";
+import type { CapletsResult, CodeModeCallableCaplet, Page, PageInput, ReadCodeModeRecoveryInput, ReadCodeModeRecoveryResult, ReadLogsInput, ReadLogsResult, ToolCallResult } from "./types";
 export type CodeModeCapletHandle = {
     readonly id: string;
     inspect(): Promise<unknown>;
@@ -19,6 +19,7 @@ export type CodeModeCapletHandle = {
 };
 export type CodeModeDebugApi = {
     readLogs(input: ReadLogsInput): Promise<ReadLogsResult>;
+    readRecovery(input: ReadCodeModeRecoveryInput): Promise<ReadCodeModeRecoveryResult>;
 };
 export type CodeModeCapletsApi = {
     [capletId: string]: CodeModeCapletHandle | CodeModeDebugApi | (CodeModeCapletHandle & CodeModeDebugApi);
@@ -27,6 +28,7 @@ export type CodeModeCapletsApi = {
 export type CreateCodeModeCapletsApiInput = {
     service: NativeCapletsService;
     readLogs?: (input: ReadLogsInput) => Promise<ReadLogsResult>;
+    readRecovery?: (input: ReadCodeModeRecoveryInput) => Promise<ReadCodeModeRecoveryResult>;
 };
 export declare function listCodeModeCallableCaplets(service: NativeCapletsService): CodeModeCallableCaplet[];
 export declare function createCodeModeCapletsApi(input: CreateCodeModeCapletsApiInput): CodeModeCapletsApi;

package/dist/code-mode/diagnostics-builtins.generated.d.ts

@@ -0,0 +1 @@
+export declare const CODE_MODE_DIAGNOSTICS_BUILTINS_DECLARATION: "type CodeModeBufferEncoding=\"utf8\"|\"utf-8\"|\"base64\"|\"base64url\"|\"hex\";interface CodeModeBuffer{readonly byteLength:number;readonly length:number;toString(encoding?:CodeModeBufferEncoding):string;toUint8Array():Uint8Array;}interface CodeModeBufferConstructor{from(input:string|ArrayLike<number>|ArrayBuffer|ArrayBufferView|CodeModeBuffer,encoding?:CodeModeBufferEncoding,):CodeModeBuffer;isBuffer(value:unknown):value is CodeModeBuffer;byteLength(input:string|ArrayLike<number>|ArrayBuffer|ArrayBufferView|CodeModeBuffer,encoding?:CodeModeBufferEncoding,):number;}declare const Buffer:CodeModeBufferConstructor;declare function atob(input:string):string;declare function btoa(input:string):string;type CodeModeURLSearchParamsInit=|string|Array<[string,string]>|Record<string,string>|URLSearchParams;declare class URLSearchParams{constructor(init?:CodeModeURLSearchParamsInit);append(name:string,value:string):void;delete(name:string):void;entries():IterableIterator<[string,string]>;forEach(callback:(value:string,key:string,parent:URLSearchParams)=>void):void;get(name:string):string|null;getAll(name:string):string[];has(name:string):boolean;keys():IterableIterator<string>;set(name:string,value:string):void;toString():string;values():IterableIterator<string>;[Symbol.iterator]():IterableIterator<[string,string]>;}declare class URL{constructor(input:string|URL,base?:string|URL);readonly hash:string;readonly host:string;readonly hostname:string;readonly href:string;readonly origin:string;readonly password:string;readonly pathname:string;readonly port:string;readonly protocol:string;readonly search:string;readonly searchParams:URLSearchParams;readonly username:string;toJSON():string;toString():string;}declare class TextEncoder{readonly encoding:\"utf-8\";encode(input?:string):Uint8Array;}declare class TextDecoder{readonly encoding:\"utf-8\";constructor(label?:string);decode(input?:ArrayBuffer|ArrayBufferView):string;}interface CodeModeCrypto{randomUUID():string;getRandomValues<T extends ArrayBufferView>(typedArray:T):T;}declare const crypto:CodeModeCrypto;declare function structuredClone<T>(value:T):T;type CodeModeHeadersInit=Headers|Record<string,string>|Array<[string,string]>;declare class Headers{constructor(init?:CodeModeHeadersInit);append(name:string,value:string):void;delete(name:string):void;entries():IterableIterator<[string,string]>;forEach(callback:(value:string,key:string,parent:Headers)=>void):void;get(name:string):string|null;has(name:string):boolean;keys():IterableIterator<string>;set(name:string,value:string):void;values():IterableIterator<string>;[Symbol.iterator]():IterableIterator<[string,string]>;}type CodeModeBlobPart=string|ArrayBuffer|ArrayBufferView|Blob;type CodeModeEndingType=\"transparent\"|\"native\";declare class Blob{constructor(parts?:CodeModeBlobPart[],options?:{type?:string;endings?:CodeModeEndingType},);readonly size:number;readonly type:string;arrayBuffer():Promise<ArrayBuffer>;slice(start?:number,end?:number,type?:string):Blob;text():Promise<string>;}declare class File extends Blob{constructor(parts:CodeModeBlobPart[],name:string,options?:{type?:string;lastModified?:number},);readonly lastModified:number;readonly name:string;}declare class FormData{constructor();append(name:string,value:string|Blob,filename?:string):void;delete(name:string):void;entries():IterableIterator<[string,string|File]>;get(name:string):string|File|null;getAll(name:string):Array<string|File>;has(name:string):boolean;keys():IterableIterator<string>;set(name:string,value:string|Blob,filename?:string):void;values():IterableIterator<string|File>;[Symbol.iterator]():IterableIterator<[string,string|File]>;}type CodeModeReadableStreamReadResult<T>=|{done:false;value:T}|{done:true;value?:undefined};interface ReadableStreamDefaultController<T>{enqueue(value:T):void;close():void;}interface ReadableStreamDefaultReader<T>{read():Promise<CodeModeReadableStreamReadResult<T>>;}declare class ReadableStream<T=unknown>{constructor(source?:{start?:(controller:ReadableStreamDefaultController<T>)=>void});getReader():ReadableStreamDefaultReader<T>;}interface WritableStreamDefaultWriter<T>{write(chunk:T):Promise<void>;close():Promise<void>;}declare class WritableStream<T=unknown>{constructor(sink?:{write?:(chunk:T)=>unknown;close?:()=>unknown});getWriter():WritableStreamDefaultWriter<T>;}interface TransformStreamDefaultController<T>{enqueue(value:T):void;}declare class TransformStream<I=unknown,O=unknown>{constructor(transformer?:{transform?:(chunk:I,controller:TransformStreamDefaultController<O>)=>void;flush?:(controller:ReadableStreamDefaultController<O>)=>void;});readonly readable:ReadableStream<O>;readonly writable:WritableStream<I>;}type CodeModeAbortListener=(event:{type:\"abort\";target:AbortSignal})=>void;declare class AbortSignal{readonly aborted:boolean;readonly reason:unknown;onabort:CodeModeAbortListener|null;addEventListener(type:\"abort\",listener:CodeModeAbortListener|null):void;removeEventListener(type:\"abort\",listener:CodeModeAbortListener|null):void;dispatchEvent(event:{type:\"abort\";target:AbortSignal}):boolean;throwIfAborted():void;static abort(reason?:unknown):AbortSignal;}declare class AbortController{readonly signal:AbortSignal;abort(reason?:unknown):void;}type CodeModeBodyInit=Blob|FormData|string|ArrayBuffer|ArrayBufferView|null|undefined;interface Body{readonly body:null;readonly bodyUsed:boolean;arrayBuffer():Promise<ArrayBuffer>;blob():Promise<Blob>;formData():Promise<FormData>;json():Promise<unknown>;text():Promise<string>;}declare class Request implements Body{constructor(input:string|URL|Request,init?:{method?:string;headers?:CodeModeHeadersInit;body?:CodeModeBodyInit;signal?:AbortSignal;},);readonly body:null;readonly bodyUsed:boolean;readonly headers:Headers;readonly method:string;readonly signal:AbortSignal;readonly url:string;arrayBuffer():Promise<ArrayBuffer>;blob():Promise<Blob>;clone():Request;formData():Promise<FormData>;json():Promise<unknown>;text():Promise<string>;}declare class Response implements Body{constructor(body?:CodeModeBodyInit,init?:{headers?:CodeModeHeadersInit;status?:number;statusText?:string},);readonly body:null;readonly bodyUsed:boolean;readonly headers:Headers;readonly ok:boolean;readonly redirected:false;readonly status:number;readonly statusText:string;readonly type:\"default\";readonly url:\"\";arrayBuffer():Promise<ArrayBuffer>;blob():Promise<Blob>;clone():Response;formData():Promise<FormData>;json():Promise<unknown>;text():Promise<string>;static json(data:unknown,init?:{headers?:CodeModeHeadersInit;status?:number;statusText?:string},):Response;}declare function queueMicrotask(callback:()=>void):void;type CodeModeTimerHandler=(...args:unknown[])=>void;declare function setTimeout(callback:CodeModeTimerHandler,delay?:number,...args:unknown[]):number;declare function clearTimeout(timerId:number):void;declare function setInterval(callback:CodeModeTimerHandler,delay?:number,...args:unknown[]):number;declare function clearInterval(timerId:number):void;";

package/dist/code-mode/diagnostics.d.ts

@@ -4,5 +4,13 @@ export type DiagnoseCodeModeTypeScriptInput = {
     declaration: string;
     maxDiagnostics?: number;
     timeoutMs?: number;
+    session?: CodeModeDiagnosticsSession;
 };
 export declare function diagnoseCodeModeTypeScript(input: DiagnoseCodeModeTypeScriptInput): CodeModeDiagnostic[];
+export declare class CodeModeDiagnosticsSession {
+    #private;
+    declaration(): string;
+    recordSuccessfulCell(code: string, declaration?: string): void;
+    clear(): void;
+    private declarationExcluding;
+}

package/dist/code-mode/index.d.ts

@@ -1,3 +1,3 @@
 export { codeModeDeclarationHash, generateCodeModeDeclarations, generateCodeModeRunToolDescription, minifyCodeModeDeclarationText, } from "./declarations";
 export { hasDirectFetchCall, hasExecutableImport } from "./static-analysis";
-export type { CodeModeCallableCaplet, CodeModeDeclarationInput, CodeModeDiagnostic, CodeModeLogEntry, CodeModeLogs, CodeModeRunEnvelope, CodeModeRunError, CodeModeRunMeta, CodeModeTypesJson, JsonPrimitive, JsonValue, ReadLogsInput, ReadLogsResult, ToolCallError, ToolCallMeta, ToolCallResult, } from "./types";
+export type { CodeModeCallableCaplet, CodeModeDeclarationInput, CodeModeDiagnostic, CodeModeLogEntry, CodeModeLogs, CodeModeRecoveryClassification, CodeModeRecoveryEntry, CodeModeRunEnvelope, CodeModeRunError, CodeModeRunMeta, CodeModeSessionStatus, CodeModeTypesJson, JsonPrimitive, JsonValue, ReadCodeModeRecoveryInput, ReadCodeModeRecoveryResult, ReadLogsInput, ReadLogsResult, ToolCallError, ToolCallMeta, ToolCallResult, } from "./types";

package/dist/code-mode/journal.d.ts

@@ -0,0 +1,103 @@
+import type { CodeModeDiagnostic } from "./types";
+export type CodeModeRecoveryClassification = "setup_like" | "side_effecting" | "unknown";
+export type CodeModeJournalOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    code: string;
+    message: string;
+};
+export type CodeModeJournalEntry = {
+    timestamp: string;
+    code: string;
+    declarationHash: string;
+    outcome: CodeModeJournalOutcome;
+    diagnostics: Array<Pick<CodeModeDiagnostic, "code" | "severity" | "message">>;
+    recoveryClassification: CodeModeRecoveryClassification;
+    logsStored?: boolean;
+    summary?: string;
+};
+export type StoreCodeModeJournalEntryInput = {
+    sessionId: string;
+    journalScope?: string;
+    code: string;
+    declarationHash: string;
+    outcome: CodeModeJournalOutcome;
+    diagnostics: CodeModeDiagnostic[];
+    recoveryClassification: CodeModeRecoveryClassification;
+    logRef?: string;
+    summary?: string;
+};
+export type StoreCodeModeJournalEntryResult = {
+    recoveryRef: string;
+    expiresAt: string;
+    journalKey: string;
+};
+export type ReadCodeModeRecoveryInput = {
+    recoveryRef: string;
+    cursor?: string;
+    limit?: number;
+};
+export type ReadCodeModeRecoveryResult = {
+    entries: CodeModeJournalEntry[];
+    nextCursor?: string;
+};
+export type CodeModeJournalLookupResult = {
+    expiresAt: string;
+    recoveryRef?: string;
+};
+export type CodeModeJournalStoreOptions = {
+    stateDir?: string;
+    now?: () => Date;
+    retentionMs?: number;
+    maxEntries?: number;
+    maxCodeBytes?: number;
+    maxSummaryBytes?: number;
+    secret?: string;
+};
+export declare class CodeModeJournalStore {
+    private readonly stateDir;
+    private readonly now;
+    private readonly retentionMs;
+    private readonly maxEntries;
+    private readonly maxCodeBytes;
+    private readonly maxSummaryBytes;
+    private readonly configuredSecret;
+    private secret;
+    private recoveryRefs;
+    private sessionRecoveryRefs;
+    private nextPruneAt;
+    constructor(options?: CodeModeJournalStoreOptions);
+    store(input: StoreCodeModeJournalEntryInput): Promise<StoreCodeModeJournalEntryResult>;
+    lookupSession(sessionId: string): Promise<CodeModeJournalLookupResult | undefined>;
+    lookupRecoveryRef(recoveryRef: string): Promise<CodeModeJournalLookupResult | undefined>;
+    readRecovery(input: ReadCodeModeRecoveryInput): Promise<ReadCodeModeRecoveryResult>;
+    private entryFromInput;
+    private findByRecoveryRefHash;
+    private findBySessionIdHash;
+    private findByRecoveryRefHashSlow;
+    private findBySessionIdHashSlow;
+    private writeIndex;
+    private readIndexPath;
+    private readJournalPath;
+    private writeJournal;
+    private pruneExpired;
+    private isExpired;
+    private journalKey;
+    private recoveryRefHash;
+    private recoveryRefForJournalKey;
+    private sessionIdHash;
+    private hmac;
+    private loadSecret;
+    private ensureJournalDir;
+    private journalDir;
+    private journalPath;
+    private recoveryIndexPath;
+    private sessionIndexPath;
+    private secretPath;
+}
+export declare function classifyCodeModeRecovery(input: {
+    code: string;
+    invokedCaplet: boolean;
+    sessionDisposedAfterRun?: boolean;
+}): CodeModeRecoveryClassification;

package/dist/code-mode/platform-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/code-mode/platform-host.d.ts

@@ -0,0 +1,6 @@
+import type { QuickJSContext, QuickJSDeferredPromise } from "quickjs-emscripten";
+export type CodeModePlatformHost = {
+    dispose(): void;
+};
+export type CodeModePlatformHostOptions = Record<string, never>;
+export declare function installCodeModePlatformHost(context: QuickJSContext, pendingDeferreds: Set<QuickJSDeferredPromise>, _options: CodeModePlatformHostOptions): CodeModePlatformHost;