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

package/dist/module.json

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

package/dist/modules/agent/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;