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

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

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { parentSchema } from "../schemas.js";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import { getResolvedOptions } from "../helpers.js";
 import {
-  getAvailableOptions,
   getMutatedOptionValue,
   optionValueToStorable
 } from "#blokkli/editor/helpers/options";
@@ -11,8 +12,12 @@ const paramsSchema = z.object({
   bundle: z.string().optional().describe("Filter by exact bundle name"),
   bundles: z.array(z.string()).optional().describe("Filter by any of these bundles"),
   // Structure filters
-  hasChildren: z.boolean().optional().describe("Filter by whether paragraph has child paragraphs"),
-  isRootLevel: z.boolean().optional().describe("Filter to root level paragraphs (nesting 0)"),
+  hasChildren: booleanParam(
+    "Filter by whether paragraph has child paragraphs"
+  ).optional(),
+  isRootLevel: booleanParam(
+    "Filter to root level paragraphs (nesting 0)"
+  ).optional(),
   nestingLevel: z.number().optional().describe("Filter to exact nesting level"),
   parentBundle: z.string().optional().describe("Filter to paragraphs whose parent is this bundle"),
   inField: z.string().optional().describe("Filter to paragraphs in a field with this name"),
@@ -24,7 +29,7 @@ const paramsSchema = z.object({
     value: z.union([z.string(), z.boolean(), z.number()]).describe("Expected option value")
   }).optional().describe("Filter to paragraphs where an option equals a value"),
   // Pagination
-  limit: z.number().optional().default(50).describe("Maximum number of results to return (default: 50)")
+  limit: z.coerce.number().optional().default(50).describe("Maximum number of results to return (default: 50)")
 });
 const paragraphResultSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
@@ -47,12 +52,12 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `found ${r.total || 0} paragraphs${r.hasMore ? " (more available)" : ""}`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentFindBlocksRunning", "Finding blocks...");
+    return $t("aiAgentFindBlocksRunning", "Finding blocks", { more: true });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { blocks, state, context, types, dom, definitions, $t } = ctx.app;
+    const { blocks, state, context, types, dom, $t } = ctx.app;
     const limit = params.limit ?? 50;
     let candidates = blocks.getAllBlocks();
     if (params.bundle) {
@@ -104,17 +109,13 @@ export default defineBlokkliAgentTool({
     if (params.optionEquals) {
       const { key, value } = params.optionEquals;
       candidates = candidates.filter((block) => {
-        const definition = definitions.getBlockDefinition(
+        const availableOptions = getResolvedOptions(
+          ctx.app,
           block.bundle,
           block.fieldListType,
           block.parentBlockBundle
         );
-        if (!definition) return false;
-        const availableOptions = getAvailableOptions(
-          definition.options,
-          definition.globalOptions,
-          definitions.globalOptions.value
-        );
+        if (!availableOptions) return false;
         const optionDef = availableOptions.find((o) => o.property === key);
         if (!optionDef) return false;
         const currentValue = getMutatedOptionValue(

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { readBlockContentFields } from "../helpers.js";
 const paramsSchema = z.object({});
 const blockContentSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
@@ -14,14 +15,16 @@ const resultSchema = z.object({
 });
 export default defineBlokkliAgentTool({
   name: "get_all_page_content",
-  description: "Get all text content from the entire page in a single call. Returns a flat list of all paragraphs with their concatenated text. Use this as the first tool when reviewing or analyzing page content.",
+  description: "Get a flat list of every paragraph on the page with its uuid, bundle, and the concatenated text of its OWN editable fields (does NOT follow references \u2014 a teaser appears with empty text). Use this when you need per-block uuids to act on specific blocks (translate, rewrite, delete). For any question about what the page SAYS \u2014 summarising, writing an intro that matches the content, translating the page, reviewing meaning \u2014 call `get_page_text` instead; it reads the actual rendered DOM (so teaser/referenced content is included) and returns Markdown the LLM can reason about directly.",
   category: "query",
   lazy: true,
   volatile: true,
   prunedSummary: (r) => `${r.content?.length || 0} paragraphs`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetAllPageContentRunning", "Getting all page content...");
+    return $t("aiAgentGetAllPageContentRunning", "Getting all page content", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
@@ -31,24 +34,15 @@ export default defineBlokkliAgentTool({
     function processBlock(blockUuid) {
       const block = blocks.getBlock(blockUuid);
       if (!block) return;
-      const editables = ctx.app.directive.getEditablesForBlock(blockUuid);
       const textParts = [];
-      for (const editable of editables) {
-        const fieldType = ctx.app.fieldValue.resolveFieldType(
-          ctx.itemEntityType,
-          block.bundle,
-          editable.fieldName
-        );
-        if (!fieldType) continue;
-        const value = ctx.app.fieldValue.readValue(
-          ctx.itemEntityType,
-          blockUuid,
-          block.bundle,
-          editable.fieldName,
-          fieldType
-        );
-        if (value.trim()) {
-          textParts.push(value.trim());
+      for (const f of readBlockContentFields(
+        ctx.app,
+        blockUuid,
+        ctx.itemEntityType,
+        block.bundle
+      )) {
+        if (f.value.trim()) {
+          textParts.push(f.value.trim());
         }
       }
       const droppableFields = ctx.app.types.droppableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, block.bundle).map((f) => f.name);

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

@@ -1,12 +1,11 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { getAvailableOptions } from "#blokkli/editor/helpers/options";
 import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
 import { blockOptionsMapSchema } from "../schemas.js";
-import { extractOptionLabels } from "../helpers.js";
+import { extractOptionLabels, getResolvedOptions } from "../helpers.js";
 const paramsSchema = z.object({
   parentUuid: z.string().describe("The parent entity UUID"),
-  field: z.string().describe("The field name"),
+  parentField: z.string().describe("The field name on the parent"),
   bundles: z.array(z.string()).optional().describe(
     "Optional list of bundle names to filter by. If omitted, returns all allowed bundles."
   )
@@ -53,29 +52,31 @@ export default defineBlokkliAgentTool({
   lazy: true,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetBundleInfoRunning", "Getting bundle info...");
+    return $t("aiAgentGetBundleInfoRunning", "Getting bundle info", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { fields, types, state, definitions, $t, context, blocks } = ctx.app;
+    const { fields, types, state, $t, context, blocks } = ctx.app;
     const label = $t(
       "aiAgentGetBundleInfoDone",
       "Got bundle info for @field"
-    ).replace("@field", params.field);
-    const field = fields.find(params.parentUuid, params.field);
+    ).replace("@field", params.parentField);
+    const field = fields.find(params.parentUuid, params.parentField);
     if (!field) {
       return {
         label,
         result: {
-          fieldLabel: params.field,
+          fieldLabel: params.parentField,
           cardinality: -1,
           currentCount: 0,
           bundles: []
         }
       };
     }
-    const fieldKey = `${params.parentUuid}:${params.field}`;
+    const fieldKey = `${params.parentUuid}:${params.parentField}`;
     const currentCount = state.getFieldBlockCount(fieldKey);
     const allowedBundles = params.bundles ? field.allowedBundles.filter((b) => params.bundles.includes(b)) : field.allowedBundles;
     const includeOptions = allowedBundles.length < 3;
@@ -107,28 +108,24 @@ export default defineBlokkliAgentTool({
       }
       let options;
       if (includeOptions) {
-        const definition = definitions.getBlockDefinition(
+        const availableOptions = getResolvedOptions(
+          ctx.app,
           bundle,
           "default",
           parentBundle
         );
-        if (definition) {
-          const availableOptions = getAvailableOptions(
-            definition.options,
-            definition.globalOptions,
-            definitions.globalOptions.value
-          );
+        if (availableOptions) {
           if (availableOptions.length > 0) {
             options = {};
             for (const opt of availableOptions) {
-              const currentValue = getRuntimeOptionValue(
+              const resolvedValue = getRuntimeOptionValue(
                 opt.option,
                 opt.option.default
               );
               const entry = {
                 type: opt.option.type,
                 label: opt.option.label,
-                currentValue
+                currentValue: resolvedValue ?? ""
               };
               if (opt.option.description) {
                 entry.description = opt.option.description;
@@ -137,11 +134,13 @@ export default defineBlokkliAgentTool({
               if (labels) {
                 entry.options = labels;
               }
-              if ("min" in opt.option) {
-                entry.min = opt.option.min;
+              const optMin = opt.option.min;
+              const optMax = opt.option.max;
+              if (typeof optMin === "number") {
+                entry.min = optMin;
               }
-              if ("max" in opt.option) {
-                entry.max = opt.option.max;
+              if (typeof optMax === "number") {
+                entry.max = optMax;
               }
               if ("step" in opt.option && opt.option.type === "range") {
                 entry.step = opt.option.step;

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

@@ -1,13 +1,19 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-const paramsSchema = z.object({
-  uuids: z.array(z.string()).describe(
-    "One or more paragraph UUIDs (or the page UUID to get page-level fields)"
-  ),
-  includeNested: z.boolean().optional().default(true).describe(
-    "Recursively include content fields from all nested child paragraphs (default: true). Set to false to only get direct fields."
-  )
-});
+import { readBlockContentFields } from "../helpers.js";
+import { stringArrayParam, tolerantSingularKeys } from "../schemas.js";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
+const paramsSchema = tolerantSingularKeys(
+  z.object({
+    uuids: stringArrayParam(
+      "Array of paragraph UUIDs. To get page-level fields, pass the page UUID in this array."
+    ),
+    includeNested: booleanParam(
+      "Recursively include content fields from all nested child paragraphs (default: true). Set to false to only get direct fields."
+    ).optional().default(true)
+  }),
+  { uuid: "uuids" }
+);
 const fieldSchema = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("plain").describe("Plain text field"),
@@ -61,12 +67,14 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `fields for ${Object.keys(r || {}).length} paragraphs`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetContentFieldsRunning", "Getting content fields...");
+    return $t("aiAgentGetContentFieldsRunning", "Getting content fields", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { blocks, directive, state, types, $t, context } = ctx.app;
+    const { blocks, state, types, $t, context } = ctx.app;
     const result = {};
     const processedUuids = /* @__PURE__ */ new Set();
     function processEntity(entityUuid) {
@@ -106,29 +114,20 @@ export default defineBlokkliAgentTool({
       processedUuids.add(blockUuid);
       const block = blocks.getBlock(blockUuid);
       if (!block) return;
-      const editables = directive.getEditablesForBlock(blockUuid);
-      for (const editable of editables) {
-        const fieldType = ctx.app.fieldValue.resolveFieldType(
-          ctx.itemEntityType,
-          block.bundle,
-          editable.fieldName
-        );
-        if (!fieldType) continue;
-        const currentValue = ctx.app.fieldValue.readValue(
-          ctx.itemEntityType,
-          blockUuid,
-          block.bundle,
-          editable.fieldName,
-          fieldType
-        );
+      for (const f of readBlockContentFields(
+        ctx.app,
+        blockUuid,
+        ctx.itemEntityType,
+        block.bundle
+      )) {
         const config = types.editableFieldConfig.forName(
           ctx.itemEntityType,
           block.bundle,
-          editable.fieldName
+          f.fieldName
         );
-        addField(result, blockUuid, editable.fieldName, {
-          type: fieldType,
-          currentValue,
+        addField(result, blockUuid, f.fieldName, {
+          type: f.fieldType,
+          currentValue: f.value,
           required: config?.required ?? false,
           maxLength: config?.maxLength ?? 0
         });

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

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 const paramsSchema = z.object({
-  before: z.number().optional().describe("How many mutations before current to include"),
-  after: z.number().optional().describe("How many mutations after current to include (redo-able)")
+  before: z.coerce.number().optional().describe("How many mutations before current to include"),
+  after: z.coerce.number().optional().describe("How many mutations after current to include (redo-able)")
 });
 const mutationSummarySchema = z.object({
   index: z.number().describe("History index for use with go_to_history_index"),
@@ -32,7 +32,9 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `index ${r.currentIndex ?? -1}/${r.totalCount ?? 0}`,
   modes: ["editing", "translating"],
   label($t) {
-    return $t("aiAgentGetMutationHistoryRunning", "Getting mutation history...");
+    return $t("aiAgentGetMutationHistoryRunning", "Getting mutation history", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,

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

@@ -56,7 +56,9 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `page structure (${r.totalParagraphs ?? 0} paragraphs)`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetPageStructureRunning", "Getting page structure...");
+    return $t("aiAgentGetPageStructureRunning", "Getting page structure", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const paramsSchema = z.object({});
+const resultSchema = z.object({
+  text: z.string().describe(
+    "The page rendered as Markdown \u2014 exactly what the user sees, in reading order"
+  ),
+  truncated: z.boolean().optional().describe("True when the Markdown exceeded the size cap and was cut off")
+});
+const MAX_LENGTH = 5e4;
+const STRIP_SELECTOR = [
+  "[hidden]",
+  '[aria-hidden="true"]',
+  '[data-bk-is-muted="true"]',
+  "style",
+  "script"
+].join(", ");
+export default defineBlokkliAgentTool({
+  name: "get_page_text",
+  description: 'Get the rendered page as Markdown \u2014 exactly what the user sees, in reading order, with headings/lists/tables preserved and content from referenced entities (teasers, etc.) included because it reads from the actual DOM. ALWAYS PREFER this over `get_all_page_content` for any question about page meaning or content ("what does this page say", "summarize the page", "write an intro that matches the content", "translate the page"). Reach for `get_all_page_content` only when you need per-block UUIDs to act on specific blocks.',
+  category: "query",
+  lazy: true,
+  volatile: true,
+  prunedSummary: (r) => `${r.text?.length ?? 0} chars of page text`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetPageTextRunning", "Reading page content", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx) {
+    const { ui, $t } = ctx.app;
+    const clone = ui.providerElement.cloneNode(true);
+    for (const el of Array.from(clone.querySelectorAll(STRIP_SELECTOR))) {
+      el.remove();
+    }
+    const { default: TurndownService } = await import("turndown");
+    const turndown = new TurndownService({
+      headingStyle: "atx",
+      codeBlockStyle: "fenced",
+      bulletListMarker: "-"
+    });
+    const REMOVED_TAGS = /* @__PURE__ */ new Set([
+      "SVG",
+      "IFRAME",
+      "PICTURE",
+      "VIDEO",
+      "AUDIO",
+      "CANVAS"
+    ]);
+    turndown.remove((node) => REMOVED_TAGS.has(node.nodeName));
+    let text = turndown.turndown(clone.innerHTML).trim();
+    let truncated = false;
+    if (text.length > MAX_LENGTH) {
+      text = text.slice(0, MAX_LENGTH) + "\n\n[TRUNCATED]";
+      truncated = true;
+    }
+    return {
+      label: $t("aiAgentGetPageTextDone", "Read page content"),
+      result: truncated ? { text, truncated } : { text }
+    };
+  }
+});

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

@@ -1,16 +1,24 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { parentSchema, blockOptionsMapSchema } from "../schemas.js";
-import { buildBlockOptionsMap } from "../helpers.js";
-import { getAvailableOptions } from "#blokkli/editor/helpers/options";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import {
+  buildBlockOptionsMap,
+  getResolvedOptions,
+  readBlockContentFields
+} from "../helpers.js";
 import { fragmentBlockBundle } from "#blokkli-build/config";
 const paramsSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
-  includeParentChain: z.boolean().optional().default(true).describe("Include ancestor parent paragraphs up to the page"),
-  includeSiblings: z.boolean().optional().default(false).describe("Include sibling paragraphs in the same field"),
-  includeChildren: z.boolean().optional().default(true).describe("Include child fields summary"),
-  includeContentFields: z.boolean().optional().default(true).describe("Include content fields (text, media, links) with values"),
-  includeOptions: z.boolean().optional().default(true).describe("Include paragraph options")
+  includeParentChain: booleanParam(
+    "Include ancestor parent paragraphs up to the page"
+  ).optional().default(true),
+  includeSiblings: booleanParam("Include sibling paragraphs in the same field").optional().default(false),
+  includeChildren: booleanParam("Include child fields summary").optional().default(true),
+  includeContentFields: booleanParam(
+    "Include content fields (text, media, links) with values"
+  ).optional().default(true),
+  includeOptions: booleanParam("Include paragraph options").optional().default(true)
 });
 const parentChainItemSchema = z.object({
   uuid: z.string().describe("The parent paragraph UUID"),
@@ -93,21 +101,14 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `context for ${r.bundle || "paragraph"} (${r.uuid?.slice(0, 8) || "?"})`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetBlockContextRunning", "Getting block context...");
+    return $t("aiAgentGetBlockContextRunning", "Getting block context", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const {
-      blocks,
-      state,
-      context,
-      types,
-      directive,
-      definitions,
-      selection,
-      $t
-    } = ctx.app;
+    const { blocks, state, context, types, selection, $t } = ctx.app;
     const block = blocks.getBlock(params.uuid);
     if (!block) {
       return {
@@ -197,25 +198,16 @@ export default defineBlokkliAgentTool({
     }
     if (params.includeContentFields) {
       const fields = [];
-      const editables = directive.getEditablesForBlock(params.uuid);
-      for (const editable of editables) {
-        const fieldType = ctx.app.fieldValue.resolveFieldType(
-          ctx.itemEntityType,
-          block.bundle,
-          editable.fieldName
-        );
-        if (!fieldType) continue;
-        const currentValue = ctx.app.fieldValue.readValue(
-          ctx.itemEntityType,
-          params.uuid,
-          block.bundle,
-          editable.fieldName,
-          fieldType
-        );
+      for (const f of readBlockContentFields(
+        ctx.app,
+        params.uuid,
+        ctx.itemEntityType,
+        block.bundle
+      )) {
         fields.push({
-          field: editable.fieldName,
-          type: fieldType,
-          currentValue
+          field: f.fieldName,
+          type: f.fieldType,
+          currentValue: f.value
         });
       }
       const droppableConfigs = types.droppableFieldConfig.forEntityTypeAndBundle(
@@ -238,24 +230,18 @@ export default defineBlokkliAgentTool({
       const selectionItem = selection.items.value.find(
         (v) => v.uuid === params.uuid
       );
-      const definition = definitions.getBlockDefinition(
+      const availableOptions = getResolvedOptions(
+        ctx.app,
         block.bundle,
         selectionItem?.fieldListType ?? "default",
         selectionItem?.parentBlockBundle ?? null
       );
-      if (definition) {
-        const availableOptions = getAvailableOptions(
-          definition.options,
-          definition.globalOptions,
-          definitions.globalOptions.value
+      if (availableOptions && availableOptions.length > 0) {
+        result.options = buildBlockOptionsMap(
+          availableOptions,
+          state.mutatedOptions,
+          params.uuid
         );
-        if (availableOptions.length > 0) {
-          result.options = buildBlockOptionsMap(
-            availableOptions,
-            state.mutatedOptions,
-            params.uuid
-          );
-        }
       }
     }
     return {

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

@@ -1,8 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { getAvailableOptions } from "#blokkli/editor/helpers/options";
 import { blockOptionsMapSchema } from "../schemas.js";
-import { buildBlockOptionsMap } from "../helpers.js";
+import { buildBlockOptionsMap, getResolvedOptions } from "../helpers.js";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The paragraph UUIDs to get options for")
 });
@@ -19,12 +18,14 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `options for ${Object.keys(r || {}).length} paragraphs`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetBlockOptionsRunning", "Getting block options...");
+    return $t("aiAgentGetBlockOptionsRunning", "Getting block options", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { blocks, state, definitions, selection, types, $t } = ctx.app;
+    const { blocks, state, selection, types, $t } = ctx.app;
     const result = {};
     const affectedUuids = [];
     for (const uuid of params.uuids) {
@@ -32,17 +33,13 @@ export default defineBlokkliAgentTool({
       if (!block) continue;
       const bundle = block.library?.reusableBundle || block.bundle;
       const selectionItem = selection.items.value.find((v) => v.uuid === uuid);
-      const definition = definitions.getBlockDefinition(
+      const availableOptions = getResolvedOptions(
+        ctx.app,
         bundle,
         selectionItem?.fieldListType ?? "default",
         selectionItem?.parentBlockBundle ?? null
       );
-      if (!definition) continue;
-      const availableOptions = getAvailableOptions(
-        definition.options,
-        definition.globalOptions,
-        definitions.globalOptions.value
-      );
+      if (!availableOptions) continue;
       result[uuid] = buildBlockOptionsMap(
         availableOptions,
         state.mutatedOptions,

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

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
 const paramsSchema = z.object({
-  maxNestingLevel: z.number().optional().describe(
+  maxNestingLevel: z.coerce.number().optional().describe(
     "Maximum nesting depth to include (0 = only root paragraphs, 1 = root + direct children, etc.). Omit for unlimited depth."
   ),
-  includeDimensions: z.boolean().optional().default(false).describe(
+  includeDimensions: booleanParam(
     "Include x, y, width, height for each paragraph (default: false)"
-  )
+  ).optional().default(false)
 });
 const dimensionsSchema = z.object({
   x: z.number().describe("X position in artboard coordinates"),
@@ -148,7 +149,10 @@ export default defineBlokkliAgentTool({
   label($t) {
     return $t(
       "aiAgentGetBlocksInViewportRunning",
-      "Getting blocks in viewport..."
+      "Getting blocks in viewport",
+      {
+        more: true
+      }
     );
   },
   paramsSchema,

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { runReadabilityAnalysis } from "../helpers.js";
+import { runReadabilityAnalysis } from "../readability.js";
 const issueSchema = z.object({
   text: z.string(),
   impact: z.string().optional(),
@@ -29,7 +29,9 @@ export default defineBlokkliAgentTool({
   requiredAdapterMethods: ["getAnalyzers"],
   isAvailable: (app) => app.readability.isAvailable.value,
   label($t) {
-    return $t("aiAgentAnalyzeContentRunning", "Analyzing content...");
+    return $t("aiAgentAnalyzeContentRunning", "Analyzing content", {
+      more: true
+    });
   },
   prunedSummary: (r) => {
     let count = 0;

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;