@blokkli/editor 2.0.0-alpha.32 → 2.0.0-alpha.34

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

@@ -0,0 +1,289 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { generateUUID } from "#blokkli/editor/helpers/uuid";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema,
+  resolvePosition,
+  optionValueSchema,
+  validateOptionValue
+} from "../schemas.js";
+import { itemEntityType } from "#blokkli-build/config";
+import {
+  getAvailableOptions,
+  optionValueToStorable
+} from "#blokkli/editor/helpers/options";
+const contentFieldValueSchema = z.union([
+  z.string().describe(
+    "Text value for plain/markup content fields, or a URL string (starting with http) for link content fields"
+  ),
+  z.object({
+    entityType: z.string().describe('Entity type (e.g., "media", "node")'),
+    entityId: z.string().describe("Entity ID")
+  }).describe(
+    "Entity reference for reference content fields (media, content references)"
+  )
+]);
+const contentFieldsSchema = z.record(
+  z.string().describe("The content field name"),
+  contentFieldValueSchema
+).optional().describe(
+  "Content field values to set on the new paragraph, keyed by field name. Use this to set text content and media/entity references in one step."
+);
+const blockSchema = z.object({
+  bundle: z.string().describe("The paragraph bundle to add"),
+  contentFields: contentFieldsSchema,
+  options: z.record(z.string(), optionValueSchema).optional().describe(
+    "Paragraph options to set as key-value pairs (e.g. alignment, style). Use get_bundle_info to see available options."
+  ),
+  children: z.record(
+    z.string().describe("Paragraph field name"),
+    z.lazy(() => z.array(blockSchema)).describe("Child paragraphs for this field")
+  ).optional().describe(
+    "Nested child paragraphs keyed by paragraph field name. Recursive \u2014 children can also have children."
+  )
+});
+const paramsSchema = z.object({
+  paragraphs: z.array(blockSchema).min(1).describe("Array of paragraphs to add, in order"),
+  parent: parentSchema.describe("The parent entity to add the paragraphs to"),
+  position: positionSchema
+});
+function validateContentFields(ctx, block, path) {
+  if (!block.contentFields) return void 0;
+  for (const [fieldName, fieldValue] of Object.entries(block.contentFields)) {
+    const editableConfig = ctx.app.types.editableFieldConfig.forName(
+      ctx.itemEntityType,
+      block.bundle,
+      fieldName
+    );
+    const droppableConfig = ctx.app.types.droppableFieldConfig.forName(
+      ctx.itemEntityType,
+      block.bundle,
+      fieldName
+    );
+    if (!editableConfig && !droppableConfig) {
+      const editableFieldNames = ctx.app.types.editableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, block.bundle).map((f) => f.name);
+      const droppableFieldNames = ctx.app.types.droppableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, block.bundle).map((f) => f.name);
+      const availableFields = [...editableFieldNames, ...droppableFieldNames];
+      return `${path}: Field "${fieldName}" does not exist on bundle "${block.bundle}". ` + (availableFields.length ? `Available content fields: ${availableFields.join(", ")}` : "This bundle has no content fields.");
+    }
+    if (editableConfig && typeof fieldValue !== "string") {
+      return `${path}: Field "${fieldName}" is a text field and expects a string value, got ${typeof fieldValue}.`;
+    }
+    if (droppableConfig) {
+      if (typeof fieldValue === "string" && droppableConfig.type !== "link") {
+        return `${path}: Field "${fieldName}" is a reference field and expects { entityType, entityId }, got a string.`;
+      }
+    }
+  }
+  return void 0;
+}
+function validateBlockOptions(ctx, block, path) {
+  if (!block.options) return void 0;
+  const { definitions } = ctx.app;
+  const definition = definitions.getBlockDefinition(block.bundle, "default");
+  if (!definition) {
+    return `${path}: Paragraph definition not found for bundle "${block.bundle}".`;
+  }
+  const availableOptions = getAvailableOptions(
+    definition.options,
+    definition.globalOptions,
+    definitions.globalOptions.value
+  );
+  for (const [key, value] of Object.entries(block.options)) {
+    const optionDef = availableOptions.find((o) => o.property === key);
+    if (!optionDef) {
+      const availableKeys = availableOptions.map((o) => o.property);
+      return `${path}: Option "${key}" is not available for bundle "${block.bundle}". ` + (availableKeys.length ? `Available options: ${availableKeys.join(", ")}` : "This bundle has no options.");
+    }
+    const valueError = validateOptionValue(key, value, optionDef);
+    if (valueError) {
+      return `${path}: ${valueError}`;
+    }
+  }
+  return void 0;
+}
+function validateBlockTree(ctx, blocks, allowedBundles, fieldLabel, pathPrefix) {
+  const { types } = ctx.app;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const path = `${pathPrefix}Paragraph ${i + 1}`;
+    const bundleDefinition = types.getBlockBundleDefinition(block.bundle);
+    if (!bundleDefinition) {
+      return `${path}: Bundle "${block.bundle}" does not exist.`;
+    }
+    if (allowedBundles.length && !allowedBundles.includes(block.bundle)) {
+      return `${path}: Bundle "${block.bundle}" is not allowed in field "${fieldLabel}". Allowed bundles: ${allowedBundles.join(", ")}`;
+    }
+    const contentError = validateContentFields(ctx, block, path);
+    if (contentError) return contentError;
+    const optionsError = validateBlockOptions(ctx, block, path);
+    if (optionsError) return optionsError;
+    if (block.children) {
+      for (const [childFieldName, childBlocks] of Object.entries(
+        block.children
+      )) {
+        const childFieldConfig = types.fieldConfig.forName(
+          ctx.itemEntityType,
+          block.bundle,
+          childFieldName
+        );
+        if (!childFieldConfig) {
+          const availableBlockFields = types.fieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, block.bundle).map((f) => f.name);
+          return `${path}: Paragraph field "${childFieldName}" does not exist on bundle "${block.bundle}". ` + (availableBlockFields.length ? `Available paragraph fields: ${availableBlockFields.join(", ")}` : "This bundle has no paragraph fields.");
+        }
+        if (!childBlocks.length) continue;
+        const childError = validateBlockTree(
+          ctx,
+          childBlocks,
+          childFieldConfig.allowedBundles,
+          childFieldName,
+          `${path} > ${childFieldName} > `
+        );
+        if (childError) return childError;
+      }
+    }
+  }
+  return void 0;
+}
+function buildEventBlocks(ctx, blocks) {
+  const { definitions } = ctx.app;
+  return blocks.map((block) => {
+    const blockUuid = generateUUID();
+    const values = block.contentFields ? Object.entries(block.contentFields).map(([fieldName, fieldValue]) => ({
+      fieldName,
+      fieldValue
+    })) : void 0;
+    let options;
+    if (block.options) {
+      const definition = definitions.getBlockDefinition(block.bundle, "default");
+      if (definition) {
+        const availableOptions = getAvailableOptions(
+          definition.options,
+          definition.globalOptions,
+          definitions.globalOptions.value
+        );
+        options = {};
+        for (const [key, value] of Object.entries(block.options)) {
+          const optionDef = availableOptions.find((o) => o.property === key);
+          if (optionDef) {
+            options[key] = optionValueToStorable(optionDef.option, value);
+          }
+        }
+      }
+    }
+    let children;
+    if (block.children) {
+      children = {};
+      for (const [fieldName, childBlocks] of Object.entries(block.children)) {
+        if (childBlocks.length) {
+          children[fieldName] = buildEventBlocks(ctx, childBlocks);
+        }
+      }
+    }
+    return {
+      bundle: block.bundle,
+      blockUuid,
+      values,
+      options,
+      children
+    };
+  });
+}
+function countBlocks(blocks) {
+  let count = blocks.length;
+  for (const block of blocks) {
+    if (block.children) {
+      for (const childBlocks of Object.values(block.children)) {
+        count += countBlocks(childBlocks);
+      }
+    }
+  }
+  return count;
+}
+function collectAllUuids(blocks) {
+  const uuids = [];
+  for (const block of blocks) {
+    uuids.push(block.blockUuid);
+    if (block.children) {
+      for (const childBlocks of Object.values(block.children)) {
+        uuids.push(...collectAllUuids(childBlocks));
+      }
+    }
+  }
+  return uuids;
+}
+export default defineBlokkliAgentTool({
+  name: "add_paragraphs",
+  description: "Add one or more new paragraphs to the page. Supports nested structures via the `children` property \u2014 define entire paragraph trees in a single call. IMPORTANT: Always provide content field values (text, media/entity references) directly via contentFields, instead of adding empty paragraphs! For reference content fields (media), set the value to { entityType, entityId } from search_media results. NOTE: You can ONLY provide content fields, NOT paragraph fields! For nested paragraphs, use the `children` property keyed by paragraph field name. You can also set paragraph options inline via the `options` property (key-value pairs).",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? `added ${r.newParagraphs?.length || 0} paragraphs` : "rejected",
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentAddBlocksRunning", "Adding blocks...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["addNewBlocks"],
+  execute(ctx, params) {
+    const { types, context, blocks } = 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) {
+      return {
+        error: "Parent not found."
+      };
+    }
+    const field = types.getFieldConfig(entityType, bundle, params.parent.field);
+    if (!field) {
+      const availableFields = types.fieldConfig.forEntityTypeAndBundle(entityType, bundle).map((f) => f.name);
+      return {
+        error: `Field "${params.parent.field}" not found on bundle "${bundle}". Available fields: ${availableFields.length ? availableFields.join(", ") : "none"}. Use get_child_paragraphs to get the correct parent object.`
+      };
+    }
+    const validationError = validateBlockTree(
+      ctx,
+      params.paragraphs,
+      field.allowedBundles,
+      params.parent.field,
+      ""
+    );
+    if (validationError) {
+      return { error: validationError };
+    }
+    const eventBlocks = buildEventBlocks(ctx, params.paragraphs);
+    const totalCount = countBlocks(eventBlocks);
+    const blockUuids = collectAllUuids(eventBlocks);
+    const { $t } = ctx.app;
+    const label = totalCount === 1 ? $t("aiAgentAddBlockDone", "Added @bundle").replace(
+      "@bundle",
+      types.getBlockLabel(eventBlocks[0].bundle)
+    ) : $t("aiAgentAddBlocksDone", "Added @count blocks").replace(
+      "@count",
+      String(totalCount)
+    );
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    if ("error" in resolved) return resolved;
+    return {
+      type: "add",
+      label,
+      apply: (adapter) => adapter.addNewBlocks({
+        blocks: eventBlocks,
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        afterUuid: resolved.afterUuid
+      }),
+      affectedUuids: blockUuids
+    };
+  }
+});

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

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

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

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema,
+  resolvePosition
+} from "../schemas.js";
+import { fromLibraryBlockBundle, itemEntityType } from "#blokkli-build/config";
+const paramsSchema = z.object({
+  libraryItemUuid: z.string().describe(
+    "The UUID of the reusable paragraph to add (from search_reusable_paragraphs results)"
+  ),
+  parent: parentSchema.describe(
+    "The parent entity to add the reusable paragraph to."
+  ),
+  position: positionSchema
+});
+export default defineBlokkliAgentTool({
+  name: "add_reusable_paragraph",
+  description: "Add a reusable paragraph to the page. Reusable paragraphs stay linked to the original: edits to the paragraph are reflected everywhere it is used. Use search_reusable_paragraphs first to find available paragraphs.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "added reusable paragraph" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentAddLibraryItemRunning", "Adding reusable block...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["addLibraryItem"],
+  execute(ctx, params) {
+    const { types, fields, context, blocks, $t } = ctx.app;
+    const field = fields.find(params.parent.uuid, params.parent.field);
+    if (!field) {
+      return {
+        error: `Field not found: ${params.parent.field} on entity ${params.parent.uuid}`
+      };
+    }
+    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 fieldConfig = types.getFieldConfig(
+        parentEntityType,
+        parentBundle,
+        params.parent.field
+      );
+      if (fieldConfig?.allowedBundles.length && !fieldConfig.allowedBundles.includes(fromLibraryBlockBundle)) {
+        return {
+          error: `Field "${params.parent.field}" does not allow from_library bundles.`
+        };
+      }
+    }
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    if ("error" in resolved) return resolved;
+    return {
+      type: "add",
+      label: $t("aiAgentAddLibraryItemDone", "Added reusable block"),
+      apply: (adapter) => adapter.addLibraryItem({
+        libraryItemUuid: params.libraryItemUuid,
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        afterUuid: resolved.afterUuid
+      })
+    };
+  }
+});

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

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

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

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema,
+  resolvePosition
+} from "../schemas.js";
+const paramsSchema = z.object({
+  templateUuid: z.string().describe(
+    "The UUID of the template to add (from search_templates results)"
+  ),
+  parent: parentSchema.describe("The parent entity to add the template to"),
+  position: positionSchema
+});
+export default defineBlokkliAgentTool({
+  name: "add_template",
+  description: "Add a template to the page. Templates are copied when added, so changes to the added paragraphs won't affect other pages using the same template. Requires user approval before the template is actually added.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? `added template (${r.newParagraphs?.length || 0} paragraphs)` : "rejected",
+  lazy: true,
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentAddTemplateRunning", "Adding template...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["templatesAdd"],
+  execute(ctx, params) {
+    const { fields, $t } = ctx.app;
+    const field = fields.find(params.parent.uuid, params.parent.field);
+    if (!field) {
+      return {
+        error: `Field not found: ${params.parent.field} on entity ${params.parent.uuid}`
+      };
+    }
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    if ("error" in resolved) return resolved;
+    return {
+      type: "add",
+      label: $t("aiAgentAddTemplateDone", "Added template"),
+      apply: (adapter) => adapter.templatesAdd({
+        templateUuid: params.templateUuid,
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        afterUuid: resolved.afterUuid
+      })
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/ask_question/Component.d.vue.ts

@@ -0,0 +1,19 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { AskQuestionParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: AskQuestionParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: {
+        selected: string | string[] | null;
+        label?: string | undefined;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: ((result: {
+        selected: string | string[] | null;
+        label?: string | undefined;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,113 @@
+<template>
+  <ToolCard
+    icon="bk_mdi_help"
+    :title="params.question"
+    class="bk-agent-tool-question"
+    @cancel="cancel"
+  >
+    <div class="bk-agent-tool-question-inner">
+      <FormCheckboxes
+        v-if="params.multiSelect"
+        id="ask-question"
+        v-model="selectedMulti"
+        label=""
+        :options="params.options"
+      />
+
+      <div v-else>
+        <FormRadio
+          id="ask-question"
+          v-model="selectedSingle"
+          label=""
+          :options="radioOptions"
+        />
+        <div v-if="isOtherSelected" class="bk-agent-tool-question-other">
+          <textarea
+            ref="otherTextarea"
+            v-model="otherText"
+            class="bk-form-input"
+            :rows="2"
+            :placeholder="
+  $t('aiAgentAskQuestionOtherPlaceholder', 'Type your answer...')
+"
+          />
+        </div>
+      </div>
+    </div>
+
+    <template #actions>
+      <button
+        class="bk-button bk-is-small bk-is-lime bk-is-fullwidth"
+        :disabled="!hasSelection"
+        @click="confirm"
+      >
+        <Icon name="bk_mdi_check" />
+        {{ $t("aiAgentConfirm", "Confirm") }}
+      </button>
+    </template>
+  </ToolCard>
+</template>
+
+<script setup>
+import { ref, computed, watch, nextTick, useBlokkli } from "#imports";
+import { Icon, FormRadio, FormCheckboxes } from "#blokkli/editor/components";
+import ToolCard from "../../features/agent/Panel/ToolCard/index.vue";
+const OTHER_VALUE = "__other__";
+const props = defineProps({
+  context: { type: null, required: true },
+  params: { type: null, required: true }
+});
+const emit = defineEmits(["done"]);
+const { $t } = useBlokkli();
+const selectedSingle = ref("");
+const selectedMulti = ref([]);
+const otherText = ref("");
+const otherTextarea = ref(null);
+const radioOptions = computed(() => [
+  ...props.params.options,
+  {
+    value: OTHER_VALUE,
+    label: $t("aiAgentAskQuestionOther", "None of the above")
+  }
+]);
+const isOtherSelected = computed(() => selectedSingle.value === OTHER_VALUE);
+watch(isOtherSelected, (isOther) => {
+  if (isOther) {
+    nextTick(() => {
+      otherTextarea.value?.focus();
+    });
+  }
+});
+const hasSelection = computed(() => {
+  if (props.params.multiSelect) {
+    return selectedMulti.value.length > 0;
+  }
+  if (isOtherSelected.value) {
+    return otherText.value.trim().length > 0;
+  }
+  return selectedSingle.value !== "";
+});
+function getSelectedLabel() {
+  if (props.params.multiSelect) {
+    const labels = selectedMulti.value.map((v) => props.params.options.find((o) => o.value === v)?.label).filter(Boolean);
+    return labels.join(", ");
+  }
+  if (isOtherSelected.value) {
+    return otherText.value.trim();
+  }
+  return props.params.options.find((o) => o.value === selectedSingle.value)?.label || selectedSingle.value;
+}
+function confirm() {
+  const selectedLabel = getSelectedLabel();
+  const label = `${props.params.question} -> ${selectedLabel}`;
+  if (props.params.multiSelect) {
+    emit("done", { selected: selectedMulti.value, label });
+  } else {
+    const value = isOtherSelected.value ? otherText.value.trim() : selectedSingle.value;
+    emit("done", { selected: value, label });
+  }
+}
+function cancel() {
+  emit("done", { selected: null, label: $t("aiAgentCancelled", "Cancelled") });
+}
+</script>

package/dist/modules/agent/runtime/app/tools/ask_question/Component.vue.d.ts

@@ -0,0 +1,19 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { AskQuestionParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: AskQuestionParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: {
+        selected: string | string[] | null;
+        label?: string | undefined;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: ((result: {
+        selected: string | string[] | null;
+        label?: string | undefined;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+declare const paramsSchema: z.ZodObject<{
+    question: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+    multiSelect: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const resultSchema: z.ZodObject<{
+    selected: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AskQuestionParams = z.infer<typeof paramsSchema>;
+export type AskQuestionResult = z.infer<typeof resultSchema>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import Component from "./Component.vue";
+const optionSchema = z.object({
+  value: z.string().describe("The option value"),
+  label: z.string().describe("The display label")
+});
+const paramsSchema = z.object({
+  question: z.string().describe("The question to ask the user"),
+  options: z.array(optionSchema).describe("Available options to choose from"),
+  multiSelect: z.boolean().default(false).describe(
+    `Allow selecting multiple options. If false, the user has the option to enter a custom option if none of the options are good.`
+  )
+});
+const resultSchema = z.object({
+  selected: z.union([z.string(), z.array(z.string())]).nullable().describe("Selected value(s), or null if cancelled"),
+  label: z.string().optional().describe("Human-readable label of what was selected (for UI display)")
+});
+export default defineBlokkliAgentTool({
+  name: "ask_question",
+  description: "Ask the user a question with predefined options.",
+  category: "query",
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentAskQuestionRunning", "Waiting for answer...");
+  },
+  paramsSchema,
+  resultSchema,
+  component: Component,
+  execute(_ctx, params) {
+    return params;
+  },
+  mockParams: () => ({
+    question: "Which style do you prefer for the hero section?",
+    options: [
+      { value: "minimal", label: "Minimal" },
+      { value: "bold", label: "Bold" },
+      { value: "classic", label: "Classic" }
+    ],
+    multiSelect: false
+  }),
+  mockParamsVariants: () => [
+    {
+      question: "Which sections should be included on the page?",
+      options: [
+        { value: "hero", label: "Hero" },
+        { value: "features", label: "Features" },
+        { value: "testimonials", label: "Testimonials" },
+        { value: "pricing", label: "Pricing" }
+      ],
+      multiSelect: true
+    }
+  ]
+});

package/dist/modules/agent/runtime/app/tools/batch_rewrite_text/Component.d.vue.ts

@@ -0,0 +1,29 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { BatchRewriteParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: BatchRewriteParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: {
+        acceptedCount: number;
+        rejectedByUser: Record<string, Record<string, {
+            reasonForRejection: string;
+        }>>;
+        label: string;
+        agentMessage?: string | undefined;
+        historyIndex?: number | undefined;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: ((result: {
+        acceptedCount: number;
+        rejectedByUser: Record<string, Record<string, {
+            reasonForRejection: string;
+        }>>;
+        label: string;
+        agentMessage?: string | undefined;
+        historyIndex?: number | undefined;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;