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

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

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

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

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

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";
+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.number().optional().default(20).describe("Maximum number of results to return (default: 20)")
+});
+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...");
+  },
+  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-item-bundle]");
+      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,70 @@
+<template>
+  <ToolCard
+    icon="bk_mdi_image"
+    :title="params.prompt || $t('mediaSelectTitle', 'Select a media item')"
+    @cancel="cancel"
+  >
+    <div class="bk-media-select-list">
+      <button
+        v-for="item in params.items"
+        :key="item.mediaId"
+        type="button"
+        class="bk-media-select-item"
+        :class="{ 'bk-is-selected': 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>
+        <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"
+        :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>;
+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>;
+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")
+});
+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")
+});
+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...");
+  },
+  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,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  getAvailableOptions,
+  optionValueToStorable
+} from "#blokkli/editor/helpers/options";
+import {
+  mutationResultSchema,
+  optionValueSchema,
+  validateOptionValue
+} from "../schemas.js";
+import { onlyUnique } from "#blokkli/helpers";
+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")
+});
+const paramsSchema = z.object({
+  paragraphs: z.array(paragraphOptionsSchema).describe("Array of paragraphs with their options to set")
+});
+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...");
+  },
+  lazy: true,
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["updateOptions"],
+  execute(ctx, params) {
+    const { blocks, definitions, 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 bundle = block.library?.reusableBundle || block.bundle;
+      const selectionItem = selection.items.value.find(
+        (v) => v.uuid === blockEntry.uuid
+      );
+      const definition = definitions.getBlockDefinition(
+        bundle,
+        selectionItem?.fieldListType ?? "default",
+        selectionItem?.parentBlockBundle
+      );
+      if (!definition) {
+        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) {
+          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,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "../schemas.js";
+const paramsSchema = z.object({
+  uuidA: z.string().describe("First paragraph UUID"),
+  uuidB: z.string().describe("Second paragraph UUID")
+});
+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...");
+  },
+  lazy: true,
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["swapBlocks"],
+  execute(ctx, params) {
+    const { blocks, types, $t } = ctx.app;
+    if (params.uuidA === params.uuidB) {
+      return { error: "Both UUIDs refer to the same paragraph" };
+    }
+    const blockA = blocks.getBlock(params.uuidA);
+    if (!blockA) {
+      return { error: `Paragraph not found: ${params.uuidA}` };
+    }
+    const blockB = blocks.getBlock(params.uuidB);
+    if (!blockB) {
+      return { error: `Paragraph not found: ${params.uuidB}` };
+    }
+    const fieldConfigA = types.getFieldConfig(
+      blockA.host.type,
+      blockA.host.bundle,
+      blockA.host.fieldName
+    );
+    if (!fieldConfigA) {
+      return {
+        error: `Could not find field config for paragraph A's parent field`
+      };
+    }
+    const fieldConfigB = types.getFieldConfig(
+      blockB.host.type,
+      blockB.host.bundle,
+      blockB.host.fieldName
+    );
+    if (!fieldConfigB) {
+      return {
+        error: `Could not find field config for paragraph B's parent field`
+      };
+    }
+    if (!fieldConfigB.allowedBundles.includes(blockA.bundle)) {
+      return {
+        error: `Cannot swap: bundle "${blockA.bundle}" (uuid: ${params.uuidA}) is not allowed in field "${blockB.host.fieldName}" (parent: ${blockB.host.uuid}). Allowed bundles: ${fieldConfigB.allowedBundles.join(", ")}`
+      };
+    }
+    if (!fieldConfigA.allowedBundles.includes(blockB.bundle)) {
+      return {
+        error: `Cannot swap: bundle "${blockB.bundle}" (uuid: ${params.uuidB}) is not allowed in field "${blockA.host.fieldName}" (parent: ${blockA.host.uuid}). Allowed bundles: ${fieldConfigA.allowedBundles.join(", ")}`
+      };
+    }
+    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.uuidA, params.uuidB],
+      apply: (adapter) => adapter.swapBlocks(params.uuidA, params.uuidB)
+    };
+  }
+});

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

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

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const paramsSchema = z.object({
+  url: z.string().url().describe("The URL to fetch content from"),
+  format: z.enum(["markdown", "html"]).default("markdown").describe(
+    'Output format: "markdown" (default) converts HTML to readable Markdown preserving structure, "html" returns cleaned raw HTML'
+  )
+});
+const resultSchema = z.object({
+  content: z.string().describe("The page content in the requested format (markdown or html)"),
+  title: z.string().describe("The page title"),
+  format: z.enum(["markdown", "html"]).describe("The format of the content"),
+  url: z.string().describe("The final URL (may differ from input if redirected)")
+});
+export default defineBlokkliAgentTool({
+  name: "web_fetch",
+  description: 'Fetch and extract content from a web page. Only allowed origins can be fetched. By default returns Markdown which preserves document structure (headings, lists, links). Use format="html" if you need the raw HTML.',
+  category: "query",
+  lazy: true,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentWebFetchRunning", "Fetching web page...");
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx, params) {
+    const { $t } = ctx.app;
+    const response = await fetch("/api/blokkli/agent/fetch", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ url: params.url, format: params.format })
+    });
+    if (!response.ok) {
+      let errorMessage = "Failed to fetch URL";
+      try {
+        const errorData = await response.json();
+        errorMessage = errorData.message || errorMessage;
+      } catch {
+      }
+      return { error: errorMessage };
+    }
+    const result = await response.json();
+    return {
+      label: $t("aiAgentWebFetchDone", "Fetched '@title'").replace(
+        "@title",
+        result.title || params.url
+      ),
+      result
+    };
+  }
+});