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

package/dist/modules/agent/runtime/app/tools/batch_rewrite_text/Component.vue

@@ -0,0 +1,190 @@
+<template>
+  <ToolCard
+    v-if="params.requireApproval !== false"
+    icon="bk_mdi_edit"
+    :title="
+  $t('aiAgentBatchRewriteTitle', 'Rewrite @count fields').replace(
+    '@count',
+    String(items.length)
+  )
+"
+    @cancel="rejectAll"
+  >
+    <div
+      v-if="!isApplying"
+      class="bk-batch-rewrite-list"
+      @mouseleave="onMouseLeave"
+    >
+      <ItemComponent
+        v-for="item in items"
+        :key="item.id"
+        v-model:selected="selected[item.id]"
+        v-model:reason="reasons[item.id]"
+        :uuid="item.uuid"
+        :field-name="item.fieldName"
+        :field-label="item.fieldLabel"
+        :new-value="item.value"
+      />
+    </div>
+
+    <template #actions>
+      <button
+        class="bk-button bk-is-small bk-is-lime bk-is-fullwidth"
+        @click="applySelected"
+      >
+        <Icon name="bk_mdi_check" />
+        <span>{{ applyLabel }}</span>
+      </button>
+    </template>
+  </ToolCard>
+</template>
+
+<script setup>
+import { computed, useBlokkli, ref, reactive, onMounted } from "#imports";
+import { Icon } from "#blokkli/editor/components";
+import ToolCard from "../../features/agent/Panel/ToolCard/index.vue";
+import ItemComponent from "./Item.vue";
+import { itemEntityType } from "#blokkli-build/config";
+const props = defineProps({
+  context: { type: null, required: true },
+  params: { type: null, required: true }
+});
+const emit = defineEmits(["done"]);
+const {
+  $t,
+  state,
+  blocks,
+  context: editorContext,
+  types,
+  eventBus
+} = useBlokkli();
+const isApplying = ref(false);
+onMounted(() => {
+  if (props.params.requireApproval === false) {
+    applySelected();
+  }
+});
+function resolveFieldLabel(uuid, fieldName) {
+  let entityType;
+  let bundle;
+  if (uuid === editorContext.value.entityUuid) {
+    entityType = editorContext.value.entityType;
+    bundle = editorContext.value.entityBundle;
+  } else {
+    const block = blocks.getBlock(uuid);
+    if (!block) {
+      return fieldName;
+    }
+    entityType = itemEntityType;
+    bundle = block.bundle;
+  }
+  const config = types.editableFieldConfig.forName(
+    entityType,
+    bundle,
+    fieldName
+  );
+  return config?.label || fieldName;
+}
+let idCounter = 0;
+const items = Object.entries(props.params.uuids).flatMap(
+  ([uuid, fields]) => Object.entries(fields).map(([fieldName, value]) => ({
+    id: idCounter++,
+    uuid,
+    fieldName,
+    fieldLabel: resolveFieldLabel(uuid, fieldName),
+    value
+  }))
+);
+const selected = reactive(
+  Object.fromEntries(items.map((item) => [item.id, true]))
+);
+const reasons = reactive(
+  Object.fromEntries(items.map((item) => [item.id, ""]))
+);
+const selectedCount = computed(
+  () => items.filter((item) => selected[item.id]).length
+);
+function onMouseLeave() {
+  eventBus.emit("highlight", null);
+}
+async function applySelected() {
+  const rejectedByUser = {};
+  const entityUuid = editorContext.value.entityUuid;
+  const batchItems = [];
+  const entityItems = [];
+  for (const item of items) {
+    if (!selected[item.id]) {
+      const fields = rejectedByUser[item.uuid] ?? {};
+      fields[item.fieldName] = { reasonForRejection: reasons[item.id] || "" };
+      rejectedByUser[item.uuid] = fields;
+      continue;
+    }
+    if (item.uuid === entityUuid) {
+      entityItems.push({
+        fieldName: item.fieldName,
+        fieldValue: item.value
+      });
+    } else {
+      batchItems.push({
+        uuid: item.uuid,
+        fieldName: item.fieldName,
+        fieldValue: item.value
+      });
+    }
+  }
+  isApplying.value = true;
+  await state.mutateWithLoadingState(
+    () => props.context.adapter.updateFieldValueBatched({
+      items: batchItems,
+      entityItems
+    })
+  );
+  const acceptedCount = batchItems.length + entityItems.length;
+  const label = acceptedCount === items.length ? $t(
+    "aiAgentBatchRewriteAllApplied",
+    "All @count changes applied"
+  ).replace("@count", String(acceptedCount)) : $t(
+    "aiAgentBatchRewriteSomeApplied",
+    "@applied of @total changes applied"
+  ).replace("@applied", String(acceptedCount)).replace("@total", String(items.length));
+  const rejectedWithoutReason = [];
+  for (const [uuid, fields] of Object.entries(rejectedByUser)) {
+    for (const [fieldName, v] of Object.entries(fields)) {
+      if (!v?.reasonForRejection) {
+        rejectedWithoutReason.push({ uuid, fieldName });
+      }
+    }
+  }
+  let agentMessage;
+  if (rejectedWithoutReason.length === 1 || rejectedWithoutReason.length === 2) {
+    const fieldList = rejectedWithoutReason.map((r) => `"${r.fieldName}" of paragraph ${r.uuid}`).join(" and ");
+    agentMessage = `The user rejected ${fieldList} without a reason. Use the ask_question tool to present the user with 2 or more alternative texts for each rejected field.`;
+  } else if (rejectedWithoutReason.length > 2) {
+    agentMessage = "Some changes were rejected without a reason. Ask the user what they would like to change instead.";
+  }
+  emit("done", {
+    acceptedCount,
+    rejectedByUser,
+    label,
+    agentMessage,
+    historyIndex: state.currentMutationIndex.value
+  });
+}
+function rejectAll() {
+  const rejectedByUser = {};
+  for (const item of items) {
+    const fields = rejectedByUser[item.uuid] ?? {};
+    fields[item.fieldName] = { reasonForRejection: "" };
+    rejectedByUser[item.uuid] = fields;
+  }
+  emit("done", {
+    acceptedCount: 0,
+    rejectedByUser,
+    label: $t("aiAgentBatchRewriteAllRejected", "All changes rejected"),
+    agentMessage: "All changes were rejected by the user. Ask the user what they would like to change instead."
+  });
+}
+const applyLabel = computed(() => {
+  return $t("aiAgentBatchRewriteApply", "Apply @count of @total").replace("@count", selectedCount.value.toString()).replace("@total", items.length.toString());
+});
+</script>

package/dist/modules/agent/runtime/app/tools/batch_rewrite_text/Component.vue.d.ts

@@ -0,0 +1,29 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { BatchRewriteParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: BatchRewriteParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: {
+        acceptedCount: number;
+        rejectedByUser: Record<string, Record<string, {
+            reasonForRejection: string;
+        }>>;
+        label: string;
+        agentMessage?: string | undefined;
+        historyIndex?: number | undefined;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: ((result: {
+        acceptedCount: number;
+        rejectedByUser: Record<string, Record<string, {
+            reasonForRejection: string;
+        }>>;
+        label: string;
+        agentMessage?: string | undefined;
+        historyIndex?: number | undefined;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/agent/runtime/app/tools/batch_rewrite_text/Item.d.vue.ts

@@ -0,0 +1,20 @@
+type __VLS_Props = {
+    uuid: string;
+    fieldName: string;
+    fieldLabel: string;
+    newValue: string;
+};
+type __VLS_ModelProps = {
+    'selected'?: boolean;
+    'reason'?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:selected": (value: boolean) => any;
+    "update:reason": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:selected"?: ((value: boolean) => any) | undefined;
+    "onUpdate:reason"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/agent/runtime/app/tools/batch_rewrite_text/Item.vue

@@ -0,0 +1,90 @@
+<template>
+  <div
+    class="bk-batch-rewrite-item"
+    :class="{ 'bk-is-deselected': !selected }"
+    @mouseenter="onMouseEnter"
+  >
+    <label class="bk-checkbox">
+      <input type="checkbox" :checked="selected" @change="onChange" />
+      <span>{{ fieldLabel }}</span>
+    </label>
+    <div class="bk-batch-rewrite-change">
+      <div @click.prevent="onChange">
+        <DiffValue :before="override.originalValue" :after="newValue" />
+      </div>
+      <div v-if="!selected" class="bk-batch-rewrite-reason">
+        <FlexTextarea
+          v-model="reason"
+          textarea-class
+          :max-height="100"
+          :min-height="42"
+          :placeholder="
+  $t(
+    'aiAgentBatchRewriteReasonPlaceholder',
+    'Reason for rejection (optional)'
+  )
+"
+          @click.prevent
+        />
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { watch, onBeforeUnmount, useBlokkli, nextTick } from "#imports";
+import { DiffValue, FlexTextarea } from "#blokkli/editor/components";
+import { useEditableFieldOverride } from "#blokkli/editor/composables";
+import { itemEntityType } from "#blokkli-build/config";
+const props = defineProps({
+  uuid: { type: String, required: true },
+  fieldName: { type: String, required: true },
+  fieldLabel: { type: String, required: true },
+  newValue: { type: String, required: true }
+});
+const selected = defineModel("selected", { type: Boolean, ...{ default: false } });
+const reason = defineModel("reason", { type: String, ...{ default: "" } });
+const { blocks, context, eventBus, $t } = useBlokkli();
+function resolveHost() {
+  if (props.uuid === context.value.entityUuid) {
+    return {
+      type: context.value.entityType,
+      bundle: context.value.entityBundle,
+      uuid: props.uuid
+    };
+  }
+  const block = blocks.getBlock(props.uuid);
+  return {
+    type: itemEntityType,
+    bundle: block?.bundle || "",
+    uuid: props.uuid
+  };
+}
+const host = resolveHost();
+const override = useEditableFieldOverride(props.fieldName, host);
+function onMouseEnter() {
+  if (override.element) {
+    eventBus.emit("highlight", override.element);
+    eventBus.emit("scrollIntoView", {
+      element: override.element,
+      immediate: true
+    });
+  }
+}
+override.setValue(props.newValue);
+async function onChange() {
+  selected.value = !selected.value;
+  await nextTick();
+  onMouseEnter();
+}
+watch(selected, (isSelected) => {
+  if (isSelected) {
+    override.setValue(props.newValue);
+  } else {
+    override.restore();
+  }
+});
+onBeforeUnmount(() => {
+  override.restore();
+});
+</script>

package/dist/modules/agent/runtime/app/tools/batch_rewrite_text/Item.vue.d.ts

@@ -0,0 +1,20 @@
+type __VLS_Props = {
+    uuid: string;
+    fieldName: string;
+    fieldLabel: string;
+    newValue: string;
+};
+type __VLS_ModelProps = {
+    'selected'?: boolean;
+    'reason'?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:selected": (value: boolean) => any;
+    "update:reason": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:selected"?: ((value: boolean) => any) | undefined;
+    "onUpdate:reason"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>;
+    requireApproval: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const resultSchema: z.ZodObject<{
+    acceptedCount: z.ZodNumber;
+    rejectedByUser: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        reasonForRejection: z.ZodString;
+    }, z.core.$strip>>>;
+    label: z.ZodString;
+    agentMessage: z.ZodOptional<z.ZodString>;
+    historyIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type BatchRewriteParams = z.infer<typeof paramsSchema>;
+export type BatchRewriteResult = z.infer<typeof resultSchema>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import Component from "./Component.vue";
+const paramsSchema = z.object({
+  uuids: z.record(z.string(), z.record(z.string(), z.string())).describe(
+    "A map of uuids containing a map of field names to field values."
+  ),
+  requireApproval: z.boolean().optional().describe("Whether to show the approval UI.")
+});
+const resultSchema = z.object({
+  acceptedCount: z.number().describe("Number of changes accepted by the user"),
+  rejectedByUser: z.record(
+    z.string(),
+    z.record(
+      z.string(),
+      z.object({
+        reasonForRejection: z.string().describe(
+          "Reason provided by the user for rejecting, empty if no reason given"
+        )
+      })
+    )
+  ).describe(
+    "Map of rejected paragraph UUID to field name to rejection details"
+  ),
+  label: z.string().describe("Human-readable summary shown in the UI"),
+  agentMessage: z.string().optional().describe(
+    "Detailed message for the agent, replaces label in the LLM context"
+  ),
+  historyIndex: z.number().optional().describe("The mutation history index after applying changes")
+});
+export default defineBlokkliAgentTool({
+  name: "batch_rewrite_text",
+  description: 'Rewrite text content in multiple content fields at once. Set requireApproval to true when the user should confirm the changes first. EXAMPLE: { "uuids": { "<UUID>": { "title": "New title", "text": "New text" } } }',
+  category: "mutation",
+  prunedSummary: (r) => `${r.acceptedCount || 0} accepted, ${Object.keys(r.rejectedByUser || {}).length} rejected`,
+  modes: ["editing", "translating"],
+  label($t) {
+    return $t("aiAgentBatchRewriteTextRunning", "Rewriting multiple texts...");
+  },
+  paramsSchema,
+  resultSchema,
+  requiredAdapterMethods: ["updateFieldValueBatched"],
+  component: Component,
+  execute(_ctx, params) {
+    return params;
+  },
+  mockParams: () => ({
+    uuids: {
+      "mock-1": { title: "Updated Title Text" },
+      "mock-2": { body: "This is the new body content with some changes." },
+      "mock-3": { subtitle: "A fresh subtitle here" }
+    },
+    requireApproval: true
+  })
+});

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

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

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

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "../schemas.js";
+const paramsSchema = z.object({
+  uuids: z.array(z.string()).describe("The UUIDs of the paragraphs to delete")
+});
+export default defineBlokkliAgentTool({
+  name: "delete_paragraphs",
+  description: "Delete one or more paragraphs from the page. Requires user approval before the paragraphs are actually deleted.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "deleted paragraphs" : "rejected",
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentDeleteBlocksRunning", "Deleting blocks...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["deleteBlocks"],
+  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("aiAgentDeleteBlockDone", "Deleted @bundle").replace(
+      "@bundle",
+      types.getBlockLabel(firstBlock.bundle)
+    ) : $t("aiAgentDeleteBlocksDone", "Deleted @count blocks").replace(
+      "@count",
+      String(validBlocks.length)
+    );
+    return {
+      type: "delete",
+      label,
+      apply: (adapter) => adapter.deleteBlocks(params.uuids)
+    };
+  }
+});

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

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

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

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "../schemas.js";
+import { fromLibraryBlockBundle } from "#blokkli-build/config";
+const paramsSchema = z.object({
+  uuids: z.array(z.string()).describe("UUIDs of library paragraphs to detach")
+});
+export default defineBlokkliAgentTool({
+  name: "detach_reusable_paragraph",
+  description: "Detach one or more library paragraphs to create editable copies. IMPORTANT: The original library paragraph UUIDs will no longer exist after detaching. The result includes newParagraphs containing the UUIDs and bundles of the newly created editable paragraph. Use these new UUIDs for any subsequent operations.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? `detached ${r.newParagraphs?.length || 0} paragraphs` : "rejected",
+  lazy: true,
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentDetachLibraryBlockRunning", "Detaching library block...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["detachReusableBlock"],
+  execute(ctx, params) {
+    const { blocks, $t } = ctx.app;
+    if (params.uuids.length === 0) {
+      return { error: "No paragraph UUIDs provided" };
+    }
+    for (const uuid of params.uuids) {
+      const block = blocks.getBlock(uuid);
+      if (!block) {
+        return { error: `Paragraph not found: ${uuid}` };
+      }
+      if (block.bundle !== fromLibraryBlockBundle) {
+        return {
+          error: `Paragraph ${uuid} is not a library paragraph (bundle: ${block.bundle}). Only ${fromLibraryBlockBundle} paragraphs can be detached.`
+        };
+      }
+    }
+    const label = params.uuids.length === 1 ? $t("aiAgentDetachLibraryBlockDone", "Detached library block") : $t(
+      "aiAgentDetachLibraryBlocksDone",
+      "Detached @count library blocks"
+    ).replace("@count", String(params.uuids.length));
+    return {
+      type: "rewrite",
+      label,
+      apply: (adapter) => adapter.detachReusableBlock({ uuids: params.uuids })
+    };
+  }
+});

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

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

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

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema,
+  resolvePosition
+} from "../schemas.js";
+import {
+  validateBlocksExist,
+  validateSameField,
+  validateFieldCardinality,
+  validateBundlesAllowed
+} from "../../helpers/validation.js";
+import { getFieldKey } from "#blokkli/helpers";
+import { itemEntityType } from "#blokkli-build/config";
+const paramsSchema = z.object({
+  uuids: z.array(z.string()).min(1).describe("Paragraph UUIDs to duplicate"),
+  parent: parentSchema.optional().describe("Target parent field. If omitted, duplicates in same field."),
+  position: positionSchema.describe(
+    'Where to place the duplicated paragraphs (only when parent is provided). Defaults to "end".'
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "duplicate_paragraphs",
+  description: "Duplicate one or more paragraphs, with ALL their child paragraphs. Without parent parameter, duplicates in the same field. With parent parameter, duplicates to a different field.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? `duplicated ${r.newParagraphs?.length || 0} paragraphs` : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentDuplicateBlocksRunning", "Duplicating blocks...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["duplicateBlocks"],
+  execute(ctx, params) {
+    const { $t, types, context, blocks } = ctx.app;
+    const blocksResult = validateBlocksExist(ctx.app, params.uuids);
+    if ("error" in blocksResult) return blocksResult;
+    if (params.parent) {
+      if (!ctx.adapter.pasteExistingBlocks) {
+        return {
+          error: "Duplicating to another field is not supported by this adapter"
+        };
+      }
+      const isRootEntity = params.parent.uuid === context.value.entityUuid;
+      const entityType = isRootEntity ? context.value.entityType : itemEntityType;
+      const targetBundle = isRootEntity ? context.value.entityBundle : blocks.getBlock(params.parent.uuid)?.bundle;
+      if (!targetBundle) {
+        return { error: "Target parent not found." };
+      }
+      const fieldConfig = types.getFieldConfig(
+        entityType,
+        targetBundle,
+        params.parent.field
+      );
+      if (!fieldConfig) {
+        return {
+          error: `Field "${params.parent.field}" not found on target parent.`
+        };
+      }
+      const bundles2 = blocksResult.blocks.map((b) => b.bundle);
+      if (fieldConfig.allowedBundles.length) {
+        const disallowed = bundles2.filter(
+          (b) => !fieldConfig.allowedBundles.includes(b)
+        );
+        if (disallowed.length > 0) {
+          return {
+            error: `Bundle(s) "${disallowed.join(", ")}" not allowed in field "${params.parent.field}". Allowed: ${fieldConfig.allowedBundles.join(", ")}`
+          };
+        }
+      }
+      const fieldKey = getFieldKey(params.parent.uuid, params.parent.field);
+      if (fieldConfig.cardinality !== -1) {
+        const currentCount = ctx.app.state.getFieldBlockCount(fieldKey);
+        if (currentCount + params.uuids.length > fieldConfig.cardinality) {
+          return {
+            error: `Field "${params.parent.field}" can only hold ${fieldConfig.cardinality} paragraphs (currently has ${currentCount}, trying to add ${params.uuids.length})`
+          };
+        }
+      }
+      const label2 = params.uuids.length === 1 ? $t(
+        "aiAgentDuplicateBlockToFieldDone",
+        "Duplicated @bundle to @field"
+      ).replace(
+        "@bundle",
+        types.getBlockLabel(blocksResult.blocks[0].bundle)
+      ).replace("@field", params.parent.field) : $t(
+        "aiAgentDuplicateBlocksToFieldDone",
+        "Duplicated @count blocks to @field"
+      ).replace("@count", String(params.uuids.length)).replace("@field", params.parent.field);
+      const resolved = resolvePosition(
+        ctx.app,
+        params.parent.uuid,
+        params.parent.field,
+        params.position
+      );
+      if ("error" in resolved) return resolved;
+      return {
+        type: "add",
+        label: label2,
+        apply: (adapter) => adapter.pasteExistingBlocks({
+          uuids: params.uuids,
+          host: {
+            type: params.parent.type,
+            uuid: params.parent.uuid,
+            fieldName: params.parent.field
+          },
+          preceedingUuid: resolved.afterUuid
+        })
+      };
+    }
+    const fieldResult = validateSameField(blocksResult.blocks);
+    if ("error" in fieldResult) return fieldResult;
+    const cardinalityResult = validateFieldCardinality(
+      ctx.app,
+      fieldResult.host,
+      fieldResult.fieldKey,
+      params.uuids.length
+    );
+    if (!cardinalityResult.valid) return { error: cardinalityResult.error };
+    const bundles = blocksResult.blocks.map((b) => b.bundle);
+    const bundlesResult = validateBundlesAllowed(
+      ctx.app,
+      fieldResult.host,
+      bundles
+    );
+    if (!bundlesResult.valid) return { error: bundlesResult.error };
+    const label = params.uuids.length === 1 ? $t("aiAgentDuplicateBlockDone", "Duplicated @bundle").replace(
+      "@bundle",
+      types.getBlockLabel(blocksResult.blocks[0].bundle)
+    ) : $t("aiAgentDuplicateBlocksDone", "Duplicated @count blocks").replace(
+      "@count",
+      String(params.uuids.length)
+    );
+    return {
+      type: "add",
+      // duplicating adds blocks
+      label,
+      apply: (adapter) => adapter.duplicateBlocks(params.uuids)
+    };
+  }
+});

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

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