@blokkli/editor 2.0.0-alpha.59 → 2.0.0-alpha.60

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@blokkli/editor",
   "configKey": "blokkli",
-  "version": "2.0.0-alpha.59",
+  "version": "2.0.0-alpha.60",
   "compatibility": {
     "nuxt": ">=3.15.0"
   },

package/dist/module.mjs

@@ -19,7 +19,7 @@ import 'typescript';
 import 'oxc-walker';
 
 const name = "@blokkli/editor";
-const version = "2.0.0-alpha.59";
+const version = "2.0.0-alpha.60";
 
 function validateOption(optionKey, option, icons) {
   const errors = [];
@@ -1512,6 +1512,7 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_add_column_right",
   "bk_mdi_add_comment",
   "bk_mdi_add_row_below",
+  "bk_mdi_alternate_email",
   "bk_mdi_anchor",
   "bk_mdi_architecture",
   "bk_mdi_area_chart",
@@ -1552,6 +1553,7 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_construction",
   "bk_mdi_content_copy",
   "bk_mdi_content_paste",
+  "bk_mdi_crop_9_16",
   "bk_mdi_csv",
   "bk_mdi_dashboard",
   "bk_mdi_data_object",
@@ -1569,6 +1571,7 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_exit_to_app",
   "bk_mdi_expand_all",
   "bk_mdi_extension",
+  "bk_mdi_eye_tracking",
   "bk_mdi_feature_search",
   "bk_mdi_fit_screen",
   "bk_mdi_format_bold",
@@ -1601,11 +1604,13 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_lists",
   "bk_mdi_lock",
   "bk_mdi_logo_dev",
+  "bk_mdi_mark_chat_read",
   "bk_mdi_menu",
   "bk_mdi_mobile",
   "bk_mdi_mobile_rotate",
   "bk_mdi_monitor",
   "bk_mdi_newspaper",
+  "bk_mdi_notifications",
   "bk_mdi_open_in_new",
   "bk_mdi_palette",
   "bk_mdi_person",
@@ -1658,6 +1663,7 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_undo",
   "bk_mdi_unpublished",
   "bk_mdi_upload",
+  "bk_mdi_verified",
   "bk_mdi_video_camera_back",
   "bk_mdi_visibility",
   "bk_mdi_visibility_off",
@@ -1921,7 +1927,9 @@ export default adapterExtensions
   }
 );
 
+const logger$2 = useLogger("@blokkli/editor");
 let processor = null;
+let processorUnavailable = false;
 function postcssMangleClasses(selectorParser) {
   const plugin = () => ({
     postcssPlugin: "postcss-mangle-blokkli-classes",
@@ -1963,12 +1971,16 @@ function postcssMangleClasses(selectorParser) {
   plugin.postcss = true;
   return plugin;
 }
+async function ensureProcessor() {
+  if (processor || processorUnavailable) return processor;
+  processor = await createProcessor();
+  return processor;
+}
 async function processCSS(css, from, contentPaths) {
-  if (!processor) {
-    processor = await createProcessor();
-  }
+  const proc = await ensureProcessor();
+  if (!proc) return css;
   const sourceDirectives = contentPaths?.length ? "\n" + contentPaths.map((dir) => `@source "${dir}/**/*.vue";`).join("\n") : "";
-  const result = await processor.process(css + sourceDirectives, {
+  const result = await proc.process(css + sourceDirectives, {
     from: from || "module.css"
   });
   return result.css;
@@ -2006,12 +2018,13 @@ async function createProcessor() {
     return postcss(plugins);
   } catch (e) {
     if (e.code === "MODULE_NOT_FOUND") {
+      processorUnavailable = true;
       const missing = e.message.match(/Cannot find module '([^']+)'/)?.[1] || "unknown";
-      throw new Error(
-        `Missing dependency "${missing}" required for processing module CSS.
-Install the required PostCSS packages:
-npm install -D postcss tailwindcss @tailwindcss/postcss postcss-import postcss-nesting postcss-replace @thedutchcoder/postcss-rem-to-px`
+      logger$2.warn(
+        `bl\xF6kkli's PostCSS pipeline is disabled \u2014 missing dependency "${missing}". This is only required if you author custom bl\xF6kkli modules or features that use Tailwind v4 \`@apply\` / \`theme()\` in their <style> blocks. To enable it, install:
+  npm install -D postcss tailwindcss @tailwindcss/postcss postcss-import postcss-nesting postcss-replace @thedutchcoder/postcss-rem-to-px`
       );
+      return null;
     }
     throw e;
   }
@@ -2174,6 +2187,7 @@ async function stripDistBoilerplate(css) {
   return result.css;
 }
 async function processStyleBlocks(code, filePath, tailwindConfigPath) {
+  if (!await ensureProcessor()) return code;
   const styleRegex = /<style([^>]*)>([\s\S]*?)<\/style>/g;
   let result = code;
   let styleMatch;
@@ -4378,8 +4392,11 @@ const module$1 = defineNuxtModule({
       blockCollector,
       theme
     );
-    const moduleRoot = helper.resolvers.module.resolve(".");
-    if (!moduleRoot.includes("/node_modules/")) {
+    const distMarker = helper.resolvers.module.resolve(
+      "./modules/tailwind/index.mjs"
+    );
+    const isRunningFromDist = helper.fileCache.fileExists(distMarker);
+    if (!isRunningFromDist) {
       context.addContentPath(helper.resolvers.module.resolve("./runtime"));
       context.addContentPath(helper.resolvers.module.resolve("./modules"));
     }

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

@@ -0,0 +1,29 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { ComponentParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: ComponentParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: ComponentToolResult<{
+        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: ComponentToolResult<{
+        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/auto_translate_paragraphs/Component.vue

@@ -0,0 +1,172 @@
+<template>
+  <DiffApproval
+    v-if="phase === 'approving' && approvalItems.length > 0"
+    :items="approvalItems"
+    insertions-only
+    show-reason
+    @apply="onApply"
+    @cancel="onCancel"
+  />
+</template>
+
+<script setup>
+import { useBlokkli, ref, onMounted } from "#imports";
+import { DiffApproval } from "#blokkli/editor/components";
+import {
+  skippedFieldsMessage,
+  appendAgentNote,
+  rejectedWithoutReasonMessage
+} from "../fieldDiffApproval";
+const props = defineProps({
+  context: { type: null, required: true },
+  params: { type: Object, required: true }
+});
+const emit = defineEmits(["done"]);
+const blokkli = useBlokkli();
+const { $t, state, context: entityContext, types } = blokkli;
+const phase = ref("loading");
+const approvalItems = ref([]);
+const adapter = props.context.adapter;
+const skippedNote = skippedFieldsMessage(props.params.skipped);
+function emitDone(result) {
+  emit("done", {
+    ...result,
+    agentMessage: appendAgentNote(result.agentMessage, skippedNote)
+  });
+}
+function resolveFieldLabel(entityType, bundle, fieldName) {
+  const config = types.editableFieldConfig.forName(
+    entityType,
+    bundle,
+    fieldName
+  );
+  return config?.label || fieldName;
+}
+onMounted(async () => {
+  const sourceLanguage = state.translation.value.sourceLanguage || "";
+  const targetLanguage = entityContext.value.language;
+  if (!sourceLanguage) {
+    emitDone({
+      acceptedCount: 0,
+      rejectedByUser: {},
+      label: $t("aiAgentAutoTranslateNoSource", "No source language available"),
+      agentMessage: "The host entity has no source language configured, so there is nothing to auto-translate from."
+    });
+    return;
+  }
+  const requestedUuids = new Set(props.params.uuids);
+  const sourceValues = await adapter.loadTextFieldValuesForLanguage(sourceLanguage);
+  const toTranslate = sourceValues.filter(
+    (v) => requestedUuids.has(v.uuid) && v.value.trim().length > 0
+  );
+  if (!toTranslate.length) {
+    emitDone({
+      acceptedCount: 0,
+      rejectedByUser: {},
+      label: $t("aiAgentAutoTranslateNoFields", "No text fields to translate"),
+      agentMessage: "No text fields were found on the requested paragraphs in the source language. Use get_page_structure or get_content_fields to inspect what is editable."
+    });
+    return;
+  }
+  const byKey = new Map(
+    toTranslate.map((v) => [`${v.uuid}:${v.fieldName}`, v])
+  );
+  const response = await adapter.requestTranslation(
+    toTranslate.map((v) => ({
+      key: `${v.uuid}:${v.fieldName}`,
+      text: v.value,
+      isHtml: v.fieldType === "markup",
+      sourceLanguage,
+      targetLanguage
+    }))
+  );
+  if (!response.success || !response.data.length) {
+    emitDone({
+      acceptedCount: 0,
+      rejectedByUser: {},
+      label: $t("aiAgentAutoTranslateFailed", "Translation request failed"),
+      agentMessage: 'The backend translation service returned no results. Inform the user \u2014 they may need to retry, or use delegate_text_rewrite with template "translate" instead.'
+    });
+    return;
+  }
+  let id = 0;
+  approvalItems.value = response.data.map((result) => {
+    const separatorIndex = result.key.indexOf(":");
+    const uuid = result.key.substring(0, separatorIndex);
+    const fieldName = result.key.substring(separatorIndex + 1);
+    const source = byKey.get(result.key);
+    return {
+      id: id++,
+      uuid,
+      fieldName,
+      fieldLabel: source ? resolveFieldLabel(source.entityType, source.entityBundle, fieldName) : fieldName,
+      value: result.translatedText
+    };
+  });
+  phase.value = "approving";
+});
+async function onApply(data) {
+  const targetLanguage = entityContext.value.language;
+  const items = approvalItems.value;
+  const rejectedByUser = {};
+  const accepted = [];
+  for (const item of items) {
+    if (data.selected[item.id]) {
+      accepted.push(item);
+      continue;
+    }
+    const fields = rejectedByUser[item.uuid] ?? {};
+    fields[item.fieldName] = {
+      reasonForRejection: data.reasons[item.id] || ""
+    };
+    rejectedByUser[item.uuid] = fields;
+  }
+  if (accepted.length) {
+    await state.mutateWithLoadingState(
+      () => adapter.importTranslationsBatched({
+        items: accepted.map((item) => ({
+          langcode: targetLanguage,
+          uuid: item.uuid,
+          fieldName: item.fieldName,
+          fieldValue: item.value
+        }))
+      })
+    );
+  }
+  const acceptedCount = accepted.length;
+  const label = acceptedCount === items.length ? $t(
+    "aiAgentAutoTranslateAllApplied",
+    "All @count translations applied"
+  ).replace("@count", String(acceptedCount)) : $t(
+    "aiAgentAutoTranslateSomeApplied",
+    "@applied of @total translations applied"
+  ).replace("@applied", String(acceptedCount)).replace("@total", String(items.length));
+  const _details = accepted.map((item) => ({
+    fieldLabel: item.fieldLabel,
+    before: "",
+    after: item.value
+  }));
+  emitDone({
+    acceptedCount,
+    rejectedByUser,
+    label,
+    agentMessage: rejectedWithoutReasonMessage(rejectedByUser),
+    historyIndex: state.currentMutationIndex.value,
+    _details
+  });
+}
+function onCancel() {
+  const rejectedByUser = {};
+  for (const item of approvalItems.value) {
+    const fields = rejectedByUser[item.uuid] ?? {};
+    fields[item.fieldName] = { reasonForRejection: "" };
+    rejectedByUser[item.uuid] = fields;
+  }
+  emitDone({
+    acceptedCount: 0,
+    rejectedByUser,
+    label: $t("aiAgentAutoTranslateAllRejected", "All translations rejected"),
+    agentMessage: "All translations were rejected by the user. Ask what they would like instead before retrying."
+  });
+}
+</script>

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

@@ -0,0 +1,29 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { ComponentParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: ComponentParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: ComponentToolResult<{
+        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: ComponentToolResult<{
+        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/auto_translate_paragraphs/index.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { fieldDiffResultSchema } from '../schemas.js';
+import { type SkippedField } from '../fieldDiffApproval.js';
+declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type AutoTranslateParams = z.infer<typeof paramsSchema>;
+export type AutoTranslateResult = z.infer<typeof fieldDiffResultSchema>;
+/**
+ * Resolved params handed to the Component after `execute` has validated the
+ * UUIDs. `uuids` only contains paragraphs that exist; `skipped` lists the
+ * dropped references so the Component can report them back to the agent.
+ */
+export type ComponentParams = {
+    uuids: string[];
+    skipped: SkippedField[];
+};
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  requireBundlePermission,
+  requireNoRestrictedAncestor
+} from "../../helpers/validation.js";
+import { onlyUnique } from "#blokkli/helpers";
+import { fieldDiffResultSchema } from "../schemas.js";
+import { stringArrayParam } from "../schemas.js";
+import { resolveHost } from "../helpers.js";
+import { skippedFieldsMessage } from "../fieldDiffApproval.js";
+import Component from "./Component.vue";
+import DetailsComponent from "../../components/FieldDiffDetails/index.vue";
+const paramsSchema = z.object({
+  uuids: stringArrayParam(
+    "UUIDs of paragraphs to auto-translate. Every editable text field on each paragraph is sent to the backend's translation service. The user reviews and accepts/rejects each translation before it is applied. The source language is always the host entity's source language; the target language is the currently-edited language."
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "auto_translate_paragraphs",
+  description: "Translate every editable text field of one or more paragraphs into the currently-edited language using the backend's configured translation service (e.g. DeepL via Drupal) \u2014 not the agent's own LLM. The user reviews each translation in a diff approval UI before it is applied. Only available in translating mode and only when the adapter exposes a translation service. Prefer this when the user asks for an automatic translation; use `delegate_text_rewrite` with `template: 'translate'` only when the user specifically wants the agent to do the translation, or when no backend translation service is configured.",
+  category: "mutation",
+  lazy: false,
+  modes: ["translating"],
+  prunedSummary: (r) => `${r.acceptedCount || 0} accepted, ${Object.keys(r.rejectedByUser || {}).length} rejected`,
+  label($t) {
+    return $t("aiAgentAutoTranslateRunning", "Auto-translating", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema: fieldDiffResultSchema,
+  requiredAdapterMethods: [
+    "loadTextFieldValuesForLanguage",
+    "requestTranslation",
+    "importTranslationsBatched"
+  ],
+  component: Component,
+  detailsComponent: DetailsComponent,
+  buildDetails: (result) => result,
+  execute(ctx, params) {
+    if (ctx.app.state.editMode.value !== "translating") {
+      return {
+        error: "auto_translate_paragraphs is only available when the editor is in translating mode."
+      };
+    }
+    const skipped = [];
+    const keptUuids = [];
+    for (const uuid of params.uuids) {
+      const host = resolveHost(ctx.app, uuid);
+      if (!host) {
+        skipped.push({ uuid, fieldName: "*", reason: "paragraph not found" });
+        continue;
+      }
+      keptUuids.push(uuid);
+    }
+    if (!keptUuids.length) {
+      return {
+        error: skippedFieldsMessage(skipped) ?? "No paragraph UUIDs were provided."
+      };
+    }
+    const bundles = keptUuids.map((uuid) => ctx.app.blocks.getBlock(uuid)?.bundle).filter((b) => !!b).filter(onlyUnique);
+    if (bundles.length) {
+      const denied = requireBundlePermission(ctx.app, bundles, "edit");
+      if (denied) return denied;
+    }
+    const ancestorDenied = requireNoRestrictedAncestor(ctx.app, keptUuids);
+    if (ancestorDenied) return ancestorDenied;
+    return {
+      uuids: keptUuids,
+      skipped
+    };
+  },
+  mockParams: () => ({
+    uuids: [
+      "4526d2d0-f122-4093-902f-e2f00a433981",
+      "9485812c-0ecd-4699-85b2-3a031d47a0a1"
+    ]
+  })
+});

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

@@ -36,6 +36,7 @@
     :items="completedItems"
     show-reason
     @apply="applySelected"
+    @cancel="rejectAllFromApproval"
   />
 
   <ToolCard
@@ -154,6 +155,21 @@ function finishWithError() {
     _usage: streamUsage.value
   });
 }
+function rejectAllFromApproval() {
+  const rejectedByUser = {};
+  for (const item of completedItems.value) {
+    const fields = rejectedByUser[item.uuid] ?? {};
+    fields[item.fieldName] = { reasonForRejection: "" };
+    rejectedByUser[item.uuid] = fields;
+  }
+  emitDone({
+    acceptedCount: 0,
+    rejectedByUser,
+    label: $t("aiAgentDelegateRewriteAllRejected", "All changes rejected"),
+    agentMessage: "All proposed changes were rejected by the user. Ask the user what they would like to change instead.",
+    _usage: streamUsage.value
+  });
+}
 async function applySelected(data) {
   const { selected, reasons } = data;
   const { acceptedCount, rejectedByUser, label } = await applyFieldDiffs(

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

@@ -15,7 +15,7 @@ const resultSchema = z.object({
 });
 export default defineBlokkliAgentTool({
   name: "get_all_page_content",
-  description: "Get all text content from the entire page in a single call. Returns a flat list of all paragraphs with their concatenated text. Use this as the first tool when reviewing or analyzing page content.",
+  description: "Get a flat list of every paragraph on the page with its uuid, bundle, and the concatenated text of its OWN editable fields (does NOT follow references \u2014 a teaser appears with empty text). Use this when you need per-block uuids to act on specific blocks (translate, rewrite, delete). For any question about what the page SAYS \u2014 summarising, writing an intro that matches the content, translating the page, reviewing meaning \u2014 call `get_page_text` instead; it reads the actual rendered DOM (so teaser/referenced content is included) and returns Markdown the LLM can reason about directly.",
   category: "query",
   lazy: true,
   volatile: true,

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

@@ -1,16 +1,19 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { readBlockContentFields } from "../helpers.js";
-import { stringArrayParam } from "../schemas.js";
+import { stringArrayParam, tolerantSingularKeys } from "../schemas.js";
 import { booleanParam } from "#blokkli/agent/shared/toolParams";
-const paramsSchema = z.object({
-  uuids: stringArrayParam(
-    "One or more paragraph UUIDs (or the page UUID to get page-level fields)"
-  ),
-  includeNested: booleanParam(
-    "Recursively include content fields from all nested child paragraphs (default: true). Set to false to only get direct fields."
-  ).optional().default(true)
-});
+const paramsSchema = tolerantSingularKeys(
+  z.object({
+    uuids: stringArrayParam(
+      "Array of paragraph UUIDs. To get page-level fields, pass the page UUID in this array."
+    ),
+    includeNested: booleanParam(
+      "Recursively include content fields from all nested child paragraphs (default: true). Set to false to only get direct fields."
+    ).optional().default(true)
+  }),
+  { uuid: "uuids" }
+);
 const fieldSchema = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("plain").describe("Plain text field"),

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

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

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const paramsSchema = z.object({});
+const resultSchema = z.object({
+  text: z.string().describe(
+    "The page rendered as Markdown \u2014 exactly what the user sees, in reading order"
+  ),
+  truncated: z.boolean().optional().describe("True when the Markdown exceeded the size cap and was cut off")
+});
+const MAX_LENGTH = 5e4;
+const STRIP_SELECTOR = [
+  "[hidden]",
+  '[aria-hidden="true"]',
+  '[data-bk-is-muted="true"]',
+  "style",
+  "script"
+].join(", ");
+export default defineBlokkliAgentTool({
+  name: "get_page_text",
+  description: 'Get the rendered page as Markdown \u2014 exactly what the user sees, in reading order, with headings/lists/tables preserved and content from referenced entities (teasers, etc.) included because it reads from the actual DOM. ALWAYS PREFER this over `get_all_page_content` for any question about page meaning or content ("what does this page say", "summarize the page", "write an intro that matches the content", "translate the page"). Reach for `get_all_page_content` only when you need per-block UUIDs to act on specific blocks.',
+  category: "query",
+  lazy: true,
+  volatile: true,
+  prunedSummary: (r) => `${r.text?.length ?? 0} chars of page text`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetPageTextRunning", "Reading page content", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx) {
+    const { ui, $t } = ctx.app;
+    const clone = ui.providerElement.cloneNode(true);
+    for (const el of Array.from(clone.querySelectorAll(STRIP_SELECTOR))) {
+      el.remove();
+    }
+    const { default: TurndownService } = await import("turndown");
+    const turndown = new TurndownService({
+      headingStyle: "atx",
+      codeBlockStyle: "fenced",
+      bulletListMarker: "-"
+    });
+    const REMOVED_TAGS = /* @__PURE__ */ new Set([
+      "SVG",
+      "IFRAME",
+      "PICTURE",
+      "VIDEO",
+      "AUDIO",
+      "CANVAS"
+    ]);
+    turndown.remove((node) => REMOVED_TAGS.has(node.nodeName));
+    let text = turndown.turndown(clone.innerHTML).trim();
+    let truncated = false;
+    if (text.length > MAX_LENGTH) {
+      text = text.slice(0, MAX_LENGTH) + "\n\n[TRUNCATED]";
+      truncated = true;
+    }
+    return {
+      label: $t("aiAgentGetPageTextDone", "Read page content"),
+      result: truncated ? { text, truncated } : { text }
+    };
+  }
+});

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

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

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

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { stringArrayParam } from "../schemas.js";
+const paramsSchema = z.object({
+  uuids: stringArrayParam(
+    "Paragraph UUIDs to resolve references for. Returns the entities (media, nodes, taxonomy terms, ...) currently referenced by these paragraphs via any of their reference fields."
+  )
+});
+const resultSchema = z.object({
+  entities: z.array(
+    z.object({
+      entityUuid: z.string().describe(
+        'UUID of the referenced entity. Pass this as `mediaId` to replace_media_field when the entityType is "media".'
+      ),
+      entityType: z.string().describe('e.g. "media", "node", "taxonomy_term"'),
+      entityBundle: z.string().describe(
+        'e.g. "image", "canto". Pass this as `mediaBundle` to replace_media_field when the entityType is "media".'
+      ),
+      label: z.string().describe("Human-readable label of the entity"),
+      editUrl: z.string().describe("Backend edit URL of the entity"),
+      referencedBy: z.array(z.string()).describe(
+        "Paragraph UUIDs (from the input) that reference this entity"
+      )
+    })
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "get_referenced_entities",
+  description: "Resolve which entities (media items, referenced nodes, taxonomy terms, etc.) are currently referenced by one or more paragraphs. Use this when get_content_fields shows a paragraph has a reference field but you need the actual referenced entity ID \u2014 for example, to copy a media reference from one paragraph into another field via replace_media_field.",
+  category: "query",
+  lazy: false,
+  volatile: true,
+  prunedSummary: (r) => `${r.entities?.length ?? 0} referenced entities`,
+  modes: ["readonly", "editing", "translating", "review"],
+  requiredAdapterMethods: ["getReferencedEntities"],
+  label($t) {
+    return $t("aiAgentGetReferencedEntitiesRunning", "Resolving references", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx, params) {
+    const { $t } = ctx.app;
+    const raw = await ctx.adapter.getReferencedEntities(params.uuids);
+    const result = {
+      entities: raw.map((e) => ({
+        entityUuid: e.entityUuid,
+        entityType: e.entityType,
+        entityBundle: e.entityBundle,
+        label: e.label,
+        editUrl: e.editUrl,
+        referencedBy: e.uuids
+      }))
+    };
+    const label = $t(
+      "aiAgentGetReferencedEntitiesDone",
+      "Resolved @count referenced entities"
+    ).replace("@count", String(result.entities.length));
+    return { label, result, affectedUuids: params.uuids };
+  }
+});