@blokkli/editor 2.0.0-alpha.31 → 2.0.0-alpha.33

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

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "../schemas.js";
+const paramsSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID or entity UUID containing the media field"),
+  field: z.string().describe("The content field name (reference type)"),
+  mediaId: z.string().describe("The media item ID (from search_media results)"),
+  mediaBundle: z.string().describe('The media bundle type (e.g., "image")')
+});
+export default defineBlokkliAgentTool({
+  name: "replace_media_field",
+  description: "Replace the media on an existing paragraph field. Use get_content_fields first to see available reference fields, then search_media to find media items.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "replaced media" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentReplaceMediaRunning", "Replacing media...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["mediaLibraryReplaceMedia"],
+  execute(ctx, params) {
+    const { blocks, types, $t, context } = ctx.app;
+    const isEntity = params.uuid === context.value.entityUuid;
+    const block = !isEntity ? blocks.getBlock(params.uuid) : null;
+    if (!isEntity && !block) {
+      return { error: `Paragraph not found: ${params.uuid}` };
+    }
+    const entityType = isEntity ? context.value.entityType : ctx.itemEntityType;
+    const bundle = isEntity ? context.value.entityBundle : block.bundle;
+    const config = types.droppableFieldConfig.forName(
+      entityType,
+      bundle,
+      params.field
+    );
+    if (!config) {
+      return {
+        error: `Field "${params.field}" is not a reference content field on ${bundle}`
+      };
+    }
+    const allowedMedia = config.allowed.find((v) => v.type === "media");
+    if (!allowedMedia) {
+      return {
+        error: `Field "${params.field}" does not accept media items`
+      };
+    }
+    if (!allowedMedia.bundles.includes(params.mediaBundle)) {
+      return {
+        error: `Field "${params.field}" does not accept ${params.mediaBundle} media. Allowed: ${allowedMedia.bundles.join(", ")}`
+      };
+    }
+    return {
+      type: "rewrite",
+      label: $t("aiAgentReplaceMediaDone", "Replaced media on @field").replace(
+        "@field",
+        config.label
+      ),
+      apply: (adapter) => {
+        if (isEntity) {
+          if (!adapter.mediaLibraryReplaceEntityMedia) {
+            throw new Error("Entity media replacement not supported");
+          }
+          return adapter.mediaLibraryReplaceEntityMedia({
+            host: {
+              type: entityType,
+              uuid: params.uuid,
+              fieldName: params.field
+            },
+            mediaId: params.mediaId
+          });
+        }
+        return adapter.mediaLibraryReplaceMedia({
+          host: {
+            type: entityType,
+            uuid: params.uuid,
+            fieldName: params.field
+          },
+          mediaId: params.mediaId
+        });
+      },
+      affectedUuids: [params.uuid]
+    };
+  }
+});

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

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+import type { OptionItem } from '#blokkli/editor/helpers/options';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+/**
+ * Shared schema for a single block option with its current value.
+ */
+export declare const blockOptionSchema: z.ZodObject<{
+    type: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    min: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    max: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    step: z.ZodOptional<z.ZodNumber>;
+    currentValue: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>;
+}, z.core.$strip>;
+/**
+ * Shared schema for a record of block options keyed by property name.
+ */
+export declare const blockOptionsMapSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    min: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    max: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    step: z.ZodOptional<z.ZodNumber>;
+    currentValue: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>;
+}, z.core.$strip>>;
+export type BlockOptionsMap = z.infer<typeof blockOptionsMapSchema>;
+/**
+ * Build a block options map from available options and mutated state.
+ */
+export declare function buildBlockOptionsMap(availableOptions: OptionItem[], mutatedOptions: Record<string, Record<string, string>>, uuid: string): BlockOptionsMap;
+/**
+ * Schema for a parent entity (the container of a block).
+ * A parent is an entity + field combination where blocks can be placed.
+ * Used consistently across tools for specifying block locations.
+ */
+export declare const parentSchema: z.ZodObject<{
+    type: z.ZodString;
+    uuid: z.ZodString;
+    field: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for mutation tool results.
+ * Mutation tools return either a MutationAction (handled by framework) or an error.
+ */
+export declare const mutationResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        add: "add";
+        delete: "delete";
+        move: "move";
+        rewrite: "rewrite";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+/**
+ * Shared schema for option values (used by add_blocks and set_block_options).
+ */
+export declare const optionValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>;
+/**
+ * Validate a single option value against its definition.
+ * Returns an error string or undefined if valid.
+ */
+export declare function validateOptionValue(key: string, value: string | boolean | number | string[], optionDef: OptionItem): string | undefined;
+/**
+ * Resolve an editable field config to its simplified type.
+ * Returns 'plain' for text fields, 'markup' for rich text/frame fields, null for unsupported.
+ */
+export declare function getFieldType(app: BlokkliApp, entityType: string, bundle: string, fieldName: string): 'plain' | 'markup' | null;
+/**
+ * Read the current value of an editable field on a block or entity.
+ * Tries the registered getValue() callback first, falls back to DOM element reading.
+ */
+export declare function getEditableValue(app: BlokkliApp, entityType: string, uuid: string, bundle: string, fieldName: string, fieldType: 'plain' | 'markup'): string;
+/**
+ * Get all child fields and their paragraphs for a given entity UUID.
+ * Walks mutatedFields to find fields belonging to the entity.
+ */
+export declare function getParagraphChildren(app: BlokkliApp, uuid: string): {
+    fieldName: string;
+    paragraphs: {
+        uuid: string;
+        bundle: string;
+    }[];
+}[];
+/**
+ * Shared schema for the `position` parameter used by mutation tools that insert blocks.
+ *
+ * Values:
+ * - `"start"` — insert at the beginning of the field
+ * - `"end"` (default when omitted) — append at the end of the field
+ * - `"after:<UUID>"` — insert after the block with the given UUID
+ * - `"before:<UUID>"` — insert before the block with the given UUID
+ */
+export declare const positionSchema: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+/**
+ * Resolve a `position` string to the `afterUuid` value expected by adapter methods.
+ *
+ * Returns `{ afterUuid: string | null }` on success, or `{ error: string }` if
+ * the referenced UUID is not found in the target field.
+ */
+export declare function resolvePosition(app: BlokkliApp, parentUuid: string, fieldName: string, position?: string): {
+    afterUuid: string | null;
+} | {
+    error: string;
+};
+/**
+ * Schema for the success result sent back to the AI after mutation is applied.
+ */
+export declare const mutationSuccessSchema: z.ZodUnion<readonly [z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    newParagraphs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        bundle: z.ZodString;
+        paragraphFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    historyIndex: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    rejected: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;

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

@@ -0,0 +1,242 @@
+import { z } from "zod";
+import { getMutatedOptionValue } from "#blokkli/editor/helpers/options";
+import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
+function extractOptionLabels(option) {
+  if (!("options" in option) || !option.options) return void 0;
+  const raw = option.options;
+  const labels = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string") {
+      labels[key] = value;
+    } else if (typeof value === "object" && value !== null && "label" in value) {
+      labels[key] = String(value.label);
+    } else {
+      labels[key] = key;
+    }
+  }
+  return labels;
+}
+export const blockOptionSchema = z.object({
+  type: z.string().describe(
+    "The option type (checkbox, radios, checkboxes, text, number, range, color, datetime-local)"
+  ),
+  label: z.string().describe("The display label"),
+  description: z.string().optional().describe("Optional description"),
+  options: z.record(z.string(), z.string()).optional().describe("Available choices for radios/checkboxes (key \u2192 label)"),
+  min: z.union([z.number(), z.string()]).optional().describe("Minimum value for number/range/datetime-local types"),
+  max: z.union([z.number(), z.string()]).optional().describe("Maximum value for number/range/datetime-local types"),
+  step: z.number().optional().describe("Step increment for range type"),
+  currentValue: z.union([z.string(), z.boolean(), z.number(), z.array(z.string())]).describe("The current value")
+});
+export const blockOptionsMapSchema = z.record(
+  z.string().describe("Option property name"),
+  blockOptionSchema
+);
+export function buildBlockOptionsMap(availableOptions, mutatedOptions, uuid) {
+  const result = {};
+  for (const opt of availableOptions) {
+    const rawValue = getMutatedOptionValue(
+      mutatedOptions,
+      uuid,
+      opt.property,
+      opt.option.default
+    );
+    const currentValue = getRuntimeOptionValue(opt.option, rawValue);
+    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;
+    }
+    result[opt.property] = entry;
+  }
+  return result;
+}
+export const parentSchema = z.object({
+  type: z.string().describe(
+    "The entity type of the parent. Do NOT guess this - always use the parent object returned by get_child_paragraphs."
+  ),
+  uuid: z.string().describe("The UUID of the parent entity or paragraph"),
+  field: z.string().describe(
+    "The field name on the parent. Do NOT guess this - always use the parent object returned by get_child_paragraphs."
+  )
+});
+export const mutationResultSchema = z.union([
+  z.object({
+    type: z.enum(["add", "delete", "move", "rewrite", "options"]).describe("Type of mutation"),
+    label: z.string().describe("Human-readable description")
+  }),
+  z.object({
+    error: z.string().describe("Error message if the mutation failed")
+  })
+]);
+export const optionValueSchema = z.union([
+  z.string(),
+  z.boolean(),
+  z.number(),
+  z.array(z.string())
+]);
+export function validateOptionValue(key, value, optionDef) {
+  const optionType = optionDef.option.type;
+  if (optionType === "checkbox") {
+    if (typeof value !== "boolean" && value !== "1" && value !== "0" && value !== "true" && value !== "false") {
+      return `Option "${key}" expects a boolean value`;
+    }
+  } else if (optionType === "radios") {
+    if (typeof value !== "string") {
+      return `Option "${key}" expects a string value`;
+    }
+    if ("options" in optionDef.option && optionDef.option.options) {
+      const allowedKeys = Object.keys(optionDef.option.options);
+      if (!allowedKeys.includes(value)) {
+        return `Option "${key}" value must be one of: ${allowedKeys.join(", ")}`;
+      }
+    }
+  } else if (optionType === "checkboxes") {
+    if (!Array.isArray(value) && typeof value !== "string") {
+      return `Option "${key}" expects an array of strings or comma-separated string`;
+    }
+    if ("options" in optionDef.option && optionDef.option.options) {
+      const allowedKeys = Object.keys(optionDef.option.options);
+      const values = Array.isArray(value) ? value : value.split(",");
+      for (const v of values) {
+        if (!allowedKeys.includes(v)) {
+          return `Option "${key}" value "${v}" is not allowed. Must be one of: ${allowedKeys.join(", ")}`;
+        }
+      }
+    }
+  } else if (optionType === "number" || optionType === "range") {
+    const numValue = typeof value === "number" ? value : Number.parseFloat(String(value));
+    if (Number.isNaN(numValue)) {
+      return `Option "${key}" expects a numeric value`;
+    }
+    if ("min" in optionDef.option && numValue < optionDef.option.min) {
+      return `Option "${key}" value must be >= ${optionDef.option.min}`;
+    }
+    if ("max" in optionDef.option && numValue > optionDef.option.max) {
+      return `Option "${key}" value must be <= ${optionDef.option.max}`;
+    }
+  }
+  return void 0;
+}
+export function getFieldType(app, entityType, bundle, fieldName) {
+  const config = app.types.editableFieldConfig.forName(
+    entityType,
+    bundle,
+    fieldName
+  );
+  if (!config) return null;
+  if (config.type === "table") return null;
+  if (config.type === "frame" || config.type === "markup") return "markup";
+  return "plain";
+}
+export function getEditableValue(app, entityType, uuid, bundle, fieldName, fieldType) {
+  const editables = app.directive.getEditablesForBlock(uuid);
+  const editable = editables.find((e) => e.fieldName === fieldName);
+  if (editable?.getValue) {
+    return editable.getValue();
+  }
+  const element = app.directive.findEditableElement(fieldName, {
+    type: entityType,
+    uuid,
+    bundle
+  });
+  if (element) {
+    return fieldType === "markup" ? element.innerHTML || "" : element.textContent || "";
+  }
+  return "";
+}
+export function getParagraphChildren(app, uuid) {
+  const result = [];
+  for (const field of app.state.mutatedFields.value) {
+    if (field.entityUuid === uuid && field.list.length > 0) {
+      result.push({
+        fieldName: field.name,
+        paragraphs: field.list.map((item) => ({
+          uuid: item.uuid,
+          bundle: item.bundle
+        }))
+      });
+    }
+  }
+  return result;
+}
+export const positionSchema = z.string().optional().default("end").describe(
+  'Where to place the paragraph(s). "start" = beginning, "end" (default) = append at end, "after:<UUID>" = after a specific paragraph, "before:<UUID>" = before a specific paragraph.'
+);
+export function resolvePosition(app, parentUuid, fieldName, position) {
+  const fieldList = app.state.mutatedFields.value.find(
+    (f) => f.entityUuid === parentUuid && f.name === fieldName
+  );
+  const list = fieldList?.list ?? [];
+  if (position === void 0 || position === "end") {
+    const lastBlock = list.at(-1);
+    return { afterUuid: lastBlock?.uuid ?? null };
+  }
+  if (position === "start") {
+    return { afterUuid: null };
+  }
+  if (position.startsWith("after:")) {
+    const uuid = position.slice(6);
+    const found = list.find((b) => b.uuid === uuid);
+    if (!found) {
+      return {
+        error: `Position "after:${uuid}": paragraph not found in field "${fieldName}".`
+      };
+    }
+    return { afterUuid: uuid };
+  }
+  if (position.startsWith("before:")) {
+    const uuid = position.slice(7);
+    const index = list.findIndex((b) => b.uuid === uuid);
+    if (index === -1) {
+      return {
+        error: `Position "before:${uuid}": paragraph not found in field "${fieldName}".`
+      };
+    }
+    const preceding = index > 0 ? list[index - 1] : void 0;
+    return { afterUuid: preceding?.uuid ?? null };
+  }
+  return {
+    error: `Invalid position value: "${position}". Use "start", "end", "after:<UUID>", or "before:<UUID>".`
+  };
+}
+export const mutationSuccessSchema = z.union([
+  z.object({
+    success: z.literal(true),
+    newParagraphs: z.array(
+      z.object({
+        uuid: z.string(),
+        bundle: z.string(),
+        paragraphFields: z.array(z.string()).optional().describe(
+          "Paragraph fields on this new paragraph that can hold nested paragraphs. Call get_child_paragraphs with this paragraph's UUID to add paragraphs to these fields."
+        )
+      })
+    ).optional().describe(
+      "Paragraphs created by this mutation (for add/duplicate operations), with their UUIDs and bundle types"
+    ),
+    historyIndex: z.number().describe("Current position in mutation history (-1 = pristine)")
+  }),
+  z.object({
+    success: z.literal(false),
+    rejected: z.literal(true).optional().describe("True if user rejected the change")
+  }),
+  z.object({
+    error: z.string().describe("Error message")
+  })
+]);

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

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

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const resultSchema = z.array(
+  z.object({
+    id: z.string().describe("The unique ID of the content item"),
+    title: z.string().describe("The display title of the content item"),
+    entityType: z.string().describe("The entity type"),
+    entityBundle: z.string().describe("The entity bundle"),
+    targetBundles: z.array(z.string()).describe("Paragraph bundles that can be created from this content item"),
+    context: z.string().optional().describe("Additional context information"),
+    text: z.string().optional().describe("Description text"),
+    imageUrl: z.string().optional().describe("URL of the preview image")
+  })
+);
+export default defineBlokkliAgentTool({
+  resolve: async (ctx) => {
+    if (!ctx.adapter.getContentSearchTabs || !ctx.adapter.getContentSearchResults) {
+      return [];
+    }
+    const tabs = await ctx.adapter.getContentSearchTabs();
+    return tabs.map((tab) => {
+      const typesDescription = tab.types.map((type) => {
+        return `${type.type} (${type.bundles.join(", ")})`;
+      }).join(", ");
+      const description = `Content search for these entities: ${typesDescription}`;
+      return defineBlokkliAgentTool({
+        name: `search_content_${tab.id}`,
+        description,
+        category: "query",
+        lazy: true,
+        requiredAdapterMethods: [
+          "getContentSearchTabs",
+          "getContentSearchResults"
+        ],
+        modes: ["readonly", "editing", "translating", "review"],
+        label() {
+          return `Searching ${tab.title}...`;
+        },
+        paramsSchema: z.object({
+          query: z.string().describe(`Search query for ${tab.title}`)
+        }),
+        resultSchema,
+        async execute(toolCtx, params) {
+          const items = await toolCtx.adapter.getContentSearchResults(
+            tab.id,
+            params.query
+          );
+          return {
+            label: `Searched ${tab.title} for "${params.query}"`,
+            result: items.map((item) => ({
+              id: item.id,
+              title: item.title,
+              entityType: item.entityType,
+              entityBundle: item.entityBundle,
+              targetBundles: item.targetBundles,
+              context: item.context,
+              text: item.text,
+              imageUrl: item.imageUrl
+            }))
+          };
+        }
+      });
+    });
+  }
+});

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+declare const resultSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        mediaId: z.ZodString;
+        label: z.ZodString;
+        mediaBundle: z.ZodString;
+        thumbnail: z.ZodOptional<z.ZodString>;
+        targetBundles: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+export type SearchMediaResult = z.infer<typeof resultSchema>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const paramsSchema = z.object({
+  query: z.string().optional().describe(
+    "Search text to filter media items. Omit or leave empty to list all available media."
+  ),
+  bundle: z.string().optional().describe('Media bundle filter (e.g., "image", "video")')
+});
+const resultSchema = z.object({
+  items: z.array(
+    z.object({
+      mediaId: z.string().describe("The unique ID of the media item"),
+      label: z.string().describe("The display label/title of the media"),
+      mediaBundle: z.string().describe('The media type (e.g., "image", "video")'),
+      thumbnail: z.string().optional().describe("URL of the thumbnail image"),
+      targetBundles: z.array(z.string()).describe("Paragraph bundles that can be created from this media")
+    })
+  ),
+  total: z.number().describe("Total number of matching media items")
+});
+export default defineBlokkliAgentTool({
+  name: "search_media",
+  description: "Search the media library for images, videos, and other media. Returns media items that can be added to the page using add_media_paragraph. If more than one matching media is found: USE THE select_media TOOL TO LET THE USER PICK.",
+  category: "query",
+  lazy: true,
+  prunedSummary: (r) => `found ${r.total || 0} media items`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentSearchMediaRunning", "Searching media...");
+  },
+  paramsSchema,
+  resultSchema,
+  requiredAdapterMethods: ["mediaLibraryGetResults"],
+  async execute(ctx, params) {
+    const { $t } = ctx.app;
+    const filters = {};
+    const query = (params.query ?? "").replaceAll("*", "").replaceAll("%", "");
+    if (query) filters.text = query;
+    if (params.bundle) filters.bundle = params.bundle;
+    const apiResult = await ctx.adapter.mediaLibraryGetResults({
+      filters,
+      page: 0
+    });
+    const result = {
+      items: apiResult.items.map((item) => ({
+        mediaId: item.mediaId,
+        label: item.label,
+        mediaBundle: item.mediaBundle || "",
+        thumbnail: item.thumbnail,
+        targetBundles: item.targetBundles
+      })),
+      total: apiResult.total
+    };
+    const label = query ? $t("aiAgentSearchMediaDone", "Searched media for '@query'").replace(
+      "@query",
+      query
+    ) : $t("aiAgentSearchMediaAllDone", "Searched all media");
+    return { label, result };
+  }
+});

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

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

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

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { parentSchema } from "../schemas.js";
+import { fromLibraryBlockBundle, itemEntityType } from "#blokkli-build/config";
+const paramsSchema = z.object({
+  parent: parentSchema.optional().describe(
+    "The parent entity where a reusable paragraph would be added. When provided, results are filtered to only include bundles allowed in this field."
+  )
+});
+const reusableParagraphSchema = z.object({
+  uuid: z.string().describe("The unique UUID of the reusable paragraph"),
+  label: z.string().describe("The display label"),
+  bundle: z.string().describe("The paragraph bundle type of the reusable paragraph")
+});
+const resultSchema = z.object({
+  items: z.array(reusableParagraphSchema).describe("Matching reusable paragraphs"),
+  total: z.number().describe("Total number of matching reusable paragraphs")
+});
+export default defineBlokkliAgentTool({
+  name: "search_reusable_paragraphs",
+  description: "Search for reusable paragraphs. These are pre-built paragraphs that can be placed on multiple pages. Unlike templates, reusable paragraphs stay linked: editing the reusable paragraph updates all pages using it. Use add_reusable_paragraph to add a result to the page.",
+  category: "query",
+  prunedSummary: (r) => `found ${r.total} reusable paragraphs`,
+  modes: ["readonly", "editing", "translating", "review"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentSearchLibraryRunning", "Searching reusable blocks...");
+  },
+  paramsSchema,
+  resultSchema,
+  requiredAdapterMethods: ["getLibraryItems"],
+  async execute(ctx, params) {
+    const { types, context, blocks, $t } = ctx.app;
+    let bundles = [];
+    if (params.parent) {
+      const isRootEntity = params.parent.uuid === context.value.entityUuid;
+      const parentEntityType = isRootEntity ? context.value.entityType : itemEntityType;
+      const parentBundle = isRootEntity ? context.value.entityBundle : blocks.getBlock(params.parent.uuid)?.bundle;
+      if (!parentBundle) {
+        return { error: `Parent not found: ${params.parent.uuid}` };
+      }
+      const field = types.getFieldConfig(
+        parentEntityType,
+        parentBundle,
+        params.parent.field
+      );
+      if (!field) {
+        return {
+          error: `Field "${params.parent.field}" not found on bundle "${parentBundle}".`
+        };
+      }
+      if (field.allowedBundles.length && !field.allowedBundles.includes(fromLibraryBlockBundle)) {
+        return {
+          error: `Field "${params.parent.field}" does not allow the from_library bundle.`
+        };
+      }
+      bundles = field.allowedBundles.filter((b) => b !== fromLibraryBlockBundle);
+    }
+    const apiResult = await ctx.adapter.getLibraryItems({
+      bundles,
+      page: 0,
+      filters: {}
+    });
+    const result = {
+      items: apiResult.items.map((item) => ({
+        uuid: item.uuid,
+        label: item.label || "",
+        bundle: item.bundle
+      })),
+      total: apiResult.total
+    };
+    const label = $t("aiAgentSearchLibraryDone", "Searched library");
+    return { label, result };
+  }
+});

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

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