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

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

@@ -16,6 +16,7 @@ import {
 import { validateFieldCardinality } from "../../helpers/validation.js";
 import { getFieldKey } from "#blokkli/helpers";
 import { optionValueToStorable } from "#blokkli/editor/helpers/options";
+import { countNewParagraphs } from "#blokkli/agent/app/helpers/mutationResult";
 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"
@@ -46,7 +47,7 @@ const blockSchema = z.object({
     "Nested child paragraphs keyed by paragraph field name. Recursive \u2014 children can also have children."
   )
 });
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   paragraphs: z.array(blockSchema).min(1).describe("Array of paragraphs to add, in order"),
   parent: parentSchema.describe("The parent entity to add the paragraphs to"),
   position: positionSchema
@@ -225,18 +226,19 @@ function collectAllUuids(blocks) {
   }
   return uuids;
 }
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "add_paragraphs",
-  description: "Add one or more new paragraphs to the page. Supports nested structures via the `children` property \u2014 define entire paragraph trees in a single call. IMPORTANT: Always provide content field values (text, media/entity references) directly via contentFields, instead of adding empty paragraphs! For reference content fields (media), set the value to { entityType, entityId } from search_media results. NOTE: You can ONLY provide content fields, NOT paragraph fields! For nested paragraphs, use the `children` property keyed by paragraph field name. You can also set paragraph options inline via the `options` property (key-value pairs).",
+  description: "Add one or more new paragraphs to the page. Supports nested structures via the `children` property \u2014 define entire paragraph trees in a single call. IMPORTANT: Always provide content field values (text, media/entity references) directly via contentFields, instead of adding empty paragraphs! For reference content fields (media), set the value to { entityType, entityId } from search_media results. NOTE: You can ONLY provide content fields, NOT paragraph fields! For nested paragraphs, use the `children` property keyed by paragraph field name. You can also set paragraph options inline via the `options` property (key-value pairs). The success result mirrors the input shape: each top-level entry in `newParagraphs` includes its own `children` keyed by paragraph field, so the structure round-trips and a nested child does NOT appear as a sibling \u2014 treat the tree as the source of truth instead of guessing from order.",
   category: "mutation",
   lazy: false,
-  prunedSummary: (r) => r.success ? `added ${r.newParagraphs?.length || 0} paragraphs` : "rejected",
+  prunedSummary: (r) => r.success ? `added ${countNewParagraphs(r.newParagraphs ?? [])} paragraphs` : "rejected",
   modes: ["editing"],
   label($t) {
     return $t("aiAgentAddBlocksRunning", "Adding blocks", { more: true });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["addNewBlocks"],
   execute(ctx, params) {
     const { types } = ctx.app;

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

@@ -1,2 +1,24 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    libraryItemUuid: z.ZodString;
+    parent: z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>;
+    position: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rewrite: "rewrite";
+        delete: "delete";
+        add: "add";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
 declare const _default: any;
 export default _default;

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

@@ -4,7 +4,7 @@ import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.j
 import { resolvePosition, resolveHost } from "../helpers.js";
 import { requireBundlePermission } from "../../helpers/validation.js";
 import { fromLibraryBlockBundle } from "#blokkli-build/config";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   libraryItemUuid: z.string().describe(
     "The UUID of the reusable paragraph to add (from search_reusable_paragraphs results)"
   ),
@@ -13,6 +13,7 @@ const paramsSchema = z.object({
   ),
   position: positionSchema
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "add_reusable_paragraph",
   description: "Add a reusable paragraph to the page. Reusable paragraphs stay linked to the original: edits to the paragraph are reflected everywhere it is used. Use search_reusable_paragraphs first to find available paragraphs.",
@@ -26,7 +27,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["addLibraryItem"],
   execute(ctx, params) {
     const denied = requireBundlePermission(

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

@@ -1,2 +1,24 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    templateUuid: z.ZodString;
+    parent: z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>;
+    position: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rewrite: "rewrite";
+        delete: "delete";
+        add: "add";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
 declare const _default: any;
 export default _default;

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

@@ -2,25 +2,27 @@ import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
 import { resolvePosition } from "../helpers.js";
-const paramsSchema = z.object({
+import { countNewParagraphs } from "#blokkli/agent/app/helpers/mutationResult";
+export const paramsSchema = z.object({
   templateUuid: z.string().describe(
     "The UUID of the template to add (from search_templates results)"
   ),
   parent: parentSchema.describe("The parent entity to add the template to"),
   position: positionSchema
 });
+export const resultSchema = mutationResultSchema;
 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.",
   category: "mutation",
-  prunedSummary: (r) => r.success ? `added template (${r.newParagraphs?.length || 0} paragraphs)` : "rejected",
+  prunedSummary: (r) => r.success ? `added template (${countNewParagraphs(r.newParagraphs ?? [])} paragraphs)` : "rejected",
   lazy: true,
   modes: ["editing"],
   label($t) {
     return $t("aiAgentAddTemplateRunning", "Adding template", { more: true });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["templatesAdd"],
   execute(ctx, params) {
     const { fields, $t } = ctx.app;

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

@@ -1,14 +1,14 @@
 import { z } from 'zod';
-declare const paramsSchema: z.ZodObject<{
+export declare const paramsSchema: z.ZodObject<{
     question: z.ZodString;
     options: z.ZodArray<z.ZodObject<{
         value: z.ZodString;
         label: z.ZodString;
     }, z.core.$strip>>;
-    multiSelect: any;
+    multiSelect: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
     paragraphUuids: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-declare const resultSchema: z.ZodObject<{
+export declare const resultSchema: z.ZodObject<{
     selected: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     label: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

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

@@ -1,22 +1,23 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import { booleanParamWithDefault } from "../../../shared/toolParams.js";
 import Component from "./Component.vue";
 const optionSchema = z.object({
   value: z.string().describe("The option value"),
   label: z.string().describe("The display label")
 });
-const paramsSchema = z.object({
+export 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: 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),
+  multiSelect: booleanParamWithDefault(
+    `Allow selecting multiple options. If false, the user has the option to enter a custom option if none of the options are good.`,
+    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."
   )
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   selected: z.union([z.string(), z.array(z.string())]).nullable().describe("Selected value(s), or null if cancelled"),
   label: z.string().optional().describe("Human-readable label of what was selected (for UI display)")
 });

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,28 @@
+import { z } from 'zod';
+import { fieldDiffResultSchema } from '../schemas.js';
+import { type SkippedField } from '../fieldDiffApproval.js';
+export 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[];
+};
+export 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>;
+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, 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";
+export 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 const resultSchema = fieldDiffResultSchema;
+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,
+  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/check_readability_for_texts/index.d.ts

@@ -1,2 +1,19 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    texts: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        level: z.ZodEnum<{
+            unknown: "unknown";
+            ok: "ok";
+            good: "good";
+            hard: "hard";
+        }>;
+        score: z.ZodNullable<z.ZodNumber>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

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

@@ -7,12 +7,12 @@ const textResultSchema = z.object({
   score: z.number().nullable(),
   note: z.string().optional()
 });
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   texts: z.array(z.string()).describe(
     "Text strings to check for readability. Each string is analyzed independently."
   )
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   results: z.array(textResultSchema)
 });
 export default defineBlokkliAgentTool({

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/delegate_text_rewrite/index.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { fieldDiffResultSchema } from '../schemas.js';
 import { type SkippedField } from '../fieldDiffApproval.js';
-declare const paramsSchema: z.ZodObject<{
+export declare const paramsSchema: z.ZodObject<{
     request: z.ZodDiscriminatedUnion<[z.ZodObject<{
         template: z.ZodLiteral<"fix_readability">;
     }, z.core.$strip>, z.ZodObject<{
@@ -37,5 +37,14 @@ export type ComponentParams = {
     /** Field references dropped because the paragraph/field doesn't exist. */
     skipped: SkippedField[];
 };
+export 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>;
 declare const _default: any;
 export default _default;

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

@@ -39,10 +39,11 @@ const requestSchema = z.discriminatedUnion("template", [
 ]).describe(
   "The transform to perform. Pick a template and provide its parameters:\n- fix_readability: fix flagged readability issues (no extra params \u2014 issues are resolved automatically).\n- translate: translate all fields into `targetLanguage`.\n- rewrite: general-purpose rewrite using `instruction`.\n- generate_content: write new content using `instruction` (optional `context`)."
 );
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   request: requestSchema,
   fields: z.array(fieldSchema).describe("The fields to transform (UUIDs and field names only)")
 });
+export const resultSchema = fieldDiffResultSchema;
 export default defineBlokkliAgentTool({
   name: "delegate_text_rewrite",
   description: "Rewrite, translate, fix readability, or generate text fields with live streaming preview. Set `request` to the chosen template and its parameters (see the request field). The content will be streamed live into the page for immediate visual feedback.",
@@ -56,7 +57,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: fieldDiffResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["updateFieldValueBatched"],
   component: Component,
   detailsComponent: DetailsComponent,