@blokkli/editor 2.0.0-alpha.32 → 2.0.0-alpha.34

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

@@ -0,0 +1,192 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { getFieldType, getEditableValue } from "../schemas.js";
+const paramsSchema = z.object({
+  uuids: z.array(z.string()).describe(
+    "One or more paragraph UUIDs (or the page UUID to get page-level fields)"
+  ),
+  includeNested: z.boolean().optional().default(true).describe(
+    "Recursively include content fields from all nested child paragraphs (default: true). Set to false to only get direct fields."
+  )
+});
+const fieldSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("plain").describe("Plain text field"),
+    currentValue: z.string().describe("Current field value"),
+    required: z.boolean().describe("Whether this field is required"),
+    maxLength: z.number().describe("Maximum character length (0 means unlimited)")
+  }),
+  z.object({
+    type: z.literal("markup").describe("Rich text / HTML field"),
+    currentValue: z.string().describe("Current field value"),
+    required: z.boolean().describe("Whether this field is required"),
+    maxLength: z.number().describe("Maximum character length (0 means unlimited)")
+  }),
+  z.object({
+    type: z.literal("reference").describe("Entity reference field"),
+    label: z.string().describe("Human-readable field label"),
+    allowed: z.array(
+      z.object({
+        type: z.string().describe('The entity type (e.g., "media", "node")'),
+        bundles: z.array(z.string()).describe("The bundles accepted for this entity type")
+      })
+    ).describe("Entity types and bundles this field accepts")
+  }),
+  z.object({
+    type: z.literal("link").describe("Link field"),
+    label: z.string().describe("Human-readable field label"),
+    allowed: z.array(
+      z.object({
+        type: z.string().describe('The entity type (e.g., "media", "node")'),
+        bundles: z.array(z.string()).describe("The bundles accepted for this entity type")
+      })
+    ).describe("Entity types and bundles this field accepts")
+  })
+]);
+const resultSchema = z.record(
+  z.string().describe("Paragraph UUID"),
+  z.record(z.string().describe("Field name"), fieldSchema)
+);
+function addField(result, uuid, fieldName, field) {
+  if (!result[uuid]) {
+    result[uuid] = {};
+  }
+  result[uuid][fieldName] = field;
+}
+export default defineBlokkliAgentTool({
+  name: "get_content_fields",
+  description: "Get all content fields (text, media, links) for a paragraph and optionally its nested children",
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => `fields for ${Object.keys(r || {}).length} paragraphs`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetContentFieldsRunning", "Getting content fields...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { blocks, directive, state, types, $t, context } = ctx.app;
+    const result = {};
+    const processedUuids = /* @__PURE__ */ new Set();
+    function processEntity(entityUuid) {
+      const entityType = context.value.entityType;
+      const entityBundle = context.value.entityBundle;
+      const editableConfigs = types.editableFieldConfig.forEntityTypeAndBundle(entityType, entityBundle).filter((f) => f.type !== "table");
+      for (const config of editableConfigs) {
+        const fieldType = config.type === "frame" || config.type === "markup" ? "markup" : "plain";
+        const currentValue = getEditableValue(
+          ctx.app,
+          entityType,
+          entityUuid,
+          entityBundle,
+          config.name,
+          fieldType
+        );
+        addField(result, entityUuid, config.name, {
+          type: fieldType,
+          currentValue,
+          required: config.required,
+          maxLength: config.maxLength
+        });
+      }
+      const droppableConfigs = types.droppableFieldConfig.forEntityTypeAndBundle(
+        entityType,
+        entityBundle
+      );
+      for (const config of droppableConfigs) {
+        addField(result, entityUuid, config.name, {
+          type: config.type,
+          label: config.label,
+          allowed: config.allowed
+        });
+      }
+    }
+    function processBlock(blockUuid) {
+      if (processedUuids.has(blockUuid)) return;
+      processedUuids.add(blockUuid);
+      const block = blocks.getBlock(blockUuid);
+      if (!block) return;
+      const editables = directive.getEditablesForBlock(blockUuid);
+      for (const editable of editables) {
+        const fieldType = getFieldType(
+          ctx.app,
+          ctx.itemEntityType,
+          block.bundle,
+          editable.fieldName
+        );
+        if (!fieldType) continue;
+        const currentValue = getEditableValue(
+          ctx.app,
+          ctx.itemEntityType,
+          blockUuid,
+          block.bundle,
+          editable.fieldName,
+          fieldType
+        );
+        const config = types.editableFieldConfig.forName(
+          ctx.itemEntityType,
+          block.bundle,
+          editable.fieldName
+        );
+        addField(result, blockUuid, editable.fieldName, {
+          type: fieldType,
+          currentValue,
+          required: config?.required ?? false,
+          maxLength: config?.maxLength ?? 0
+        });
+      }
+      const droppableConfigs = types.droppableFieldConfig.forEntityTypeAndBundle(
+        ctx.itemEntityType,
+        block.bundle
+      );
+      for (const config of droppableConfigs) {
+        addField(result, blockUuid, config.name, {
+          type: config.type,
+          label: config.label,
+          allowed: config.allowed
+        });
+      }
+      if (params.includeNested) {
+        const mutatedFields = state.mutatedFields.value;
+        for (const field of mutatedFields) {
+          if (field.entityUuid === blockUuid) {
+            for (const child of field.list) {
+              processBlock(child.uuid);
+            }
+          }
+        }
+      }
+    }
+    let hasEntity = false;
+    for (const uuid of params.uuids) {
+      if (uuid === context.value.entityUuid) {
+        hasEntity = true;
+        processEntity(uuid);
+      } else {
+        processBlock(uuid);
+      }
+    }
+    const count = params.uuids.length;
+    const label = hasEntity && count === 1 ? $t(
+      "aiAgentGetEntityContentFieldsDone",
+      "Got content fields of page entity"
+    ) : count === 1 ? $t(
+      "aiAgentGetContentFieldsDone",
+      "Got content fields of @bundle block"
+    ).replace(
+      "@bundle",
+      types.getBlockLabel(
+        blocks.getBlock(params.uuids[0])?.bundle || "unknown"
+      )
+    ) : $t(
+      "aiAgentGetContentFieldsMultipleDone",
+      "Got content fields of @count blocks"
+    ).replace("@count", String(count));
+    return {
+      label,
+      result,
+      affectedUuids: params.uuids
+    };
+  }
+});

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

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

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

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const paramsSchema = z.object({
+  before: z.number().optional().describe("How many mutations before current to include"),
+  after: z.number().optional().describe("How many mutations after current to include (redo-able)")
+});
+const mutationSummarySchema = z.object({
+  index: z.number().describe("History index for use with go_to_history_index"),
+  label: z.string().describe("Human-readable mutation label")
+});
+const currentMutationSchema = z.object({
+  index: z.number().describe("History index for use with go_to_history_index"),
+  label: z.string().describe("Human-readable mutation label"),
+  pluginId: z.string().optional().describe("Internal plugin ID"),
+  affectedParagraphUuid: z.string().optional().describe("UUID of the paragraph that was affected")
+});
+const resultSchema = z.object({
+  currentIndex: z.number().describe("Current position in history (-1 = pristine state)"),
+  totalCount: z.number().describe("Total mutations in history"),
+  canUndo: z.boolean().describe("Whether undo is possible"),
+  canRedo: z.boolean().describe("Whether redo is possible"),
+  currentMutation: currentMutationSchema.nullable().describe("Details of current mutation (null if at pristine state)"),
+  mutationsBefore: z.array(mutationSummarySchema).optional().describe("Previous mutations (if before > 0)"),
+  mutationsAfter: z.array(mutationSummarySchema).optional().describe("Following mutations (if after > 0)")
+});
+export default defineBlokkliAgentTool({
+  name: "get_mutation_history",
+  description: `Get information about the mutation history. Returns current position, undo/redo availability, and optionally context mutations before/after the current position. Use with go_to_history_index to navigate.`,
+  category: "query",
+  volatile: true,
+  lazy: true,
+  prunedSummary: (r) => `index ${r.currentIndex ?? -1}/${r.totalCount ?? 0}`,
+  modes: ["editing", "translating"],
+  label($t) {
+    return $t("aiAgentGetMutationHistoryRunning", "Getting mutation history...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { state, $t } = ctx.app;
+    const mutations = state.mutations.value;
+    const currentIndex = state.currentMutationIndex.value;
+    const totalCount = mutations.length;
+    const canUndo = currentIndex > -1;
+    const canRedo = currentIndex < totalCount - 1;
+    const getMutationLabel = (mutation) => {
+      return mutation.plugin?.label || mutation.pluginId || "Unknown mutation";
+    };
+    let currentMutation = null;
+    if (currentIndex >= 0 && currentIndex < mutations.length) {
+      const mutation = mutations[currentIndex];
+      if (mutation) {
+        currentMutation = {
+          index: currentIndex,
+          label: getMutationLabel(mutation),
+          pluginId: mutation.pluginId,
+          affectedParagraphUuid: mutation.plugin?.affectedItemUuid
+        };
+      }
+    }
+    let mutationsBefore;
+    if (params.before && params.before > 0 && currentIndex >= 0) {
+      const startIndex = Math.max(0, currentIndex - params.before);
+      mutationsBefore = [];
+      for (let i = startIndex; i < currentIndex; i++) {
+        const mutation = mutations[i];
+        if (mutation) {
+          mutationsBefore.push({
+            index: i,
+            label: getMutationLabel(mutation)
+          });
+        }
+      }
+    }
+    let mutationsAfter;
+    if (params.after && params.after > 0 && currentIndex < totalCount - 1) {
+      const endIndex = Math.min(totalCount - 1, currentIndex + params.after);
+      mutationsAfter = [];
+      for (let i = currentIndex + 1; i <= endIndex; i++) {
+        const mutation = mutations[i];
+        if (mutation) {
+          mutationsAfter.push({
+            index: i,
+            label: getMutationLabel(mutation)
+          });
+        }
+      }
+    }
+    return {
+      label: $t("aiAgentGetMutationHistoryDone", "Got mutation history"),
+      result: {
+        currentIndex,
+        totalCount,
+        canUndo,
+        canRedo,
+        currentMutation,
+        mutationsBefore,
+        mutationsAfter
+      }
+    };
+  }
+});

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

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

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

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  buildPageStructure,
+  buildBlock,
+  countBlocks
+} from "#blokkli/agent/app/helpers/pageStructure";
+const paramsSchema = z.object({
+  uuid: z.string().optional().describe(
+    "UUID of a specific paragraph. When provided, returns only that paragraph and its subtree. Omit to get the full page structure."
+  )
+});
+const resultSchema = z.object({
+  totalParagraphs: z.number().describe(
+    "Total number of paragraphs in scope (full page or subtree when uuid is given)"
+  ),
+  structure: z.string().describe("The page structure as an XML tree of paragraphs and fields")
+});
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function formatBlock(block, indent) {
+  const hasContent = block.contentFields || block.fields;
+  if (!hasContent) {
+    return `${indent}<Paragraph uuid="${block.uuid}" bundle="${escapeXml(block.bundle)}" />`;
+  }
+  const lines = [];
+  lines.push(
+    `${indent}<Paragraph uuid="${block.uuid}" bundle="${escapeXml(block.bundle)}">`
+  );
+  if (block.contentFields) {
+    for (const [name, value] of Object.entries(block.contentFields)) {
+      lines.push(
+        `${indent}  <ContentField name="${escapeXml(name)}">${escapeXml(value)}</ContentField>`
+      );
+    }
+  }
+  if (block.fields) {
+    for (const [fieldName, children] of Object.entries(block.fields)) {
+      lines.push(`${indent}  <ParagraphField name="${escapeXml(fieldName)}">`);
+      for (const child of children) {
+        lines.push(formatBlock(child, indent + "    "));
+      }
+      lines.push(`${indent}  </ParagraphField>`);
+    }
+  }
+  lines.push(`${indent}</Paragraph>`);
+  return lines.join("\n");
+}
+export default defineBlokkliAgentTool({
+  name: "get_page_structure",
+  description: "Get page structure as an XML tree of paragraphs, their fields, and content previews. Without a UUID, returns the full page. With a UUID, returns that paragraph and its subtree.",
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => `page structure (${r.totalParagraphs ?? 0} paragraphs)`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetPageStructureRunning", "Getting page structure...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    if (params.uuid) {
+      const block = ctx.app.blocks.getBlock(params.uuid);
+      if (!block) {
+        return { error: `Paragraph with UUID "${params.uuid}" not found.` };
+      }
+      const paragraph = buildBlock(ctx.app, params.uuid, block.bundle);
+      const total = countBlocks(paragraph);
+      return {
+        label: ctx.app.$t(
+          "aiAgentGetPageStructureDone",
+          "Got page structure (@count paragraphs)"
+        ).replace("@count", String(total)),
+        result: {
+          totalParagraphs: total,
+          structure: formatBlock(paragraph, "")
+        }
+      };
+    }
+    const pageContext = ctx.app.context.value;
+    const ps = buildPageStructure(ctx.app);
+    const lines = [];
+    lines.push(
+      `<Page uuid="${pageContext.entityUuid}" type="${escapeXml(pageContext.entityType)}" bundle="${escapeXml(pageContext.entityBundle)}">`
+    );
+    if (ps.entityContentFields) {
+      for (const [name, value] of Object.entries(ps.entityContentFields)) {
+        lines.push(
+          `  <ContentField name="${escapeXml(name)}">${escapeXml(value)}</ContentField>`
+        );
+      }
+    }
+    for (const [fieldName, blocks] of Object.entries(ps.fields)) {
+      lines.push(`  <ParagraphField name="${escapeXml(fieldName)}">`);
+      for (const block of blocks) {
+        lines.push(formatBlock(block, "    "));
+      }
+      lines.push(`  </ParagraphField>`);
+    }
+    lines.push(`</Page>`);
+    return {
+      label: ctx.app.$t(
+        "aiAgentGetPageStructureDone",
+        "Got page structure (@count paragraphs)"
+      ).replace("@count", String(ps.totalParagraphs)),
+      result: {
+        totalParagraphs: ps.totalParagraphs,
+        structure: lines.join("\n")
+      }
+    };
+  }
+});

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

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

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

@@ -0,0 +1,275 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  parentSchema,
+  blockOptionsMapSchema,
+  buildBlockOptionsMap
+} from "../schemas.js";
+import { getAvailableOptions } from "#blokkli/editor/helpers/options";
+const paramsSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  includeParentChain: z.boolean().optional().default(true).describe("Include ancestor parent paragraphs up to the page"),
+  includeSiblings: z.boolean().optional().default(false).describe("Include sibling paragraphs in the same field"),
+  includeChildren: z.boolean().optional().default(true).describe("Include child fields summary"),
+  includeContentFields: z.boolean().optional().default(true).describe("Include content fields (text, media, links) with values"),
+  includeOptions: z.boolean().optional().default(true).describe("Include paragraph options")
+});
+const parentChainItemSchema = z.object({
+  uuid: z.string().describe("The parent paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label"),
+  field: z.string().describe("The field name this paragraph is in")
+});
+const siblingInfoSchema = z.object({
+  total: z.number().describe("Total number of siblings including this paragraph"),
+  position: z.number().describe("1-based position of this paragraph"),
+  prev: z.object({
+    uuid: z.string(),
+    bundle: z.string()
+  }).nullable().describe("Previous sibling paragraph"),
+  next: z.object({
+    uuid: z.string(),
+    bundle: z.string()
+  }).nullable().describe("Next sibling paragraph")
+});
+const childFieldSchema = z.object({
+  name: z.string().describe("Field name"),
+  label: z.string().describe("Human-readable field label"),
+  count: z.number().describe("Number of paragraphs in this field"),
+  cardinality: z.number().describe("Max paragraphs allowed (-1 = unlimited)"),
+  bundles: z.array(z.string()).describe("Unique bundle types in this field")
+});
+const contentFieldSchema = z.discriminatedUnion("type", [
+  z.object({
+    field: z.string().describe("The field name"),
+    type: z.literal("plain").describe("Plain text field"),
+    currentValue: z.string().describe("Current field value")
+  }),
+  z.object({
+    field: z.string().describe("The field name"),
+    type: z.literal("markup").describe("Rich text / HTML field"),
+    currentValue: z.string().describe("Current field value")
+  }),
+  z.object({
+    field: z.string().describe("The field name"),
+    label: z.string().describe("Human-readable field label"),
+    type: z.literal("reference").describe("Entity reference field"),
+    allowed: z.array(
+      z.object({
+        type: z.string().describe('The entity type (e.g., "media", "node")'),
+        bundles: z.array(z.string()).describe("The bundles accepted for this entity type")
+      })
+    ).describe("Entity types and bundles this field accepts")
+  }),
+  z.object({
+    field: z.string().describe("The field name"),
+    label: z.string().describe("Human-readable field label"),
+    type: z.literal("link").describe("Link field"),
+    allowed: z.array(
+      z.object({
+        type: z.string().describe('The entity type (e.g., "media", "node")'),
+        bundles: z.array(z.string()).describe("The bundles accepted for this entity type")
+      })
+    ).describe("Entity types and bundles this field accepts")
+  })
+]);
+const resultSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label"),
+  nestingLevel: z.number().describe("Nesting depth (0 = root level)"),
+  parent: parentSchema.nullable().describe("The parent entity containing this paragraph"),
+  parentChain: z.array(parentChainItemSchema).optional().describe("Ancestor parent paragraphs from immediate parent to page"),
+  siblings: siblingInfoSchema.optional().describe("Information about sibling paragraphs in the same field"),
+  childFields: z.array(childFieldSchema).optional().describe("Child fields with paragraph counts"),
+  contentFields: z.array(contentFieldSchema).optional().describe("Content fields (text, media, links) with current values"),
+  options: blockOptionsMapSchema.optional().describe("Paragraph options with current values")
+});
+export default defineBlokkliAgentTool({
+  name: "get_paragraph_context",
+  description: "Get comprehensive context for a single paragraph including parent chain, siblings, children, content fields, and options. Preferred over multiple individual tool calls.",
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => `context for ${r.bundle || "paragraph"} (${r.uuid?.slice(0, 8) || "?"})`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetBlockContextRunning", "Getting block context...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const {
+      blocks,
+      state,
+      context,
+      types,
+      directive,
+      definitions,
+      selection,
+      $t
+    } = ctx.app;
+    const block = blocks.getBlock(params.uuid);
+    if (!block) {
+      return {
+        error: `Paragraph not found: ${params.uuid}`
+      };
+    }
+    const bundleLabel = types.getBlockLabel(block.bundle);
+    const fieldList = state.getFieldListForBlock(params.uuid);
+    let parent = null;
+    if (fieldList) {
+      const parentType = fieldList.entityUuid === context.value.entityUuid ? context.value.entityType : ctx.itemEntityType;
+      parent = {
+        type: parentType,
+        uuid: fieldList.entityUuid,
+        field: fieldList.name
+      };
+    }
+    const result = {
+      uuid: params.uuid,
+      bundle: block.bundle,
+      label: bundleLabel,
+      nestingLevel: state.getNestingLevel(params.uuid),
+      parent
+    };
+    if (params.includeParentChain) {
+      const parentChain = [];
+      let currentUuid = state.getParentEntityUuid(params.uuid);
+      while (currentUuid && currentUuid !== context.value.entityUuid) {
+        const parentBlock = blocks.getBlock(currentUuid);
+        const parentField = state.getFieldListForBlock(currentUuid);
+        if (parentBlock && parentField) {
+          parentChain.push({
+            uuid: currentUuid,
+            bundle: parentBlock.bundle,
+            label: types.getBlockLabel(parentBlock.bundle),
+            field: parentField.name
+          });
+        }
+        currentUuid = state.getParentEntityUuid(currentUuid);
+      }
+      result.parentChain = parentChain;
+    }
+    if (params.includeSiblings && fieldList) {
+      const siblings = fieldList.list;
+      const currentIndex = siblings.findIndex(
+        (item) => item.uuid === params.uuid
+      );
+      if (currentIndex !== -1) {
+        const prevSibling = currentIndex > 0 ? siblings[currentIndex - 1] : null;
+        const nextSibling = currentIndex < siblings.length - 1 ? siblings[currentIndex + 1] : null;
+        result.siblings = {
+          total: siblings.length,
+          position: currentIndex + 1,
+          prev: prevSibling ? { uuid: prevSibling.uuid, bundle: prevSibling.bundle } : null,
+          next: nextSibling ? { uuid: nextSibling.uuid, bundle: nextSibling.bundle } : null
+        };
+      }
+    }
+    if (params.includeChildren) {
+      const mutatedFields = state.mutatedFields.value;
+      const childFields = [];
+      for (const field of mutatedFields) {
+        if (field.entityUuid === params.uuid && field.list.length > 0) {
+          const uniqueBundles = [
+            ...new Set(field.list.map((item) => item.bundle))
+          ];
+          const fieldConfig = types.fieldConfig.forName(
+            field.entityType,
+            block.bundle,
+            field.name
+          );
+          childFields.push({
+            name: field.name,
+            label: fieldConfig?.label || field.name,
+            count: field.list.length,
+            cardinality: fieldConfig?.cardinality ?? -1,
+            bundles: uniqueBundles
+          });
+        }
+      }
+      if (childFields.length > 0) {
+        result.childFields = childFields;
+      }
+    }
+    if (params.includeContentFields) {
+      const fields = [];
+      const editables = directive.getEditablesForBlock(params.uuid);
+      for (const editable of editables) {
+        const config = types.editableFieldConfig.forName(
+          ctx.itemEntityType,
+          block.bundle,
+          editable.fieldName
+        );
+        if (!config) continue;
+        if (config.type === "table") continue;
+        const fieldType = config.type === "frame" || config.type === "markup" ? "markup" : "plain";
+        let currentValue = "";
+        if (editable.getValue) {
+          currentValue = editable.getValue();
+        } else {
+          const element = directive.findEditableElement(editable.fieldName, {
+            type: ctx.itemEntityType,
+            uuid: params.uuid,
+            bundle: block.bundle
+          });
+          if (element) {
+            currentValue = fieldType === "markup" ? element.innerHTML || "" : element.textContent || "";
+          }
+        }
+        fields.push({
+          field: editable.fieldName,
+          type: fieldType,
+          currentValue
+        });
+      }
+      const droppableConfigs = types.droppableFieldConfig.forEntityTypeAndBundle(
+        ctx.itemEntityType,
+        block.bundle
+      );
+      for (const config of droppableConfigs) {
+        fields.push({
+          field: config.name,
+          label: config.label,
+          type: config.type,
+          allowed: config.allowed
+        });
+      }
+      if (fields.length > 0) {
+        result.contentFields = fields;
+      }
+    }
+    if (params.includeOptions) {
+      const selectionItem = selection.items.value.find(
+        (v) => v.uuid === params.uuid
+      );
+      const definition = definitions.getBlockDefinition(
+        block.bundle,
+        selectionItem?.fieldListType ?? "default",
+        selectionItem?.parentBlockBundle
+      );
+      if (definition) {
+        const availableOptions = getAvailableOptions(
+          definition.options,
+          definition.globalOptions,
+          definitions.globalOptions.value
+        );
+        if (availableOptions.length > 0) {
+          result.options = buildBlockOptionsMap(
+            availableOptions,
+            state.mutatedOptions,
+            params.uuid
+          );
+        }
+      }
+    }
+    return {
+      label: $t(
+        "aiAgentGetBlockContextDone",
+        "Got context for @bundle"
+      ).replace("@bundle", bundleLabel),
+      result,
+      affectedUuids: [params.uuid]
+    };
+  }
+});