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

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@blokkli/editor",
   "configKey": "blokkli",
-  "version": "2.0.0-alpha.60",
+  "version": "2.0.0-alpha.61",
   "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.60";
+const version = "2.0.0-alpha.61";
 
 function validateOption(optionKey, option, icons) {
   const errors = [];

package/dist/modules/agent/index.mjs

@@ -176,8 +176,8 @@ function createClientTemplate(toolCollector, skillsCollector, options, routes) {
         const entries = toolsWithNames.map((t) => {
           const importPath = rel(t.filePath);
           return `  '${t.name}': {
-    params: _ToolParams<typeof import('${importPath}')['default']>
-    result: _ToolResult<typeof import('${importPath}')['default']>
+    params: z.infer<typeof import('${importPath}')['paramsSchema']>
+    result: z.infer<typeof import('${importPath}')['resultSchema']>
   }`;
         }).join("\n");
         toolMapBlock = `export interface AgentToolMap {
@@ -192,9 +192,6 @@ ${entries}
 import type { McpToolDefinition } from '#blokkli/agent/app/types'
 import type { AgentModelDefinition } from '#blokkli/agent/shared/types'
 
-type _ToolParams<T> = T extends { paramsSchema: infer P extends z.ZodType } ? z.infer<P> : never
-type _ToolResult<T> = T extends { resultSchema: infer R extends z.ZodType } ? z.infer<R> : never
-
 ${toolMapBlock}
 
 export type AgentToolName = ${agentToolNameType}

package/dist/modules/agent/runtime/app/features/agent/Container.vue

@@ -78,7 +78,7 @@ const agentApp = {
 provide(INJECT_AGENT_APP, agentApp);
 async function consumePromptRequest(request) {
   emit("consumed");
-  const { prompt, selectedUuids } = request;
+  const { prompt, selectedBlocks } = request;
   const promptText = prompt.getPrompt(blokkli);
   const userPromptText = prompt.getUserPrompt?.(blokkli);
   let preSeededResults = void 0;
@@ -86,7 +86,7 @@ async function consumePromptRequest(request) {
   if (prompt.preExecute) {
     const preResult = await prompt.preExecute({
       app: blokkli,
-      selectedUuids,
+      selectedBlocks,
       runTool: tools.runForPrompt
     });
     if (preResult) {
@@ -97,7 +97,7 @@ async function consumePromptRequest(request) {
   agent.sendPrompt({
     prompt: promptText,
     displayPrompt: userPromptText,
-    selectedUuids,
+    selectedBlocks,
     autoLoadTools: prompt.tools,
     autoLoadSkills: prompt.skills,
     preSeededResults,

package/dist/modules/agent/runtime/app/features/agent/Panel/index.vue

@@ -243,16 +243,27 @@ function scrollToBottomOnSend() {
   isAtBottom.value = true;
   nextTick(scrollToBottom);
 }
+function snapshotInitialSelection() {
+  if (conversation.value.length) return void 0;
+  const items = app.selection.items.value;
+  if (!items.length) return void 0;
+  return items.map((item) => ({
+    uuid: item.uuid,
+    bundle: item.bundle,
+    label: app.types.getBlockLabel(item.bundle)
+  }));
+}
 function onWelcomePrompt(prompt) {
-  agent.sendPrompt({ prompt });
+  agent.sendPrompt({ prompt, selectedBlocks: snapshotInitialSelection() });
   scrollToBottomOnSend();
 }
 function onSubmit(submitAttachments) {
   const text = inputValue.value.trim();
   if (!text && !submitAttachments.length || isProcessing.value || !isConnected.value)
     return;
+  const selectedBlocks = snapshotInitialSelection();
   if (!submitAttachments.length) {
-    agent.sendPrompt({ prompt: inputValue.value });
+    agent.sendPrompt({ prompt: inputValue.value, selectedBlocks });
   } else {
     const attachmentBlocks = submitAttachments.map(
       (att) => `<attachment type="${att.type}">
@@ -265,7 +276,8 @@ ${attachmentBlocks}` : attachmentBlocks;
     agent.sendPrompt({
       prompt,
       displayPrompt: text,
-      attachments: submitAttachments
+      attachments: submitAttachments,
+      selectedBlocks
     });
   }
   inputValue.value = "";

package/dist/modules/agent/runtime/app/features/agent/index.vue

@@ -149,7 +149,11 @@ defineItemDropdownAction(() => {
           app.eventBus.emit("sidebar:open", "agent");
           pendingPromptRequest.value = {
             prompt,
-            selectedUuids: [...app.selection.uuids.value]
+            selectedBlocks: app.selection.items.value.map((item) => ({
+              uuid: item.uuid,
+              bundle: item.bundle,
+              label: app.types.getBlockLabel(item.bundle)
+            }))
           };
         }
       };

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

@@ -2,13 +2,14 @@ import type { AgentPromptDefinition } from '#blokkli/agent/app/types';
 import type { BlokkliUser } from '#blokkli/editor/types/user';
 import type { AdapterSearchArguments } from '#blokkli/editor/adapter';
 import type { PluginConfigInput } from '#blokkli/editor/types/pluginConfig';
+import type { SelectedBlock } from '#blokkli/agent/shared/types';
 /**
  * A pending request from the outer feature's item-dropdown action that the
  * inner container consumes on mount (or on change if already mounted).
  */
 export type PendingPromptRequest = {
     prompt: AgentPromptDefinition;
-    selectedUuids: string[];
+    selectedBlocks: SelectedBlock[];
 };
 export type AgentConversationHostInfo = {
     entityType: string;

package/dist/modules/agent/runtime/app/helpers/mutationResult.d.ts

@@ -0,0 +1,38 @@
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+/**
+ * Tree-shaped entry in the `newParagraphs` payload returned by mutation tools.
+ *
+ * Mirrors the input shape of `add_paragraphs` — nested children are grouped by
+ * paragraph field name so the LLM can verify the structure round-tripped. A
+ * flat list was previously emitted; the model could not tell whether a child
+ * UUID was actually a sibling that got placed at the top level by mistake.
+ */
+export type NewParagraphNode = {
+    uuid: string;
+    bundle: string;
+    paragraphFields?: string[];
+    children?: Record<string, NewParagraphNode[]>;
+};
+/**
+ * Build the tree-shaped `newParagraphs` payload from a flat list of newly
+ * created block UUIDs (computed as the set diff of `getAllUuids()` before vs
+ * after a mutation).
+ *
+ * A block whose host is ALSO in `newUuids` is nested under that parent's
+ * `children[fieldName]`. Top-level entries are blocks whose parent already
+ * existed before the mutation — these were inserted into the target field.
+ *
+ * Per-block lookup uses `app.blocks.getBlock` (host metadata) and
+ * `app.types.fieldConfig` (paragraph-field discovery), so no extra adapter
+ * round-trips are needed.
+ */
+export declare function buildNewParagraphsTree(newUuids: string[], app: BlokkliApp, itemEntityType: string): NewParagraphNode[];
+/**
+ * Count every node in a `newParagraphs` tree, including nested children.
+ *
+ * The tree-shaped envelope means a top-level array of length 1 can still
+ * represent dozens of added blocks (one parent with many children). Callers
+ * that report "added N paragraphs" should count recursively so the figure
+ * stays honest.
+ */
+export declare function countNewParagraphs(nodes: NewParagraphNode[]): number;

package/dist/modules/agent/runtime/app/helpers/mutationResult.js

@@ -0,0 +1,49 @@
+export function buildNewParagraphsTree(newUuids, app, itemEntityType) {
+  if (!newUuids.length) return [];
+  const newSet = new Set(newUuids);
+  const nodes = /* @__PURE__ */ new Map();
+  const roots = [];
+  const pendingChildren = /* @__PURE__ */ new Map();
+  for (const uuid of newUuids) {
+    const block = app.blocks.getBlock(uuid);
+    if (!block) continue;
+    const paragraphFields = app.types.fieldConfig.forEntityTypeAndBundle(itemEntityType, block.bundle).map((f) => f.name);
+    const node = {
+      uuid,
+      bundle: block.bundle,
+      ...paragraphFields.length ? { paragraphFields } : {}
+    };
+    nodes.set(uuid, node);
+    const host = block.host;
+    if (host.type === itemEntityType && newSet.has(host.uuid)) {
+      let perField = pendingChildren.get(host.uuid);
+      if (!perField) {
+        perField = /* @__PURE__ */ new Map();
+        pendingChildren.set(host.uuid, perField);
+      }
+      const bucket = perField.get(host.fieldName) ?? [];
+      bucket.push(node);
+      perField.set(host.fieldName, bucket);
+    } else {
+      roots.push(node);
+    }
+  }
+  for (const [parentUuid, perField] of pendingChildren) {
+    const parent = nodes.get(parentUuid);
+    if (!parent) continue;
+    parent.children = Object.fromEntries(perField);
+  }
+  return roots;
+}
+export function countNewParagraphs(nodes) {
+  let total = 0;
+  for (const node of nodes) {
+    total += 1;
+    if (node.children) {
+      for (const childList of Object.values(node.children)) {
+        total += countNewParagraphs(childList);
+      }
+    }
+  }
+  return total;
+}

package/dist/modules/agent/runtime/app/prompts/fixReadability.js

@@ -28,11 +28,11 @@ export default defineBlokkliAgentPrompt({
             "Fix the readability of the selected paragraphs."
           );
         },
-        async preExecute({ selectedUuids, runTool }) {
+        async preExecute({ selectedBlocks, runTool }) {
           const readability = await runTool(
             "get_readability_issues",
-            selectedUuids.length ? {
-              uuids: selectedUuids
+            selectedBlocks.length ? {
+              uuids: selectedBlocks.map((b) => b.uuid)
             } : {}
           );
           const fields = Object.entries(readability.result).flatMap(

package/dist/modules/agent/runtime/app/providers/agentProvider.d.ts

@@ -1,5 +1,6 @@
 import { type Ref } from '#imports';
 import type { Attachment, PreSeededToolResult, AutoExecuteTool } from '#blokkli/agent/app/types';
+import type { SelectedBlock } from '#blokkli/agent/shared/types';
 import type { BlokkliApp } from '#blokkli/editor/types/app';
 import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
 import type { SocketProvider } from './socketProvider.js';
@@ -9,7 +10,7 @@ import type { ToolsProvider } from './toolsProvider.js';
 export type SendPromptOptions = {
     prompt: string;
     displayPrompt?: string;
-    selectedUuids?: string[];
+    selectedBlocks?: SelectedBlock[];
     attachments?: Attachment[];
     autoLoadTools?: string[];
     autoLoadSkills?: string[];

package/dist/modules/agent/runtime/app/providers/agentProvider.js

@@ -9,19 +9,19 @@ function buildSendContext(options) {
   const {
     prompt,
     displayPrompt,
-    selectedUuids,
+    selectedBlocks,
     autoLoadTools,
     autoLoadSkills,
     preSeededResults,
     autoExecuteTools,
     promptId
   } = options;
-  const hasData = !!promptId || displayPrompt !== void 0 && displayPrompt !== prompt || !!selectedUuids?.length || !!autoLoadTools?.length || !!autoLoadSkills?.length || !!preSeededResults?.length || !!autoExecuteTools?.length;
+  const hasData = !!promptId || displayPrompt !== void 0 && displayPrompt !== prompt || !!selectedBlocks?.length || !!autoLoadTools?.length || !!autoLoadSkills?.length || !!preSeededResults?.length || !!autoExecuteTools?.length;
   if (!hasData) return void 0;
   return {
     promptId,
     serverPrompt: displayPrompt !== void 0 && displayPrompt !== prompt ? prompt : void 0,
-    selectedUuids: selectedUuids?.length ? [...selectedUuids] : void 0,
+    selectedBlocks: selectedBlocks?.length ? [...selectedBlocks] : void 0,
     autoLoadTools: autoLoadTools?.length ? [...autoLoadTools] : void 0,
     autoLoadSkills: autoLoadSkills?.length ? [...autoLoadSkills] : void 0,
     preSeededResults: preSeededResults?.length ? preSeededResults : void 0,
@@ -217,7 +217,7 @@ export default function agentProvider({
     const {
       prompt,
       displayPrompt,
-      selectedUuids,
+      selectedBlocks,
       attachments,
       autoLoadTools,
       autoLoadSkills,
@@ -280,7 +280,7 @@ export default function agentProvider({
     socket.send({
       type: "start",
       prompt,
-      selectedUuids: selectedUuids?.length ? selectedUuids : void 0,
+      selectedBlocks: selectedBlocks?.length ? selectedBlocks : void 0,
       autoLoadTools: resolvedAutoLoadTools?.length ? resolvedAutoLoadTools : void 0,
       autoLoadSkills: resolvedAutoLoadSkills?.length ? resolvedAutoLoadSkills : void 0,
       preSeededResults: serverPreSeeded,
@@ -323,7 +323,7 @@ export default function agentProvider({
       displayPrompt: isEdit ? void 0 : displayedText,
       attachments: target.attachments,
       rollbackToUserMessageIndex: userMessageIndex,
-      selectedUuids: ctx?.selectedUuids,
+      selectedBlocks: ctx?.selectedBlocks,
       autoLoadTools: ctx?.autoLoadTools,
       autoLoadSkills: ctx?.autoLoadSkills,
       preSeededResults: isEdit ? void 0 : ctx?.preSeededResults,

package/dist/modules/agent/runtime/app/providers/toolsProvider.js

@@ -11,6 +11,7 @@ import {
   asRecord,
   splitMeta
 } from "#blokkli/agent/app/helpers";
+import { buildNewParagraphsTree } from "#blokkli/agent/app/helpers/mutationResult";
 import { mcpTools } from "#blokkli-build/agent-client";
 import { itemEntityType } from "#blokkli-build/config";
 import { generateId } from "#blokkli/agent/app/helpers/id";
@@ -104,22 +105,11 @@ export default function toolsProvider({
       return newUuids;
     }
     function buildMutationResult(newUuids) {
-      const newParagraphs = action.type === "add" && newUuids.length ? newUuids.map((uuid) => {
-        const block = app.blocks.getBlock(uuid);
-        if (!block) return null;
-        const blockFieldNames = app.types.fieldConfig.forEntityTypeAndBundle(itemEntityType, block.bundle).map((f) => f.name);
-        return {
-          uuid,
-          bundle: block.bundle,
-          ...blockFieldNames.length ? { paragraphFields: blockFieldNames } : {}
-        };
-      }).filter(
-        (b) => b !== null
-      ) : void 0;
+      const newParagraphs = action.type === "add" ? buildNewParagraphsTree(newUuids, app, itemEntityType) : [];
       return {
         success: true,
         historyIndex: state.currentMutationIndex.value,
-        newParagraphs: newParagraphs?.length ? newParagraphs : void 0,
+        newParagraphs: newParagraphs.length ? newParagraphs : void 0,
         ...action.result
       };
     }

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

@@ -1,2 +1,27 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    itemId: z.ZodString;
+    itemEntityType: z.ZodString;
+    itemEntityBundle: z.ZodString;
+    targetBundle: 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_content_search_paragraphs/index.js

@@ -3,7 +3,7 @@ import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
 import { resolvePosition } from "../helpers.js";
 import { requireBundlePermission } from "../../helpers/validation.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   itemId: z.string().describe("Content item ID from search_content results"),
   itemEntityType: z.string().describe("Entity type of the content item"),
   itemEntityBundle: z.string().describe("Entity bundle of the content item"),
@@ -13,6 +13,7 @@ const paramsSchema = z.object({
   parent: parentSchema.describe("The parent entity to add the paragraph to"),
   position: positionSchema
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "add_content_search_paragraphs",
   description: "Add a paragraph using a content item from search results. Use search_content first to find content items, then use this tool to add one to the page.",
@@ -28,7 +29,7 @@ export default defineBlokkliAgentTool({
     );
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["addContentSearchItem"],
   execute(ctx, params) {
     const denied = requireBundlePermission(

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

@@ -1,2 +1,24 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    name: 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_fragment/index.js

@@ -3,11 +3,12 @@ import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
 import { resolvePosition } from "../helpers.js";
 import { fragmentBlockBundle } from "#blokkli-build/config";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   name: z.string().describe("The fragment name to add"),
   parent: parentSchema.describe("The parent entity to add the fragment to"),
   position: positionSchema
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "add_fragment",
   description: "Add a fragment paragraph to the page.",
@@ -19,7 +20,7 @@ export default defineBlokkliAgentTool({
     return $t("aiAgentAddFragmentRunning", "Adding fragment", { more: true });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["fragmentsAddBlock"],
   execute(ctx, params) {
     const { fields, definitions, permissions } = ctx.app;

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

@@ -1,2 +1,26 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    mediaId: z.ZodString;
+    mediaBundle: z.ZodString;
+    targetBundle: 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_media_paragraph/index.js

@@ -3,7 +3,7 @@ import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
 import { resolvePosition } from "../helpers.js";
 import { requireBundlePermission } from "../../helpers/validation.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   mediaId: z.string().describe("Media item ID from search_media results"),
   mediaBundle: z.string().describe('Media bundle type (e.g., "image")'),
   targetBundle: z.string().describe(
@@ -12,6 +12,7 @@ const paramsSchema = z.object({
   parent: parentSchema.describe("The parent entity to add the paragraph to"),
   position: positionSchema
 });
+export const resultSchema = mutationResultSchema;
 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.",
@@ -25,7 +26,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["mediaLibraryAddBlock"],
   execute(ctx, params) {
     const denied = requireBundlePermission(

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

@@ -1,2 +1,34 @@
+import { z } from 'zod';
+type OptionValue = string | boolean | number | string[];
+type BlockInput = {
+    bundle: string;
+    contentFields?: Record<string, string | {
+        entityType: string;
+        entityId: string;
+    }>;
+    options?: Record<string, OptionValue>;
+    children?: Record<string, BlockInput[]>;
+};
+export declare const paramsSchema: z.ZodObject<{
+    paragraphs: z.ZodArray<z.ZodType<BlockInput, unknown, z.core.$ZodTypeInternals<BlockInput, unknown>>>;
+    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_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;