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

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

@@ -1,38 +1,9 @@
-import { getMutatedOptionValue } from "#blokkli/editor/helpers/options";
+import {
+  getMutatedOptionValue,
+  getAvailableOptions
+} from "#blokkli/editor/helpers/options";
 import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
-function mapAnalysisToResult(analysis) {
-  const result = {};
-  for (const [key, fieldResult] of Object.entries(analysis)) {
-    const slashIndex = key.indexOf("/");
-    if (slashIndex === -1) continue;
-    const uuid = key.slice(0, slashIndex);
-    const fieldName = key.slice(slashIndex + 1);
-    const issueChunks = fieldResult.chunks.filter(
-      (c) => c.score !== null && (c.band === "hard" || c.band === "ok")
-    );
-    if (issueChunks.length === 0) continue;
-    if (!result[uuid]) {
-      result[uuid] = {};
-    }
-    result[uuid][fieldName] = {
-      fieldValue: fieldResult.rawValue || void 0,
-      issues: issueChunks.map((c) => ({
-        text: c.text,
-        impact: c.impact,
-        score: c.score
-      }))
-    };
-  }
-  return result;
-}
-export async function runReadabilityAnalysis(app) {
-  const analysis = await app.readability.analyzeAllFields();
-  return mapAnalysisToResult(analysis);
-}
-export async function runReadabilityAnalysisForValues(app, fields) {
-  const analysis = await app.readability.analyzeFieldValues(fields);
-  return mapAnalysisToResult(analysis);
-}
+import { itemEntityType } from "#blokkli-build/config";
 export function extractOptionLabels(option) {
   if (!("options" in option) || !option.options) return void 0;
   const raw = option.options;
@@ -57,7 +28,7 @@ export function buildBlockOptionsMap(availableOptions, mutatedOptions, uuid) {
       opt.property,
       opt.option.default
     );
-    const currentValue = getRuntimeOptionValue(opt.option, rawValue);
+    const currentValue = getRuntimeOptionValue(opt.option, rawValue) ?? "";
     result[opt.property] = buildBlockOptionEntry(opt.option, currentValue);
   }
   return result;
@@ -130,11 +101,13 @@ export function validateOptionValue(key, value, optionDef) {
     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}`;
+    const optMin = optionDef.option.min;
+    const optMax = optionDef.option.max;
+    if (typeof optMin === "number" && numValue < optMin) {
+      return `Option "${key}" value must be >= ${optMin}`;
     }
-    if ("max" in optionDef.option && numValue > optionDef.option.max) {
-      return `Option "${key}" value must be <= ${optionDef.option.max}`;
+    if (typeof optMax === "number" && numValue > optMax) {
+      return `Option "${key}" value must be <= ${optMax}`;
     }
   }
   return void 0;
@@ -250,3 +223,55 @@ export function resolvePosition(app, parentUuid, fieldName, position) {
     error: `Invalid position value: "${position}". Use "start", "end", "after:<UUID>", or "before:<UUID>".`
   };
 }
+export function resolveHost(app, uuid) {
+  const ctx = app.context.value;
+  if (uuid === ctx.entityUuid) {
+    return {
+      entityType: ctx.entityType,
+      bundle: ctx.entityBundle,
+      uuid,
+      isRoot: true
+    };
+  }
+  const block = app.blocks.getBlock(uuid);
+  if (!block) return null;
+  return {
+    entityType: itemEntityType,
+    bundle: block.bundle,
+    uuid,
+    isRoot: false
+  };
+}
+export function getResolvedOptions(app, bundleOrBlock, fieldListType, parentBundle) {
+  const definition = app.definitions.getBlockDefinition(
+    bundleOrBlock,
+    fieldListType,
+    parentBundle
+  );
+  if (!definition) return null;
+  return getAvailableOptions(
+    definition.options,
+    definition.globalOptions,
+    app.definitions.globalOptions.value
+  );
+}
+export function readBlockContentFields(app, uuid, entityType, bundle) {
+  const result = [];
+  for (const editable of app.directive.getEditablesForBlock(uuid)) {
+    const fieldType = app.fieldValue.resolveFieldType(
+      entityType,
+      bundle,
+      editable.fieldName
+    );
+    if (!fieldType) continue;
+    const value = app.fieldValue.readValue(
+      entityType,
+      uuid,
+      bundle,
+      editable.fieldName,
+      fieldType
+    );
+    result.push({ fieldName: editable.fieldName, fieldType, value });
+  }
+  return result;
+}

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

@@ -1,11 +1,13 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
-import { resolvePosition } from "../helpers.js";
+import { resolvePosition, resolveHost } from "../helpers.js";
 import {
   requireBundlePermission,
-  requireNoRestrictedAncestor
+  requireNoRestrictedAncestor,
+  validateFieldCardinality
 } from "../../helpers/validation.js";
+import { getFieldKey } from "#blokkli/helpers";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The UUIDs of the paragraphs to move"),
   parent: parentSchema.describe("The target parent entity"),
@@ -19,7 +21,7 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => r.success ? "moved paragraphs" : "rejected",
   modes: ["editing"],
   label($t) {
-    return $t("aiAgentMoveBlocksRunning", "Moving blocks...");
+    return $t("aiAgentMoveBlocksRunning", "Moving blocks", { more: true });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,
@@ -35,7 +37,11 @@ export default defineBlokkliAgentTool({
       if (!block) {
         return { error: `Paragraph not found: ${uuid}` };
       }
-      validBlocks.push({ uuid, bundle: block.bundle });
+      validBlocks.push({
+        uuid,
+        bundle: block.bundle,
+        currentFieldKey: getFieldKey(block.host.uuid, block.host.fieldName)
+      });
     }
     const denied = requireBundlePermission(
       ctx.app,
@@ -50,6 +56,32 @@ export default defineBlokkliAgentTool({
         error: "Permission denied: target parent is inside a block with restricted editing permissions"
       };
     }
+    const targetHost = resolveHost(ctx.app, params.parent.uuid);
+    if (!targetHost) {
+      return {
+        error: `Target parent "${params.parent.uuid}" not found. Use get_page_structure or get_child_paragraphs to find a valid parent UUID.`
+      };
+    }
+    const targetFieldKey = getFieldKey(params.parent.uuid, params.parent.field);
+    const additionalCount = validBlocks.filter(
+      (b) => b.currentFieldKey !== targetFieldKey
+    ).length;
+    if (additionalCount > 0) {
+      const cardinality = validateFieldCardinality(
+        ctx.app,
+        {
+          type: targetHost.entityType,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field,
+          bundle: targetHost.bundle
+        },
+        targetFieldKey,
+        additionalCount
+      );
+      if (!cardinality.valid) {
+        return { error: cardinality.error };
+      }
+    }
     const { $t } = ctx.app;
     const firstBlock = validBlocks[0];
     const label = validBlocks.length === 1 && firstBlock ? $t("aiAgentMoveBlockDone", "Moved @bundle").replace(

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

@@ -0,0 +1,45 @@
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { ReadabilityBand } from '#blokkli/editor/features/analyze/readability/types';
+import type { TextFieldValue } from '#blokkli/editor/providers/fieldValue';
+type ReadabilityIssue = {
+    text: string;
+    impact?: string;
+    score?: number;
+};
+type ReadabilityFieldResult = {
+    fieldValue?: string;
+    issues: ReadabilityIssue[];
+};
+export type ReadabilityResult = Record<string, Record<string, ReadabilityFieldResult>>;
+/** User-facing readability level (the band vocabulary is `easy|ok|hard`). */
+export type ReadabilityLevel = 'good' | 'ok' | 'hard';
+/** Map a readability band to its user-facing level (`easy` → `good`). */
+export declare function bandToLevel(band: ReadabilityBand): ReadabilityLevel;
+/**
+ * Reduce a field's readability chunks to its single worst assessment. Chunks
+ * with a null band/score can't be analyzed (e.g. the text is below the
+ * analyzer's minimum word count) and are ignored. The "worst" chunk is the one
+ * with the highest-severity band, tie-broken by the lowest score, so the
+ * returned `level` and `score` always come from the same chunk.
+ *
+ * Returns `null` when nothing was scorable — callers decide how to surface that
+ * (e.g. an "unknown" level, or "good"/no-retry).
+ */
+export declare function worstReadability(chunks: ReadonlyArray<{
+    band: ReadabilityBand | null;
+    score: number | null;
+}>): {
+    level: ReadabilityLevel;
+    score: number;
+} | null;
+/**
+ * Run readability analysis against all fields on the page and return results
+ * grouped by paragraph UUID and field name.
+ */
+export declare function runReadabilityAnalysis(app: BlokkliApp): Promise<ReadabilityResult>;
+/**
+ * Run readability analysis for specific field values (without reading from
+ * DOM/adapter). Used by the retry loop to analyze proposed values directly.
+ */
+export declare function runReadabilityAnalysisForValues(app: BlokkliApp, fields: TextFieldValue[]): Promise<ReadabilityResult>;
+export {};

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

@@ -0,0 +1,51 @@
+const BAND_SEVERITY = {
+  easy: 0,
+  ok: 1,
+  hard: 2
+};
+export function bandToLevel(band) {
+  return band === "hard" ? "hard" : band === "ok" ? "ok" : "good";
+}
+export function worstReadability(chunks) {
+  let worst = null;
+  for (const chunk of chunks) {
+    if (chunk.band === null || chunk.score === null) continue;
+    if (!worst || BAND_SEVERITY[chunk.band] > BAND_SEVERITY[worst.band] || BAND_SEVERITY[chunk.band] === BAND_SEVERITY[worst.band] && chunk.score < worst.score) {
+      worst = { band: chunk.band, score: chunk.score };
+    }
+  }
+  return worst ? { level: bandToLevel(worst.band), score: worst.score } : null;
+}
+function mapAnalysisToResult(analysis) {
+  const result = {};
+  for (const [key, fieldResult] of Object.entries(analysis)) {
+    const slashIndex = key.indexOf("/");
+    if (slashIndex === -1) continue;
+    const uuid = key.slice(0, slashIndex);
+    const fieldName = key.slice(slashIndex + 1);
+    const issueChunks = fieldResult.chunks.filter(
+      (c) => c.score !== null && (c.band === "hard" || c.band === "ok")
+    );
+    if (issueChunks.length === 0) continue;
+    if (!result[uuid]) {
+      result[uuid] = {};
+    }
+    result[uuid][fieldName] = {
+      fieldValue: fieldResult.rawValue || void 0,
+      issues: issueChunks.map((c) => ({
+        text: c.text,
+        impact: c.impact,
+        score: c.score
+      }))
+    };
+  }
+  return result;
+}
+export async function runReadabilityAnalysis(app) {
+  const analysis = await app.readability.analyzeAllFields();
+  return mapAnalysisToResult(analysis);
+}
+export async function runReadabilityAnalysisForValues(app, fields) {
+  const analysis = await app.readability.analyzeFieldValues(fields);
+  return mapAnalysisToResult(analysis);
+}

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema, parentSchema } from "../schemas.js";
-import { itemEntityType } from "#blokkli-build/config";
+import { resolveHost } from "../helpers.js";
 import {
   requireBundlePermission,
   requireNoRestrictedAncestor
@@ -20,19 +20,20 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => r.success ? "rearranged paragraphs" : "rejected",
   modes: ["editing"],
   label($t) {
-    return $t("aiAgentRearrangeBlocksRunning", "Rearranging blocks...");
+    return $t("aiAgentRearrangeBlocksRunning", "Rearranging blocks", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,
   requiredAdapterMethods: ["rearrangeBlocks"],
   execute(ctx, params) {
-    const { blocks, types, context, state, $t } = ctx.app;
-    const isRootEntity = params.parent.uuid === context.value.entityUuid;
-    const entityType = isRootEntity ? context.value.entityType : itemEntityType;
-    const bundle = isRootEntity ? context.value.entityBundle : blocks.getBlock(params.parent.uuid)?.bundle;
-    if (!bundle) {
+    const { blocks, types, state, $t } = ctx.app;
+    const host = resolveHost(ctx.app, params.parent.uuid);
+    if (!host) {
       return { error: "Parent not found." };
     }
+    const { entityType, bundle } = host;
     const field = types.getFieldConfig(entityType, bundle, params.parent.field);
     if (!field) {
       const availableFields = types.fieldConfig.forEntityTypeAndBundle(entityType, bundle).map((f) => f.name);

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

@@ -21,7 +21,8 @@ export default defineBlokkliAgentTool({
   label($t) {
     return $t(
       "aiAgentReplaceContentSearchItemRunning",
-      "Replacing content reference..."
+      "Replacing content reference",
+      { more: true }
     );
   },
   lazy: true,

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

@@ -19,7 +19,7 @@ export default defineBlokkliAgentTool({
   modes: ["editing"],
   lazy: true,
   label($t) {
-    return $t("aiAgentReplaceMediaRunning", "Replacing media...");
+    return $t("aiAgentReplaceMediaRunning", "Replacing media", { more: true });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,

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

@@ -52,6 +52,14 @@ export declare const mutationResultSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, 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>>;
 /**
  * Shared schema for option values (used by add_blocks and set_block_options).
  */
@@ -66,6 +74,20 @@ export declare const optionValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodB
  * - `"before:<UUID>"` — insert before the block with the given UUID
  */
 export declare const positionSchema: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+/**
+ * Shared result schema for the interactive field-diff rewrite tools
+ * (`update_text_fields`, `delegate_text_rewrite`). Both present a diff approval
+ * UI and report what the user accepted/rejected.
+ */
+export declare const fieldDiffResultSchema: z.ZodObject<{
+    acceptedCount: z.ZodNumber;
+    rejectedByUser: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        reasonForRejection: z.ZodString;
+    }, z.core.$strip>>>;
+    label: z.ZodString;
+    agentMessage: z.ZodOptional<z.ZodString>;
+    historyIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 /**
  * Schema for the success result sent back to the AI after mutation is applied.
  */

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

@@ -33,6 +33,12 @@ export const mutationResultSchema = z.union([
     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 const optionValueSchema = z.union([
   z.string(),
   z.boolean(),
@@ -42,6 +48,27 @@ export const optionValueSchema = z.union([
 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 const fieldDiffResultSchema = z.object({
+  acceptedCount: z.number().describe("Number of changes accepted by the user"),
+  rejectedByUser: z.record(
+    z.string(),
+    z.record(
+      z.string(),
+      z.object({
+        reasonForRejection: z.string().describe(
+          "Reason provided by the user for rejecting, empty if no reason given"
+        )
+      })
+    )
+  ).describe(
+    "Map of rejected paragraph UUID to field name to rejection details"
+  ),
+  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")
+});
 export const mutationSuccessSchema = z.union([
   z.object({
     success: z.literal(true),

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

@@ -20,7 +20,9 @@ export default defineBlokkliAgentTool({
   requiredAdapterMethods: ["getContentSearchTabs", "getContentSearchResults"],
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentSearchContentRunning", "Searching content...");
+    return $t("aiAgentSearchContentRunning", "Searching content", {
+      more: true
+    });
   },
   paramsSchema: z.object({
     tab: z.string().describe(

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

@@ -26,7 +26,7 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `found ${r.total || 0} media items`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentSearchMediaRunning", "Searching media...");
+    return $t("aiAgentSearchMediaRunning", "Searching media", { more: true });
   },
   paramsSchema,
   resultSchema,

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

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { parentSchema } from "../schemas.js";
-import { fromLibraryBlockBundle, itemEntityType } from "#blokkli-build/config";
+import { fromLibraryBlockBundle } from "#blokkli-build/config";
+import { resolveHost } from "../helpers.js";
 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."
@@ -24,29 +25,29 @@ export default defineBlokkliAgentTool({
   modes: ["readonly", "editing", "translating", "review"],
   lazy: true,
   label($t) {
-    return $t("aiAgentSearchLibraryRunning", "Searching reusable blocks...");
+    return $t("aiAgentSearchLibraryRunning", "Searching reusable blocks", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   requiredAdapterMethods: ["getLibraryItems"],
   async execute(ctx, params) {
-    const { types, context, blocks, $t } = ctx.app;
+    const { types, $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) {
+      const host = resolveHost(ctx.app, params.parent.uuid);
+      if (!host) {
         return { error: `Parent not found: ${params.parent.uuid}` };
       }
       const field = types.getFieldConfig(
-        parentEntityType,
-        parentBundle,
+        host.entityType,
+        host.bundle,
         params.parent.field
       );
       if (!field) {
         return {
-          error: `Field "${params.parent.field}" not found on bundle "${parentBundle}".`
+          error: `Field "${params.parent.field}" not found on bundle "${host.bundle}".`
         };
       }
       if (field.allowedBundles.length && !field.allowedBundles.includes(fromLibraryBlockBundle)) {

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

@@ -21,7 +21,9 @@ export default defineBlokkliAgentTool({
   modes: ["readonly", "editing", "translating", "review"],
   lazy: true,
   label($t) {
-    return $t("aiAgentSearchTemplatesRunning", "Searching templates...");
+    return $t("aiAgentSearchTemplatesRunning", "Searching templates", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,

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

@@ -5,7 +5,7 @@ const paramsSchema = z.object({
     'The text to search for. For regex, use JavaScript regex literal format: /pattern/flags (e.g., "/hello|world/gi" to match either word case-insensitively). Plain text is matched case-insensitively by default.'
   ),
   bundle: z.string().optional().describe("Optional: only search in paragraphs of this bundle type"),
-  limit: z.number().optional().default(20).describe("Maximum number of results to return (default: 20)")
+  limit: z.coerce.number().optional().default(20).describe("Maximum number of results to return (default: 20)")
 });
 const resultSchema = z.object({
   matches: z.array(
@@ -27,7 +27,7 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `${r.totalMatches || 0} paragraphs matched`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentSearchTextRunning", "Searching text...");
+    return $t("aiAgentSearchTextRunning", "Searching text", { more: true });
   },
   paramsSchema,
   resultSchema,

package/dist/modules/agent/runtime/app/tools/select_media/Component.vue

@@ -4,26 +4,40 @@
     :title="params.prompt || $t('mediaSelectTitle', 'Select a media item')"
     @cancel="cancel"
   >
-    <div class="bk-media-select-list">
+    <div class="_bk_flex _bk_flex-col _bk_divide-y _bk_divide-mono-200">
       <button
         v-for="item in params.items"
         :key="item.mediaId"
         type="button"
-        class="bk-media-select-item"
-        :class="{ 'bk-is-selected': selectedId === item.mediaId }"
+        class="_bk_flex _bk_items-center _bk_gap-10 _bk_px-10 _bk_py-8 _bk_cursor-pointer _bk_hover:bg-mono-50"
+        :class="{ '_bk_bg-accent-100': selectedId === item.mediaId }"
         @click="selectedId = item.mediaId"
       >
-        <div class="bk-media-select-thumbnail">
-          <img v-if="item.thumbnail" :src="item.thumbnail" :alt="item.label" />
-          <Icon v-else name="bk_mdi_image" />
+        <div
+          class="_bk_w-40 _bk_h-40 _bk_bg-mono-100 _bk_rounded _bk_overflow-hidden _bk_shrink-0 _bk_flex _bk_items-center _bk_justify-center"
+          :class="{
+  '_bk_outline _bk_outline-accent-700 _bk_relative _bk_z-40': selectedId === item.mediaId
+}"
+        >
+          <img
+            v-if="item.thumbnail"
+            :src="item.thumbnail"
+            :alt="item.label"
+            class="_bk_w-full _bk_h-full _bk_object-cover"
+          />
+          <Icon v-else name="bk_mdi_image" class="_bk_w-20 _bk_h-20 _bk_text-mono-300" />
+        </div>
+        <div
+          class="_bk_text-sm _bk_text-mono-700 _bk_flex-1 _bk_break-words _bk_max-w-full _bk_overflow-hidden"
+        >
+          {{ item.label }}
         </div>
-        <div class="bk-media-select-label">{{ item.label }}</div>
       </button>
     </div>
 
     <template #actions>
       <button
-        class="bk-button bk-is-small bk-is-lime bk-is-fullwidth"
+        class="bk-button bk-is-small bk-scheme-lime bk-is-fullwidth"
         :disabled="!selectedId"
         @click="confirm"
       >

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

@@ -21,7 +21,7 @@ export default defineBlokkliAgentTool({
   category: "query",
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentSelectMediaRunning", "Selecting media...");
+    return $t("aiAgentSelectMediaRunning", "Selecting media", { more: true });
   },
   lazy: true,
   paramsSchema,

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

@@ -1,11 +1,8 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  getAvailableOptions,
-  optionValueToStorable
-} from "#blokkli/editor/helpers/options";
+import { optionValueToStorable } from "#blokkli/editor/helpers/options";
 import { mutationResultSchema, optionValueSchema } from "../schemas.js";
-import { validateOptionValue } from "../helpers.js";
+import { validateOptionValue, getResolvedOptions } from "../helpers.js";
 import { onlyUnique } from "#blokkli/helpers";
 import {
   requireBundlePermission,
@@ -25,14 +22,16 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => r.success ? "updated options" : "rejected",
   modes: ["editing"],
   label($t) {
-    return $t("aiAgentSetBlockOptionsRunning", "Setting block options...");
+    return $t("aiAgentSetBlockOptionsRunning", "Setting block options", {
+      more: true
+    });
   },
   lazy: true,
   paramsSchema,
   resultSchema: mutationResultSchema,
   requiredAdapterMethods: ["updateOptions"],
   execute(ctx, params) {
-    const { blocks, definitions, selection } = ctx.app;
+    const { blocks, selection } = ctx.app;
     if (params.paragraphs.length === 0) {
       return { error: "No paragraphs provided" };
     }
@@ -57,21 +56,17 @@ export default defineBlokkliAgentTool({
       const selectionItem = selection.items.value.find(
         (v) => v.uuid === blockEntry.uuid
       );
-      const definition = definitions.getBlockDefinition(
+      const availableOptions = getResolvedOptions(
+        ctx.app,
         bundle,
         selectionItem?.fieldListType ?? "default",
         selectionItem?.parentBlockBundle ?? null
       );
-      if (!definition) {
+      if (!availableOptions) {
         return {
           error: `Paragraph definition not found for bundle: ${bundle}`
         };
       }
-      const availableOptions = getAvailableOptions(
-        definition.options,
-        definition.globalOptions,
-        definitions.globalOptions.value
-      );
       for (const [key, value] of optionEntries) {
         const optionDef = availableOptions.find((o) => o.property === key);
         if (!optionDef) {