@revenexx/editor 0.1.0

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

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+export const paramsSchema = z.object({
+  query: z.string().describe(
+    '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.coerce.number().optional().default(20).describe("Maximum number of results to return (default: 20)")
+});
+export const resultSchema = z.object({
+  matches: z.array(
+    z.object({
+      uuid: z.string().describe("The paragraph UUID"),
+      bundle: z.string().describe("The paragraph type"),
+      matchedText: z.string().describe("The text snippet containing the match"),
+      matchCount: z.number().describe("Number of times the query appears in this paragraph")
+    })
+  ),
+  totalMatches: z.number().describe("Total number of paragraphs that matched")
+});
+export default defineBlokkliAgentTool({
+  name: "search_text",
+  description: 'Search for text in paragraph content. Returns paragraphs containing matches with text snippets. Only searches text directly in each paragraph, not in nested child paragraphs. For regex, use /pattern/flags format (e.g., "/hello|world/gi").',
+  category: "query",
+  volatile: true,
+  lazy: true,
+  prunedSummary: (r) => `${r.totalMatches || 0} paragraphs matched`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentSearchTextRunning", "Searching text", { more: true });
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { blocks, dom, element, $t } = ctx.app;
+    const limit = params.limit ?? 20;
+    const regexLiteralMatch = params.query.match(/^\/(.+)\/([gimsuy]*)$/);
+    let regex;
+    try {
+      if (regexLiteralMatch && regexLiteralMatch[1]) {
+        const pattern = regexLiteralMatch[1];
+        const flags = regexLiteralMatch[2] || "gi";
+        regex = new RegExp(pattern, flags);
+      } else {
+        const escapedQuery = params.query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        regex = new RegExp(escapedQuery, "gi");
+      }
+    } catch {
+      return {
+        label: $t("aiAgentSearchTextError", "Invalid regex pattern"),
+        result: {
+          matches: [],
+          totalMatches: 0
+        }
+      };
+    }
+    const getBlockOwnText = (el) => {
+      if (!el) return "";
+      const clone = el.cloneNode(true);
+      const nestedBlocks = clone.querySelectorAll("[data-bk-uuid]");
+      nestedBlocks.forEach((nested) => nested.remove());
+      const altTexts = element.queryAll(clone, "img", "searchTextAlt", (img) => {
+        if (img instanceof HTMLImageElement) {
+          return [img.alt, img.title].filter(Boolean).join(" ");
+        }
+      }).join(" ");
+      return ((clone.textContent ?? "") + " " + altTexts).trim();
+    };
+    const getSnippet = (text, maxLength = 150) => {
+      const searchRegex = new RegExp(regex.source, regex.flags.replace("g", ""));
+      const match = text.match(searchRegex);
+      if (!match || match.index === void 0) {
+        return text.slice(0, maxLength);
+      }
+      const matchLength = match[0].length;
+      const start = Math.max(0, match.index - 50);
+      const end = Math.min(text.length, match.index + matchLength + 100);
+      let snippet = text.slice(start, end).trim();
+      if (start > 0) snippet = "..." + snippet;
+      if (end < text.length) snippet = snippet + "...";
+      return snippet;
+    };
+    const allBlocks = blocks.getAllBlocks();
+    const matches = [];
+    for (const block of allBlocks) {
+      if (params.bundle && block.bundle !== params.bundle) continue;
+      const el = dom.getDragElement(block);
+      const text = getBlockOwnText(el);
+      const matchArray = text.match(regex);
+      if (matchArray && matchArray.length > 0) {
+        matches.push({
+          uuid: block.uuid,
+          bundle: block.bundle,
+          matchedText: getSnippet(text),
+          matchCount: matchArray.length
+        });
+      }
+    }
+    matches.sort((a, b) => b.matchCount - a.matchCount);
+    const limitedMatches = matches.slice(0, limit);
+    const affectedUuids = matches.length === 1 ? [matches[0].uuid] : void 0;
+    return {
+      label: $t(
+        "aiAgentSearchTextDone",
+        "Found @count blocks matching '@query'"
+      ).replace("@count", String(matches.length)).replace("@query", params.query),
+      result: {
+        matches: limitedMatches,
+        totalMatches: matches.length
+      },
+      affectedUuids
+    };
+  }
+});

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

@@ -0,0 +1,29 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { SelectMediaParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: SelectMediaParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: {
+        selected: {
+            mediaId: string;
+            label: string;
+            mediaBundle: string;
+            thumbnail?: string | undefined;
+        } | null;
+        label?: string | undefined;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: ((result: {
+        selected: {
+            mediaId: string;
+            label: string;
+            mediaBundle: string;
+            thumbnail?: string | undefined;
+        } | 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/select_media/Component.vue

@@ -0,0 +1,84 @@
+<template>
+  <ToolCard
+    icon="bk_mdi_image"
+    :title="params.prompt || $t('mediaSelectTitle', 'Select a media item')"
+    @cancel="cancel"
+  >
+    <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_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_size-100 _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>
+      </button>
+    </div>
+
+    <template #actions>
+      <button
+        class="bk-button bk-is-small bk-scheme-lime bk-is-fullwidth"
+        :disabled="!selectedId"
+        @click="confirm"
+      >
+        <Icon name="bk_mdi_check" />
+        {{ $t("mediaSelectConfirm", "Use selected") }}
+      </button>
+    </template>
+  </ToolCard>
+</template>
+
+<script setup>
+import { ref, useBlokkli } from "#imports";
+import { Icon } from "#blokkli/editor/components";
+import ToolCard from "../../features/agent/Panel/ToolCard/index.vue";
+const props = defineProps({
+  context: { type: null, required: true },
+  params: { type: null, required: true }
+});
+const emit = defineEmits(["done"]);
+const { $t } = useBlokkli();
+const selectedId = ref(null);
+function getSelectedItem() {
+  if (!selectedId.value) return null;
+  return props.params.items.find((item) => item.mediaId === selectedId.value) || null;
+}
+function confirm() {
+  const item = getSelectedItem();
+  if (item) {
+    const prompt = props.params.prompt || $t("mediaSelectTitle", "Select a media item");
+    emit("done", {
+      selected: {
+        mediaId: item.mediaId,
+        label: item.label,
+        mediaBundle: item.mediaBundle,
+        thumbnail: item.thumbnail
+      },
+      label: `${prompt} -> ${item.label}`
+    });
+  }
+}
+function cancel() {
+  emit("done", { selected: null });
+}
+</script>

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

@@ -0,0 +1,29 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { SelectMediaParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: SelectMediaParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: {
+        selected: {
+            mediaId: string;
+            label: string;
+            mediaBundle: string;
+            thumbnail?: string | undefined;
+        } | null;
+        label?: string | undefined;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: ((result: {
+        selected: {
+            mediaId: string;
+            label: string;
+            mediaBundle: string;
+            thumbnail?: string | undefined;
+        } | 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/select_media/index.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+declare const mediaItemSchema: z.ZodObject<{
+    mediaId: z.ZodString;
+    label: z.ZodString;
+    mediaBundle: z.ZodString;
+    thumbnail: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const paramsSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        mediaId: z.ZodString;
+        label: z.ZodString;
+        mediaBundle: z.ZodString;
+        thumbnail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    selected: z.ZodNullable<z.ZodObject<{
+        mediaId: z.ZodString;
+        label: z.ZodString;
+        mediaBundle: z.ZodString;
+        thumbnail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SelectMediaParams = z.infer<typeof paramsSchema>;
+export type SelectMediaResult = z.infer<typeof resultSchema>;
+export type SelectMediaItem = z.infer<typeof mediaItemSchema>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import Component from "./Component.vue";
+const mediaItemSchema = 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")
+});
+export const paramsSchema = z.object({
+  items: z.array(mediaItemSchema).describe("Media items from search_media to display for selection"),
+  prompt: z.string().optional().describe("Optional message to show the user explaining what to select")
+});
+export const resultSchema = z.object({
+  selected: mediaItemSchema.nullable().describe("The selected media item, or null if the user cancelled"),
+  label: z.string().optional().describe("Human-readable label of the prompt (for UI display)")
+});
+export default defineBlokkliAgentTool({
+  name: "select_media",
+  description: "Show a thumbnail grid of media items for the user to select from. Use this when search_media returns multiple results and you want the user to choose one.",
+  category: "query",
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentSelectMediaRunning", "Selecting media", { more: true });
+  },
+  lazy: true,
+  paramsSchema,
+  resultSchema,
+  component: Component,
+  execute(_ctx, params) {
+    return params;
+  },
+  mockParams: () => ({
+    items: [
+      {
+        mediaId: "1",
+        label: "Sunset Beach",
+        mediaBundle: "image",
+        thumbnail: "https://picsum.photos/seed/1/200"
+      },
+      {
+        mediaId: "2",
+        label: "Mountain View",
+        mediaBundle: "image",
+        thumbnail: "https://picsum.photos/seed/2/200"
+      },
+      {
+        mediaId: "3",
+        label: "City Lights",
+        mediaBundle: "image",
+        thumbnail: "https://picsum.photos/seed/3/200"
+      },
+      {
+        mediaId: "4",
+        label: "Forest Path",
+        mediaBundle: "image",
+        thumbnail: "https://picsum.photos/seed/4/200"
+      },
+      {
+        mediaId: "5",
+        label: "Ocean Waves",
+        mediaBundle: "image",
+        thumbnail: "https://picsum.photos/seed/5/200"
+      },
+      {
+        mediaId: "6",
+        label: "Desert Dunes",
+        mediaBundle: "image",
+        thumbnail: "https://picsum.photos/seed/6/200"
+      }
+    ],
+    prompt: "Select an image for the hero section"
+  })
+});

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    paragraphs: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        options: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rewrite: "rewrite";
+        delete: "delete";
+        add: "add";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { optionValueToStorable } from "#blokkli/editor/helpers/options";
+import { mutationResultSchema, optionValueSchema } from "../schemas.js";
+import { validateOptionValue, getResolvedOptions } from "../helpers.js";
+import { onlyUnique } from "#blokkli/helpers";
+import {
+  requireBundlePermission,
+  requireNoRestrictedAncestor
+} from "../../helpers/validation.js";
+const paragraphOptionsSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  options: z.record(z.string(), optionValueSchema).describe("Options to set as key-value pairs")
+});
+export const paramsSchema = z.object({
+  paragraphs: z.array(paragraphOptionsSchema).describe("Array of paragraphs with their options to set")
+});
+export const resultSchema = mutationResultSchema;
+export default defineBlokkliAgentTool({
+  name: "set_paragraph_options",
+  description: "Set options on one or more paragraphs. Each paragraph entry contains a UUID and an options object with key-value pairs.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "updated options" : "rejected",
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentSetBlockOptionsRunning", "Setting block options", {
+      more: true
+    });
+  },
+  lazy: true,
+  paramsSchema,
+  resultSchema,
+  requiredAdapterMethods: ["updateOptions"],
+  execute(ctx, params) {
+    const { blocks, selection } = ctx.app;
+    if (params.paragraphs.length === 0) {
+      return { error: "No paragraphs provided" };
+    }
+    const validatedOptions = [];
+    const updatedBlocks = /* @__PURE__ */ new Set();
+    for (const blockEntry of params.paragraphs) {
+      const optionEntries = Object.entries(blockEntry.options);
+      if (optionEntries.length === 0) {
+        continue;
+      }
+      const block = blocks.getBlock(blockEntry.uuid);
+      if (!block) {
+        return { error: `Paragraph not found: ${blockEntry.uuid}` };
+      }
+      const denied = requireBundlePermission(ctx.app, [block.bundle], "edit");
+      if (denied) return denied;
+      const ancestorDenied = requireNoRestrictedAncestor(ctx.app, [
+        blockEntry.uuid
+      ]);
+      if (ancestorDenied) return ancestorDenied;
+      const bundle = block.library?.reusableBundle || block.bundle;
+      const selectionItem = selection.items.value.find(
+        (v) => v.uuid === blockEntry.uuid
+      );
+      const availableOptions = getResolvedOptions(
+        ctx.app,
+        bundle,
+        selectionItem?.fieldListType ?? "default",
+        selectionItem?.parentBlockBundle ?? null
+      );
+      if (!availableOptions) {
+        return {
+          error: `Paragraph definition not found for bundle: ${bundle}`
+        };
+      }
+      for (const [key, value] of optionEntries) {
+        const optionDef = availableOptions.find((o) => o.property === key);
+        if (!optionDef) {
+          return {
+            error: `Option "${key}" is not available for paragraph type "${bundle}"`
+          };
+        }
+        const valueError = validateOptionValue(key, value, optionDef);
+        if (valueError) {
+          return { error: valueError };
+        }
+        const storableValue = optionValueToStorable(optionDef.option, value);
+        validatedOptions.push({
+          uuid: blockEntry.uuid,
+          key,
+          value: storableValue
+        });
+      }
+      updatedBlocks.add(blockEntry.uuid);
+    }
+    if (validatedOptions.length === 0) {
+      return { error: "No options to update" };
+    }
+    const blockCount = updatedBlocks.size;
+    const optionCount = validatedOptions.length;
+    const { $t } = ctx.app;
+    const label = blockCount === 1 ? $t(
+      "aiAgentUpdateOptionsOnBlockDone",
+      "Updated @count option(s) on block"
+    ).replace("@count", String(optionCount)) : $t(
+      "aiAgentUpdateOptionsOnBlocksDone",
+      "Updated @count option(s) on @blockCount blocks"
+    ).replace("@count", String(optionCount)).replace("@blockCount", String(blockCount));
+    const affectedUuids = params.paragraphs.map((v) => v.uuid).filter(onlyUnique);
+    return {
+      type: "options",
+      label,
+      affectedUuids,
+      apply: (adapter) => adapter.updateOptions(validatedOptions)
+    };
+  }
+});

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuid1: z.ZodString;
+    uuid2: z.ZodString;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rewrite: "rewrite";
+        delete: "delete";
+        add: "add";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "../schemas.js";
+import { getSwapDisabledReason } from "#blokkli/editor/helpers/swap";
+export const paramsSchema = z.object({
+  uuid1: z.string().describe("First paragraph UUID"),
+  uuid2: z.string().describe("Second paragraph UUID")
+});
+export const resultSchema = mutationResultSchema;
+export default defineBlokkliAgentTool({
+  name: "swap_paragraphs",
+  description: "Swap the positions of two paragraphs, either in the same field or different fields.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "swapped paragraphs" : "rejected",
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentSwapBlocksRunning", "Swapping blocks", { more: true });
+  },
+  lazy: true,
+  paramsSchema,
+  resultSchema,
+  requiredAdapterMethods: ["swapBlocks"],
+  execute(ctx, params) {
+    const { blocks, types, $t, permissions } = ctx.app;
+    const blockA = blocks.getBlock(params.uuid1);
+    if (!blockA) {
+      return { error: `Paragraph not found: ${params.uuid1}` };
+    }
+    const blockB = blocks.getBlock(params.uuid2);
+    if (!blockB) {
+      return { error: `Paragraph not found: ${params.uuid2}` };
+    }
+    const reason = getSwapDisabledReason(blockA, blockB, {
+      getFieldConfig: types.getFieldConfig,
+      checkBlockBundlePermission: permissions.checkBlockBundlePermission,
+      blockHasRestrictedAncestor: permissions.blockHasRestrictedAncestor
+    });
+    if (reason) {
+      return { error: reason };
+    }
+    const labelA = types.getBlockLabel(blockA.bundle);
+    const labelB = types.getBlockLabel(blockB.bundle);
+    const label = $t("aiAgentSwapBlocksDone", "Swapped @bundleA and @bundleB").replace("@bundleA", labelA).replace("@bundleB", labelB);
+    return {
+      type: "move",
+      label,
+      affectedUuids: [params.uuid1, params.uuid2],
+      apply: (adapter) => adapter.swapBlocks(params.uuid1, params.uuid2)
+    };
+  }
+});

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

@@ -0,0 +1,51 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { ComponentParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: ComponentParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: ComponentToolResult<{
+        acceptedCount: number;
+        rejectedByUser: Record<string, Record<string, {
+            reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
+        }>>;
+        label: string;
+        agentMessage?: string | undefined;
+        historyIndex?: number | undefined;
+    }>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: ((result: ComponentToolResult<{
+        acceptedCount: number;
+        rejectedByUser: Record<string, Record<string, {
+            reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
+        }>>;
+        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;