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

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

@@ -5,12 +5,13 @@ import {
   requireBundlePermission,
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuid: z.string().describe("The paragraph UUID or entity UUID containing the media field"),
   field: z.string().describe("The content field name (reference type)"),
   mediaId: z.string().describe("The media item ID (from search_media results)"),
   mediaBundle: z.string().describe('The media bundle type (e.g., "image")')
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "replace_media_field",
   description: "Replace the media on an existing paragraph field. Use get_content_fields first to see available reference fields, then search_media to find media items.",
@@ -22,7 +23,7 @@ export default defineBlokkliAgentTool({
     return $t("aiAgentReplaceMediaRunning", "Replacing media", { more: true });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["mediaLibraryReplaceMedia"],
   execute(ctx, params) {
     const { blocks, types, $t, context } = ctx.app;

package/dist/modules/agent/runtime/app/tools/schemas.d.ts

@@ -60,6 +60,18 @@ export declare const mutationResultSchema: z.ZodUnion<readonly [z.ZodObject<{
  * a single string is accepted as a fallback.
  */
 export declare function stringArrayParam(description: string): z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>;
+/**
+ * Wraps an object params schema to tolerate a singular key when the schema
+ * actually expects its plural form (e.g. `uuid` → `uuids`). LLMs — especially
+ * the smaller models — frequently pick the singular form when a tool
+ * description mentions both ("one or more UUIDs"). Without this, the call
+ * fails validation and the model often retries with the same wrong key.
+ *
+ * The generated JSON Schema is unchanged (the wrapping happens via
+ * `z.preprocess`), so the model is still guided to the plural form; the
+ * singular form is silently accepted as a fallback.
+ */
+export declare function tolerantSingularKeys<T extends z.ZodType>(schema: T, aliases: Record<string, string>): z.ZodPipe<z.ZodTransform<unknown, unknown>, T>;
 /**
  * Shared schema for option values (used by add_blocks and set_block_options).
  */
@@ -88,16 +100,23 @@ export declare const fieldDiffResultSchema: z.ZodObject<{
     agentMessage: z.ZodOptional<z.ZodString>;
     historyIndex: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
+/**
+ * Schema for a single entry in a mutation's `newParagraphs` payload. Recursive
+ * so nested children appear under their parent's `children` keyed by paragraph
+ * field name — mirroring the input shape of `add_paragraphs`.
+ */
+type NewParagraphEntry = {
+    uuid: string;
+    bundle: string;
+    paragraphFields?: string[];
+    children?: Record<string, NewParagraphEntry[]>;
+};
 /**
  * Schema for the success result sent back to the AI after mutation is applied.
  */
 export declare const mutationSuccessSchema: z.ZodUnion<readonly [z.ZodObject<{
     success: z.ZodLiteral<true>;
-    newParagraphs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        uuid: z.ZodString;
-        bundle: z.ZodString;
-        paragraphFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>;
+    newParagraphs: z.ZodOptional<z.ZodArray<z.ZodType<NewParagraphEntry, unknown, z.core.$ZodTypeInternals<NewParagraphEntry, unknown>>>>;
     historyIndex: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
     success: z.ZodLiteral<false>;
@@ -105,3 +124,4 @@ export declare const mutationSuccessSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     error: z.ZodString;
 }, z.core.$strip>]>;
+export {};

package/dist/modules/agent/runtime/app/tools/schemas.js

@@ -39,6 +39,26 @@ export function stringArrayParam(description) {
     z.array(z.string()).describe(description)
   );
 }
+export function tolerantSingularKeys(schema, aliases) {
+  return z.preprocess((value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return value;
+    }
+    const obj = value;
+    const remapped = {};
+    let touched = false;
+    for (const key of Object.keys(obj)) {
+      const plural = aliases[key];
+      if (plural && !(plural in obj)) {
+        remapped[plural] = obj[key];
+        touched = true;
+      } else {
+        remapped[key] = obj[key];
+      }
+    }
+    return touched ? remapped : obj;
+  }, schema);
+}
 export const optionValueSchema = z.union([
   z.string(),
   z.boolean(),
@@ -69,19 +89,26 @@ export const fieldDiffResultSchema = z.object({
   ),
   historyIndex: z.number().optional().describe("The mutation history index after applying changes")
 });
+const newParagraphEntrySchema = z.lazy(
+  () => z.object({
+    uuid: z.string(),
+    bundle: z.string(),
+    paragraphFields: z.array(z.string()).optional().describe(
+      "Paragraph fields on this new paragraph that can hold nested paragraphs. Call get_child_paragraphs with this paragraph's UUID to add paragraphs to these fields."
+    ),
+    children: z.record(
+      z.string().describe("Paragraph field name"),
+      z.array(newParagraphEntrySchema)
+    ).optional().describe(
+      "Nested paragraphs created inside this entry, keyed by paragraph field name. Mirrors the `children` shape used by add_paragraphs \u2014 the structure round-trips, so a child here means it actually landed inside this parent."
+    )
+  })
+);
 export const mutationSuccessSchema = z.union([
   z.object({
     success: z.literal(true),
-    newParagraphs: z.array(
-      z.object({
-        uuid: z.string(),
-        bundle: z.string(),
-        paragraphFields: z.array(z.string()).optional().describe(
-          "Paragraph fields on this new paragraph that can hold nested paragraphs. Call get_child_paragraphs with this paragraph's UUID to add paragraphs to these fields."
-        )
-      })
-    ).optional().describe(
-      "Paragraphs created by this mutation (for add/duplicate operations), with their UUIDs and bundle types"
+    newParagraphs: z.array(newParagraphEntrySchema).optional().describe(
+      "Top-level paragraphs created by this mutation (for add/duplicate operations). Nested children appear under each entry's `children` keyed by paragraph field name; the tree mirrors what was requested."
     ),
     historyIndex: z.number().describe("Current position in mutation history (-1 = pristine)")
   }),

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

@@ -1,2 +1,17 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    tab: z.ZodString;
+    query: z.ZodString;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    entityType: z.ZodString;
+    entityBundle: z.ZodString;
+    targetBundles: z.ZodArray<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
 declare const _default: any;
 export default _default;

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

@@ -1,6 +1,12 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-const resultSchema = z.array(
+export const paramsSchema = z.object({
+  tab: z.string().describe(
+    "The tab ID to search in. See the system prompt for available tab IDs."
+  ),
+  query: z.string().describe("The search query")
+});
+export const resultSchema = z.array(
   z.object({
     id: z.string().describe("The unique ID of the content item"),
     title: z.string().describe("The display title of the content item"),
@@ -24,12 +30,7 @@ export default defineBlokkliAgentTool({
       more: true
     });
   },
-  paramsSchema: z.object({
-    tab: z.string().describe(
-      "The tab ID to search in. See the system prompt for available tab IDs."
-    ),
-    query: z.string().describe("The search query")
-  }),
+  paramsSchema,
   resultSchema,
   async execute(ctx, params) {
     const tabs = await ctx.adapter.getContentSearchTabs();

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

@@ -1,5 +1,9 @@
 import { z } from 'zod';
-declare const resultSchema: z.ZodObject<{
+export declare const paramsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    bundle: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         mediaId: z.ZodString;
         label: z.ZodString;

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

@@ -1,12 +1,12 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   query: z.string().optional().describe(
-    "Search text to filter media items. Omit or leave empty to list all available media."
+    'Search text to filter media items. Searching for "foobar test" will search the exact full string, so prefer searching single for words.'
   ),
   bundle: z.string().optional().describe('Media bundle filter (e.g., "image", "video")')
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   items: z.array(
     z.object({
       mediaId: z.string().describe("The unique ID of the media item"),

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

@@ -1,2 +1,18 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    parent: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        label: z.ZodString;
+        bundle: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

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

@@ -3,7 +3,7 @@ import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { parentSchema } from "../schemas.js";
 import { fromLibraryBlockBundle } from "#blokkli-build/config";
 import { resolveHost } from "../helpers.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   parent: parentSchema.optional().describe(
     "The parent entity where a reusable paragraph would be added. When provided, results are filtered to only include bundles allowed in this field."
   )
@@ -13,7 +13,7 @@ const reusableParagraphSchema = z.object({
   label: z.string().describe("The display label"),
   bundle: z.string().describe("The paragraph bundle type of the reusable paragraph")
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   items: z.array(reusableParagraphSchema).describe("Matching reusable paragraphs"),
   total: z.number().describe("Total number of matching reusable paragraphs")
 });

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

@@ -1,2 +1,15 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    templates: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        itemBundles: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   query: z.string().optional().describe("Search text to filter templates")
 });
 const templateSchema = z.object({
@@ -9,7 +9,7 @@ const templateSchema = z.object({
   description: z.string().optional().describe("A short description of the template"),
   itemBundles: z.array(z.string()).describe("Paragraph types contained in the template")
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   templates: z.array(templateSchema).describe("Matching templates"),
   total: z.number().describe("Total number of matching templates")
 });

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

@@ -1,2 +1,17 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    query: z.ZodString;
+    bundle: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    matches: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        bundle: z.ZodString;
+        matchedText: z.ZodString;
+        matchCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    totalMatches: z.ZodNumber;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

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

@@ -1,13 +1,13 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   query: z.string().describe(
     'The text to search for. For regex, use JavaScript regex literal format: /pattern/flags (e.g., "/hello|world/gi" to match either word case-insensitively). Plain text is matched case-insensitively by default.'
   ),
   bundle: z.string().optional().describe("Optional: only search in paragraphs of this bundle type"),
   limit: z.coerce.number().optional().default(20).describe("Maximum number of results to return (default: 20)")
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   matches: z.array(
     z.object({
       uuid: z.string().describe("The paragraph UUID"),

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

@@ -14,7 +14,7 @@
         @click="selectedId = item.mediaId"
       >
         <div
-          class="_bk_w-40 _bk_h-40 _bk_bg-mono-100 _bk_rounded _bk_overflow-hidden _bk_shrink-0 _bk_flex _bk_items-center _bk_justify-center"
+          class="_bk_size-100 _bk_bg-mono-100 _bk_rounded _bk_overflow-hidden _bk_shrink-0 _bk_flex _bk_items-center _bk_justify-center"
           :class="{
   '_bk_outline _bk_outline-accent-700 _bk_relative _bk_z-40': selectedId === item.mediaId
 }"

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

@@ -5,7 +5,7 @@ declare const mediaItemSchema: z.ZodObject<{
     mediaBundle: z.ZodString;
     thumbnail: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const paramsSchema: z.ZodObject<{
+export declare const paramsSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         mediaId: z.ZodString;
         label: z.ZodString;
@@ -14,7 +14,7 @@ declare const paramsSchema: z.ZodObject<{
     }, z.core.$strip>>;
     prompt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const resultSchema: z.ZodObject<{
+export declare const resultSchema: z.ZodObject<{
     selected: z.ZodNullable<z.ZodObject<{
         mediaId: z.ZodString;
         label: z.ZodString;

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

@@ -7,11 +7,11 @@ const mediaItemSchema = z.object({
   mediaBundle: z.string().describe('The media type (e.g., "image", "video")'),
   thumbnail: z.string().optional().describe("URL of the thumbnail image")
 });
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   items: z.array(mediaItemSchema).describe("Media items from search_media to display for selection"),
   prompt: z.string().optional().describe("Optional message to show the user explaining what to select")
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   selected: mediaItemSchema.nullable().describe("The selected media item, or null if the user cancelled"),
   label: z.string().optional().describe("Human-readable label of the prompt (for UI display)")
 });

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

@@ -1,2 +1,21 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    paragraphs: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        options: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+}, 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/set_paragraph_options/index.js

@@ -12,9 +12,10 @@ const paragraphOptionsSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
   options: z.record(z.string(), optionValueSchema).describe("Options to set as key-value pairs")
 });
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   paragraphs: z.array(paragraphOptionsSchema).describe("Array of paragraphs with their options to set")
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "set_paragraph_options",
   description: "Set options on one or more paragraphs. Each paragraph entry contains a UUID and an options object with key-value pairs.",
@@ -28,7 +29,7 @@ export default defineBlokkliAgentTool({
   },
   lazy: true,
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["updateOptions"],
   execute(ctx, params) {
     const { blocks, selection } = ctx.app;

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

@@ -1,2 +1,19 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuid1: z.ZodString;
+    uuid2: 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/swap_paragraphs/index.js

@@ -2,10 +2,11 @@ import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema } from "../schemas.js";
 import { getSwapDisabledReason } from "#blokkli/editor/helpers/swap";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuid1: z.string().describe("First paragraph UUID"),
   uuid2: z.string().describe("Second paragraph UUID")
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "swap_paragraphs",
   description: "Swap the positions of two paragraphs, either in the same field or different fields.",
@@ -17,7 +18,7 @@ export default defineBlokkliAgentTool({
   },
   lazy: true,
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["swapBlocks"],
   execute(ctx, params) {
     const { blocks, types, $t, permissions } = ctx.app;

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

@@ -6,14 +6,14 @@ declare const operationSchema: z.ZodObject<{
     fieldName: z.ZodString;
     search: z.ZodString;
     replace: z.ZodString;
-    selector: any;
+    selector: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
 }, z.core.$strip>;
 declare const updateSchema: z.ZodObject<{
     uuid: z.ZodString;
     fieldName: z.ZodString;
     value: z.ZodString;
 }, z.core.$strip>;
-declare const paramsSchema: z.ZodObject<{
+export declare const paramsSchema: z.ZodObject<{
     updates: z.ZodOptional<z.ZodArray<z.ZodObject<{
         uuid: z.ZodString;
         fieldName: z.ZodString;
@@ -24,9 +24,9 @@ declare const paramsSchema: z.ZodObject<{
         fieldName: z.ZodString;
         search: z.ZodString;
         replace: z.ZodString;
-        selector: any;
+        selector: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
     }, z.core.$strip>>>;
-    requireApproval: any;
+    requireApproval: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
 }, z.core.$strip>;
 export type BatchRewriteParams = z.infer<typeof paramsSchema>;
 export type BatchRewriteResult = z.infer<typeof fieldDiffResultSchema>;
@@ -42,5 +42,14 @@ export type ComponentParams = {
     requireApproval?: boolean;
     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/update_text_fields/index.js

@@ -6,7 +6,7 @@ import {
 } from "../../helpers/validation.js";
 import { onlyUnique } from "#blokkli/helpers";
 import { fieldDiffResultSchema } from "../schemas.js";
-import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import { optionalBooleanParam } from "../../../shared/toolParams.js";
 import { resolveHost } from "../helpers.js";
 import { skippedFieldsMessage } from "../fieldDiffApproval.js";
 import Component from "./Component.vue";
@@ -20,26 +20,27 @@ const operationSchema = z.object({
   replace: z.string().describe(
     "The replacement text (or innerHTML when search is a CSS selector)"
   ),
-  selector: booleanParam(
+  selector: optionalBooleanParam(
     "Set to true when search is a CSS selector instead of a text search"
-  ).optional()
+  )
 });
 const updateSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
   fieldName: z.string().describe("The editable field name"),
   value: z.string().describe("The complete new field value \u2014 overwrites the entire field")
 });
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   updates: z.array(updateSchema).optional().describe(
     "Full-replacement mode: a list of { uuid, fieldName, value } entries. Each overwrites the entire field with the given value. Use when the value changes substantially or you already have the final text."
   ),
   operations: z.array(operationSchema).optional().describe(
     "Patch mode: search/replace operations applied to each field's CURRENT value, so `search` must match the existing content exactly. Best for small targeted edits like typo fixes \u2014 avoids re-sending the whole value. If `search` is not found, that field is left unchanged."
   ),
-  requireApproval: booleanParam(
+  requireApproval: optionalBooleanParam(
     "The approval UI is shown by default. Set to false to apply the changes immediately without confirmation \u2014 only when the user supplied the exact text themselves."
-  ).optional()
+  )
 });
+export const resultSchema = fieldDiffResultSchema;
 export default defineBlokkliAgentTool({
   name: "update_text_fields",
   description: "Update text content fields on one or more paragraphs. Two modes, which may be combined in a single call:\n- Full replacement via `updates`: a list of { uuid, fieldName, value } entries, each overwriting the entire field with a complete new value. Use when the value changes substantially or you already have the final text.\n- Patch via `operations`: search/replace pairs applied to each field's CURRENT value (so `search` must match the existing content). Best for small edits like typo fixes, since you only send the changed part. Set `selector: true` on an operation to treat `search` as a CSS selector (e.g. \"p:nth-child(3)\") and `replace` as the matched element's innerHTML.\nThe approval UI is shown by default; set requireApproval to false to apply immediately (only when the user supplied the exact text).",
@@ -53,7 +54,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: fieldDiffResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["updateFieldValueBatched"],
   component: Component,
   detailsComponent: DetailsComponent,

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

@@ -1,2 +1,19 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    url: z.ZodString;
+    format: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+    }>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    content: z.ZodString;
+    title: z.ZodString;
+    format: z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+    }>;
+    url: z.ZodString;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

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

@@ -1,13 +1,13 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { routeFetch } from "#blokkli-build/agent-client";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   url: z.string().url().describe("The URL to fetch content from"),
   format: z.enum(["markdown", "html"]).default("markdown").describe(
     'Output format: "markdown" (default) converts HTML to readable Markdown preserving structure, "html" returns cleaned raw HTML'
   )
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   content: z.string().describe("The page content in the requested format (markdown or html)"),
   title: z.string().describe("The page title"),
   format: z.enum(["markdown", "html"]).describe("The format of the content"),

package/dist/modules/agent/runtime/app/types/index.d.ts

@@ -1,11 +1,12 @@
 import type { BlokkliApp } from '#blokkli/editor/types/app';
 import type { FullBlokkliAdapter, MutationResponseLike, AdapterMethods } from '#blokkli/editor/adapter';
 import type { EditMode } from '#blokkli/editor/types/state';
-import { type UsageTurn } from '#blokkli/agent/shared/types';
+import { type SelectedBlock, type UsageTurn } from '#blokkli/agent/shared/types';
 import { z } from 'zod';
 import type { Component } from 'vue';
 import type { AgentToolName, AgentSkillName, AgentToolMap } from '#blokkli-build/agent-client';
 import type { TextProvider } from '#blokkli/editor/providers/texts';
+import type { NewParagraphNode } from '#blokkli/agent/app/helpers/mutationResult';
 /**
  * A host entity (parent of a block).
  * Used consistently across tools for specifying block locations.
@@ -23,11 +24,7 @@ export type McpToolCategory = 'query' | 'mutation';
 export type MutationToolResult = {
     success: true;
     historyIndex: number;
-    newParagraphs?: Array<{
-        uuid: string;
-        bundle: string;
-        paragraphFields?: string[];
-    }>;
+    newParagraphs?: NewParagraphNode[];
 } | {
     success: false;
     rejected?: true;
@@ -312,7 +309,7 @@ export type AgentPromptDefinition = {
      */
     preExecute?: (ctx: {
         app: BlokkliApp;
-        selectedUuids: string[];
+        selectedBlocks: SelectedBlock[];
         runTool: <T extends AgentToolName>(toolName: T, params: AgentToolMap[T]['params']) => Promise<PreSeededToolResult & {
             result: AgentToolMap[T]['result'];
         }>;
@@ -365,7 +362,7 @@ declare const userConversationItemSchema: z.ZodObject<{
     sendContext: z.ZodOptional<z.ZodObject<{
         promptId: z.ZodOptional<z.ZodString>;
         serverPrompt: z.ZodOptional<z.ZodString>;
-        selectedUuids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        selectedBlocks: z.ZodOptional<z.ZodArray<any>>;
         autoLoadTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
         autoLoadSkills: z.ZodOptional<z.ZodArray<z.ZodString>>;
         preSeededResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -470,7 +467,7 @@ export declare const conversationItemSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     sendContext: z.ZodOptional<z.ZodObject<{
         promptId: z.ZodOptional<z.ZodString>;
         serverPrompt: z.ZodOptional<z.ZodString>;
-        selectedUuids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        selectedBlocks: z.ZodOptional<z.ZodArray<any>>;
         autoLoadTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
         autoLoadSkills: z.ZodOptional<z.ZodArray<z.ZodString>>;
         preSeededResults: z.ZodOptional<z.ZodArray<z.ZodObject<{