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

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

@@ -1,11 +1,9 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  parentSchema,
-  blockOptionsMapSchema,
-  buildBlockOptionsMap
-} from "../schemas.js";
+import { parentSchema, blockOptionsMapSchema } from "../schemas.js";
+import { buildBlockOptionsMap } from "../helpers.js";
 import { getAvailableOptions } from "#blokkli/editor/helpers/options";
+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"),
@@ -77,6 +75,7 @@ const resultSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
   bundle: z.string().describe("The paragraph type"),
   label: z.string().describe("Human-readable paragraph label"),
+  fragmentName: z.string().optional().describe("The fragment name, if this paragraph is a fragment block"),
   nestingLevel: z.number().describe("Nesting depth (0 = root level)"),
   parent: parentSchema.nullable().describe("The parent entity containing this paragraph"),
   parentChain: z.array(parentChainItemSchema).optional().describe("Ancestor parent paragraphs from immediate parent to page"),
@@ -132,6 +131,9 @@ export default defineBlokkliAgentTool({
       nestingLevel: state.getNestingLevel(params.uuid),
       parent
     };
+    if (block.bundle === fragmentBlockBundle && block.fragment?.name) {
+      result.fragmentName = block.fragment.name;
+    }
     if (params.includeParentChain) {
       const parentChain = [];
       let currentUuid = state.getParentEntityUuid(params.uuid);

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

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { getAvailableOptions } from "#blokkli/editor/helpers/options";
-import { blockOptionsMapSchema, buildBlockOptionsMap } from "../schemas.js";
+import { blockOptionsMapSchema } from "../schemas.js";
+import { buildBlockOptionsMap } from "../helpers.js";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The paragraph UUIDs to get options for")
 });

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

@@ -23,11 +23,10 @@ export default defineBlokkliAgentTool({
   resultSchema,
   execute(ctx) {
     const { selection, types, $t } = ctx.app;
-    const paragraphs = selection.uuids.value.map((uuid) => {
-      const item = selection.items.value.find((v) => v.uuid === uuid);
+    const paragraphs = selection.items.value.map((item) => {
       const bundle = item?.bundle ?? "unknown";
       return {
-        uuid,
+        uuid: item.uuid,
         bundle,
         label: types.getBlockLabel(bundle)
       };

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

@@ -0,0 +1,53 @@
+import type { OptionItem } from '#blokkli/editor/helpers/options';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { BlockOptionsMap } from './schemas.js';
+/**
+ * Extract a simple key→label map from the various radios/checkboxes option formats.
+ * Handles plain strings, icon objects, color objects, grid objects, etc.
+ */
+export declare function extractOptionLabels(option: Record<string, unknown>): Record<string, string> | undefined;
+/**
+ * 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;
+/**
+ * Build a block options map from option definitions, using defaults as current values.
+ */
+export declare function buildBlockOptionsMapFromDefinitions(options: Record<string, Record<string, unknown>>): BlockOptionsMap;
+/**
+ * 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;
+    }[];
+}[];
+/**
+ * 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;
+};

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

@@ -0,0 +1,187 @@
+import { getMutatedOptionValue } from "#blokkli/editor/helpers/options";
+import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
+export 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 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);
+    result[opt.property] = buildBlockOptionEntry(opt.option, currentValue);
+  }
+  return result;
+}
+export function buildBlockOptionsMapFromDefinitions(options) {
+  const result = {};
+  for (const [key, opt] of Object.entries(options)) {
+    result[key] = buildBlockOptionEntry(
+      opt,
+      opt.default
+    );
+  }
+  return result;
+}
+function buildBlockOptionEntry(opt, currentValue) {
+  const entry = {
+    type: opt.type,
+    label: opt.label,
+    currentValue
+  };
+  if (opt.description) {
+    entry.description = opt.description;
+  }
+  const labels = extractOptionLabels(opt);
+  if (labels) {
+    entry.options = labels;
+  }
+  if ("min" in opt) {
+    entry.min = opt.min;
+  }
+  if ("max" in opt) {
+    entry.max = opt.max;
+  }
+  if ("step" in opt && opt.type === "range") {
+    entry.step = opt.step;
+  }
+  return entry;
+}
+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 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>".`
+  };
+}

package/dist/modules/agent/runtime/app/tools/move_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";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The UUIDs of the paragraphs to move"),
   parent: parentSchema.describe("The target parent entity"),

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

@@ -1,6 +1,4 @@
 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.
  */
@@ -28,10 +26,6 @@ export declare const blockOptionsMapSchema: z.ZodRecord<z.ZodString, z.ZodObject
     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.
@@ -50,9 +44,9 @@ export declare const mutationResultSchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodEnum<{
         add: "add";
         delete: "delete";
-        options: "options";
         move: "move";
         rewrite: "rewrite";
+        options: "options";
     }>;
     label: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
@@ -62,32 +56,6 @@ export declare const mutationResultSchema: z.ZodUnion<readonly [z.ZodObject<{
  * 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.
  *
@@ -98,17 +66,6 @@ export declare function getParagraphChildren(app: BlokkliApp, uuid: string): {
  * - `"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.
  */

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

@@ -1,21 +1,4 @@
 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)"
@@ -32,41 +15,6 @@ 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."
@@ -91,131 +39,9 @@ export const optionValueSchema = z.union([
   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),

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

@@ -13,53 +13,46 @@ const resultSchema = z.array(
   })
 );
 export default defineBlokkliAgentTool({
-  resolve: async (ctx) => {
-    if (!ctx.adapter.getContentSearchTabs || !ctx.adapter.getContentSearchResults) {
-      return [];
-    }
+  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...");
+  },
+  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")
+  }),
+  resultSchema,
+  async execute(ctx, params) {
     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
-            }))
-          };
-        }
-      });
-    });
+    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
+      }))
+    };
   }
 });