@openclaw/lobster 2026.10.10-beta.5 → 2026.11.5-beta.1

package/README.md

@@ -16,6 +16,14 @@ Restart the Gateway after installing or updating the plugin.
 - This plugin integrates Lobster with OpenClaw _without core changes_.
 - Input checkpoints return the question and schema; resume with `responseJson` containing the user's answer as JSON. See [structured input](https://docs.openclaw.ai/tools/lobster#structured-input).
 
+The tool's optional `cwd` is relative to the Gateway working directory. Nonblank
+values preserve leading and trailing whitespace as part of the directory name;
+blank values use the Gateway working directory.
+
+Workflow file paths also preserve their literal spelling, so `" wf.lobster"`
+does not select `wf.lobster`. The embedded runtime still requires a supported
+file extension; a space after `.lobster` is rejected rather than trimmed.
+
 ## Enable
 
 Because this tool can trigger side effects (via workflows), it is registered with `optional: true`.

package/dist/.setup/lobster-schema-compiler-T2XZzavY.mjs

@@ -0,0 +1,32 @@
+import { createJsonSchemaValidatorProvider } from "openclaw/plugin-sdk/json-schema-validator";
+// extensions/lobster/src/lobster-schema-compiler.ts
+const providers = /* @__PURE__ */ new WeakMap();
+const createProvider = () => createJsonSchemaValidatorProvider({
+	dialect: "draft7",
+	formats: /* @__PURE__ */ new Map(),
+	validateSchema: true,
+	duplicateIds: "reject"
+});
+/** Keep each dependency-owned Ajv namespace for that engine's module lifetime. */
+const compileLobsterSchema = (schema, options) => {
+	let provider = options.addUsedSchema ? providers.get(options.scope) : void 0;
+	if (!provider) {
+		provider = createProvider();
+		if (options.addUsedSchema) providers.set(options.scope, provider);
+	}
+	const prepared = provider.getValidator(schema);
+	const validate = Object.assign((value) => {
+		if (prepared.check(value)) {
+			validate.errors = null;
+			return true;
+		}
+		const errors = prepared.errors(value);
+		validate.errors = (options.allErrors ? errors : errors.slice(0, 1)).map((error) => ({
+			instancePath: error.instancePath ?? "",
+			message: error.message ?? "schema validation failed"
+		}));
+		return false;
+	}, { errors: null });
+	return validate;
+};
+export { compileLobsterSchema };

package/dist/.source-module-urls/00dc8c474cfa3e6e755374b6a78ce42a8dcd5a5a37a90df29d7baaef767292a6.json

@@ -1 +1 @@
-{"version":3,"entries":[{"output":"index.js","source":"extensions/lobster/index.ts"}],"chunks":[{"output":"index.js","sha256":"2f0522e54f338e6c61ec9741dd883dbced293f62f2839921823682d7e893fc66","facadeSource":"extensions/lobster/index.ts","sources":["extensions/lobster/index.ts","extensions/lobster/src/lobster-runner.ts","extensions/lobster/src/lobster-tool.ts"]}],"unrenderedSources":[]}
+{"version":3,"entries":[{"output":"index.js","source":"extensions/lobster/index.ts"}],"chunks":[{"output":".setup/lobster-schema-compiler-T2XZzavY.mjs","sha256":"b3f3fbb8536c6be50e1c0761257a8d243f2ac811e836c01b98a0033f13e8312d","facadeSource":"extensions/lobster/src/lobster-schema-compiler.ts","sources":["extensions/lobster/src/lobster-schema-compiler.ts"]},{"output":"index.js","sha256":"20c2dc6df86d75791ed9162221ccdcdb3c16929f168687fb0e3ea8f45297964b","facadeSource":"extensions/lobster/index.ts","sources":["extensions/lobster/index.ts","extensions/lobster/src/lobster-runner.ts","extensions/lobster/src/lobster-tool.ts"]}],"unrenderedSources":[]}

package/dist/index.js

@@ -9,7 +9,7 @@ import { Readable, Writable } from "node:stream";
 import { extractErrorCode, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
-//#region extensions/lobster/src/lobster-runner.ts
+// extensions/lobster/src/lobster-runner.ts
 const workflowExts = /* @__PURE__ */ new Set([
 	".lobster",
 	".yaml",
@@ -18,7 +18,7 @@ const workflowExts = /* @__PURE__ */ new Set([
 ]);
 function resolveLobsterCwd(cwdRaw) {
 	if (typeof cwdRaw !== "string" || !cwdRaw.trim()) return process.cwd();
-	const cwd = cwdRaw.trim();
+	const cwd = cwdRaw;
 	if (path.isAbsolute(cwd)) throw new Error("cwd must be a relative path");
 	const base = process.cwd();
 	const resolved = path.resolve(base, cwd);
@@ -61,7 +61,7 @@ function normalizeEnvelope(envelope, maxStdoutBytes) {
 async function detectWorkflowFile(candidate, cwd) {
 	const trimmed = candidate.trim();
 	if (!trimmed || trimmed.includes("|") || !workflowExts.has(path.extname(trimmed).toLowerCase())) return null;
-	const resolved = path.isAbsolute(trimmed) ? trimmed : path.resolve(cwd, trimmed);
+	const resolved = path.isAbsolute(candidate) ? candidate : path.resolve(cwd, candidate);
 	try {
 		if (!(await stat(resolved)).isFile()) throw new Error("Workflow path is not a file");
 		return resolved;
@@ -71,17 +71,24 @@ async function detectWorkflowFile(candidate, cwd) {
 	}
 }
 async function loadEmbeddedToolRuntimeFromPackage() {
-	return await import([
+	const { getRuntimeExecutionProfile } = await import("openclaw/plugin-sdk/runtime-profile");
+	const profile = getRuntimeExecutionProfile();
+	const runtime = await import([
 		"@clawdbot",
 		"lobster",
 		"core"
 	].join("/"));
+	if (profile !== "embedded-aot") return runtime;
+	const { compileLobsterSchema } = await import("./.setup/lobster-schema-compiler-T2XZzavY.mjs");
+	return {
+		runToolRequest: (params) => runtime.withSchemaCompiler(compileLobsterSchema, () => runtime.runToolRequest(params)),
+		resumeToolRequest: (params) => runtime.withSchemaCompiler(compileLobsterSchema, () => runtime.resumeToolRequest(params))
+	};
 }
-function createEmbeddedLobsterRunner(options) {
-	const loadRuntime = options?.loadRuntime ?? loadEmbeddedToolRuntimeFromPackage;
+function createEmbeddedLobsterRunner() {
 	let runtimePromise;
 	return { async run(params) {
-		runtimePromise ??= loadRuntime();
+		runtimePromise ??= loadEmbeddedToolRuntimeFromPackage();
 		const runtime = await runtimePromise;
 		const controller = new AbortController();
 		return await raceWithTimeout(async () => {
@@ -97,8 +104,8 @@ function createEmbeddedLobsterRunner(options) {
 			};
 			let envelope;
 			if (params.action === "run") {
-				const pipeline = params.pipeline?.trim() ?? "";
-				if (!pipeline) throw new Error("pipeline required");
+				const pipeline = params.pipeline ?? "";
+				if (!pipeline.trim()) throw new Error("pipeline required");
 				const filePath = await detectWorkflowFile(pipeline, params.cwd);
 				if (filePath) {
 					const parsedArgsJson = params.argsJson?.trim() ?? "";
@@ -151,9 +158,8 @@ function createEmbeddedLobsterRunner(options) {
 		});
 	} };
 }
-//#endregion
-//#region extensions/lobster/src/lobster-tool.ts
-function createLobsterTool(api) {
+// extensions/lobster/src/lobster-tool.ts
+function createLobsterTool() {
 	const runner = createEmbeddedLobsterRunner();
 	return {
 		name: "lobster",
@@ -179,7 +185,6 @@ function createLobsterTool(api) {
 			const cwd = resolveLobsterCwd(params.cwd);
 			const timeoutMs = readPositiveIntegerParam(params, "timeoutMs") ?? 2e4;
 			const maxStdoutBytes = readPositiveIntegerParam(params, "maxStdoutBytes") ?? 512e3;
-			if (api.runtime?.version && api.logger?.debug) api.logger.debug(`lobster plugin runtime=${api.runtime.version}`);
 			const runnerParams = {
 				action,
 				...typeof params.pipeline === "string" ? { pipeline: params.pipeline } : {},
@@ -198,8 +203,7 @@ function createLobsterTool(api) {
 		}
 	};
 }
-//#endregion
-//#region extensions/lobster/index.ts
+// extensions/lobster/index.ts
 var lobster_default = definePluginEntry({
 	id: "lobster",
 	name: "Lobster",
@@ -207,12 +211,11 @@ var lobster_default = definePluginEntry({
 	register(api) {
 		api.registerTool((ctx) => {
 			if (ctx.sandboxed) return null;
-			return createLobsterTool(api);
+			return createLobsterTool();
 		}, {
 			optional: true,
 			workspaceAccess: "execute"
 		});
 	}
 });
-//#endregion
 export { lobster_default as default };

package/node_modules/@clawdbot/lobster/dist/src/commands/stdlib/llm_invoke.js

@@ -6,89 +6,9 @@ import { Ajv } from "ajv";
 import { diffAndStore, ensureDirectory, atomicWriteWasPublished, isJsonSyntaxError, readStateJsonWithLock, stableStringify, withFileLock, writeFileAtomic, } from "../../state/store.js";
 import { createCompileCached } from "../../validation.js";
 import { httpResponseLimitFromEnv, readResponseTextCapped } from "../../read_response_text.js";
+import { validatePayload, validateResponseEnvelope } from "./llm_invoke_validators.generated.js";
 const ajv = new Ajv({ allErrors: true, strict: false });
 const compileCachedLocal = createCompileCached(ajv);
-const artifactSchema = {
-    type: "object",
-    properties: {
-        kind: { type: "string" },
-        role: { type: "string" },
-        name: { type: "string" },
-        mimeType: { type: "string" },
-        text: { type: "string" },
-        data: {},
-        uri: { type: "string" },
-    },
-    additionalProperties: true,
-};
-const payloadSchema = {
-    type: "object",
-    properties: {
-        prompt: { type: "string", minLength: 1 },
-        model: { type: "string", minLength: 1 },
-        artifacts: { type: "array", items: artifactSchema },
-        artifactHashes: { type: "array", items: { type: "string", minLength: 10 } },
-        schemaVersion: { type: "string" },
-        metadata: { type: "object", additionalProperties: true },
-        outputSchema: { type: "object", additionalProperties: true },
-        temperature: { type: "number" },
-        maxOutputTokens: { type: "number" },
-        retryContext: {
-            type: "object",
-            properties: {
-                attempt: { type: "number" },
-                validationErrors: { type: "array", items: { type: "string" } },
-            },
-            additionalProperties: false,
-        },
-    },
-    required: ["prompt", "artifacts", "artifactHashes"],
-    additionalProperties: false,
-};
-const responseSchema = {
-    type: "object",
-    properties: {
-        ok: { type: "boolean" },
-        result: {
-            type: "object",
-            properties: {
-                runId: { type: "string" },
-                model: { type: "string" },
-                prompt: { type: "string" },
-                status: { type: "string" },
-                output: {
-                    type: "object",
-                    properties: {
-                        text: { type: "string" },
-                        data: {},
-                        format: { type: "string" },
-                    },
-                    required: [],
-                    additionalProperties: true,
-                },
-                usage: {
-                    type: "object",
-                    properties: {
-                        inputTokens: { type: "number" },
-                        outputTokens: { type: "number" },
-                        totalTokens: { type: "number" },
-                    },
-                    additionalProperties: true,
-                },
-                warnings: { type: "array", items: { type: "string" } },
-                metadata: { type: "object", additionalProperties: true },
-                diagnostics: { type: "object", additionalProperties: true },
-            },
-            required: ["output"],
-            additionalProperties: true,
-        },
-        error: { type: "object", additionalProperties: true },
-    },
-    required: ["ok"],
-    additionalProperties: true,
-};
-const validatePayload = ajv.compile(payloadSchema);
-const validateResponseEnvelope = ajv.compile(responseSchema);
 const DEFAULT_MAX_VALIDATION_RETRIES = 1;
 const STATE_VERSION = 1;
 // Identity version of the response cache key. See computeCacheKey.
@@ -957,4 +877,3 @@ async function* streamOf(items) {
     for (const item of items)
         yield item;
 }
-//# sourceMappingURL=llm_invoke.js.map

package/node_modules/@clawdbot/lobster/dist/src/commands/stdlib/llm_invoke_schemas.js

@@ -0,0 +1,79 @@
+const artifactSchema = {
+    type: "object",
+    properties: {
+        kind: { type: "string" },
+        role: { type: "string" },
+        name: { type: "string" },
+        mimeType: { type: "string" },
+        text: { type: "string" },
+        data: {},
+        uri: { type: "string" },
+    },
+    additionalProperties: true,
+};
+export const payloadSchema = {
+    type: "object",
+    properties: {
+        prompt: { type: "string", minLength: 1 },
+        model: { type: "string", minLength: 1 },
+        artifacts: { type: "array", items: artifactSchema },
+        artifactHashes: { type: "array", items: { type: "string", minLength: 10 } },
+        schemaVersion: { type: "string" },
+        metadata: { type: "object", additionalProperties: true },
+        outputSchema: { type: "object", additionalProperties: true },
+        temperature: { type: "number" },
+        maxOutputTokens: { type: "number" },
+        retryContext: {
+            type: "object",
+            properties: {
+                attempt: { type: "number" },
+                validationErrors: { type: "array", items: { type: "string" } },
+            },
+            additionalProperties: false,
+        },
+    },
+    required: ["prompt", "artifacts", "artifactHashes"],
+    additionalProperties: false,
+};
+export const responseSchema = {
+    type: "object",
+    properties: {
+        ok: { type: "boolean" },
+        result: {
+            type: "object",
+            properties: {
+                runId: { type: "string" },
+                model: { type: "string" },
+                prompt: { type: "string" },
+                status: { type: "string" },
+                output: {
+                    type: "object",
+                    properties: {
+                        text: { type: "string" },
+                        data: {},
+                        format: { type: "string" },
+                    },
+                    required: [],
+                    additionalProperties: true,
+                },
+                usage: {
+                    type: "object",
+                    properties: {
+                        inputTokens: { type: "number" },
+                        outputTokens: { type: "number" },
+                        totalTokens: { type: "number" },
+                    },
+                    additionalProperties: true,
+                },
+                warnings: { type: "array", items: { type: "string" } },
+                metadata: { type: "object", additionalProperties: true },
+                diagnostics: { type: "object", additionalProperties: true },
+            },
+            required: ["output"],
+            additionalProperties: true,
+        },
+        error: { type: "object", additionalProperties: true },
+    },
+    required: ["ok"],
+    additionalProperties: true,
+};