@blokkli/editor 2.0.0-alpha.31 → 2.0.0-alpha.33

package/dist/modules/agent/runtime/app/tools/get_paragraph_options/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/get_paragraph_options/index.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { getAvailableOptions } from "#blokkli/editor/helpers/options";
+import { blockOptionsMapSchema, buildBlockOptionsMap } from "../schemas.js";
+const paramsSchema = z.object({
+  uuids: z.array(z.string()).describe("The paragraph UUIDs to get options for")
+});
+const resultSchema = z.record(
+  z.string().describe("Paragraph UUID"),
+  blockOptionsMapSchema.describe("Options for this paragraph")
+);
+export default defineBlokkliAgentTool({
+  name: "get_paragraph_options",
+  description: "Get available options and their current values for one or more paragraphs",
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => `options for ${Object.keys(r || {}).length} paragraphs`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetBlockOptionsRunning", "Getting block options...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { blocks, state, definitions, selection, types, $t } = ctx.app;
+    const result = {};
+    const affectedUuids = [];
+    for (const uuid of params.uuids) {
+      const block = blocks.getBlock(uuid);
+      if (!block) continue;
+      const bundle = block.library?.reusableBundle || block.bundle;
+      const selectionItem = selection.items.value.find((v) => v.uuid === uuid);
+      const definition = definitions.getBlockDefinition(
+        bundle,
+        selectionItem?.fieldListType ?? "default",
+        selectionItem?.parentBlockBundle
+      );
+      if (!definition) continue;
+      const availableOptions = getAvailableOptions(
+        definition.options,
+        definition.globalOptions,
+        definitions.globalOptions.value
+      );
+      result[uuid] = buildBlockOptionsMap(
+        availableOptions,
+        state.mutatedOptions,
+        uuid
+      );
+      affectedUuids.push(uuid);
+    }
+    const count = affectedUuids.length;
+    const firstUuid = affectedUuids[0];
+    const firstBlock = firstUuid ? blocks.getBlock(firstUuid) : null;
+    const label = count === 1 && firstBlock ? $t("aiAgentGetBlockOptionsDone", "Got options of @bundle").replace(
+      "@bundle",
+      types.getBlockLabel(firstBlock.bundle)
+    ) : $t(
+      "aiAgentGetBlockOptionsMultipleDone",
+      "Got options of @count blocks"
+    ).replace("@count", String(count));
+    return { label, result, affectedUuids };
+  }
+});

package/dist/modules/agent/runtime/app/tools/get_paragraphs_in_viewport/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/get_paragraphs_in_viewport/index.js

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const paramsSchema = z.object({
+  maxNestingLevel: z.number().optional().describe(
+    "Maximum nesting depth to include (0 = only root paragraphs, 1 = root + direct children, etc.). Omit for unlimited depth."
+  ),
+  includeDimensions: z.boolean().optional().default(false).describe(
+    "Include x, y, width, height for each paragraph (default: false)"
+  )
+});
+const dimensionsSchema = z.object({
+  x: z.number().describe("X position in artboard coordinates"),
+  y: z.number().describe("Y position in artboard coordinates"),
+  width: z.number().describe("Width in pixels"),
+  height: z.number().describe("Height in pixels")
+});
+const nestedBlockSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label"),
+  dimensions: dimensionsSchema.optional().describe("Paragraph position and size (if requested)"),
+  children: z.record(z.string(), z.array(z.lazy(() => nestedBlockSchema))).optional().describe("Child paragraphs organized by field name")
+});
+const rootBlockSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label"),
+  dimensions: dimensionsSchema.optional().describe("Paragraph position and size (if requested)"),
+  visibilityPercent: z.number().describe("Percentage of paragraph area visible in viewport (0-100)"),
+  parent: z.object({
+    type: z.string().describe("Parent entity type"),
+    uuid: z.string().describe("Parent entity UUID"),
+    field: z.string().describe("Field name containing this paragraph")
+  }).describe("Parent field information"),
+  children: z.record(z.string(), z.array(nestedBlockSchema)).optional().describe("Child paragraphs organized by field name")
+});
+const resultSchema = z.object({
+  paragraphs: z.array(rootBlockSchema).describe("Root-level paragraphs currently visible in the viewport")
+});
+function getDimensions(app, uuid) {
+  const rect = app.dom.getBlockRect(uuid);
+  if (!rect) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  return {
+    x: Math.round(rect.x),
+    y: Math.round(rect.y),
+    width: Math.round(rect.width),
+    height: Math.round(rect.height)
+  };
+}
+function calculateVisibility(app, uuid) {
+  const artboardRect = app.dom.getBlockRect(uuid);
+  if (!artboardRect) return 0;
+  const viewport = app.ui.visibleViewport.value;
+  const rect = app.ui.getViewportRelativeRect(artboardRect);
+  const intersectX = Math.max(
+    0,
+    Math.min(rect.x + rect.width, viewport.x + viewport.width) - Math.max(rect.x, viewport.x)
+  );
+  const intersectY = Math.max(
+    0,
+    Math.min(rect.y + rect.height, viewport.y + viewport.height) - Math.max(rect.y, viewport.y)
+  );
+  const intersectArea = intersectX * intersectY;
+  const blockArea = rect.width * rect.height;
+  if (blockArea === 0) return 0;
+  return Math.round(intersectArea / blockArea * 100);
+}
+function buildNestedBlockTree(app, uuid, options) {
+  const block = app.blocks.getBlock(uuid);
+  const bundle = block?.bundle ?? "unknown";
+  const result = {
+    uuid,
+    bundle,
+    label: app.types.getBlockLabel(bundle)
+  };
+  if (options.includeDimensions) {
+    result.dimensions = getDimensions(app, uuid);
+  }
+  const shouldIncludeChildren = options.maxNestingLevel === void 0 || options.currentLevel < options.maxNestingLevel;
+  if (shouldIncludeChildren) {
+    const mutatedFields = app.state.mutatedFields.value;
+    const childFields = {};
+    for (const field of mutatedFields) {
+      if (field.entityUuid === uuid && field.list.length > 0) {
+        childFields[field.name] = field.list.map(
+          (item) => buildNestedBlockTree(app, item.uuid, {
+            ...options,
+            currentLevel: options.currentLevel + 1
+          })
+        );
+      }
+    }
+    if (Object.keys(childFields).length > 0) {
+      result.children = childFields;
+    }
+  }
+  return result;
+}
+function buildRootBlockTree(app, uuid, options) {
+  const block = app.blocks.getBlock(uuid);
+  const bundle = block?.bundle ?? "unknown";
+  const parentField = app.state.getFieldListForBlock(uuid);
+  const parent = parentField ? {
+    type: parentField.entityType,
+    uuid: parentField.entityUuid,
+    field: parentField.name
+  } : { type: "unknown", uuid: "unknown", field: "unknown" };
+  const result = {
+    uuid,
+    bundle,
+    label: app.types.getBlockLabel(bundle),
+    visibilityPercent: calculateVisibility(app, uuid),
+    parent
+  };
+  if (options.includeDimensions) {
+    result.dimensions = getDimensions(app, uuid);
+  }
+  const shouldIncludeChildren = options.maxNestingLevel === void 0 || options.currentLevel < options.maxNestingLevel;
+  if (shouldIncludeChildren) {
+    const mutatedFields = app.state.mutatedFields.value;
+    const childFields = {};
+    for (const field of mutatedFields) {
+      if (field.entityUuid === uuid && field.list.length > 0) {
+        childFields[field.name] = field.list.map(
+          (item) => buildNestedBlockTree(app, item.uuid, {
+            ...options,
+            currentLevel: options.currentLevel + 1
+          })
+        );
+      }
+    }
+    if (Object.keys(childFields).length > 0) {
+      result.children = childFields;
+    }
+  }
+  return result;
+}
+export default defineBlokkliAgentTool({
+  name: "get_paragraphs_in_viewport",
+  description: `Get paragraphs currently visible in the viewport with their visibility percentage. Use this for viewport-relative queries like "the paragraph at the top", "what's in the center", or "paragraphs near the bottom". NOT for getting all page content - use get_all_page_content for that.`,
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => `${r.paragraphs?.length || 0} paragraphs in viewport`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t(
+      "aiAgentGetBlocksInViewportRunning",
+      "Getting blocks in viewport..."
+    );
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { dom, state, $t } = ctx.app;
+    const visibleUuids = dom.getVisibleBlocks();
+    const buildOptions = {
+      includeDimensions: params.includeDimensions ?? false,
+      maxNestingLevel: params.maxNestingLevel,
+      currentLevel: 0
+    };
+    const rootUuids = visibleUuids.filter(
+      (uuid) => state.getNestingLevel(uuid) === 0
+    );
+    const blockTrees = rootUuids.map(
+      (uuid) => buildRootBlockTree(ctx.app, uuid, buildOptions)
+    );
+    blockTrees.sort((a, b) => b.visibilityPercent - a.visibilityPercent);
+    return {
+      label: $t(
+        "aiAgentGetBlocksInViewportDone",
+        "Got @count blocks in viewport"
+      ).replace("@count", String(blockTrees.length)),
+      result: {
+        paragraphs: blockTrees
+      }
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/get_selected_paragraphs/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/get_selected_paragraphs/index.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const paramsSchema = z.object({});
+const paragraphSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label")
+});
+const resultSchema = z.object({
+  paragraphs: z.array(paragraphSchema).describe("Currently selected paragraphs")
+});
+export default defineBlokkliAgentTool({
+  name: "get_selected_paragraphs",
+  description: "Get the paragraphs currently selected by the user. Returns an empty array if nothing is selected.",
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => `${r.paragraphs?.length || 0} paragraphs selected`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetSelectedBlocksRunning", "Getting selected blocks...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx) {
+    const { selection, types, $t } = ctx.app;
+    const paragraphs = selection.uuids.value.map((uuid) => {
+      const item = selection.items.value.find((v) => v.uuid === uuid);
+      const bundle = item?.bundle ?? "unknown";
+      return {
+        uuid,
+        bundle,
+        label: types.getBlockLabel(bundle)
+      };
+    });
+    const count = paragraphs.length;
+    const label = count ? $t("aiAgentGetSelectedBlocksDone", "@count block(s) selected").replace(
+      "@count",
+      String(count)
+    ) : $t("aiAgentGetSelectedBlocksNone", "No blocks selected");
+    return {
+      label,
+      result: { paragraphs },
+      affectedUuids: paragraphs.map((b) => b.uuid)
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/go_to_history_index/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/go_to_history_index/index.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "../schemas.js";
+const paramsSchema = z.object({
+  index: z.number().describe(
+    "History index to navigate to (-1 = pristine state, 0+ = mutation index)"
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "go_to_history_index",
+  description: `Navigate to a specific point in mutation history (undo/redo). -1 = pristine state, 0 = first mutation, etc.`,
+  category: "mutation",
+  lazy: true,
+  prunedSummary: (r) => r.success ? `navigated to index ${r.historyIndex ?? "?"}` : "rejected",
+  modes: ["editing", "translating"],
+  label($t) {
+    return $t("aiAgentGoToHistoryIndexRunning", "Navigating history...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["setHistoryIndex"],
+  execute(ctx, params) {
+    const { $t, state } = ctx.app;
+    const mutations = state.mutations.value;
+    const currentIndex = state.currentMutationIndex.value;
+    const minIndex = -1;
+    const maxIndex = mutations.length - 1;
+    if (params.index < minIndex) {
+      return { error: `Index ${params.index} is below minimum (-1)` };
+    }
+    if (params.index > maxIndex) {
+      return {
+        error: `Index ${params.index} exceeds maximum (${maxIndex}). There are ${mutations.length} mutations.`
+      };
+    }
+    if (params.index === currentIndex) {
+      return { error: `Already at history index ${params.index}` };
+    }
+    const isUndo = params.index < currentIndex;
+    const steps = Math.abs(currentIndex - params.index);
+    const label = isUndo ? $t("aiAgentUndoDone", "Undid @count changes").replace(
+      "@count",
+      String(steps)
+    ) : $t("aiAgentRedoDone", "Redid @count changes").replace(
+      "@count",
+      String(steps)
+    );
+    return {
+      type: "move",
+      label,
+      apply: (adapter) => adapter.setHistoryIndex(params.index)
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/move_paragraphs/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/move_paragraphs/index.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema,
+  resolvePosition
+} from "../schemas.js";
+const paramsSchema = z.object({
+  uuids: z.array(z.string()).describe("The UUIDs of the paragraphs to move"),
+  parent: parentSchema.describe("The target parent entity"),
+  position: positionSchema
+});
+export default defineBlokkliAgentTool({
+  name: "move_paragraphs",
+  description: "Move one or more paragraphs to a different parent field. All paragraphs are moved to the same location and they KEEP their UUIDs!!",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "moved paragraphs" : "rejected",
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentMoveBlocksRunning", "Moving blocks...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["moveMultipleBlocks"],
+  execute(ctx, params) {
+    const { blocks, types } = ctx.app;
+    if (params.uuids.length === 0) {
+      return { error: "No paragraph UUIDs provided" };
+    }
+    const validBlocks = [];
+    for (const uuid of params.uuids) {
+      const block = blocks.getBlock(uuid);
+      if (!block) {
+        return { error: `Paragraph not found: ${uuid}` };
+      }
+      validBlocks.push({ uuid, bundle: block.bundle });
+    }
+    const { $t } = ctx.app;
+    const firstBlock = validBlocks[0];
+    const label = validBlocks.length === 1 && firstBlock ? $t("aiAgentMoveBlockDone", "Moved @bundle").replace(
+      "@bundle",
+      types.getBlockLabel(firstBlock.bundle)
+    ) : $t("aiAgentMoveBlocksDone", "Moved @count blocks").replace(
+      "@count",
+      String(validBlocks.length)
+    );
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    if ("error" in resolved) return resolved;
+    return {
+      type: "move",
+      label,
+      apply: (adapter) => adapter.moveMultipleBlocks({
+        uuids: params.uuids,
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        afterUuid: resolved.afterUuid
+      })
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/rearrange_paragraphs/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/rearrange_paragraphs/index.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema, parentSchema } from "../schemas.js";
+import { itemEntityType } from "#blokkli-build/config";
+const paramsSchema = z.object({
+  parent: parentSchema.describe("The parent field containing the paragraphs"),
+  uuids: z.array(z.string()).min(2).describe(
+    "The UUIDs of the paragraphs in the desired order. Must include ALL paragraphs currently in the field."
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "rearrange_paragraphs",
+  description: "Rearrange paragraphs within a single field by specifying the desired order. You must provide ALL paragraph UUIDs that are currently in the field \u2014 use get_child_paragraphs to get them. This only reorders, it does not add or remove paragraphs.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "rearranged paragraphs" : "rejected",
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentRearrangeBlocksRunning", "Rearranging blocks...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["rearrangeBlocks"],
+  execute(ctx, params) {
+    const { blocks, types, context, state, $t } = ctx.app;
+    const isRootEntity = params.parent.uuid === context.value.entityUuid;
+    const entityType = isRootEntity ? context.value.entityType : itemEntityType;
+    const bundle = isRootEntity ? context.value.entityBundle : blocks.getBlock(params.parent.uuid)?.bundle;
+    if (!bundle) {
+      return { error: "Parent not found." };
+    }
+    const field = types.getFieldConfig(entityType, bundle, params.parent.field);
+    if (!field) {
+      const availableFields = types.fieldConfig.forEntityTypeAndBundle(entityType, bundle).map((f) => f.name);
+      return {
+        error: `Field "${params.parent.field}" not found on bundle "${bundle}". Available fields: ${availableFields.length ? availableFields.join(", ") : "none"}.`
+      };
+    }
+    const mutatedField = state.mutatedFields.value.find(
+      (f) => f.entityUuid === params.parent.uuid && f.name === params.parent.field
+    );
+    if (!mutatedField || mutatedField.list.length === 0) {
+      return {
+        error: `Field "${params.parent.field}" has no paragraphs on parent "${params.parent.uuid}".`
+      };
+    }
+    const currentUuids = mutatedField.list.map((item) => item.uuid);
+    if (params.uuids.length !== currentUuids.length) {
+      return {
+        error: `Expected ${currentUuids.length} UUIDs (all paragraphs in the field), got ${params.uuids.length}. Current UUIDs: ${currentUuids.join(", ")}`
+      };
+    }
+    const providedSet = new Set(params.uuids);
+    const currentSet = new Set(currentUuids);
+    if (providedSet.size !== params.uuids.length) {
+      return { error: "Duplicate UUIDs provided." };
+    }
+    for (const uuid of params.uuids) {
+      if (!currentSet.has(uuid)) {
+        return {
+          error: `Paragraph "${uuid}" is not in field "${params.parent.field}". Current UUIDs: ${currentUuids.join(", ")}`
+        };
+      }
+    }
+    for (const uuid of currentUuids) {
+      if (!providedSet.has(uuid)) {
+        return {
+          error: `Missing paragraph "${uuid}" from the provided list. You must include ALL paragraphs in the field.`
+        };
+      }
+    }
+    const isAlreadyInOrder = params.uuids.every(
+      (uuid, i) => uuid === currentUuids[i]
+    );
+    if (isAlreadyInOrder) {
+      return { error: "The paragraphs are already in the requested order." };
+    }
+    const label = $t(
+      "aiAgentRearrangeBlocksDone",
+      "Rearranged @count blocks"
+    ).replace("@count", String(params.uuids.length));
+    return {
+      type: "move",
+      label,
+      affectedUuids: params.uuids,
+      apply: (adapter) => adapter.rearrangeBlocks({
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        uuids: params.uuids
+      })
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/replace_content_search_item/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/replace_content_search_item/index.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "../schemas.js";
+const paramsSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID containing the content reference field"),
+  field: z.string().describe("The content field name (reference type)"),
+  itemId: z.string().describe("Content item ID from search_content_* results"),
+  itemEntityType: z.string().describe("Entity type of the content item"),
+  itemEntityBundle: z.string().describe("Entity bundle of the content item")
+});
+export default defineBlokkliAgentTool({
+  name: "replace_content_search_item",
+  description: "Replace a content reference on an existing paragraph field. Use get_content_fields first to see available reference fields, then search_content_* to find content items.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "replaced content reference" : "rejected",
+  modes: ["editing"],
+  label($t) {
+    return $t(
+      "aiAgentReplaceContentSearchItemRunning",
+      "Replacing content reference..."
+    );
+  },
+  lazy: true,
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["replaceContentSearchItem"],
+  execute(ctx, params) {
+    const { blocks, types, $t } = ctx.app;
+    const block = blocks.getBlock(params.uuid);
+    if (!block) {
+      return { error: `Paragraph not found: ${params.uuid}` };
+    }
+    const config = types.droppableFieldConfig.forName(
+      ctx.itemEntityType,
+      block.bundle,
+      params.field
+    );
+    if (!config) {
+      return {
+        error: `Field "${params.field}" is not a reference content field on ${block.bundle} paragraphs`
+      };
+    }
+    const allowedRestriction = config.allowed.find(
+      (v) => v.type === params.itemEntityType
+    );
+    if (!allowedRestriction) {
+      return {
+        error: `Field "${params.field}" does not accept ${params.itemEntityType} entities. Allowed types: ${config.allowed.map((v) => v.type).join(", ")}`
+      };
+    }
+    if (!allowedRestriction.bundles.includes(params.itemEntityBundle)) {
+      return {
+        error: `Field "${params.field}" does not accept ${params.itemEntityBundle} bundles. Allowed: ${allowedRestriction.bundles.join(", ")}`
+      };
+    }
+    const item = {
+      id: params.itemId,
+      entityType: params.itemEntityType,
+      entityBundle: params.itemEntityBundle,
+      title: params.itemId,
+      targetBundles: []
+    };
+    return {
+      type: "rewrite",
+      label: $t(
+        "aiAgentReplaceContentSearchItemDone",
+        "Replaced content reference on @field"
+      ).replace("@field", config.label),
+      apply: (adapter) => adapter.replaceContentSearchItem({
+        host: {
+          type: ctx.itemEntityType,
+          uuid: params.uuid,
+          fieldName: params.field
+        },
+        item
+      }),
+      affectedUuids: [params.uuid]
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/replace_media_field/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;