@alfe.ai/integrations 0.2.2 → 0.2.3

package/dist/index.js

@@ -1713,27 +1713,38 @@ const delay$1 = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
 /**
-* Structural equality for config read-back comparison. Primitives compare by
-* `Object.is`; arrays are order-SENSITIVE (config arrays are positional);
-* plain objects are order-INSENSITIVE (key order in JSON is not meaningful).
-* Used only to confirm a value landed after a `config set` exited non-zero.
+* Asymmetric structural containment for verify-after-write: is every field we
+* INTENDED present in the ACTUAL read-back with our value? `actual` may carry
+* EXTRA keys that `intended` does not.
+*
+* Verify-after-write only needs to answer "did our write land?", and OpenClaw
+* NORMALIZES config on load — most notably it enriches every
+* `models.providers.*.models` entry with schema defaults (`reasoning`, `input`,
+* `cost`, `contextWindow`, `maxTokens`, …) that the applier never wrote. A
+* strict `deepEqual` against the enriched read-back is therefore GUARANTEED to
+* fail for model lists (extra keys → unequal key counts), which strands the
+* `alfe` activation in `error` forever even though the write succeeded. A subset
+* check tolerates enrichment while still catching a genuine failure (a value
+* OpenClaw never stored, or stored differently).
+*
+* Arrays stay positional and length-EXACT (enrichment adds object fields, never
+* elements, and never reorders); each element is compared by subset. Objects
+* require every `intended` key to be present-and-subset-matching in `actual`;
+* primitives compare by `Object.is`.
 */
-function deepEqual(a, b) {
-	if (Object.is(a, b)) return true;
-	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
-	const aIsArr = Array.isArray(a);
-	const bIsArr = Array.isArray(b);
-	if (aIsArr !== bIsArr) return false;
-	if (aIsArr && bIsArr) {
-		if (a.length !== b.length) return false;
-		return a.every((v, i) => deepEqual(v, b[i]));
-	}
-	const ao = a;
-	const bo = b;
-	const aKeys = Object.keys(ao);
-	const bKeys = Object.keys(bo);
-	if (aKeys.length !== bKeys.length) return false;
-	return aKeys.every((k) => Object.prototype.hasOwnProperty.call(bo, k) && deepEqual(ao[k], bo[k]));
+function deepSubset(intended, actual) {
+	if (Object.is(intended, actual)) return true;
+	if (typeof intended !== "object" || typeof actual !== "object" || intended === null || actual === null) return false;
+	const iIsArr = Array.isArray(intended);
+	const aIsArr = Array.isArray(actual);
+	if (iIsArr !== aIsArr) return false;
+	if (iIsArr && aIsArr) {
+		if (intended.length !== actual.length) return false;
+		return intended.every((v, i) => deepSubset(v, actual[i]));
+	}
+	const io = intended;
+	const ao = actual;
+	return Object.keys(io).every((k) => Object.prototype.hasOwnProperty.call(ao, k) && deepSubset(io[k], ao[k]));
 }
 /**
 * Describe a `config set` target WITHOUT leaking values. The value argument is
@@ -1844,7 +1855,7 @@ var OpenClawApplier = class {
 			], { timeout: 1e4 });
 			const actual = JSON.parse(stdout.trim());
 			if (actual === OPENCLAW_REDACTED) return true;
-			return deepEqual(actual, expected);
+			return deepSubset(expected, actual);
 		} catch {
 			return false;
 		}
@@ -2094,7 +2105,7 @@ var OpenClawApplier = class {
 			} catch (err) {
 				if (await this.verifyApplied(async () => {
 					const after = await readParentObject(parentPath);
-					return [...dottedKvs.entries()].every(([k, v]) => deepEqual(after[k], v));
+					return [...dottedKvs.entries()].every(([k, v]) => deepSubset(v, after[k]));
 				})) {
 					log$3.warn({ parentPath }, "openclaw config set exited non-zero but config landed — continuing");
 					continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/integrations",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Integration lifecycle management for Alfe — registry, resolution, installation, and state",
   "type": "module",
   "main": "./dist/index.js",