@tangle-network/agent-interface 0.38.0 → 0.40.0

package/dist/agent-execution-preparation.d.ts

@@ -164,9 +164,9 @@ export declare const agentExecutionPreparationAxisResultSchema: z.ZodObject<{
         harness: "harness";
         confidential: "confidential";
         extensions: "extensions";
-        instructions: "instructions";
         skills: "skills";
         commands: "commands";
+        instructions: "instructions";
         systemPrompt: "systemPrompt";
         modelDefault: "modelDefault";
         modelSmall: "modelSmall";
@@ -308,9 +308,9 @@ export declare const agentExecutionPreparationReceiptSchema: z.ZodObject<{
             harness: "harness";
             confidential: "confidential";
             extensions: "extensions";
-            instructions: "instructions";
             skills: "skills";
             commands: "commands";
+            instructions: "instructions";
             systemPrompt: "systemPrompt";
             modelDefault: "modelDefault";
             modelSmall: "modelSmall";

package/dist/agent-execution-preparation.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { canonicalCandidateDigest, canonicalCandidateJson, isCanonicalJsonValue, isWellFormedUnicode, looksLikeCredential, omitTopLevelDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+import { canonicalAgentProfileValue } from "./agent-profile-canonical.js";
 import { REASONING_EFFORTS, } from "./agent-profile.js";
 import { AGENT_PROFILE_MATERIALIZATION_AXES, profileMaterializationRequests, } from "./agent-profile-materialization.js";
 import { harnessTypeSchema } from "./harness.js";
@@ -190,7 +191,7 @@ export const agentExecutionPreparationReceiptSchema = z
  */
 export function canonicalAgentProfileDigest(profile) {
     const parsed = agentProfileSchema.parse(profile);
-    const material = canonicalProfileValue(parsed, [], new Set());
+    const material = canonicalAgentProfileValue(parsed);
     if (material === undefined || !isCanonicalJsonValue(material)) {
         throw new Error("AgentProfile must contain finite, acyclic RFC 8785 JSON values");
     }
@@ -660,64 +661,6 @@ function cleanResolvedModel(model) {
             }),
     };
 }
-function canonicalProfileValue(value, path, ancestors) {
-    if (value === undefined)
-        return undefined;
-    if (value === null ||
-        typeof value === "boolean" ||
-        typeof value === "string") {
-        return value;
-    }
-    if (typeof value === "number") {
-        if (!Number.isFinite(value)) {
-            throw new Error(`AgentProfile ${renderPath(path)} must be finite`);
-        }
-        return value;
-    }
-    if (typeof value !== "object") {
-        throw new Error(`AgentProfile ${renderPath(path)} is not JSON serializable`);
-    }
-    if (ancestors.has(value)) {
-        throw new Error(`AgentProfile ${renderPath(path)} must be acyclic`);
-    }
-    const prototype = Object.getPrototypeOf(value);
-    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
-        throw new Error(`AgentProfile ${renderPath(path)} must be a plain JSON object`);
-    }
-    const nextAncestors = new Set(ancestors).add(value);
-    if (Array.isArray(value)) {
-        return Array.from({ length: value.length }, (_, index) => {
-            if (!Object.prototype.hasOwnProperty.call(value, index)) {
-                throw new Error(`AgentProfile ${renderPath([...path, index])} cannot be a sparse array hole`);
-            }
-            const entry = value[index];
-            const normalized = canonicalProfileValue(entry, [...path, index], nextAncestors);
-            if (normalized === undefined) {
-                throw new Error(`AgentProfile ${renderPath([...path, index])} cannot be undefined`);
-            }
-            return normalized;
-        });
-    }
-    const material = Object.create(null);
-    for (const [key, entry] of Object.entries(value)) {
-        if (!isWellFormedUnicode(key)) {
-            throw new Error(`AgentProfile ${renderPath(path)} has a record key that is not valid Unicode`);
-        }
-        const normalized = canonicalProfileValue(entry, [...path, key], nextAncestors);
-        if (normalized !== undefined) {
-            Object.defineProperty(material, key, {
-                value: normalized,
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
-        }
-    }
-    return material;
-}
-function renderPath(path) {
-    return path.length === 0 ? "root" : path.join(".");
-}
 function readJsonPointer(root, pointer) {
     let value = root;
     for (const encoded of pointer.slice(1).split("/")) {

package/dist/agent-profile-canonical.d.ts

@@ -0,0 +1,12 @@
+import type { AgentCandidateJsonValue } from "./agent-candidate.js";
+/**
+ * Normalize profile-shaped data into the canonical JSON domain used for public
+ * profile identity. Undefined object entries are omitted; unsupported values,
+ * sparse arrays, and cycles are rejected with their profile path.
+ *
+ * This module is intentionally internal. Public callers should use the
+ * profile-level operations that own validation, identity, or diff semantics.
+ */
+export declare function canonicalAgentProfileValue(value: unknown): AgentCandidateJsonValue | undefined;
+/** Canonical serialization after applying AgentProfile normalization rules. */
+export declare function canonicalAgentProfileJson(value: unknown): string | undefined;

package/dist/agent-profile-canonical.js

@@ -0,0 +1,79 @@
+import { canonicalCandidateJson, isWellFormedUnicode, } from "./agent-candidate-schema-common.js";
+/**
+ * Normalize profile-shaped data into the canonical JSON domain used for public
+ * profile identity. Undefined object entries are omitted; unsupported values,
+ * sparse arrays, and cycles are rejected with their profile path.
+ *
+ * This module is intentionally internal. Public callers should use the
+ * profile-level operations that own validation, identity, or diff semantics.
+ */
+export function canonicalAgentProfileValue(value) {
+    return normalizeAgentProfileValue(value, [], new Set());
+}
+/** Canonical serialization after applying AgentProfile normalization rules. */
+export function canonicalAgentProfileJson(value) {
+    const normalized = canonicalAgentProfileValue(value);
+    return normalized === undefined
+        ? undefined
+        : canonicalCandidateJson(normalized);
+}
+function normalizeAgentProfileValue(value, path, ancestors) {
+    if (value === undefined)
+        return undefined;
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error(`AgentProfile ${renderPath(path)} must be finite`);
+        }
+        return value;
+    }
+    if (typeof value !== "object") {
+        throw new Error(`AgentProfile ${renderPath(path)} is not JSON serializable`);
+    }
+    if (ancestors.has(value)) {
+        throw new Error(`AgentProfile ${renderPath(path)} must be acyclic`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) &&
+        prototype !== Object.prototype &&
+        prototype !== null) {
+        throw new Error(`AgentProfile ${renderPath(path)} must be a plain JSON object`);
+    }
+    const nextAncestors = new Set(ancestors).add(value);
+    if (Array.isArray(value)) {
+        return Array.from({ length: value.length }, (_, index) => {
+            if (!Object.prototype.hasOwnProperty.call(value, index)) {
+                throw new Error(`AgentProfile ${renderPath([...path, index])} cannot be a sparse array hole`);
+            }
+            const entry = value[index];
+            const normalized = normalizeAgentProfileValue(entry, [...path, index], nextAncestors);
+            if (normalized === undefined) {
+                throw new Error(`AgentProfile ${renderPath([...path, index])} cannot be undefined`);
+            }
+            return normalized;
+        });
+    }
+    const material = Object.create(null);
+    for (const [key, entry] of Object.entries(value)) {
+        if (!isWellFormedUnicode(key)) {
+            throw new Error(`AgentProfile ${renderPath(path)} has a record key that is not valid Unicode`);
+        }
+        const normalized = normalizeAgentProfileValue(entry, [...path, key], nextAncestors);
+        if (normalized !== undefined) {
+            Object.defineProperty(material, key, {
+                value: normalized,
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+    }
+    return material;
+}
+function renderPath(path) {
+    return path.length === 0 ? "root" : path.join(".");
+}

package/dist/agent-profile-improvement-schema.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { AgentImprovementSurface } from "./agent-candidate.js";
 import type { AgentProfileDiff } from "./profile-diff.js";
 export declare const agentProfileImprovementTaskSchema: z.ZodObject<{
     kind: z.ZodLiteral<"agent-profile-improvement-task">;
@@ -183,11 +184,7 @@ export declare const agentProfileImprovementExecutionRefSchema: z.ZodObject<{
     digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     kind: z.ZodLiteral<"agent-profile-improvement-execution-ref">;
 }, z.core.$strict>;
-/**
- * The first product path changes only prompt and skills, but it uses the
- * shared profile-diff language so execution and activation apply identical
- * ordered patches.
- */
+/** One strict canonical profile patch in an ordered measured change. */
 export declare const agentProfileImprovementChangeStepSchema: z.ZodType<AgentProfileDiff, unknown, z.core.$ZodTypeInternals<AgentProfileDiff, unknown>>;
 export declare const agentProfileImprovementChangeSchema: z.ZodTuple<[z.ZodType<AgentProfileDiff, unknown, z.core.$ZodTypeInternals<AgentProfileDiff, unknown>>], z.ZodType<AgentProfileDiff, unknown, z.core.$ZodTypeInternals<AgentProfileDiff, unknown>>>;
 export declare const agentProfileImprovementExperimentSchema: z.ZodObject<{
@@ -1208,4 +1205,4 @@ export declare const agentProfileImprovementMeasuredComparisonSchema: z.ZodObjec
         }, z.core.$strict>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare function changedProfileImprovementSurfaces(change: readonly AgentProfileDiff[]): string[];
+export declare function changedProfileImprovementSurfaces(change: readonly AgentProfileDiff[]): AgentImprovementSurface[];

package/dist/agent-profile-improvement-schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { changedAgentProfileAxes } from "./profile-diff.js";
 import { agentCandidateLineageSchema } from "./agent-candidate-lineage-schema.js";
 import { canonicalCandidateDigest, isCanonicalJsonValue, omitTopLevelDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 import { refineAgentExecutionWithinLimits } from "./agent-execution-limits.js";
@@ -103,67 +104,48 @@ export const agentProfileImprovementExecutionRefSchema = profileImprovementEvide
     kind: z.literal("agent-profile-improvement-execution-ref"),
 })
     .strict();
-/**
- * The first product path changes only prompt and skills, but it uses the
- * shared profile-diff language so execution and activation apply identical
- * ordered patches.
- */
+/** One strict canonical profile patch in an ordered measured change. */
 export const agentProfileImprovementChangeStepSchema = agentProfileDiffSchema.superRefine((change, ctx) => {
     const changed = changedProfileImprovementSurfaces([change]);
     if (changed.length === 0) {
         ctx.addIssue({
             code: "custom",
-            message: "profile improvement patch must change prompt or skills",
+            message: "profile improvement patch must change the agent profile",
         });
     }
-    const setKeys = Object.keys(change.set ?? {});
-    if (setKeys.some((key) => key !== "prompt" && key !== "resources")) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["set"],
-            message: "profile improvement patches may set only prompt or skill resources",
-        });
-    }
-    const setResourceKeys = Object.keys(change.set?.resources ?? {});
-    if (setResourceKeys.some((key) => key !== "skills")) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["set", "resources"],
-            message: "profile improvement patches may set only skill resources",
-        });
-    }
-    if (change.set?.resources?.skills?.some((skill) => skill.kind !== "inline")) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["set", "resources", "skills"],
-            message: "measured profile skill patches require inline content with exact bytes",
-        });
-    }
-    const removeKeys = Object.keys(change.remove ?? {});
-    if (removeKeys.some((key) => key !== "prompt" && key !== "resources")) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["remove"],
-            message: "profile improvement patches may remove only prompt or skill resources",
-        });
-    }
-    if (change.remove?.resources === true) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["remove", "resources"],
-            message: "profile improvement patches may not remove unrelated resources",
-        });
+    refineInlineProfileImprovementResources(change, ctx);
+});
+function refineInlineProfileImprovementResources(change, ctx) {
+    const resources = change.set?.resources;
+    if (resources === undefined)
+        return;
+    const groups = [
+        ["files", resources.files?.map((file) => file.resource)],
+        ["tools", resources.tools],
+        ["skills", resources.skills],
+        ["agents", resources.agents],
+        ["commands", resources.commands],
+    ];
+    for (const [name, refs] of groups) {
+        for (const [index, ref] of (refs ?? []).entries()) {
+            if (ref.kind !== "inline") {
+                ctx.addIssue({
+                    code: "custom",
+                    path: ["set", "resources", name, index],
+                    message: "measured profile resource patches require inline content with exact bytes",
+                });
+            }
+        }
     }
-    const removeResources = change.remove?.resources;
-    const removeResourceKeys = Object.keys(typeof removeResources === "object" ? removeResources : {});
-    if (removeResourceKeys.some((key) => key !== "skills")) {
+    if (typeof resources.instructions === "object" &&
+        resources.instructions.kind !== "inline") {
         ctx.addIssue({
             code: "custom",
-            path: ["remove", "resources"],
-            message: "profile improvement patches may remove only skill resources",
+            path: ["set", "resources", "instructions"],
+            message: "measured profile resource patches require inline content with exact bytes",
         });
     }
-});
+}
 export const agentProfileImprovementChangeSchema = z
     .tuple([agentProfileImprovementChangeStepSchema])
     .rest(agentProfileImprovementChangeStepSchema)
@@ -420,16 +402,72 @@ export const agentProfileImprovementMeasuredComparisonSchema = z
 export function changedProfileImprovementSurfaces(change) {
     const surfaces = new Set();
     for (const step of change) {
-        if (step.set?.prompt !== undefined || step.remove?.prompt !== undefined) {
-            surfaces.add("prompt");
+        for (const axis of changedAgentProfileAxes(step)) {
+            if (axis === "prompt" ||
+                axis === "tools" ||
+                axis === "mcp" ||
+                axis === "hooks" ||
+                axis === "subagents") {
+                surfaces.add(axis);
+            }
+            else if (axis === "resources") {
+                const resources = changedResourceSurfaces(step);
+                for (const surface of resources.granular)
+                    surfaces.add(surface);
+                if (resources.other)
+                    surfaces.add("agent-profile");
+            }
+            else {
+                surfaces.add("agent-profile");
+            }
         }
-        if (step.set?.resources?.skills !== undefined ||
-            (typeof step.remove?.resources === "object" &&
-                step.remove.resources.skills !== undefined)) {
-            surfaces.add("skills");
+    }
+    const canonicalOrder = [
+        "prompt",
+        "skills",
+        "tools",
+        "mcp",
+        "hooks",
+        "subagents",
+        "agent-profile",
+    ];
+    return canonicalOrder.filter((surface) => surfaces.has(surface));
+}
+function changedResourceSurfaces(change) {
+    const granular = new Set();
+    let other = false;
+    const setResources = change.set?.resources;
+    if (setResources !== undefined) {
+        const keys = Object.keys(setResources);
+        for (const key of keys) {
+            if (key === "skills" || key === "tools")
+                granular.add(key);
+            else if (key === "agents")
+                granular.add("subagents");
+            else
+                other = true;
+        }
+        other ||= keys.length === 0;
+    }
+    const removeResources = change.remove?.resources;
+    if (removeResources === true) {
+        granular.add("skills");
+        granular.add("tools");
+        granular.add("subagents");
+        other = true;
+    }
+    else if (removeResources !== undefined) {
+        const entries = Object.entries(removeResources).filter(([, value]) => Array.isArray(value) ? value.length > 0 : value === true);
+        for (const [key] of entries) {
+            if (key === "skills" || key === "tools")
+                granular.add(key);
+            else if (key === "agents")
+                granular.add("subagents");
+            else
+                other = true;
         }
     }
-    return [...surfaces].sort();
+    return { granular, other };
 }
 function refineProfileImprovementComparison(comparison, ctx) {
     const { suite, tasks } = comparison.experiment.benchmark;

package/dist/agent-profile-improvement.d.ts

@@ -52,9 +52,9 @@ export interface AgentProfileImprovementExecutionRef extends AgentProfileImprove
  * Ordered portable profile patches retained for review and activation.
  *
  * Applying the steps in order matters: a full resource replacement is a reset
- * followed by a replacement step. Prompt and inline skill content can be
- * sensitive, so the product that persists this value owns access control and
- * redaction.
+ * followed by a replacement step. Complete profile diffs can contain sensitive
+ * host-owned configuration, so the product that persists this value owns access
+ * control and redaction.
  */
 export type AgentProfileImprovementChange = [AgentProfileDiff, ...AgentProfileDiff[]];
 /** A measured comparison of two states of one host-owned agent profile. */

package/dist/agent-profile-snapshot.d.ts

@@ -0,0 +1,9 @@
+import type { AgentProfile } from "./agent-profile.js";
+/**
+ * Detach, validate, and recursively freeze one AgentProfile at an intake boundary.
+ *
+ * The returned value is exactly the existing schema output: this function adds no
+ * defaults and applies no provider, model, or execution policy. Values outside the
+ * existing canonical profile JSON domain fail instead of becoming mutable state.
+ */
+export declare function snapshotAgentProfile(value: unknown): AgentProfile;

package/dist/agent-profile-snapshot.js

@@ -0,0 +1,24 @@
+import { canonicalAgentProfileValue } from "./agent-profile-canonical.js";
+import { agentProfileSchema } from "./profile-schema.js";
+/**
+ * Detach, validate, and recursively freeze one AgentProfile at an intake boundary.
+ *
+ * The returned value is exactly the existing schema output: this function adds no
+ * defaults and applies no provider, model, or execution policy. Values outside the
+ * existing canonical profile JSON domain fail instead of becoming mutable state.
+ */
+export function snapshotAgentProfile(value) {
+    const parsed = agentProfileSchema.parse(structuredClone(value));
+    canonicalAgentProfileValue(parsed);
+    return deepFreeze(parsed);
+}
+function deepFreeze(value, seen = new Set()) {
+    if (value === null || typeof value !== "object" || seen.has(value)) {
+        return value;
+    }
+    seen.add(value);
+    for (const child of Object.values(value)) {
+        deepFreeze(child, seen);
+    }
+    return Object.freeze(value);
+}

package/dist/index.d.ts

@@ -623,6 +623,7 @@ export * from "./agent-profile-improvement.js";
 export * from "./agent-profile-improvement-schema.js";
 export * from "./agent-execution-limits.js";
 export * from "./agent-profile.js";
+export * from "./agent-profile-snapshot.js";
 export * from "./agent-profile-activation.js";
 export * from "./agent-profile-materialization.js";
 export * from "./agent-execution-preparation.js";

package/dist/index.js

@@ -135,6 +135,7 @@ export * from "./agent-profile-improvement.js";
 export * from "./agent-profile-improvement-schema.js";
 export * from "./agent-execution-limits.js";
 export * from "./agent-profile.js";
+export * from "./agent-profile-snapshot.js";
 export * from "./agent-profile-activation.js";
 export * from "./agent-profile-materialization.js";
 export * from "./agent-execution-preparation.js";

package/dist/profile-diff.d.ts

@@ -57,6 +57,17 @@ export interface AgentProfileDiff {
     metadata?: Record<string, unknown>;
 }
 export declare function defineAgentProfileDiff<T extends AgentProfileDiff>(diff: T): T;
+/**
+ * Construct deterministic ordered profile patches that reproduce `candidate`'s
+ * canonical profile value exactly when applied to `baseline`.
+ *
+ * Profile overlays append arrays and merge records, so changed fields are reset
+ * first and then replaced. Comparison and copied values follow the same
+ * undefined-entry normalization as profile identity. The returned values use
+ * the existing {@link AgentProfileDiff} contract; an unchanged profile returns
+ * no steps.
+ */
+export declare function diffAgentProfiles(baseline: AgentProfile, candidate: AgentProfile): AgentProfileDiff[];
 export declare function applyAgentProfileDiff(base: AgentProfile, diff: AgentProfileDiff): AgentProfile;
 export declare function changedAgentProfileAxes(diff: AgentProfileDiff): AgentProfileDiffAxis[];
 export declare function pruneAgentProfileDiff(diff: AgentProfileDiff, axesToRemove: readonly AgentProfileDiffAxis[]): AgentProfileDiff;

package/dist/profile-diff.js

@@ -1,4 +1,5 @@
 import { mergeAgentProfiles } from "./agent-profile.js";
+import { canonicalAgentProfileJson } from "./agent-profile-canonical.js";
 const agentProfileDiffPropertyAxes = [
     "prompt",
     "model",
@@ -20,6 +21,110 @@ void _agentProfileDiffPropertyAxesAreExhaustive;
 export function defineAgentProfileDiff(diff) {
     return diff;
 }
+const agentProfileResourceDiffPropertyAxes = [
+    "files",
+    "tools",
+    "skills",
+    "agents",
+    "commands",
+    "instructions",
+    "failOnError",
+];
+const _agentProfileResourceDiffPropertyAxesAreExhaustive = true;
+void _agentProfileResourceDiffPropertyAxesAreExhaustive;
+/**
+ * Construct deterministic ordered profile patches that reproduce `candidate`'s
+ * canonical profile value exactly when applied to `baseline`.
+ *
+ * Profile overlays append arrays and merge records, so changed fields are reset
+ * first and then replaced. Comparison and copied values follow the same
+ * undefined-entry normalization as profile identity. The returned values use
+ * the existing {@link AgentProfileDiff} contract; an unchanged profile returns
+ * no steps.
+ */
+export function diffAgentProfiles(baseline, candidate) {
+    const remove = {};
+    const set = {};
+    if (profileValuesDiffer(baseline.name, candidate.name) ||
+        profileValuesDiffer(baseline.description, candidate.description) ||
+        profileValuesDiffer(baseline.version, candidate.version)) {
+        remove.identity = true;
+        if (candidate.name !== undefined)
+            set.name = candidate.name;
+        if (candidate.description !== undefined) {
+            set.description = candidate.description;
+        }
+        if (candidate.version !== undefined)
+            set.version = candidate.version;
+    }
+    if (profileValuesDiffer(baseline.tags, candidate.tags)) {
+        remove.tags = true;
+        if (candidate.tags !== undefined) {
+            set.tags = canonicalProfileValue(candidate.tags);
+        }
+    }
+    for (const axis of agentProfileDiffPropertyAxes) {
+        if (axis === "resources") {
+            replaceChangedProfileResources(baseline.resources, candidate.resources, remove, set);
+            continue;
+        }
+        if (!profileValuesDiffer(baseline[axis], candidate[axis]))
+            continue;
+        Object.assign(remove, { [axis]: true });
+        const value = candidate[axis];
+        if (value !== undefined) {
+            Object.assign(set, { [axis]: canonicalProfileValue(value) });
+        }
+    }
+    if (Object.keys(remove).length === 0)
+        return [];
+    const reset = {
+        kind: "agent-profile-diff",
+        remove,
+    };
+    if (Object.keys(set).length === 0)
+        return [reset];
+    return [reset, { kind: "agent-profile-diff", set }];
+}
+function replaceChangedProfileResources(baseline, candidate, remove, set) {
+    if (!profileValuesDiffer(baseline, candidate))
+        return;
+    const resourceRemove = {};
+    const resourceSet = {};
+    let changedSubfields = 0;
+    for (const axis of agentProfileResourceDiffPropertyAxes) {
+        if (!profileValuesDiffer(baseline?.[axis], candidate?.[axis]))
+            continue;
+        changedSubfields += 1;
+        Object.assign(resourceRemove, { [axis]: true });
+        const value = candidate?.[axis];
+        if (value !== undefined) {
+            Object.assign(resourceSet, { [axis]: canonicalProfileValue(value) });
+        }
+    }
+    // Distinguish an absent resources object from an explicitly empty one.
+    if (changedSubfields === 0) {
+        remove.resources = true;
+        if (candidate !== undefined) {
+            set.resources = canonicalProfileValue(candidate);
+        }
+        return;
+    }
+    remove.resources = resourceRemove;
+    const canonicalCandidate = canonicalProfileValue(candidate);
+    if (Object.keys(resourceSet).length > 0 ||
+        (canonicalCandidate !== undefined &&
+            Object.keys(canonicalCandidate).length === 0)) {
+        set.resources = resourceSet;
+    }
+}
+function profileValuesDiffer(baseline, candidate) {
+    return (canonicalAgentProfileJson(baseline) !== canonicalAgentProfileJson(candidate));
+}
+function canonicalProfileValue(value) {
+    const json = canonicalAgentProfileJson(value);
+    return (json === undefined ? undefined : JSON.parse(json));
+}
 function asMutable(value) {
     return value ? [...value] : undefined;
 }
@@ -174,12 +279,26 @@ export function applyAgentProfileDiff(base, diff) {
     const merged = mergeAgentProfiles(base, diff.set) ?? {};
     return applyRemoval(merged, diff.remove);
 }
+function hasRemovalOperation(value) {
+    if (value === true)
+        return true;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (value && typeof value === "object") {
+        return Object.values(value).some(hasRemovalOperation);
+    }
+    return false;
+}
 export function changedAgentProfileAxes(diff) {
     const axes = new Set();
     const set = diff.set;
     if (set) {
-        if (set.name || set.description || set.version || set.tags)
+        if (set.name !== undefined ||
+            set.description !== undefined ||
+            set.version !== undefined ||
+            set.tags !== undefined) {
             axes.add("identity");
+        }
         for (const axis of agentProfileDiffPropertyAxes) {
             if (set[axis] !== undefined)
                 axes.add(axis);
@@ -187,10 +306,11 @@ export function changedAgentProfileAxes(diff) {
     }
     const remove = diff.remove;
     if (remove) {
-        if (remove.identity || remove.tags)
+        if (hasRemovalOperation(remove.identity) || hasRemovalOperation(remove.tags)) {
             axes.add("identity");
+        }
         for (const axis of agentProfileDiffPropertyAxes) {
-            if (remove[axis] !== undefined)
+            if (hasRemovalOperation(remove[axis]))
                 axes.add(axis);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-interface",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",