@caplets/core 0.18.9 → 0.20.0

package/dist/native/options.d.ts

@@ -1,15 +1,25 @@
-import { type CapletsMode, type CapletsServerEnv, type CapletsServerInput } from "../server/options";
+import { type CapletsServerEnv, type CapletsServerInput } from "../server/options";
+import { type CapletsRemoteEnv } from "../remote/options";
+type CapletsMode = "auto" | "local" | "remote" | "cloud";
 export type NativeCapletsMode = CapletsMode;
 export type NativeRemoteCapletsOptions = {
     pollIntervalMs?: number;
     fetch?: typeof fetch;
+    cloud?: NativeCloudPresenceInput;
+};
+export type NativeCloudPresenceInput = {
+    url?: string;
+    accessToken?: string;
+    workspaceId?: string;
+    projectRoot?: string;
+    heartbeatIntervalMs?: number;
 };
 export type NativeCapletsServiceResolutionInput = {
     mode?: NativeCapletsMode;
     server?: CapletsServerInput;
     remote?: NativeRemoteCapletsOptions;
 };
-export type NativeCapletsEnv = CapletsServerEnv;
+export type NativeCapletsEnv = CapletsServerEnv & CapletsRemoteEnv;
 export type NativeRemoteAuthOptions = {
     enabled: false;
     user: string;
@@ -21,13 +31,22 @@ export type NativeRemoteAuthOptions = {
 export type ResolvedNativeCapletsServiceOptions = {
     mode: "local";
 } | {
-    mode: "remote";
+    mode: "remote" | "cloud";
     remote: {
         url: URL;
         auth: NativeRemoteAuthOptions;
         pollIntervalMs: number;
         requestInit: RequestInit;
+        cloud?: ResolvedNativeCloudPresenceOptions;
         fetch?: typeof fetch;
     };
 };
 export declare function resolveNativeCapletsServiceOptions(input?: NativeCapletsServiceResolutionInput, env?: NativeCapletsEnv): ResolvedNativeCapletsServiceOptions;
+export type ResolvedNativeCloudPresenceOptions = {
+    url: URL;
+    accessToken: string;
+    workspaceId: string;
+    projectRoot?: string;
+    heartbeatIntervalMs: number;
+};
+export {};

package/dist/native/remote.d.ts

@@ -13,12 +13,13 @@ export type RemoteCapletsClient = {
     close(): Promise<void>;
 };
 export type RemoteCapletsClientOptions = ResolvedNativeCapletsServiceOptions & {
-    mode: "remote";
+    mode: "remote" | "cloud";
 };
 export type RemoteNativeCapletsServiceOptions = {
     client: RemoteCapletsClient;
     clientFactory?: () => RemoteCapletsClient;
     pollIntervalMs: number;
+    authKind?: "self_hosted_remote" | "hosted_cloud";
     writeErr?: (value: string) => void;
 };
 export declare function createSdkRemoteCapletsClient(options: RemoteCapletsClientOptions["remote"]): RemoteCapletsClient;

package/dist/native/service.d.ts

@@ -1,6 +1,7 @@
 import type { NativeCapletsServiceResolutionInput } from "./options";
 import { resolveNativeCapletsServiceOptions } from "./options";
 import { type RemoteCapletsClient } from "./remote";
+import type { CodeModeCallableCaplet } from "../code-mode/types";
 import { type CapletsConfig } from "../config";
 import { generatedToolInputJsonSchemaForCaplet } from "../generated-tool-input-schema";
 export type NativeCapletsServiceOptions = NativeCapletsServiceResolutionInput & {
@@ -10,9 +11,7 @@ export type NativeCapletsServiceOptions = NativeCapletsServiceResolutionInput &
     watchDebounceMs?: number;
     watch?: boolean;
     writeErr?: (value: string) => void;
-    remoteClientFactory?: (options: Extract<ReturnType<typeof resolveNativeCapletsServiceOptions>, {
-        mode: "remote";
-    }>["remote"]) => RemoteCapletsClient;
+    remoteClientFactory?: (options: ResolvedNativeRemoteOptions) => RemoteCapletsClient;
     localServiceFactory?: (options: LocalNativeCapletsServiceOptions) => NativeCapletsService;
 };
 export type NativeCapletTool = {
@@ -20,9 +19,14 @@ export type NativeCapletTool = {
     toolName: string;
     title: string;
     description: string;
+    codeModeRun?: boolean;
+    useWhen?: string;
+    avoidWhen?: string;
     promptGuidance: string[];
     inputSchema?: ReturnType<typeof generatedToolInputJsonSchemaForCaplet> | Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
     operationNames?: string[];
+    codeModeCaplets?: CodeModeCallableCaplet[];
 };
 export type NativeCapletsToolsChangedListener = (tools: NativeCapletTool[]) => void;
 export type NativeCapletsService = {
@@ -33,7 +37,13 @@ export type NativeCapletsService = {
     close(): Promise<void>;
 };
 export declare function createNativeCapletsService(options?: NativeCapletsServiceOptions): NativeCapletsService;
+export declare function resetNativeProjectBindingFallbackWarningForTests(): void;
 type LocalNativeCapletsServiceOptions = NativeCapletsServiceOptions & {
     configLoader?: (configPath: string, projectConfigPath: string) => CapletsConfig;
 };
+type ResolvedNativeRemoteOptions = Extract<Exclude<ReturnType<typeof resolveNativeCapletsServiceOptions>, {
+    mode: "local";
+}>, {
+    remote: unknown;
+}>["remote"];
 export {};

package/dist/native/tools.d.ts

@@ -1,4 +1,6 @@
 import type { CapletConfig } from "../config";
+export declare const nativeCodeModeToolId = "code_mode";
+export declare const nativeCodeModeToolName = "caplets__code_mode";
 export declare function nativeCapletToolName(capletId: string): string;
 export declare function nativeCapletsSystemGuidance(toolNames: string[]): string;
 export declare function nativeCapletPromptGuidance(toolName: string, caplet: CapletConfig): string[];

package/dist/native.d.ts

@@ -1,6 +1,6 @@
 export { createNativeCapletsService, type NativeCapletTool, type NativeCapletsService, type NativeCapletsServiceOptions, type NativeCapletsToolsChangedListener, } from "./native/service";
 export { registerNativeCapletsProcessCleanup, type NativeCapletsProcessCleanupOptions, } from "./native/process-cleanup";
-export { nativeCapletPromptGuidance, nativeCapletToolDescription, nativeCapletToolName, nativeCapletsSystemGuidance, } from "./native/tools";
+export { nativeCapletPromptGuidance, nativeCapletToolDescription, nativeCapletToolName, nativeCapletsSystemGuidance, nativeCodeModeToolId, nativeCodeModeToolName, } from "./native/tools";
 export { generatedToolInputSchema } from "./tools";
 export { generatedToolInputJsonSchema } from "./generated-tool-input-schema";
 export { resolveNativeCapletsServiceOptions, type NativeCapletsEnv, type NativeCapletsMode, type NativeCapletsServiceResolutionInput, type NativeRemoteAuthOptions, type NativeRemoteCapletsOptions, type ResolvedNativeCapletsServiceOptions, } from "./native/options";

package/dist/native.js

@@ -1,433 +1,5 @@
-import { Pt as CapletsError, Q as ToolListChangedNotificationSchema, _ as StreamableHTTPClientTransport, a as resolveCapletsServer, b as Client, bt as parseConfig, i as resolveCapletsMode, l as capabilityDescription, n as mcpUrlForBase, o as CapletsEngine, vt as loadLocalOverlayConfigWithSources } from "./options-DnOUjft1.js";
-import { a as generatedToolInputJsonSchemaForCaplet, i as generatedToolInputJsonSchema, l as operations, o as generatedToolInputSchema } from "./generated-tool-input-schema--kVuUNc5.js";
-//#region src/native/options.ts
-const DEFAULT_POLL_INTERVAL_MS = 3e4;
-function resolveNativeCapletsServiceOptions(input = {}, env = process.env) {
-	if (resolveCapletsMode({
-		...input.mode ? { mode: input.mode } : {},
-		...input.server?.url ? { serverUrl: input.server.url } : {}
-	}, env).mode === "local") return { mode: "local" };
-	const serverFetch = input.remote?.fetch ?? input.server?.fetch;
-	const server = resolveCapletsServer({
-		...input.server,
-		...serverFetch ? { fetch: serverFetch } : {}
-	}, env);
-	return {
-		mode: "remote",
-		remote: {
-			url: mcpUrlForBase(server.baseUrl),
-			auth: server.auth,
-			pollIntervalMs: parsePollInterval(input.remote?.pollIntervalMs),
-			requestInit: server.requestInit,
-			...server.fetch ? { fetch: server.fetch } : {}
-		}
-	};
-}
-function parsePollInterval(value) {
-	if (value === void 0) return DEFAULT_POLL_INTERVAL_MS;
-	if (!Number.isInteger(value) || value < 1e3) throw new CapletsError("REQUEST_INVALID", "remote.pollIntervalMs must be an integer >= 1000.");
-	return value;
-}
-//#endregion
-//#region src/native/tools.ts
-function nativeCapletToolName(capletId) {
-	return `caplets_${capletId.replace(/_/g, "__").replace(/-/g, "_")}`;
-}
-function nativeCapletsSystemGuidance(toolNames) {
-	return [
-		"## Caplets Native Tools",
-		"",
-		"Caplets tools expose configured capability domains through progressive discovery.",
-		"",
-		"Available Caplets native tools:",
-		toolNames.length > 0 ? toolNames.map((tool) => `- ${tool}`).join("\n") : "- none",
-		"",
-		"Flow: inspect when the domain is unfamiliar; use search_tools/list_tools for actions; MCP-backed Caplets may also expose resources, prompts, and completions in their tool schema.",
-		"Use fields on call_tool when a non-GraphQL downstream outputSchema allows selecting only needed structured paths."
-	].join("\n");
-}
-function nativeCapletPromptGuidance(toolName, caplet) {
-	return caplet.backend === "mcp" ? [`Use ${toolName} for the ${caplet.name} Caplet capability domain.`, "Prefer resources for readable context, prompts for reusable workflows, and tools for actions."] : [`Use ${toolName} for the ${caplet.name} Caplet capability domain.`];
-}
-function nativeCapletToolDescription(toolName, caplet) {
-	return [
-		capabilityDescription(caplet),
-		"",
-		`Native tool name: ${toolName}`,
-		`Original Caplet ID: ${caplet.server}`
-	].join("\n");
-}
-//#endregion
-//#region src/native/remote.ts
-function createSdkRemoteCapletsClient(options) {
-	const client = new Client({
-		name: "caplets-native",
-		version: "1.0.0"
-	}, { capabilities: {} });
-	const transport = new StreamableHTTPClientTransport(options.url, {
-		requestInit: options.requestInit,
-		...options.fetch ? { fetch: options.fetch } : {}
-	});
-	const ready = client.connect(transport);
-	const readyObserved = ready.catch(() => void 0);
-	const listeners = /* @__PURE__ */ new Set();
-	client.setNotificationHandler(ToolListChangedNotificationSchema, () => {
-		for (const listener of listeners) listener();
-	});
-	return {
-		async listTools() {
-			await ready;
-			return ((await client.listTools()).tools ?? []).map((tool) => ({
-				name: tool.name,
-				...tool.title ? { title: tool.title } : {},
-				...tool.description ? { description: tool.description } : {},
-				...tool.inputSchema ? { inputSchema: tool.inputSchema } : {}
-			}));
-		},
-		async callTool(name, args) {
-			await ready;
-			const toolArguments = args && typeof args === "object" && !Array.isArray(args) ? args : void 0;
-			return await client.callTool({
-				name,
-				arguments: toolArguments
-			});
-		},
-		onToolsChanged(listener) {
-			listeners.add(listener);
-			return () => listeners.delete(listener);
-		},
-		async close() {
-			listeners.clear();
-			await readyObserved;
-			await transport.terminateSession().catch(() => void 0);
-			await client.close();
-		}
-	};
-}
-var RemoteNativeCapletsService = class {
-	options;
-	tools = [];
-	listeners = /* @__PURE__ */ new Set();
-	clientFactory;
-	client;
-	unsubscribeRemote;
-	pollTimer;
-	closed = false;
-	resetInFlight;
-	constructor(options) {
-		this.options = options;
-		this.client = options.client;
-		this.clientFactory = options.clientFactory ?? (() => options.client);
-		this.unsubscribeRemote = this.subscribeRemote(this.client);
-		this.pollTimer = setInterval(() => {
-			this.reload();
-		}, options.pollIntervalMs);
-		this.pollTimer.unref?.();
-	}
-	listTools() {
-		return [...this.tools];
-	}
-	async execute(capletId, request) {
-		try {
-			return await this.client.callTool(capletId, request);
-		} catch (error) {
-			if (isAuthFailure(error)) throw remoteAuthError();
-			if (isSessionFailure(error)) {
-				if (!await this.resetClient() || this.closed) throw error;
-				try {
-					return await this.client.callTool(capletId, request);
-				} catch (retryError) {
-					if (isAuthFailure(retryError)) throw remoteAuthError();
-					throw retryError;
-				}
-			}
-			throw error;
-		}
-	}
-	async reload() {
-		if (this.closed) return false;
-		try {
-			await this.reloadFromClient();
-			return true;
-		} catch (error) {
-			if (isSessionFailure(error)) try {
-				if (!await this.resetClient() || this.closed) return false;
-				await this.reloadFromClient();
-				return !this.closed;
-			} catch (retryError) {
-				this.warn(`Could not reload remote Caplets tools: ${errorMessage$2(retryError)}\n`);
-				return false;
-			}
-			this.warn(`Could not reload remote Caplets tools: ${errorMessage$2(error)}\n`);
-			return false;
-		}
-	}
-	onToolsChanged(listener) {
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
-	}
-	async close() {
-		if (this.closed) return;
-		this.closed = true;
-		clearInterval(this.pollTimer);
-		this.unsubscribeRemote();
-		this.listeners.clear();
-		await this.client.close();
-	}
-	async reloadFromClient() {
-		const tools = (await this.client.listTools()).map(remoteToolToNativeTool);
-		const changed = JSON.stringify(tools) !== JSON.stringify(this.tools);
-		this.tools = tools;
-		if (changed) this.emitToolsChanged();
-	}
-	subscribeRemote(client) {
-		return client.onToolsChanged(() => {
-			this.reload();
-		});
-	}
-	async resetClient() {
-		if (this.resetInFlight) return await this.resetInFlight;
-		this.resetInFlight = this.doResetClient();
-		try {
-			return await this.resetInFlight;
-		} finally {
-			this.resetInFlight = void 0;
-		}
-	}
-	async doResetClient() {
-		if (this.closed) return false;
-		this.unsubscribeRemote();
-		await this.client.close().catch(() => void 0);
-		if (this.closed) return false;
-		const nextClient = this.clientFactory();
-		if (this.closed) {
-			await nextClient.close().catch(() => void 0);
-			return false;
-		}
-		this.client = nextClient;
-		this.unsubscribeRemote = this.subscribeRemote(this.client);
-		return true;
-	}
-	emitToolsChanged() {
-		const tools = this.listTools();
-		for (const listener of this.listeners) listener(tools);
-	}
-	warn(message) {
-		this.options.writeErr?.(message);
-	}
-};
-function remoteToolToNativeTool(tool) {
-	const toolName = nativeCapletToolName(tool.name);
-	const inputSchema = isPlainObject(tool.inputSchema) ? tool.inputSchema : generatedToolInputJsonSchemaForCaplet({ backend: "tool" });
-	return {
-		caplet: tool.name,
-		toolName,
-		title: tool.title ?? tool.name,
-		description: [
-			tool.description ?? "Remote Caplets tool.",
-			"",
-			`Native tool name: ${toolName}`,
-			`Remote Caplet ID: ${tool.name}`
-		].join("\n"),
-		promptGuidance: [`Use ${toolName} through the remote Caplets service.`],
-		inputSchema,
-		operationNames: operationNamesFromSchema(inputSchema)
-	};
-}
-function operationNamesFromSchema(schema) {
-	const properties = schema.properties;
-	if (!isPlainObject(properties)) return [...operations];
-	const operation = properties.operation;
-	if (!isPlainObject(operation) || !Array.isArray(operation.enum)) return [...operations];
-	return operation.enum.filter((value) => typeof value === "string");
-}
-function isPlainObject(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function errorMessage$2(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function remoteAuthError() {
-	return new CapletsError("AUTH_FAILED", "Remote Caplets authentication failed; check CAPLETS_SERVER_USER and CAPLETS_SERVER_PASSWORD.");
-}
-function isSessionFailure(error) {
-	const message = errorMessage$2(error).toLowerCase();
-	return /session|transport|connection|connect|closed|invalid/u.test(message);
-}
-function isAuthFailure(error) {
-	const candidate = error;
-	const status = typeof candidate?.status === "number" ? candidate.status : void 0;
-	const statusCode = typeof candidate?.statusCode === "number" ? candidate.statusCode : void 0;
-	const code = typeof candidate?.code === "number" ? candidate.code : void 0;
-	if (status === 401 || status === 403 || statusCode === 401 || statusCode === 403 || code === 401 || code === 403) return true;
-	return /\b(401|403|unauthorized|forbidden)\b/iu.test(errorMessage$2(error));
-}
-//#endregion
-//#region src/native/service.ts
-function createNativeCapletsService(options = {}) {
-	const resolved = resolveNativeCapletsServiceOptions(options);
-	if (resolved.mode === "remote") {
-		const localOptions = {
-			...options,
-			mode: "local",
-			configLoader: createLocalOverlayConfigLoader(options)
-		};
-		const local = (options.localServiceFactory ?? createDefaultNativeCapletsService)(localOptions);
-		try {
-			return new CompositeNativeCapletsService(new RemoteNativeCapletsService({
-				client: (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
-				clientFactory: () => (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
-				pollIntervalMs: resolved.remote.pollIntervalMs,
-				...options.writeErr ? { writeErr: options.writeErr } : {}
-			}), local, options);
-		} catch (error) {
-			local.close().catch((closeError) => {
-				writeErr(options, `Could not close local overlay Caplets service: ${errorMessage$1(closeError)}\n`);
-			});
-			throw error;
-		}
-	}
-	return new DefaultNativeCapletsService(options);
-}
-var DefaultNativeCapletsService = class {
-	engine;
-	constructor(options) {
-		this.engine = new CapletsEngine({
-			...options,
-			writeErr: options.writeErr ?? (() => void 0)
-		});
-	}
-	listTools() {
-		return this.engine.enabledServers().map((caplet) => {
-			const toolName = nativeCapletToolName(caplet.server);
-			const inputSchema = generatedToolInputJsonSchemaForCaplet(caplet);
-			return {
-				caplet: caplet.server,
-				toolName,
-				title: caplet.name,
-				description: nativeCapletToolDescription(toolName, caplet),
-				promptGuidance: nativeCapletPromptGuidance(toolName, caplet),
-				inputSchema,
-				operationNames: [...inputSchema.properties.operation.enum]
-			};
-		});
-	}
-	async execute(capletId, request) {
-		return await this.engine.execute(capletId, request);
-	}
-	async reload() {
-		return await this.engine.reload();
-	}
-	onToolsChanged(listener) {
-		return this.engine.onReload(() => listener(this.listTools()));
-	}
-	async close() {
-		await this.engine.close();
-	}
-};
-function createDefaultNativeCapletsService(options) {
-	return new DefaultNativeCapletsService(options);
-}
-var CompositeNativeCapletsService = class {
-	remote;
-	local;
-	options;
-	listeners = /* @__PURE__ */ new Set();
-	unsubscribers;
-	tools = [];
-	closed = false;
-	batchingReload = false;
-	constructor(remote, local, options) {
-		this.remote = remote;
-		this.local = local;
-		this.options = options;
-		this.unsubscribers = [this.remote.onToolsChanged(() => this.updateMergedTools()), this.local.onToolsChanged(() => this.updateMergedTools())];
-		this.tools = this.mergeTools();
-	}
-	listTools() {
-		return [...this.tools];
-	}
-	async execute(capletId, request) {
-		if (this.local.listTools().some((tool) => tool.caplet === capletId)) return await this.local.execute(capletId, request);
-		return await this.remote.execute(capletId, request);
-	}
-	async reload() {
-		if (this.closed) return false;
-		this.batchingReload = true;
-		const remoteReloaded = await this.reloadChild(this.remote, "remote");
-		const localReloaded = await this.reloadChild(this.local, "local overlay");
-		this.batchingReload = false;
-		if (remoteReloaded === void 0 || localReloaded === void 0) return false;
-		this.updateMergedTools();
-		return remoteReloaded || localReloaded;
-	}
-	onToolsChanged(listener) {
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
-	}
-	async close() {
-		if (this.closed) return;
-		this.closed = true;
-		for (const unsubscribe of this.unsubscribers.splice(0)) unsubscribe();
-		this.listeners.clear();
-		await Promise.all([this.remote.close(), this.local.close()]);
-	}
-	updateMergedTools() {
-		if (this.closed || this.batchingReload) return;
-		const tools = this.mergeTools();
-		if (JSON.stringify(tools) === JSON.stringify(this.tools)) return;
-		this.tools = tools;
-		for (const listener of this.listeners) try {
-			listener(this.listTools());
-		} catch (error) {
-			writeErr(this.options, `Caplets tools-changed listener failed: ${errorMessage$1(error)}\n`);
-		}
-	}
-	mergeTools() {
-		const localTools = this.local.listTools();
-		const localIds = new Set(localTools.map((tool) => tool.caplet));
-		return [...this.remote.listTools().filter((tool) => !localIds.has(tool.caplet)), ...localTools];
-	}
-	async reloadChild(service, label) {
-		try {
-			return await service.reload();
-		} catch (error) {
-			writeErr(this.options, `Could not reload composite Caplets tools from ${label}: ${errorMessage$1(error)}\n`);
-			return;
-		}
-	}
-};
-function createLocalOverlayConfigLoader(options) {
-	let hasLoaded = false;
-	let previousWarnings = /* @__PURE__ */ new Set();
-	return (configPath, projectConfigPath) => {
-		let result;
-		try {
-			result = loadLocalOverlayConfigWithSources(configPath, projectConfigPath);
-		} catch (error) {
-			writeErr(options, `Caplets local overlay warning: Could not load local overlay config: ${errorMessage$1(error)}\n`);
-			if (hasLoaded) throw new CapletsError("CONFIG_INVALID", "Caplets local overlay reload failed; keeping last known-good config.", error);
-			hasLoaded = true;
-			return parseConfig({});
-		}
-		for (const warning of result.warnings) writeErr(options, `Caplets local overlay warning${typeof warning.path === "string" ? ` at ${warning.path}` : ""}: ${warning.message}\n`);
-		const warnings = new Set(result.warnings.map(warningKey));
-		if (hasLoaded && [...warnings].some((warning) => !previousWarnings.has(warning))) throw new CapletsError("CONFIG_INVALID", "Caplets local overlay reload produced new warnings; keeping last known-good config.");
-		previousWarnings = warnings;
-		hasLoaded = true;
-		return result.config;
-	};
-}
-function warningKey(warning) {
-	return `${warning.kind}\0${warning.path}\0${warning.message}`;
-}
-function writeErr(options, message) {
-	options.writeErr?.(message);
-}
-function errorMessage$1(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-//#endregion
+import { C as nativeCapletToolName, E as nativeCodeModeToolName, S as nativeCapletToolDescription, T as nativeCodeModeToolId, f as RemoteNativeCapletsService, h as resolveNativeCapletsServiceOptions, p as createSdkRemoteCapletsClient, t as createNativeCapletsService, w as nativeCapletsSystemGuidance, x as nativeCapletPromptGuidance } from "./service-D0MwLNyb.js";
+import { generatedToolInputJsonSchema, generatedToolInputSchema } from "./generated-tool-input-schema.js";
 //#region src/native/process-cleanup.ts
 function registerNativeCapletsProcessCleanup(service, options = {}) {
 	let closed = false;
@@ -457,4 +29,4 @@ function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
-export { RemoteNativeCapletsService, createNativeCapletsService, createSdkRemoteCapletsClient, generatedToolInputJsonSchema, generatedToolInputSchema, nativeCapletPromptGuidance, nativeCapletToolDescription, nativeCapletToolName, nativeCapletsSystemGuidance, registerNativeCapletsProcessCleanup, resolveNativeCapletsServiceOptions };
+export { RemoteNativeCapletsService, createNativeCapletsService, createSdkRemoteCapletsClient, generatedToolInputJsonSchema, generatedToolInputSchema, nativeCapletPromptGuidance, nativeCapletToolDescription, nativeCapletToolName, nativeCapletsSystemGuidance, nativeCodeModeToolId, nativeCodeModeToolName, registerNativeCapletsProcessCleanup, resolveNativeCapletsServiceOptions };

package/dist/observed-output-shapes/extract.d.ts

@@ -0,0 +1,5 @@
+import { type ExtractObservedOutputShapeInput, type JsonShape, type ObservedOutputShape } from "./types";
+export declare function observeOutputShape(input: ExtractObservedOutputShapeInput): ObservedOutputShape | undefined;
+export declare function extractJsonShape(value: unknown): JsonShape | undefined;
+export declare function parseShapeableJsonText(value: unknown): unknown | undefined;
+export declare function normalizedObservableValue(result: unknown): unknown | undefined;

package/dist/observed-output-shapes/file-store.d.ts

@@ -0,0 +1,17 @@
+import { type ObservedOutputShape, type ObservedOutputShapeKey, type ObservedOutputShapePruneResult, type ObservedOutputShapeStore, type ObservedOutputShapeStoreHealth } from "./types";
+export declare class FileObservedOutputShapeStore implements ObservedOutputShapeStore {
+    private readonly cacheDir;
+    private readonly options;
+    constructor(cacheDir: string, options?: {
+        ttlMs?: number | undefined;
+        maxEntries?: number | undefined;
+    });
+    read(key: ObservedOutputShapeKey): Promise<ObservedOutputShape | undefined>;
+    write(key: ObservedOutputShapeKey, shape: ObservedOutputShape): Promise<void>;
+    prune(now?: Date): Promise<ObservedOutputShapePruneResult>;
+    health(): Promise<ObservedOutputShapeStoreHealth>;
+    private pathFor;
+    private entries;
+    private ttlMs;
+    private maxEntries;
+}

package/dist/observed-output-shapes/index.d.ts

@@ -0,0 +1,7 @@
+export { FileObservedOutputShapeStore } from "./file-store";
+export { extractJsonShape, normalizedObservableValue, observeOutputShape, parseShapeableJsonText, } from "./extract";
+export { backendFingerprint, observedOutputShapeKey, observedOutputShapeStorageKey, stableHash, } from "./key";
+export { mergeJsonShapes } from "./merge";
+export { usefulOutputSchema } from "./schema";
+export { hasTruncatedShape, shapeToTypeScript, shapeType } from "./typescript";
+export { OBSERVED_OUTPUT_SHAPE_LIMITS, OBSERVED_OUTPUT_SHAPE_VERSION, type JsonShape, type ObservedOutputShape, type ObservedOutputShapeKey, type ObservedOutputShapePruneResult, type ObservedOutputShapeStore, type ObservedOutputShapeStoreHealth, } from "./types";

package/dist/observed-output-shapes/key.d.ts

@@ -0,0 +1,14 @@
+import type { CapletConfig } from "../config";
+import { type ObservedOutputShapeKey } from "./types";
+export declare function observedOutputShapeStorageKey(key: ObservedOutputShapeKey): string;
+export declare function observedOutputShapeKey(input: {
+    scope: ObservedOutputShapeKey["scope"];
+    workspaceId?: string | undefined;
+    projectFingerprint?: string | undefined;
+    caplet: CapletConfig;
+    toolName: string;
+    toolDescriptor?: unknown;
+    outputSchema?: unknown;
+}): ObservedOutputShapeKey;
+export declare function backendFingerprint(caplet: CapletConfig): string;
+export declare function stableHash(value: unknown): string;

package/dist/observed-output-shapes/merge.d.ts

@@ -0,0 +1,2 @@
+import { type JsonShape } from "./types";
+export declare function mergeJsonShapes(left: JsonShape, right: JsonShape): JsonShape;

package/dist/observed-output-shapes/pure.d.ts

@@ -0,0 +1,5 @@
+export { extractJsonShape, normalizedObservableValue, observeOutputShape, parseShapeableJsonText, } from "./extract";
+export { mergeJsonShapes } from "./merge";
+export { usefulOutputSchema } from "./schema";
+export { hasTruncatedShape, shapeToTypeScript, shapeType } from "./typescript";
+export { OBSERVED_OUTPUT_SHAPE_LIMITS, OBSERVED_OUTPUT_SHAPE_VERSION, type JsonShape, type ObservedOutputShape, type ExtractObservedOutputShapeInput, } from "./types";