@openclaw/lobster 2026.7.2-beta.5 → 2026.7.33

package/dist/index.js

@@ -1,18 +1,137 @@
+import { createRequire } from "node:module";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { optionalNonNegativeIntegerSchema, optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
 import { readNonNegativeIntegerParam, readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
+import { readFileSync } from "node:fs";
 import { stat } from "node:fs/promises";
 import path from "node:path";
 import { Readable, Writable } from "node:stream";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+//#region extensions/lobster/src/lobster-ajv-cache.ts
+const installedSymbol = Symbol.for("openclaw.lobster.ajv-compile-cache.installed");
+const cacheSymbol = Symbol.for("openclaw.lobster.ajv-compile-cache.entries");
+const maxEntries = 512;
+function stableJsonStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (seen.has(value)) throw new TypeError("Cannot cache cyclic JSON schema");
+	seen.add(value);
+	if (Array.isArray(value)) {
+		const items = value.map((entry) => stableJsonStringify(entry, seen));
+		seen.delete(value);
+		return `[${items.join(",")}]`;
+	}
+	const record = value;
+	const properties = Object.keys(record).toSorted().filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${stableJsonStringify(record[key], seen)}`);
+	seen.delete(value);
+	return `{${properties.join(",")}}`;
+}
+function compileCacheKey(schema) {
+	try {
+		return createHash("sha256").update(stableJsonStringify(schema)).digest("hex");
+	} catch {
+		return null;
+	}
+}
+function readCompileCache(instance) {
+	let cache = instance[cacheSymbol];
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		Object.defineProperty(instance, cacheSymbol, {
+			value: cache,
+			configurable: true
+		});
+	}
+	return cache;
+}
+function rememberCompiledValidator(params) {
+	const { cache, instance, key, removeSchema, schema, validate } = params;
+	if (!cache.has(key) && cache.size >= maxEntries) {
+		const oldest = cache.keys().next().value;
+		if (oldest !== void 0) {
+			const evicted = cache.get(oldest);
+			cache.delete(oldest);
+			if (evicted) removeSchema.call(instance, evicted.schema);
+		}
+	}
+	cache.set(key, {
+		schema,
+		validate
+	});
+}
+async function resolveLobsterAjvConstructor(packageEntryPath) {
+	const ajvPath = createRequire(packageEntryPath).resolve("ajv");
+	const ajvModule = await import(pathToFileURL(ajvPath).href);
+	return ajvModule.default ?? ajvModule;
+}
+async function installLobsterAjvCompileCache(packageEntryPath) {
+	let AjvCtor;
+	try {
+		AjvCtor = await resolveLobsterAjvConstructor(packageEntryPath);
+	} catch {
+		return;
+	}
+	const proto = AjvCtor.prototype;
+	if (proto[installedSymbol]) return;
+	const originalCompile = proto.compile;
+	const originalRemoveSchema = proto.removeSchema;
+	Object.defineProperty(proto, installedSymbol, {
+		value: true,
+		configurable: true
+	});
+	proto.compile = function compileWithContentCache(schema) {
+		const key = compileCacheKey(schema);
+		if (!key) return originalCompile.call(this, schema);
+		const cache = readCompileCache(this);
+		const cached = cache.get(key);
+		if (cached) return cached.validate;
+		const validate = originalCompile.call(this, schema);
+		rememberCompiledValidator({
+			cache,
+			instance: this,
+			key,
+			removeSchema: originalRemoveSchema,
+			schema,
+			validate
+		});
+		return validate;
+	};
+	proto.removeSchema = function removeSchemaAndClearContentCache(schemaKeyRef) {
+		this[cacheSymbol]?.clear();
+		return originalRemoveSchema.call(this, schemaKeyRef);
+	};
+}
+//#endregion
 //#region extensions/lobster/src/lobster-runner.ts
+const lobsterRequire = createRequire(import.meta.url);
 const workflowExts = /* @__PURE__ */ new Set([
 	".lobster",
 	".yaml",
 	".yml",
 	".json"
 ]);
+function toEmbeddedToolRuntime(moduleExports, source) {
+	const { runToolRequest, resumeToolRequest } = moduleExports;
+	if (typeof runToolRequest === "function" && typeof resumeToolRequest === "function") return {
+		runToolRequest,
+		resumeToolRequest
+	};
+	throw new Error(`${source} does not export Lobster embedded runtime functions`);
+}
+function findLobsterPackageRoot(resolvedEntryPath) {
+	let dir = path.dirname(resolvedEntryPath);
+	while (true) {
+		const packageJsonPath = path.join(dir, "package.json");
+		try {
+			if (JSON.parse(readFileSync(packageJsonPath, "utf8")).name === "@clawdbot/lobster") return dir;
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) throw new Error(`Could not locate @clawdbot/lobster package root from ${resolvedEntryPath}`);
+		dir = parent;
+	}
+}
 function normalizeForCwdSandbox(p) {
 	const normalized = path.normalize(p);
 	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
@@ -131,12 +250,29 @@ async function withTimeout(timeoutMs, fn) {
 		});
 	});
 }
-async function loadEmbeddedToolRuntimeFromPackage() {
-	return await import([
-		"@clawdbot",
-		"lobster",
-		"core"
-	].join("/"));
+async function loadEmbeddedToolRuntimeFromPackage(options = {}) {
+	const importModule = options.importModule ?? (async (specifier) => await import(specifier));
+	const packageEntryPath = (options.resolvePackageEntry ?? ((specifier) => lobsterRequire.resolve(specifier)))("@clawdbot/lobster");
+	await installLobsterAjvCompileCache(packageEntryPath);
+	let coreLoadError;
+	try {
+		return toEmbeddedToolRuntime(await importModule([
+			"@clawdbot",
+			"lobster",
+			"core"
+		].join("/")), "@clawdbot/lobster/core");
+	} catch (error) {
+		coreLoadError = error;
+	}
+	let fallbackLoadError;
+	try {
+		const packageRoot = findLobsterPackageRoot(packageEntryPath);
+		const coreRuntimeUrl = pathToFileURL(path.join(packageRoot, "dist/src/core/index.js")).href;
+		return toEmbeddedToolRuntime(await importModule(coreRuntimeUrl), coreRuntimeUrl);
+	} catch (error) {
+		fallbackLoadError = error;
+	}
+	throw new Error("Failed to load the Lobster embedded runtime", { cause: new AggregateError([coreLoadError, fallbackLoadError], "Both Lobster embedded runtime load paths failed") });
 }
 function createEmbeddedLobsterRunner(options) {
 	const loadRuntime = options?.loadRuntime ?? loadEmbeddedToolRuntimeFromPackage;
@@ -435,11 +571,12 @@ function parseResumeFlowParams(params) {
 	};
 }
 function formatManagedFlowResult(result) {
-	return jsonResult({
+	const details = {
 		...result.envelope && typeof result.envelope === "object" && !Array.isArray(result.envelope) ? result.envelope : { envelope: result.envelope },
 		flow: result.flow,
 		mutation: result.mutation
-	});
+	};
+	return jsonResult(details);
 }
 function requireTaskFlowRuntime(taskFlow, action) {
 	if (!taskFlow) throw new Error(`Managed TaskFlow ${action} mode requires a bound taskFlow runtime`);
@@ -456,7 +593,10 @@ function createLobsterTool(api, options) {
 		label: "Lobster Workflow",
 		description: "Run Lobster pipelines as a local-first workflow runtime (typed JSON envelope + resumable approvals).",
 		parameters: Type.Object({
-			action: Type.Enum(["run", "resume"], { type: "string" }),
+			action: Type.Unsafe({
+				type: "string",
+				enum: ["run", "resume"]
+			}),
 			pipeline: Type.Optional(Type.String()),
 			argsJson: Type.Optional(Type.String()),
 			token: Type.Optional(Type.String()),