@caplets/core 0.15.0 → 0.17.0

package/dist/native/options.d.ts

@@ -0,0 +1,33 @@
+import { type CapletsMode, type CapletsServerEnv, type CapletsServerInput } from "../server/options";
+export type NativeCapletsMode = CapletsMode;
+export type NativeRemoteCapletsOptions = {
+    pollIntervalMs?: number;
+    fetch?: typeof fetch;
+};
+export type NativeCapletsServiceResolutionInput = {
+    mode?: NativeCapletsMode;
+    server?: CapletsServerInput;
+    remote?: NativeRemoteCapletsOptions;
+};
+export type NativeCapletsEnv = CapletsServerEnv;
+export type NativeRemoteAuthOptions = {
+    enabled: false;
+    user: string;
+} | {
+    enabled: true;
+    user: string;
+    password: string;
+};
+export type ResolvedNativeCapletsServiceOptions = {
+    mode: "local";
+} | {
+    mode: "remote";
+    remote: {
+        url: URL;
+        auth: NativeRemoteAuthOptions;
+        pollIntervalMs: number;
+        requestInit: RequestInit;
+        fetch?: typeof fetch;
+    };
+};
+export declare function resolveNativeCapletsServiceOptions(input?: NativeCapletsServiceResolutionInput, env?: NativeCapletsEnv): ResolvedNativeCapletsServiceOptions;

package/dist/native/remote.d.ts

@@ -0,0 +1,46 @@
+import type { ResolvedNativeCapletsServiceOptions } from "./options";
+import type { NativeCapletsService, NativeCapletsToolsChangedListener, NativeCapletTool } from "./service";
+export type RemoteCapletsTool = {
+    name: string;
+    title?: string | undefined;
+    description?: string | undefined;
+};
+export type RemoteCapletsClient = {
+    listTools(): Promise<RemoteCapletsTool[]>;
+    callTool(name: string, args: unknown): Promise<unknown>;
+    onToolsChanged(listener: () => void): () => void;
+    close(): Promise<void>;
+};
+export type RemoteCapletsClientOptions = ResolvedNativeCapletsServiceOptions & {
+    mode: "remote";
+};
+export type RemoteNativeCapletsServiceOptions = {
+    client: RemoteCapletsClient;
+    clientFactory?: () => RemoteCapletsClient;
+    pollIntervalMs: number;
+    writeErr?: (value: string) => void;
+};
+export declare function createSdkRemoteCapletsClient(options: RemoteCapletsClientOptions["remote"]): RemoteCapletsClient;
+export declare class RemoteNativeCapletsService implements NativeCapletsService {
+    private readonly options;
+    private tools;
+    private readonly listeners;
+    private readonly clientFactory;
+    private client;
+    private unsubscribeRemote;
+    private readonly pollTimer;
+    private closed;
+    private resetInFlight;
+    constructor(options: RemoteNativeCapletsServiceOptions);
+    listTools(): NativeCapletTool[];
+    execute(capletId: string, request: unknown): Promise<unknown>;
+    reload(): Promise<boolean>;
+    onToolsChanged(listener: NativeCapletsToolsChangedListener): () => void;
+    close(): Promise<void>;
+    private reloadFromClient;
+    private subscribeRemote;
+    private resetClient;
+    private doResetClient;
+    private emitToolsChanged;
+    private warn;
+}

package/dist/native/service.d.ts

@@ -1,10 +1,16 @@
-export type NativeCapletsServiceOptions = {
+import type { NativeCapletsServiceResolutionInput } from "./options";
+import { resolveNativeCapletsServiceOptions } from "./options";
+import { type RemoteCapletsClient } from "./remote";
+export type NativeCapletsServiceOptions = NativeCapletsServiceResolutionInput & {
     configPath?: string;
     projectConfigPath?: string;
     authDir?: string;
     watchDebounceMs?: number;
     watch?: boolean;
     writeErr?: (value: string) => void;
+    remoteClientFactory?: (options: Extract<ReturnType<typeof resolveNativeCapletsServiceOptions>, {
+        mode: "remote";
+    }>["remote"]) => RemoteCapletsClient;
 };
 export type NativeCapletTool = {
     caplet: string;

package/dist/native.d.ts

@@ -3,3 +3,5 @@ export { registerNativeCapletsProcessCleanup } from "./native/process-cleanup";
 export { nativeCapletPromptGuidance, nativeCapletToolDescription, nativeCapletToolName, nativeCapletsSystemGuidance, } 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";
+export { createSdkRemoteCapletsClient, RemoteNativeCapletsService, type RemoteCapletsClient, type RemoteCapletsClientOptions, type RemoteCapletsTool, type RemoteNativeCapletsServiceOptions, } from "./native/remote";

package/dist/native.js

@@ -1,5 +1,34 @@
-import { a as capabilityDescription, n as generatedToolInputSchema, t as CapletsEngine } from "./engine-Bh55p8Lm.js";
+import { $ as ToolListChangedNotificationSchema, Nt as CapletsError, a as resolveCapletsServer, i as resolveCapletsMode, n as mcpUrlForBase, o as CapletsEngine, s as generatedToolInputSchema, u as capabilityDescription, v as StreamableHTTPClientTransport, x as Client } from "./options-CJEOqS87.js";
 import { generatedToolInputJsonSchema } from "./generated-tool-input-schema.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, "_")}`;
@@ -29,8 +58,210 @@ function nativeCapletToolDescription(toolName, caplet) {
 	].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 } : {}
+			}));
+		},
+		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(retryError)}\n`);
+				return false;
+			}
+			this.warn(`Could not reload remote Caplets tools: ${errorMessage(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) {
+		if (this.options.writeErr) {
+			this.options.writeErr(message);
+			return;
+		}
+		process.stderr.write(message);
+	}
+};
+function remoteToolToNativeTool(tool) {
+	const toolName = nativeCapletToolName(tool.name);
+	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.`]
+	};
+}
+function errorMessage(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(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(error));
+}
+//#endregion
 //#region src/native/service.ts
 function createNativeCapletsService(options = {}) {
+	const resolved = resolveNativeCapletsServiceOptions(options);
+	if (resolved.mode === "remote") return new RemoteNativeCapletsService({
+		client: (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
+		clientFactory: () => (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
+		pollIntervalMs: resolved.remote.pollIntervalMs,
+		...options.writeErr ? { writeErr: options.writeErr } : {}
+	});
 	return new DefaultNativeCapletsService(options);
 }
 var DefaultNativeCapletsService = class {
@@ -90,4 +321,4 @@ function registerNativeCapletsProcessCleanup(service) {
 	process.once("SIGTERM", closeAndExit);
 }
 //#endregion
-export { createNativeCapletsService, generatedToolInputJsonSchema, generatedToolInputSchema, nativeCapletPromptGuidance, nativeCapletToolDescription, nativeCapletToolName, nativeCapletsSystemGuidance, registerNativeCapletsProcessCleanup };
+export { RemoteNativeCapletsService, createNativeCapletsService, createSdkRemoteCapletsClient, generatedToolInputJsonSchema, generatedToolInputSchema, nativeCapletPromptGuidance, nativeCapletToolDescription, nativeCapletToolName, nativeCapletsSystemGuidance, registerNativeCapletsProcessCleanup, resolveNativeCapletsServiceOptions };