@blokkli/editor 2.0.0-alpha.36 → 2.0.0-alpha.38

package/dist/global/types/blockOptions.d.ts

@@ -344,14 +344,15 @@ type DefinitionOptionRadiosBase<Icon extends string = string> = {
      */
     group?: string;
 } & (DefinitionOptionRadiosColors | DefinitionOptionRadiosGrid | DefinitionOptionRadiosRadios | DefinitionOptionRadiosIconsBase<Icon>);
-type DefinitionOptionJson = {
+type DefinitionOptionJsonBase<DataType extends string = string> = {
     type: 'json';
     label: string;
     default: string;
+    dataType?: DataType;
     description?: string;
     group?: string;
 };
-export type BlockOptionDefinitionBase<Icon extends string = string> = DefinitionOptionJson | DefinitionOptionColor | DefinitionOptionCheckbox | DefinitionOptionCheckboxes | DefinitionOptionRadiosBase<Icon> | DefinitionOptionText | DefinitionOptionRange | DefinitionOptionNumber | DefinitionOptionDateTimeLocal;
+export type BlockOptionDefinitionBase<Icon extends string = string, DataType extends string = string> = DefinitionOptionJsonBase<DataType> | DefinitionOptionColor | DefinitionOptionCheckbox | DefinitionOptionCheckboxes | DefinitionOptionRadiosBase<Icon> | DefinitionOptionText | DefinitionOptionRange | DefinitionOptionNumber | DefinitionOptionDateTimeLocal;
 /**
  * Runtime block option array with validation data.
  * The third element varies by option type:
@@ -360,7 +361,7 @@ export type BlockOptionDefinitionBase<Icon extends string = string> = Definition
  * - datetime-local: optional [min?, max?] tuple
  * - other types: no third element
  */
-export type RuntimeBlockOptionArray = ['text', string] | ['json', string] | ['checkbox', boolean] | ['color', `#${string}`] | ['radios', string, string[]] | ['checkboxes', string[], string[]] | ['number', number, [number, number]] | ['range', number, [number, number]] | ['datetime-local', string | undefined] | [
+export type RuntimeBlockOptionArray = ['text', string] | ['json', string] | ['json', string, string] | ['checkbox', boolean] | ['color', `#${string}`] | ['radios', string, string[]] | ['checkboxes', string[], string[]] | ['number', number, [number, number]] | ['range', number, [number, number]] | ['datetime-local', string | undefined] | [
     'datetime-local',
     string | undefined,
     [

package/dist/module.d.mts

@@ -1,6 +1,6 @@
 import { NuxtModule } from 'nuxt/schema';
-import { M as ModuleOptions } from './shared/editor.CWQIFIEQ.mjs';
-export { a as ModuleHooks } from './shared/editor.CWQIFIEQ.mjs';
+import { M as ModuleOptions } from './shared/editor.BdBm1Z7C.mjs';
+export { a as ModuleHooks } from './shared/editor.BdBm1Z7C.mjs';
 import 'consola';
 import '../dist/global/types/definitions.js';
 import '../dist/global/types/theme.js';

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@blokkli/editor",
   "configKey": "blokkli",
-  "version": "2.0.0-alpha.36",
+  "version": "2.0.0-alpha.38",
   "compatibility": {
     "nuxt": ">=3.15.0"
   },

package/dist/module.mjs

@@ -18,7 +18,7 @@ import { d as defineCodeTemplate, a as defineFileTemplate, w as withHelper } fro
 import { defu, createDefu } from 'defu';
 
 const name = "@blokkli/editor";
-const version = "2.0.0-alpha.36";
+const version = "2.0.0-alpha.38";
 
 function sortObjectKeys(obj) {
   if (Array.isArray(obj)) {
@@ -1270,6 +1270,7 @@ class ModuleContext {
   templateContents = /* @__PURE__ */ new Map();
   adapterExtensions = [];
   featureFragments = /* @__PURE__ */ new Set();
+  complexOptionTypes = /* @__PURE__ */ new Map();
   collectors = [];
   addFeatureFragment(name) {
     if (this.featureFragments.has(name)) {
@@ -1280,6 +1281,17 @@ class ModuleContext {
   getFeatureFragmentNames() {
     return [...this.featureFragments.values()];
   }
+  registerComplexOptionType(def) {
+    if (this.complexOptionTypes.has(def.id)) {
+      throw new Error(
+        `A complex option type with id "${def.id}" already exists.`
+      );
+    }
+    this.complexOptionTypes.set(def.id, def);
+  }
+  getComplexOptionTypes() {
+    return [...this.complexOptionTypes.values()];
+  }
   registerAdapterExtension(namespace, path) {
     if (this.adapterExtensions.some((e) => e.namespace === namespace)) {
       throw new Error(`Duplicate adapter extension namespace: ${namespace}`);
@@ -1516,6 +1528,7 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_chevron_backward",
   "bk_mdi_chevron_forward",
   "bk_mdi_close",
+  "bk_mdi_collapse_all",
   "bk_mdi_comment",
   "bk_mdi_construction",
   "bk_mdi_content_copy",
@@ -1529,7 +1542,9 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_drag_pan",
   "bk_mdi_edit",
   "bk_mdi_exit_to_app",
+  "bk_mdi_expand_all",
   "bk_mdi_extension",
+  "bk_mdi_forum",
   "bk_mdi_function",
   "bk_mdi_grid_view",
   "bk_mdi_grid_view-fill",
@@ -1546,7 +1561,6 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_menu",
   "bk_mdi_mobile",
   "bk_mdi_mobile_rotate",
-  "bk_mdi_more_horiz",
   "bk_mdi_newspaper",
   "bk_mdi_open_in_new",
   "bk_mdi_palette",
@@ -3013,6 +3027,9 @@ function toRuntimeOptionArray(option) {
   } else if (option.type === "color") {
     return [option.type, option.default];
   } else if (option.type === "json") {
+    if (option.dataType) {
+      return [option.type, option.default, option.dataType];
+    }
     return [option.type, option.default];
   }
   return [option.type, option.default];
@@ -3608,6 +3625,54 @@ ${iconNames.map((name) => `  | '${name}'`).join("\n")}
 `;
 });
 
+const complexOptionTypes = defineCodeTemplate(
+  "complex-option-types",
+  (ctx) => {
+    const types = ctx.getComplexOptionTypes();
+    if (types.length === 0) {
+      return `export const COMPLEX_OPTION_TYPES = {}`;
+    }
+    const entries = types.map(
+      (t) => `  '${t.id}': {
+    editorComponent: defineAsyncComponent(() => import('${ctx.helper.toModuleBuildRelative(t.editorComponentPath)}')),
+    editorButtonLabel: '${t.editorButtonLabel}',
+    editorIcon: '${t.editorIcon}',
+  }`
+    ).join(",\n");
+    return `import { defineAsyncComponent } from 'vue'
+
+export const COMPLEX_OPTION_TYPES = {
+${entries}
+}`;
+  },
+  (ctx) => {
+    const types = ctx.getComplexOptionTypes();
+    if (types.length === 0) {
+      return `export interface ComplexOptionTypeMap {}
+export const COMPLEX_OPTION_TYPES: Record<string, never>`;
+    }
+    const imports = types.map(
+      (t) => `import type { ${t.typeName} } from '${ctx.helper.toModuleBuildRelative(t.typePath)}'`
+    ).join("\n");
+    const entries = types.map((t) => `  '${t.id}': ${t.typeName}`).join("\n");
+    return `${imports}
+import type { BlokkliIcon } from './icons'
+
+export interface ComplexOptionTypeMap {
+${entries}
+}
+
+export const COMPLEX_OPTION_TYPES: Record<string, {
+  editorComponent: import('vue').Component
+  editorButtonLabel: string
+  editorIcon: BlokkliIcon
+}>`;
+  },
+  {
+    write: true
+  }
+);
+
 const TEMPLATES = [
   icons,
   features,
@@ -3629,7 +3694,8 @@ const TEMPLATES = [
   chunkGroup,
   chunkEditing,
   importMeta,
-  materialIcons
+  materialIcons,
+  complexOptionTypes
 ];
 
 class CollectedFeatureFile extends CollectedFile {
@@ -3872,7 +3938,8 @@ const module$1 = defineNuxtModule({
     );
     const app = {
       helper,
-      context
+      context,
+      $t: (key, _defaultText) => key
     };
     for (const module of blokkliModules) {
       await module.init.setup(app, module.options);

package/dist/modules/agent/index.d.mts

@@ -1,4 +1,4 @@
-import { B as BlokkliModule } from '../../shared/editor.CWQIFIEQ.mjs';
+import { B as BlokkliModule } from '../../shared/editor.BdBm1Z7C.mjs';
 import 'nuxt/schema';
 import 'consola';
 import '../../../dist/global/types/definitions.js';

package/dist/modules/agent/index.mjs

@@ -5,6 +5,10 @@ import { d as defineBlokkliModule } from '../../shared/editor.CGf7C_0M.mjs';
 import * as fs from 'node:fs';
 import { C as Collector, a as CollectedFile } from '../../shared/editor.BFIzNSQM.mjs';
 import { d as defineCodeTemplate } from '../../shared/editor.6D5vApr0.mjs';
+import MagicString from 'magic-string';
+import { parse } from 'acorn';
+import { walk } from 'estree-walker-ts';
+import { transformSync, buildSync } from 'esbuild';
 
 function toImportName(prefix, fileName) {
   const name = fileName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
@@ -131,7 +135,7 @@ function createClientTemplate(toolCollector, promptCollector, options) {
       );
       exports$1.push(`export const models = ${JSON.stringify(options.models)}`);
       exports$1.push(
-        `export const agentName = ${JSON.stringify(options.agentName ?? "Blocki")}`
+        `export const agentName = ${JSON.stringify(options.agentName ?? "Superbl\xF6kkli")}`
       );
       exports$1.push(
         `export const hasWebFetch = ${JSON.stringify(!!options.allowedFetchOrigins)}`
@@ -144,10 +148,10 @@ function createClientTemplate(toolCollector, promptCollector, options) {
       return parts.join("\n\n") + "\n";
     },
     () => {
-      return `import type { McpToolItem, AgentPromptItem } from '#blokkli/agent/app/types'
+      return `import type { McpToolDefinition, AgentPromptItem } from '#blokkli/agent/app/types'
 import type { AgentModelDefinition } from '#blokkli/agent/shared/types'
 
-export const mcpTools: McpToolItem[]
+export const mcpTools: McpToolDefinition[]
 export const agentPrompts: AgentPromptItem[]
 export const defaultPrompts: string[]
 export const agentName: string
@@ -166,7 +170,8 @@ function createServerTemplate(options) {
     skillsCollector,
     skillsTypesPath,
     systemPromptCollector,
-    systemPromptTypesPath
+    systemPromptTypesPath,
+    mcpToolsCollector
   } = options;
   const { allowedFetchOrigins, provider, models } = moduleOptions;
   return defineCodeTemplate(
@@ -198,6 +203,15 @@ function createServerTemplate(options) {
       const systemPromptsExport = systemPrompts.length === 0 ? `export const systemPrompts = []` : `export const systemPrompts = [
   ${systemPrompts.map((sp) => sp.importName).join(",\n  ")}
 ]`;
+      const tools = mcpToolsCollector.getItems();
+      for (const tool of tools) {
+        imports.push(
+          `import ${tool.importName} from '${rel(tool.filePath)}?blokkliAgentTool'`
+        );
+      }
+      const toolDefinitionsExport = tools.length === 0 ? `export const toolDefinitions = []` : `export const toolDefinitions = [
+  ${tools.map((t) => t.importName).join(",\n  ")},
+].filter(v => v !== null)`;
       const originsJson = JSON.stringify(allowedFetchOrigins, null, 2);
       return `${imports.join("\n")}
 
@@ -211,6 +225,8 @@ export const debugPrompt = ${!!moduleOptions.debugPrompt}
 ${skillsExport}
 
 ${systemPromptsExport}
+
+${toolDefinitionsExport}
 `;
     },
     (ctx) => {
@@ -218,7 +234,7 @@ ${systemPromptsExport}
       return `import type { AIProvider } from '${rel(providersPath)}/types'
 import type { SkillDefinition } from '${rel(skillsTypesPath)}'
 import type { SystemPromptDefinition } from '${rel(systemPromptTypesPath)}'
-import type { AgentModelDefinition } from '${rel(sharedTypesPath)}'
+import type { AgentModelDefinition, ServerToolMetadata } from '${rel(sharedTypesPath)}'
 
 export const allowedFetchOrigins: string[]
 export const provider: AIProvider
@@ -226,6 +242,7 @@ export const models: AgentModelDefinition[]
 export const debugPrompt: boolean
 export const skills: SkillDefinition[]
 export const systemPrompts: SystemPromptDefinition[]
+export const toolDefinitions: ServerToolMetadata[]
 `;
     },
     {
@@ -235,6 +252,246 @@ export const systemPrompts: SystemPromptDefinition[]
   );
 }
 
+const QUERY = "?blokkliAgentTool";
+const PROPERTIES_TO_KEEP = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "category",
+  "paramsSchema",
+  "modes",
+  "lazy",
+  "volatile",
+  "requiredAdapterMethods",
+  "requiredFeatures",
+  "resolve"
+]);
+function agentToolStripPlugin() {
+  return {
+    name: "blokkli:agent-tool-strip",
+    resolveId(source, importer) {
+      if (!source.includes(QUERY)) return null;
+      const cleanPath = source.replace(QUERY, "");
+      let resolved;
+      if (importer && (cleanPath.startsWith(".") || cleanPath.startsWith("/"))) {
+        const importerDir = path.dirname(importer);
+        resolved = path.resolve(importerDir, cleanPath);
+      } else {
+        resolved = cleanPath;
+      }
+      if (!fs.existsSync(resolved) && fs.existsSync(resolved + ".ts")) {
+        resolved = resolved + ".ts";
+      }
+      return resolved + QUERY;
+    },
+    load(id) {
+      if (!id.includes(QUERY)) return null;
+      const filePath = id.replace(QUERY, "");
+      let rawSource;
+      try {
+        rawSource = fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return this.error(`Cannot read agent tool file: ${filePath}`);
+      }
+      const { code: jsSource } = transformSync(rawSource, {
+        loader: "ts",
+        format: "esm",
+        target: "esnext"
+      });
+      return transformToolSource(jsSource, filePath);
+    }
+  };
+}
+function findToolExport(ast) {
+  let result = null;
+  walk(ast, {
+    enter(node) {
+      if (result) return;
+      let callExpr = null;
+      if (node.type === "ExportDefaultDeclaration") {
+        const decl = node.declaration;
+        if (decl?.type === "CallExpression" && decl.callee?.type === "Identifier" && decl.callee.name === "defineBlokkliAgentTool") {
+          callExpr = decl;
+        }
+      }
+      if (node.type === "VariableDeclarator") {
+        const init = node.init;
+        if (init?.type === "CallExpression" && init.callee?.type === "Identifier" && init.callee.name === "defineBlokkliAgentTool") {
+          callExpr = init;
+        }
+      }
+      if (!callExpr) return;
+      const arg = callExpr.arguments[0];
+      if (arg?.type !== "ObjectExpression") return;
+      const toolObject = arg;
+      result = { toolObject, call: callExpr };
+    },
+    leave() {
+    }
+  });
+  return result;
+}
+const REQUIRED_PROPERTIES = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "category",
+  "paramsSchema"
+]);
+function validateTransformedOutput(output, filePath) {
+  let ast;
+  try {
+    ast = parse(output, {
+      sourceType: "module",
+      ecmaVersion: "latest"
+    });
+  } catch (e) {
+    return `Transformed output is not valid JavaScript${filePath ? ` (${filePath})` : ""}: ${e}`;
+  }
+  let exportedObject = null;
+  walk(ast, {
+    enter(node) {
+      if (exportedObject) return;
+      if (node.type === "ExportDefaultDeclaration") {
+        const decl = node.declaration;
+        if (decl?.type === "ObjectExpression") {
+          exportedObject = decl;
+        }
+      }
+      if (node.type === "VariableDeclarator") {
+        const id = node.id;
+        const init = node.init;
+        if (id?.type === "Identifier" && id.name === "stdin_default" && init?.type === "ObjectExpression") {
+          exportedObject = init;
+        }
+      }
+    },
+    leave() {
+    }
+  });
+  if (!exportedObject) {
+    return `No default-exported object found in transformed output${filePath ? ` (${filePath})` : ""}`;
+  }
+  const foundProps = /* @__PURE__ */ new Set();
+  for (const prop of exportedObject.properties) {
+    if (prop.type !== "Property") continue;
+    const key = prop.key;
+    if (key.type === "Identifier") {
+      foundProps.add(key.name);
+    } else if (key.type === "Literal" && typeof key.value === "string") {
+      foundProps.add(key.value);
+    }
+  }
+  const missing = [...REQUIRED_PROPERTIES].filter((p) => !foundProps.has(p));
+  if (missing.length > 0) {
+    return `Transformed tool output is missing required properties: ${missing.join(", ")}${filePath ? ` (${filePath})` : ""}`;
+  }
+  return null;
+}
+function treeShake(code) {
+  const result = buildSync({
+    stdin: { contents: code, loader: "js", resolveDir: "/tmp" },
+    bundle: true,
+    write: false,
+    format: "esm",
+    target: "esnext",
+    treeShaking: true,
+    external: ["*"]
+  });
+  return result.outputFiles[0].text;
+}
+function removeDeadImports(code) {
+  const ast = parse(code, {
+    sourceType: "module",
+    ecmaVersion: "latest"
+  });
+  const importRanges = [];
+  walk(ast, {
+    enter(node) {
+      if (node.type === "ImportDeclaration") {
+        const n = node;
+        importRanges.push({ start: n.start, end: n.end });
+      }
+    },
+    leave() {
+    }
+  });
+  const usedIds = /* @__PURE__ */ new Set();
+  walk(ast, {
+    enter(node) {
+      if (node.type === "Identifier") {
+        const n = node;
+        const inImport = importRanges.some(
+          (r) => n.start >= r.start && n.start < r.end
+        );
+        if (!inImport) {
+          usedIds.add(n.name);
+        }
+      }
+    },
+    leave() {
+    }
+  });
+  const s = new MagicString(code);
+  walk(ast, {
+    enter(node) {
+      if (node.type !== "ImportDeclaration") return;
+      const importDecl = node;
+      const hasUsedBinding = (importDecl.specifiers || []).some(
+        (spec) => usedIds.has(spec.local.name)
+      );
+      if (!hasUsedBinding) {
+        let removeEnd = importDecl.end;
+        if (code[removeEnd] === "\n") {
+          removeEnd++;
+        }
+        s.remove(importDecl.start, removeEnd);
+      }
+    },
+    leave() {
+    }
+  });
+  return s.toString();
+}
+function transformToolSource(source, filePath) {
+  const ast = parse(source, {
+    sourceType: "module",
+    ecmaVersion: "latest"
+  });
+  const exportInfo = findToolExport(ast);
+  if (!exportInfo) {
+    return source;
+  }
+  const s = new MagicString(source);
+  const { toolObject, call } = exportInfo;
+  for (const prop of toolObject.properties) {
+    if (prop.type !== "Property") continue;
+    const key = prop.key;
+    let name = null;
+    if (key.type === "Identifier") {
+      name = key.name;
+    } else if (key.type === "Literal" && typeof key.value === "string") {
+      name = key.value;
+    }
+    if (name && !PROPERTIES_TO_KEEP.has(name)) {
+      const propNode = prop;
+      let removeEnd = propNode.end;
+      const afterProp = source.substring(removeEnd);
+      const commaMatch = afterProp.match(/^\s*,/);
+      if (commaMatch) {
+        removeEnd += commaMatch[0].length;
+      }
+      s.remove(propNode.start, removeEnd);
+    }
+  }
+  s.overwrite(call.start, toolObject.start, "");
+  s.overwrite(toolObject.end, call.end, "");
+  const result = removeDeadImports(treeShake(s.toString()));
+  const error = validateTransformedOutput(result, filePath);
+  if (error) {
+    throw new Error(error);
+  }
+  return result;
+}
+
 const AGENT_ROUTE = "/api/blokkli/agent";
 const FETCH_ROUTE = "/api/blokkli/agent/fetch";
 const index = defineBlokkliModule({
@@ -386,7 +643,8 @@ export default defineNuxtConfig({
         systemPromptCollector,
         systemPromptTypesPath: moduleResolver.resolve(
           "./runtime/server/system-prompts/types"
-        )
+        ),
+        mcpToolsCollector: mcpTools
       })
     );
     addServerHandler({
@@ -412,6 +670,18 @@ export default defineNuxtConfig({
       nitroConfig.typescript.tsConfig.include ||= [];
       nitroConfig.typescript.tsConfig.include.push(relativeSkillsDir);
       nitroConfig.typescript.tsConfig.include.push(relativeSystemPromptsDir);
+      nitroConfig.rollupConfig ||= {};
+      nitroConfig.rollupConfig.plugins ||= [];
+      nitroConfig.rollupConfig.plugins.push(
+        agentToolStripPlugin()
+      );
+      nitroConfig.alias ||= {};
+      nitroConfig.alias["#blokkli/agent/app/tools/schemas"] = moduleResolver.resolve("./runtime/app/tools/schemas");
+      for (const [key, value] of Object.entries(nuxt.options.alias)) {
+        if (key.startsWith("#blokkli/") && !nitroConfig.alias[key]) {
+          nitroConfig.alias[key] = value;
+        }
+      }
     });
     nuxt.hook("nitro:init", (nitro) => {
       nitro.hooks.hook("types:extend", (types) => {

package/dist/modules/agent/runtime/app/composables/agentProvider.js

@@ -6,7 +6,7 @@ import {
   createToolMap,
   executeTool,
   getToolCategory,
-  getToolsForServer,
+  getToolInfoForServer,
   getToolDefinition,
   isMutationAction,
   isQueryResult,
@@ -251,6 +251,19 @@ export default function(app, adapter, agentName) {
     const ctx = createToolContext();
     const resolved = await resolveTools(mcpTools, ctx);
     toolMap = createToolMap(resolved);
+    const toolNames = getToolInfoForServer(
+      resolved,
+      state.editMode.value,
+      adapter
+    );
+    let contentSearchTabs;
+    if (adapter.getContentSearchTabs) {
+      try {
+        contentSearchTabs = await adapter.getContentSearchTabs();
+      } catch (e) {
+        console.warn("[blokkli agent] Failed to fetch content search tabs:", e);
+      }
+    }
     if (adapter.getAgentAuthToken) {
       try {
         const authToken = await adapter.getAgentAuthToken();
@@ -264,23 +277,18 @@ export default function(app, adapter, agentName) {
           disconnect();
           return;
         }
+        const pageContext = await buildPageContext(contentSearchTabs);
+        pendingInit = { toolNames, pageContext };
         send({ type: "authenticate", authToken });
-        pendingInit = {
-          tools: getToolsForServer(resolved, state.editMode.value, adapter),
-          pageContext: buildPageContext()
-        };
         return;
       } catch (e) {
         console.error("Failed to obtain agent auth token:", e);
       }
     }
-    sendInit(
-      getToolsForServer(resolved, state.editMode.value, adapter),
-      buildPageContext()
-    );
+    sendInit(toolNames, await buildPageContext(contentSearchTabs));
   }
-  async function sendInit(tools, pageContext) {
-    send({ type: "init", tools, pageContext });
+  async function sendInit(toolNames, pageContext) {
+    send({ type: "init", toolNames, pageContext });
     isReady.value = true;
     hasBeenReady.value = true;
     if (adapter.agentConversations && !pendingPrompt) {
@@ -305,7 +313,7 @@ export default function(app, adapter, agentName) {
       sendPrompt(prompt, displayPrompt, selectedUuids, attachments);
     }
   }
-  function buildPageContext() {
+  async function buildPageContext(contentSearchTabs) {
     const { types, definitions } = app;
     const bundles = [];
     for (const bundle of types.generallyAvailableBundles) {
@@ -360,6 +368,13 @@ export default function(app, adapter, agentName) {
         allowed: f.allowed
       }))
     ];
+    await app.analyze.ensureInitialized();
+    const analyzersList = app.analyze.analyzers.value.filter((a) => !a.requireRawPage).map((a) => ({
+      id: a.id,
+      type: a.type,
+      label: typeof a.label === "function" ? a.label(context.value.language) : a.label,
+      description: typeof a.description === "function" ? a.description(context.value.language) : a.description
+    }));
     const pageContext = {
       title: state.entity.value.label || "",
       entityType: context.value.entityType,
@@ -373,7 +388,9 @@ export default function(app, adapter, agentName) {
       isPublished: state.entity.value.status ?? null,
       editMode: state.editMode.value,
       fragments,
-      entityContentFields
+      entityContentFields,
+      ...contentSearchTabs?.length ? { contentSearchTabs } : {},
+      ...analyzersList.length ? { analyzers: analyzersList } : {}
     };
     return pageContext;
   }
@@ -412,7 +429,7 @@ export default function(app, adapter, agentName) {
     switch (data.type) {
       case "authenticated":
         if (pendingInit) {
-          sendInit(pendingInit.tools, pendingInit.pageContext);
+          sendInit(pendingInit.toolNames, pendingInit.pageContext);
           pendingInit = null;
         }
         break;

package/dist/modules/agent/runtime/app/composables/defineBlokkliAgentTool.d.ts

@@ -1,4 +1,4 @@
-import type { McpToolDefinition, McpToolCategory, McpToolFactoryInput, McpToolFactory } from '#blokkli/agent/app/types';
+import type { McpToolDefinition, McpToolCategory } from '#blokkli/agent/app/types';
 import type { AdapterMethods } from '#blokkli/editor/adapter';
 import type { z } from 'zod';
 import type { Component } from 'vue';
@@ -7,7 +7,7 @@ import type { Component } from 'vue';
  *
  * Tools are defined once and compiled into two bundles:
  * - Client bundle: Full definition with execute function (for Vue component)
- * - Server bundle: Tools are sent dynamically via WebSocket on init
+ * - Server bundle: Static metadata extracted at build time
  *
  * The Zod schemas provide:
  * - Type-safe parameter and result definitions with TypeScript inference
@@ -43,23 +43,5 @@ import type { Component } from 'vue';
  *   },
  * })
  * ```
- *
- * @example Factory pattern for dynamic tools:
- * ```typescript
- * export default defineBlokkliAgentTool({
- *   resolve: async (ctx) => {
- *     if (!ctx.adapter.getContentSearchTabs) return []
- *     const tabs = await ctx.adapter.getContentSearchTabs()
- *     return Object.entries(tabs).map(([id, label]) =>
- *       defineBlokkliAgentTool({
- *         name: `search_${id}`,
- *         requiredAdapterMethods: ['getContentSearchResults'],
- *         // ... each tool has full type safety
- *       })
- *     )
- *   },
- * })
- * ```
  */
 export declare function defineBlokkliAgentTool<TParamsSchema extends z.ZodType, TResultSchema extends z.ZodType, const TMethods extends readonly AdapterMethods[] = readonly [], TComponent extends Component | undefined = undefined, TCategory extends McpToolCategory = McpToolCategory>(options: McpToolDefinition<TParamsSchema, TResultSchema, TMethods, TComponent, TCategory>): McpToolDefinition<TParamsSchema, TResultSchema, TMethods, TComponent, TCategory>;
-export declare function defineBlokkliAgentTool(options: McpToolFactoryInput): McpToolFactory;