@blokkli/editor 2.0.0-alpha.35 → 2.0.0-alpha.37

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

@@ -1,5 +1,4 @@
-import type { McpToolDefinition, McpToolFactory, McpToolItem, McpToolContext, McpToolCategory, MutationAction, QueryResult, ToolError } from '#blokkli/agent/app/types';
-import type { ClientToolDefinition } from '#blokkli/agent/shared/types';
+import type { McpToolDefinition, McpToolContext, McpToolCategory, MutationAction, QueryResult, ToolError } from '#blokkli/agent/app/types';
 import type { BlokkliAdapter } from '#blokkli/editor/adapter';
 import type { EditMode } from '#blokkli/editor/types/state';
 /**
@@ -7,10 +6,20 @@ import type { EditMode } from '#blokkli/editor/types/state';
  */
 export declare function createToolMap(tools: McpToolDefinition[]): Record<string, McpToolDefinition>;
 /**
- * Get tools formatted for the server with JSON schemas.
+ * Get tool names for the server.
  * Filters by edit mode and adapter methods if provided.
+ * All tools are static and resolved from bundled metadata on the server.
  */
-export declare function getToolsForServer(tools: McpToolDefinition[], editMode: EditMode, adapter?: BlokkliAdapter<unknown>): ClientToolDefinition[];
+export declare function getToolInfoForServer(tools: McpToolDefinition[], editMode: EditMode, adapter?: BlokkliAdapter<unknown>): string[];
+/**
+ * Coerce stringified JSON values back to their actual types.
+ *
+ * LLMs sometimes double-serialize array or object parameters, sending e.g.
+ * `"[\"readability\"]"` (a string) instead of `["readability"]` (an array).
+ * This walks the params and attempts JSON.parse on any string that looks like
+ * a JSON array or object.
+ */
+export declare function coerceStringifiedParams(params: Record<string, unknown>): Record<string, unknown>;
 /**
  * Execute a tool by name with the given context and parameters.
  * Validates parameters with Zod before executing.
@@ -37,19 +46,7 @@ export declare function isQueryResult(result: unknown): result is QueryResult;
  */
 export declare function isToolError(result: unknown): result is ToolError;
 /**
- * Check if a tool item is a factory (produces tools dynamically at runtime).
- */
-export declare function isToolFactory(item: McpToolItem): item is McpToolFactory;
-/**
- * Check if a tool item is a static tool definition (not a factory).
- */
-export declare function isToolDefinition(item: McpToolItem): item is McpToolDefinition;
-/**
- * Resolve an array of tool items (static definitions + factories) into
- * a flat array of McpToolDefinition objects.
- *
- * Each factory's resolve callback is called to produce tools. The individual
- * tools returned by factories have their own requiredAdapterMethods, which
- * are checked later by getToolsForServer.
+ * Resolve an array of tool definitions into a flat array.
+ * All tools are now static — no factory resolution needed.
  */
-export declare function resolveTools(tools: McpToolItem[], context: McpToolContext): Promise<McpToolDefinition[]>;
+export declare function resolveTools(tools: McpToolDefinition[], _context: McpToolContext): Promise<McpToolDefinition[]>;

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

@@ -1,24 +1,7 @@
-import { z } from "zod";
 export function createToolMap(tools) {
   return Object.fromEntries(tools.map((t) => [t.name, t]));
 }
-function stripSchemaOverhead(obj) {
-  if (Array.isArray(obj)) {
-    return obj.map(stripSchemaOverhead);
-  }
-  if (typeof obj === "object" && obj !== null) {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      if (key === "$schema") continue;
-      if (key === "additionalProperties" && value === false) continue;
-      if (key === "propertyNames") continue;
-      result[key] = stripSchemaOverhead(value);
-    }
-    return result;
-  }
-  return obj;
-}
-export function getToolsForServer(tools, editMode, adapter) {
+export function getToolInfoForServer(tools, editMode, adapter) {
   return tools.filter((tool) => {
     if (!tool.modes.includes(editMode)) return false;
     if (!tool.requiredAdapterMethods) return true;
@@ -26,23 +9,31 @@ export function getToolsForServer(tools, editMode, adapter) {
     return tool.requiredAdapterMethods.every(
       (method) => typeof adapter[method] === "function"
     );
-  }).map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    input_schema: stripSchemaOverhead(
-      z.toJSONSchema(tool.paramsSchema)
-    ),
-    ...tool.lazy ? { lazy: true } : {},
-    category: tool.category,
-    ...tool.volatile ? { volatile: true } : {}
-  }));
+  }).map((t) => t.name);
+}
+export function coerceStringifiedParams(params) {
+  const result = {};
+  for (const key of Object.keys(params)) {
+    const value = params[key];
+    if (typeof value === "string" && (value[0] === "[" || value[0] === "{")) {
+      try {
+        result[key] = JSON.parse(value);
+      } catch {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
 }
 export async function executeTool(toolMap, name, context, params) {
   const tool = toolMap[name];
   if (!tool) {
     throw new Error(`Unknown tool: ${name}`);
   }
-  const validatedParams = tool.paramsSchema.parse(params);
+  const coerced = coerceStringifiedParams(params);
+  const validatedParams = tool.paramsSchema.parse(coerced);
   return tool.execute(context, validatedParams);
 }
 export function getToolCategory(toolMap, name) {
@@ -68,21 +59,6 @@ export function isQueryResult(result) {
 export function isToolError(result) {
   return typeof result === "object" && result !== null && "error" in result && typeof result.error === "string";
 }
-export function isToolFactory(item) {
-  return "__factory" in item && item.__factory === true;
-}
-export function isToolDefinition(item) {
-  return !isToolFactory(item);
-}
-export async function resolveTools(tools, context) {
-  const resolved = [];
-  for (const tool of tools) {
-    if (isToolFactory(tool)) {
-      const factoryTools = await tool.resolve(context);
-      resolved.push(...factoryTools);
-    } else {
-      resolved.push(tool);
-    }
-  }
-  return resolved;
+export async function resolveTools(tools, _context) {
+  return tools;
 }

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

@@ -2,7 +2,7 @@ import {
   getFieldType,
   getEditableValue,
   getParagraphChildren
-} from "#blokkli/agent/app/tools/schemas";
+} from "#blokkli/agent/app/tools/helpers";
 import { itemEntityType } from "#blokkli-build/config";
 const MAX_CONTENT_LENGTH = 150;
 function stripHtml(html) {

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

@@ -1,24 +1,20 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 const paramsSchema = z.object({
-  itemId: z.string().describe("Content item ID from search_content_* results"),
+  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"),
   targetBundle: z.string().describe(
-    "Paragraph bundle to create (from targetBundles in search_content_* results)"
+    "Paragraph bundle to create (from targetBundles in search_content results)"
   ),
   parent: parentSchema.describe("The parent entity to add the paragraph to"),
   position: positionSchema
 });
 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. Requires user approval.",
+  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. Requires user approval.",
   category: "mutation",
   prunedSummary: (r) => r.success ? "added content paragraph" : "rejected",
   modes: ["editing"],

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 const paramsSchema = z.object({
   name: z.string().describe("The fragment name to add"),
   parent: parentSchema.describe("The parent entity to add the fragment to"),

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 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")'),

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

@@ -5,10 +5,9 @@ import {
   mutationResultSchema,
   parentSchema,
   positionSchema,
-  resolvePosition,
-  optionValueSchema,
-  validateOptionValue
+  optionValueSchema
 } from "../schemas.js";
+import { resolvePosition, validateOptionValue } from "../helpers.js";
 import { itemEntityType } from "#blokkli-build/config";
 import {
   getAvailableOptions,

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 import { fromLibraryBlockBundle, itemEntityType } from "#blokkli-build/config";
 const paramsSchema = z.object({
   libraryItemUuid: z.string().describe(

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 const paramsSchema = z.object({
   templateUuid: z.string().describe(
     "The UUID of the template to add (from search_templates results)"

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

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const issueSchema = z.object({
+  text: z.string(),
+  impact: z.string().optional(),
+  scores: z.record(z.string(), z.number()).optional()
+});
+const fieldResultSchema = z.object({
+  fieldValue: z.string().optional(),
+  issues: z.array(issueSchema)
+});
+const paramsSchema = z.object({});
+const resultSchema = z.record(
+  z.string(),
+  z.record(z.string(), fieldResultSchema)
+);
+function resolveTargetInfo(target) {
+  const blockEl = target.closest("[data-bk-uuid]");
+  const paragraphUuid = blockEl?.getAttribute("data-bk-uuid") ?? void 0;
+  let fieldName;
+  let fieldEl;
+  let el = target;
+  while (el && el !== blockEl) {
+    if (el.dataset.blokkliEditableField) {
+      fieldName = el.dataset.blokkliEditableField;
+      fieldEl = el;
+      break;
+    }
+    el = el.parentElement;
+  }
+  const fieldText = fieldEl?.textContent?.trim() || void 0;
+  return { paragraphUuid, fieldName, fieldText };
+}
+export default defineBlokkliAgentTool({
+  name: "get_readability_issues",
+  description: "Run all readability analyzers against the full page. Returns an object keyed by paragraph UUID and field name, with the current field value and a list of issues. Each issue contains the flagged text segment, impact, and scores. Use the result to call batch_rewrite_text directly.",
+  category: "query",
+  volatile: true,
+  lazy: true,
+  modes: ["readonly", "editing", "translating", "review"],
+  requiredAdapterMethods: ["getAnalyzers"],
+  label($t) {
+    return $t("aiAgentAnalyzeContentRunning", "Analyzing content...");
+  },
+  prunedSummary: (r) => {
+    let count = 0;
+    for (const fields of Object.values(r)) {
+      for (const field of Object.values(fields)) {
+        count += field.issues.length;
+      }
+    }
+    return `found ${count} issues`;
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx) {
+    const { analyze, ui, $t } = ctx.app;
+    await analyze.ensureInitialized();
+    const readabilityAnalyzers = analyze.analyzers.value.filter(
+      (a) => a.type === "readability" && !a.requireRawPage
+    );
+    if (readabilityAnalyzers.length === 0) {
+      return {
+        label: $t(
+          "aiAgentAnalyzeContentDone",
+          "Analyzed @count results"
+        ).replace("@count", "0"),
+        result: {}
+      };
+    }
+    const analyzerCtx = analyze.createContext(ui.providerElement);
+    const result = {};
+    for (const analyzer of readabilityAnalyzers) {
+      const rawResults = await analyze.runAnalyzer(analyzer, analyzerCtx);
+      for (const r of rawResults) {
+        const rawNodes = Array.isArray(r.nodes) ? r.nodes : [r.nodes];
+        for (const node of rawNodes) {
+          const targets = Array.isArray(node.targets) ? node.targets : [node.targets];
+          for (const target of targets) {
+            if (!(target instanceof HTMLElement)) continue;
+            const info = resolveTargetInfo(target);
+            if (!info.paragraphUuid || !info.fieldName) continue;
+            const targetText = target.textContent?.trim();
+            if (!targetText) continue;
+            const uuid = info.paragraphUuid;
+            const field = info.fieldName;
+            if (!result[uuid]) {
+              result[uuid] = {};
+            }
+            if (!result[uuid][field]) {
+              result[uuid][field] = {
+                fieldValue: info.fieldText,
+                issues: []
+              };
+            }
+            result[uuid][field].issues.push({
+              text: targetText,
+              impact: node.impact,
+              scores: node.scores
+            });
+            break;
+          }
+        }
+      }
+    }
+    let issueCount = 0;
+    for (const fields of Object.values(result)) {
+      for (const field of Object.values(fields)) {
+        issueCount += field.issues.length;
+      }
+    }
+    return {
+      label: $t("aiAgentAnalyzeContentDone", "Analyzed @count results").replace(
+        "@count",
+        String(issueCount)
+      ),
+      result
+    };
+  }
+});

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

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

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

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const nodeSchema = z.object({
+  description: z.string().optional(),
+  impact: z.string().optional(),
+  scores: z.record(z.string(), z.number()).optional()
+});
+const textResultSchema = z.object({
+  text: z.string(),
+  nodes: z.array(nodeSchema)
+});
+const paramsSchema = z.object({
+  texts: z.array(z.string()).describe(
+    "Text strings to check for readability. Each string is analyzed independently."
+  )
+});
+const resultSchema = z.object({
+  results: z.array(textResultSchema)
+});
+export default defineBlokkliAgentTool({
+  name: "check_readability_for_texts",
+  description: "Check readability scores for one or more text strings. Returns readability metrics (LIX, CLI, ARI) for each text. Use this to evaluate whether a rewritten text has better readability before applying it.",
+  category: "query",
+  lazy: true,
+  modes: ["readonly", "editing", "translating", "review"],
+  requiredAdapterMethods: ["getAnalyzers"],
+  label($t) {
+    return $t("aiAgentCheckReadabilityRunning", "Checking readability...");
+  },
+  prunedSummary: (r) => {
+    return `checked readability for ${r.results.length} texts`;
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx, params) {
+    const { analyze, $t } = ctx.app;
+    await analyze.ensureInitialized();
+    const rawResults = await analyze.runOnTexts(params.texts, "readability");
+    const results = rawResults.map(
+      (tr) => ({
+        text: tr.text,
+        nodes: tr.nodes.map((node) => ({
+          description: node.description,
+          impact: node.impact,
+          scores: node.scores
+        }))
+      })
+    );
+    return {
+      label: $t(
+        "aiAgentCheckReadabilityDone",
+        "Checked readability for @count texts"
+      ).replace("@count", String(results.length)),
+      result: { results }
+    };
+  }
+});

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 import {
   validateBlocksExist,
   validateSameField,

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { getFieldType, getEditableValue } from "../schemas.js";
+import { getFieldType, getEditableValue } from "../helpers.js";
 const paramsSchema = z.object({});
 const blockContentSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),

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

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

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

@@ -0,0 +1,176 @@
+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";
+const paramsSchema = z.object({
+  parentUuid: z.string().describe("The parent entity UUID"),
+  field: z.string().describe("The field name"),
+  bundles: z.array(z.string()).optional().describe(
+    "Optional list of bundle names to filter by. If omitted, returns all allowed bundles."
+  )
+});
+const bundleSchema = z.object({
+  bundle: z.string().describe("The paragraph type identifier"),
+  label: z.string().describe("Human-readable label"),
+  description: z.string().optional().describe("Bundle description if available"),
+  contentFields: z.record(
+    z.string(),
+    z.object({
+      type: z.string().describe("Field type: plain, markup, reference, or link")
+    })
+  ).describe(
+    "Content fields (text, media, links) on this bundle, keyed by field name"
+  ),
+  paragraphFields: z.record(
+    z.string(),
+    z.object({
+      label: z.string().describe("Human-readable label"),
+      allowedBundles: z.array(z.string()).describe("Paragraph types allowed in this field"),
+      cardinality: z.number().describe("Max paragraphs allowed (-1 = unlimited)")
+    })
+  ).describe(
+    "Paragraph fields (for nested paragraphs) on this bundle, keyed by field name"
+  ),
+  options: blockOptionsMapSchema.optional().describe(
+    "Available options for this bundle with their default values (only included when few bundles are returned)"
+  )
+});
+const resultSchema = z.object({
+  fieldLabel: z.string().describe("Human-readable field label"),
+  cardinality: z.number().describe("Max paragraphs allowed (-1 = unlimited)"),
+  currentCount: z.number().describe("Current number of paragraphs in the field"),
+  bundles: z.array(bundleSchema).describe("Available paragraph types"),
+  nestingInfo: z.string().optional().describe(
+    "Summary of which bundles have paragraph fields for nested paragraphs. Use get_child_paragraphs after adding these bundles to populate their nested fields."
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "get_bundle_info",
+  description: "Get detailed information about which paragraph types can be added to a specific field, including their content fields and paragraph fields (for nested paragraphs).",
+  category: "query",
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetBundleInfoRunning", "Getting bundle info...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { fields, types, state, definitions, $t } = ctx.app;
+    const label = $t(
+      "aiAgentGetBundleInfoDone",
+      "Got bundle info for @field"
+    ).replace("@field", params.field);
+    const field = fields.find(params.parentUuid, params.field);
+    if (!field) {
+      return {
+        label,
+        result: {
+          fieldLabel: params.field,
+          cardinality: -1,
+          currentCount: 0,
+          bundles: []
+        }
+      };
+    }
+    const fieldKey = `${params.parentUuid}:${params.field}`;
+    const currentCount = state.getFieldBlockCount(fieldKey);
+    const allowedBundles = params.bundles ? field.allowedBundles.filter((b) => params.bundles.includes(b)) : field.allowedBundles;
+    const includeOptions = allowedBundles.length < 3;
+    const bundles = allowedBundles.map((bundle) => {
+      const bundleDefinition = types.getBlockBundleDefinition(bundle);
+      const contentFields = {};
+      for (const c of types.editableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, bundle).filter((c2) => c2.type !== "table")) {
+        contentFields[c.name] = {
+          type: c.type === "frame" || c.type === "markup" ? "markup" : "plain"
+        };
+      }
+      for (const c of types.droppableFieldConfig.forEntityTypeAndBundle(
+        ctx.itemEntityType,
+        bundle
+      )) {
+        contentFields[c.name] = { type: c.type };
+      }
+      const paragraphFields = {};
+      for (const c of types.fieldConfig.forEntityTypeAndBundle(
+        ctx.itemEntityType,
+        bundle
+      )) {
+        paragraphFields[c.name] = {
+          label: c.label,
+          allowedBundles: c.allowedBundles,
+          cardinality: c.cardinality
+        };
+      }
+      let options;
+      if (includeOptions) {
+        const definition = definitions.getBlockDefinition(bundle, "default");
+        if (definition) {
+          const availableOptions = getAvailableOptions(
+            definition.options,
+            definition.globalOptions,
+            definitions.globalOptions.value
+          );
+          if (availableOptions.length > 0) {
+            options = {};
+            for (const opt of availableOptions) {
+              const currentValue = getRuntimeOptionValue(
+                opt.option,
+                opt.option.default
+              );
+              const entry = {
+                type: opt.option.type,
+                label: opt.option.label,
+                currentValue
+              };
+              if (opt.option.description) {
+                entry.description = opt.option.description;
+              }
+              const labels = extractOptionLabels(opt.option);
+              if (labels) {
+                entry.options = labels;
+              }
+              if ("min" in opt.option) {
+                entry.min = opt.option.min;
+              }
+              if ("max" in opt.option) {
+                entry.max = opt.option.max;
+              }
+              if ("step" in opt.option && opt.option.type === "range") {
+                entry.step = opt.option.step;
+              }
+              options[opt.property] = entry;
+            }
+          }
+        }
+      }
+      return {
+        bundle,
+        label: bundleDefinition?.label ?? bundle,
+        description: bundleDefinition?.description,
+        contentFields,
+        paragraphFields,
+        options
+      };
+    });
+    const nestingBundles = bundles.filter(
+      (b) => Object.keys(b.paragraphFields).length > 0
+    );
+    const nestingInfo = nestingBundles.length ? nestingBundles.map(
+      (b) => `${b.bundle} has paragraph fields: ${Object.entries(
+        b.paragraphFields
+      ).map(([name, f]) => `${name} (${f.allowedBundles.join(", ")})`).join(", ")}`
+    ).join("; ") : void 0;
+    return {
+      label,
+      result: {
+        fieldLabel: field.label,
+        cardinality: field.cardinality,
+        currentCount,
+        bundles,
+        nestingInfo
+      }
+    };
+  }
+});

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { getFieldType, getEditableValue } from "../schemas.js";
+import { getFieldType, getEditableValue } from "../helpers.js";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).describe(
     "One or more paragraph UUIDs (or the page UUID to get page-level fields)"