@revenexx/editor 0.1.0

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

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+/**
+ * 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>;
+/**
+ * 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<{
+        rewrite: "rewrite";
+        add: "add";
+        delete: "delete";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+/**
+ * A parameter that accepts an array of strings OR a single string (normalized
+ * to a one-element array). LLMs frequently send a bare string for array params
+ * and otherwise fail validation on the first call. The generated JSON Schema
+ * still advertises an array, so the model is guided toward the array form while
+ * a single string is accepted as a fallback.
+ */
+export declare function stringArrayParam(description: string): z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>;
+/**
+ * Wraps an object params schema to tolerate a singular key when the schema
+ * actually expects its plural form (e.g. `uuid` → `uuids`). LLMs — especially
+ * the smaller models — frequently pick the singular form when a tool
+ * description mentions both ("one or more UUIDs"). Without this, the call
+ * fails validation and the model often retries with the same wrong key.
+ *
+ * The generated JSON Schema is unchanged (the wrapping happens via
+ * `z.preprocess`), so the model is still guided to the plural form; the
+ * singular form is silently accepted as a fallback.
+ */
+export declare function tolerantSingularKeys<T extends z.ZodType>(schema: T, aliases: Record<string, string>): z.ZodPipe<z.ZodTransform<unknown, unknown>, T>;
+/**
+ * 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>]>;
+/**
+ * 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>>;
+export declare const fieldDiffResultSchema: z.ZodObject<{
+    acceptedCount: z.ZodNumber;
+    rejectedByUser: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        reasonForRejection: z.ZodString;
+        partial: z.ZodOptional<z.ZodObject<{
+            accepted: z.ZodNumber;
+            total: z.ZodNumber;
+            rejectedSegments: z.ZodArray<z.ZodObject<{
+                tag: z.ZodString;
+                beforeHtml: z.ZodString;
+                afterHtml: z.ZodString;
+                status: z.ZodEnum<{
+                    deleted: "deleted";
+                    matched: "matched";
+                    inserted: "inserted";
+                }>;
+                reasonForRejection: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    label: z.ZodString;
+    agentMessage: z.ZodOptional<z.ZodString>;
+    historyIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Schema for a single entry in a mutation's `newParagraphs` payload. Recursive
+ * so nested children appear under their parent's `children` keyed by paragraph
+ * field name — mirroring the input shape of `add_paragraphs`.
+ */
+type NewParagraphEntry = {
+    uuid: string;
+    bundle: string;
+    paragraphFields?: string[];
+    children?: Record<string, NewParagraphEntry[]>;
+};
+/**
+ * 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.ZodType<NewParagraphEntry, unknown, z.core.$ZodTypeInternals<NewParagraphEntry, unknown>>>>;
+    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>]>;
+export {};

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

@@ -0,0 +1,139 @@
+import { z } from "zod";
+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 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 function stringArrayParam(description) {
+  return z.preprocess(
+    (value) => typeof value === "string" ? [value] : value,
+    z.array(z.string()).describe(description)
+  );
+}
+export function tolerantSingularKeys(schema, aliases) {
+  return z.preprocess((value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return value;
+    }
+    const obj = value;
+    const remapped = {};
+    let touched = false;
+    for (const key of Object.keys(obj)) {
+      const plural = aliases[key];
+      if (plural && !(plural in obj)) {
+        remapped[plural] = obj[key];
+        touched = true;
+      } else {
+        remapped[key] = obj[key];
+      }
+    }
+    return touched ? remapped : obj;
+  }, schema);
+}
+export const optionValueSchema = z.union([
+  z.string(),
+  z.boolean(),
+  z.number(),
+  z.array(z.string())
+]);
+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.'
+);
+const rejectedSegmentSchema = z.object({
+  tag: z.string().describe('HTML tag of the rejected chunk (e.g. "p", "li", "h2")'),
+  beforeHtml: z.string().describe(
+    "The original innerHTML kept in the field (empty for newly inserted chunks that were rejected and dropped)"
+  ),
+  afterHtml: z.string().describe(
+    "The innerHTML you proposed for this chunk and the user rejected (empty for deletions that were rejected and restored)"
+  ),
+  status: z.enum(["matched", "inserted", "deleted"]).describe(
+    "Whether your proposal modified an existing chunk (matched), added a new one (inserted), or removed one (deleted)"
+  ),
+  reasonForRejection: z.string().describe("Per-chunk rejection reason; empty if none given")
+});
+const fieldRejectionSchema = z.object({
+  reasonForRejection: z.string().describe(
+    "Field-level rejection reason; empty when no reason given or when rejection is per-chunk (see `partial`)"
+  ),
+  partial: z.object({
+    accepted: z.number().describe("Number of changed chunks in this field the user accepted"),
+    total: z.number().describe("Total number of changed chunks in this field"),
+    rejectedSegments: z.array(rejectedSegmentSchema).describe(
+      "Details for each rejected chunk. The field still gets updated with a hybrid value combining the accepted chunks and the original content of the rejected ones."
+    )
+  }).optional().describe(
+    "Present when the user evaluated chunk-by-chunk. When `accepted > 0`, the field was updated with a hybrid value; when `accepted === 0`, every chunk was rejected and the field stayed at its original value."
+  )
+});
+export const fieldDiffResultSchema = z.object({
+  acceptedCount: z.number().describe("Number of changes accepted by the user"),
+  rejectedByUser: z.record(z.string(), z.record(z.string(), fieldRejectionSchema)).describe(
+    "Map of paragraph UUID \u2192 field name \u2192 rejection details. A field appears here when at least one chunk was rejected (or, for non-chunked fields, when the whole field was rejected)."
+  ),
+  label: z.string().describe("Human-readable summary shown in the UI"),
+  agentMessage: z.string().optional().describe(
+    "Detailed message for the agent, replaces label in the LLM context"
+  ),
+  historyIndex: z.number().optional().describe("The mutation history index after applying changes")
+});
+const newParagraphEntrySchema = z.lazy(
+  () => 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."
+    ),
+    children: z.record(
+      z.string().describe("Paragraph field name"),
+      z.array(newParagraphEntrySchema)
+    ).optional().describe(
+      "Nested paragraphs created inside this entry, keyed by paragraph field name. Mirrors the `children` shape used by add_paragraphs \u2014 the structure round-trips, so a child here means it actually landed inside this parent."
+    )
+  })
+);
+export const mutationSuccessSchema = z.union([
+  z.object({
+    success: z.literal(true),
+    newParagraphs: z.array(newParagraphEntrySchema).optional().describe(
+      "Top-level paragraphs created by this mutation (for add/duplicate operations). Nested children appear under each entry's `children` keyed by paragraph field name; the tree mirrors what was requested."
+    ),
+    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,17 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    tab: z.ZodString;
+    query: z.ZodString;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    entityType: z.ZodString;
+    entityBundle: z.ZodString;
+    targetBundles: z.ZodArray<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+export const paramsSchema = z.object({
+  tab: z.string().describe(
+    "The tab ID to search in. See the system prompt for available tab IDs."
+  ),
+  query: z.string().describe("The search query")
+});
+export 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({
+  name: "search_content",
+  description: 'Search for content items by tab ID and query. The available tab IDs and their entity types are listed in the system prompt under "Content Search Tabs". Use the tab ID that matches the type of content you are looking for.',
+  category: "query",
+  lazy: true,
+  requiredAdapterMethods: ["getContentSearchTabs", "getContentSearchResults"],
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentSearchContentRunning", "Searching content", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx, params) {
+    const tabs = await ctx.adapter.getContentSearchTabs();
+    const tab = tabs.find((t) => t.id === params.tab);
+    if (!tab) {
+      return {
+        error: `Invalid tab ID "${params.tab}". Available tabs: ${tabs.map((t) => t.id).join(", ")}`
+      };
+    }
+    const items = await ctx.adapter.getContentSearchResults(
+      params.tab,
+      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,18 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    bundle: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export 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";
+export const paramsSchema = z.object({
+  query: z.string().optional().describe(
+    'Search text to filter media items. Searching for "foobar test" will search the exact full string, so prefer searching single for words.'
+  ),
+  bundle: z.string().optional().describe('Media bundle filter (e.g., "image", "video")')
+});
+export 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", { more: true });
+  },
+  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,18 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    parent: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        label: z.ZodString;
+        bundle: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { parentSchema } from "../schemas.js";
+import { fromLibraryBlockBundle } from "#blokkli-build/config";
+import { resolveHost } from "../helpers.js";
+export 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")
+});
+export 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", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  requiredAdapterMethods: ["getLibraryItems"],
+  async execute(ctx, params) {
+    const { types, $t } = ctx.app;
+    let bundles = [];
+    if (params.parent) {
+      const host = resolveHost(ctx.app, params.parent.uuid);
+      if (!host) {
+        return { error: `Parent not found: ${params.parent.uuid}` };
+      }
+      const field = types.getFieldConfig(
+        host.entityType,
+        host.bundle,
+        params.parent.field
+      );
+      if (!field) {
+        return {
+          error: `Field "${params.parent.field}" not found on bundle "${host.bundle}".`
+        };
+      }
+      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,15 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    templates: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        itemBundles: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+export const paramsSchema = z.object({
+  query: z.string().optional().describe("Search text to filter templates")
+});
+const templateSchema = z.object({
+  uuid: z.string().describe("The unique UUID of the template"),
+  label: z.string().describe("The display label"),
+  description: z.string().optional().describe("A short description of the template"),
+  itemBundles: z.array(z.string()).describe("Paragraph types contained in the template")
+});
+export const resultSchema = z.object({
+  templates: z.array(templateSchema).describe("Matching templates"),
+  total: z.number().describe("Total number of matching templates")
+});
+export default defineBlokkliAgentTool({
+  name: "search_templates",
+  description: "Search for available templates. Templates are reusable paragraph collections created by users that can be added to the page.",
+  category: "query",
+  prunedSummary: (r) => `found ${r.total || 0} templates`,
+  modes: ["readonly", "editing", "translating", "review"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentSearchTemplatesRunning", "Searching templates", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  requiredAdapterMethods: ["templatesSearch"],
+  async execute(ctx, params) {
+    const { $t } = ctx.app;
+    const apiResult = await ctx.adapter.templatesSearch({
+      filters: params.query ? { text: params.query } : {},
+      page: 0,
+      includeItems: false
+    });
+    const result = {
+      templates: apiResult.items.map((item) => ({
+        uuid: item.uuid,
+        label: item.label,
+        description: item.description,
+        itemBundles: item.itemBundles
+      })),
+      total: apiResult.total
+    };
+    const label = params.query ? $t(
+      "aiAgentSearchTemplatesDone",
+      "Searched templates for '@query'"
+    ).replace("@query", params.query) : $t("aiAgentSearchTemplatesAllDone", "Searched all templates");
+    return { label, result };
+  }
+});

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    query: z.ZodString;
+    bundle: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    matches: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        bundle: z.ZodString;
+        matchedText: z.ZodString;
+        matchCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    totalMatches: z.ZodNumber;
+}, z.core.$strip>;
+declare const _default: any;
+export default _default;