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

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

@@ -14,13 +14,15 @@ const paramsSchema = z.object({
 });
 export default defineBlokkliAgentTool({
   name: "add_media_paragraph",
-  description: "Add a paragraph using a media item from the library. Use search_media first to find media items, then use this tool to add one to the page. Requires user approval.",
+  description: "Add a paragraph using a media item from the library. Use search_media first to find media items, then use this tool to add one to the page.",
   category: "mutation",
   prunedSummary: (r) => r.success ? "added media paragraph" : "rejected",
   modes: ["editing"],
   lazy: true,
   label($t) {
-    return $t("aiAgentAddMediaBlockRunning", "Adding media block...");
+    return $t("aiAgentAddMediaBlockRunning", "Adding media block", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,

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

@@ -7,12 +7,15 @@ import {
   positionSchema,
   optionValueSchema
 } from "../schemas.js";
-import { resolvePosition, validateOptionValue } from "../helpers.js";
-import { itemEntityType } from "#blokkli-build/config";
 import {
-  getAvailableOptions,
-  optionValueToStorable
-} from "#blokkli/editor/helpers/options";
+  resolvePosition,
+  validateOptionValue,
+  getResolvedOptions,
+  resolveHost
+} from "../helpers.js";
+import { validateFieldCardinality } from "../../helpers/validation.js";
+import { getFieldKey } from "#blokkli/helpers";
+import { optionValueToStorable } from "#blokkli/editor/helpers/options";
 const contentFieldValueSchema = z.union([
   z.string().describe(
     "Text value for plain/markup content fields, or a URL string (starting with http) for link content fields"
@@ -80,20 +83,15 @@ function validateContentFields(ctx, block, path) {
 }
 function validateBlockOptions(ctx, block, path, parentBundle) {
   if (!block.options) return void 0;
-  const { definitions } = ctx.app;
-  const definition = definitions.getBlockDefinition(
+  const availableOptions = getResolvedOptions(
+    ctx.app,
     block.bundle,
     "default",
     parentBundle
   );
-  if (!definition) {
+  if (!availableOptions) {
     return `${path}: Paragraph definition not found for bundle "${block.bundle}".`;
   }
-  const availableOptions = getAvailableOptions(
-    definition.options,
-    definition.globalOptions,
-    definitions.globalOptions.value
-  );
   for (const [key, value] of Object.entries(block.options)) {
     const optionDef = availableOptions.find((o) => o.property === key);
     if (!optionDef) {
@@ -140,6 +138,9 @@ function validateBlockTree(ctx, blocks, allowedBundles, fieldLabel, pathPrefix,
           return `${path}: Paragraph field "${childFieldName}" does not exist on bundle "${block.bundle}". ` + (availableBlockFields.length ? `Available paragraph fields: ${availableBlockFields.join(", ")}` : "This bundle has no paragraph fields.");
         }
         if (!childBlocks.length) continue;
+        if (childFieldConfig.cardinality !== -1 && childBlocks.length > childFieldConfig.cardinality) {
+          return `${path}: Field "${childFieldName}" can only hold ${childFieldConfig.cardinality} paragraph(s), but ${childBlocks.length} were provided.`;
+        }
         const childError = validateBlockTree(
           ctx,
           childBlocks,
@@ -155,7 +156,6 @@ function validateBlockTree(ctx, blocks, allowedBundles, fieldLabel, pathPrefix,
   return void 0;
 }
 function buildEventBlocks(ctx, blocks, parentBundle) {
-  const { definitions } = ctx.app;
   return blocks.map((block) => {
     const blockUuid = generateUUID();
     const values = block.contentFields ? Object.entries(block.contentFields).map(([fieldName, fieldValue]) => ({
@@ -164,17 +164,13 @@ function buildEventBlocks(ctx, blocks, parentBundle) {
     })) : void 0;
     let options;
     if (block.options) {
-      const definition = definitions.getBlockDefinition(
+      const availableOptions = getResolvedOptions(
+        ctx.app,
         block.bundle,
         "default",
         parentBundle
       );
-      if (definition) {
-        const availableOptions = getAvailableOptions(
-          definition.options,
-          definition.globalOptions,
-          definitions.globalOptions.value
-        );
+      if (availableOptions) {
         options = {};
         for (const [key, value] of Object.entries(block.options)) {
           const optionDef = availableOptions.find((o) => o.property === key);
@@ -237,21 +233,20 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => r.success ? `added ${r.newParagraphs?.length || 0} paragraphs` : "rejected",
   modes: ["editing"],
   label($t) {
-    return $t("aiAgentAddBlocksRunning", "Adding blocks...");
+    return $t("aiAgentAddBlocksRunning", "Adding blocks", { more: true });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,
   requiredAdapterMethods: ["addNewBlocks"],
   execute(ctx, params) {
-    const { types, context, blocks } = 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) {
+    const { types } = ctx.app;
+    const host = resolveHost(ctx.app, params.parent.uuid);
+    if (!host) {
       return {
-        error: "Parent not found."
+        error: `Parent paragraph "${params.parent.uuid}" not found. Use get_page_structure or get_child_paragraphs to find a valid parent UUID.`
       };
     }
+    const { entityType, bundle, isRoot: isRootEntity } = host;
     const field = types.getFieldConfig(entityType, bundle, params.parent.field);
     if (!field) {
       const availableFields = types.fieldConfig.forEntityTypeAndBundle(entityType, bundle).map((f) => f.name);
@@ -259,6 +254,20 @@ export default defineBlokkliAgentTool({
         error: `Field "${params.parent.field}" not found on bundle "${bundle}". Available fields: ${availableFields.length ? availableFields.join(", ") : "none"}. Use get_child_paragraphs to get the correct parent object.`
       };
     }
+    const cardinality = validateFieldCardinality(
+      ctx.app,
+      {
+        type: entityType,
+        uuid: params.parent.uuid,
+        fieldName: params.parent.field,
+        bundle
+      },
+      getFieldKey(params.parent.uuid, params.parent.field),
+      params.paragraphs.length
+    );
+    if (!cardinality.valid) {
+      return { error: cardinality.error };
+    }
     if (!isRootEntity) {
       if (ctx.app.permissions.blockHasRestrictedAncestor(params.parent.uuid)) {
         return {

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

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
-import { resolvePosition } from "../helpers.js";
+import { resolvePosition, resolveHost } from "../helpers.js";
 import { requireBundlePermission } from "../../helpers/validation.js";
-import { fromLibraryBlockBundle, itemEntityType } from "#blokkli-build/config";
+import { fromLibraryBlockBundle } from "#blokkli-build/config";
 const paramsSchema = z.object({
   libraryItemUuid: z.string().describe(
     "The UUID of the reusable paragraph to add (from search_reusable_paragraphs results)"
@@ -21,7 +21,9 @@ export default defineBlokkliAgentTool({
   modes: ["editing"],
   lazy: true,
   label($t) {
-    return $t("aiAgentAddLibraryItemRunning", "Adding reusable block...");
+    return $t("aiAgentAddLibraryItemRunning", "Adding reusable block", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,
@@ -38,20 +40,18 @@ export default defineBlokkliAgentTool({
         error: "Permission denied: target parent is inside a block with restricted editing permissions"
       };
     }
-    const { types, fields, context, blocks, $t } = ctx.app;
+    const { types, fields, $t } = ctx.app;
     const field = fields.find(params.parent.uuid, params.parent.field);
     if (!field) {
       return {
         error: `Field not found: ${params.parent.field} on entity ${params.parent.uuid}`
       };
     }
-    const isRootEntity = params.parent.uuid === context.value.entityUuid;
-    const parentEntityType = isRootEntity ? context.value.entityType : itemEntityType;
-    const parentBundle = isRootEntity ? context.value.entityBundle : blocks.getBlock(params.parent.uuid)?.bundle;
-    if (parentBundle) {
+    const host = resolveHost(ctx.app, params.parent.uuid);
+    if (host) {
       const fieldConfig = types.getFieldConfig(
-        parentEntityType,
-        parentBundle,
+        host.entityType,
+        host.bundle,
         params.parent.field
       );
       if (fieldConfig?.allowedBundles.length && !fieldConfig.allowedBundles.includes(fromLibraryBlockBundle)) {

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

@@ -11,13 +11,13 @@ const paramsSchema = z.object({
 });
 export default defineBlokkliAgentTool({
   name: "add_template",
-  description: "Add a template to the page. Templates are copied when added, so changes to the added paragraphs won't affect other pages using the same template. Requires user approval before the template is actually added.",
+  description: "Add a template to the page. Templates are copied when added, so changes to the added paragraphs won't affect other pages using the same template.",
   category: "mutation",
   prunedSummary: (r) => r.success ? `added template (${r.newParagraphs?.length || 0} paragraphs)` : "rejected",
   lazy: true,
   modes: ["editing"],
   label($t) {
-    return $t("aiAgentAddTemplateRunning", "Adding template...");
+    return $t("aiAgentAddTemplateRunning", "Adding template", { more: true });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,

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

@@ -1,43 +1,40 @@
 <template>
-  <ToolCard
-    icon="bk_mdi_help"
-    :title="params.question"
-    class="bk-agent-tool-question"
-    @cancel="cancel"
-  >
-    <div class="bk-agent-tool-question-inner">
+  <ToolCard icon="bk_mdi_help" :title="params.question" @cancel="cancel">
+    <div class="_bk_p-10 bk-agent-tool-question-list">
       <FormCheckboxes
         v-if="params.multiSelect"
         id="ask-question"
         v-model="selectedMulti"
-        label=""
         :options="params.options"
+        class="bk-agent-tool-question-options"
       />
 
-      <div v-else>
+      <template v-else>
         <FormRadio
           id="ask-question"
           v-model="selectedSingle"
-          label=""
           :options="radioOptions"
+          class="bk-agent-tool-question-options"
         />
-        <div v-if="isOtherSelected" class="bk-agent-tool-question-other">
+        <div v-if="isOtherSelected" class="_bk_px-10 _bk_pt-5 _bk_pb-5">
           <textarea
             ref="otherTextarea"
             v-model="otherText"
-            class="bk-form-input"
+            class="bk-form-input bk-is-small _bk_mt-10"
             :rows="2"
             :placeholder="
-  $t('aiAgentAskQuestionOtherPlaceholder', 'Type your answer...')
+  $t('aiAgentAskQuestionOtherPlaceholder', 'Type your answer', {
+    more: true
+  })
 "
           />
         </div>
-      </div>
+      </template>
     </div>
 
     <template #actions>
       <button
-        class="bk-button bk-is-small bk-is-lime bk-is-fullwidth"
+        class="bk-button bk-is-small bk-scheme-lime bk-is-fullwidth"
         :disabled="!hasSelection"
         @click="confirm"
       >
@@ -117,3 +114,16 @@ function cancel() {
   emit("done", { selected: null, label: $t("aiAgentCancelled", "Cancelled") });
 }
 </script>
+
+<style>/*! tailwindcss v4.2.4 | MIT License | https://tailwindcss.com */
+:is(.bk-agent-tool-question-list .bk-radio,.bk-agent-tool-question-list .bk-checkbox) input + span {
+  font-size: var(--text-sm, 14px);
+  line-height: var(--bk-tw-leading, var(--text-sm--line-height, calc(1.25 / 0.875)));
+  --bk-tw-font-weight: var(--font-weight-medium, 500);
+  font-weight: var(--font-weight-medium, 500);
+}
+.bk-agent-tool-question-options  > div {
+  display: grid;
+  gap: 5px;
+}
+</style>

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

@@ -5,7 +5,7 @@ declare const paramsSchema: z.ZodObject<{
         value: z.ZodString;
         label: z.ZodString;
     }, z.core.$strip>>;
-    multiSelect: z.ZodDefault<z.ZodBoolean>;
+    multiSelect: any;
     paragraphUuids: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 declare const resultSchema: z.ZodObject<{

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
 import Component from "./Component.vue";
 const optionSchema = z.object({
   value: z.string().describe("The option value"),
@@ -8,9 +9,9 @@ const optionSchema = z.object({
 const paramsSchema = z.object({
   question: z.string().describe("The question to ask the user"),
   options: z.array(optionSchema).describe("Available options to choose from"),
-  multiSelect: z.boolean().default(false).describe(
+  multiSelect: booleanParam(
     `Allow selecting multiple options. If false, the user has the option to enter a custom option if none of the options are good.`
-  ),
+  ).default(false),
   paragraphUuids: z.array(z.string()).optional().describe(
     "Optional UUIDs of paragraphs this question relates to. When provided, these paragraphs will be highlighted on the page."
   )
@@ -25,7 +26,7 @@ export default defineBlokkliAgentTool({
   category: "query",
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentAskQuestionRunning", "Waiting for answer...");
+    return $t("aiAgentAskQuestionRunning", "Waiting for answer", { more: true });
   },
   paramsSchema,
   resultSchema,
@@ -49,7 +50,7 @@ export default defineBlokkliAgentTool({
   }),
   mockParamsVariants: () => [
     {
-      question: "Which sections should be included on the page?",
+      question: "Which of the following sections should be included on the page?",
       options: [
         { value: "hero", label: "Hero" },
         { value: "features", label: "Features" },

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"
+    ]
+  })
+});