@blokkli/editor 2.0.0-alpha.39 → 2.0.0-alpha.40

package/dist/module.json

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

package/dist/module.mjs

@@ -4,11 +4,9 @@ import MagicString from 'magic-string';
 import { walk } from 'estree-walker-ts';
 import { pathToFileURL } from 'node:url';
 import { parseURL, parseQuery } from 'ufo';
-import * as ts from 'typescript';
-import { parseAndWalk } from 'oxc-walker';
+import { C as Collector, a as CollectedFile, b as extractObjectLiteral, p as parseTsObject, t as toValidVariableName, o as onlyUnique, f as falsy, s as sortObjectKeys } from './shared/editor.9vf8ZnOp.mjs';
 import path__default, { basename, dirname as dirname$1 } from 'node:path';
 import { dirname, resolve, relative } from 'pathe';
-import { C as Collector, a as CollectedFile } from './shared/editor.BFIzNSQM.mjs';
 import micromatch from 'micromatch';
 import { hash } from 'ohash';
 import fs__default, { readFileSync, existsSync, readdirSync } from 'node:fs';
@@ -16,109 +14,11 @@ import { LANGUAGES, BK_VISIBLE_LANGUAGES, BK_HIDDEN_GLOBALLY } from './global/co
 import { createRequire } from 'node:module';
 import { d as defineCodeTemplate, a as defineFileTemplate, w as withHelper } from './shared/editor.6D5vApr0.mjs';
 import { defu, createDefu } from 'defu';
+import 'typescript';
+import 'oxc-walker';
 
 const name = "@blokkli/editor";
-const version = "2.0.0-alpha.39";
-
-function sortObjectKeys(obj) {
-  if (Array.isArray(obj)) {
-    return obj.map(sortObjectKeys);
-  } else if (obj && typeof obj === "object") {
-    const sortedObj = {};
-    const keys = Object.keys(obj).sort();
-    for (const key of keys) {
-      sortedObj[key] = sortObjectKeys(obj[key]);
-    }
-    return sortedObj;
-  }
-  return obj;
-}
-function toValidVariableName(input) {
-  let result = input.replace(/\W/g, "_");
-  if (/^\d/.test(result)) {
-    result = "_" + result;
-  }
-  if (result === "") {
-    result = "_empty";
-  }
-  return result;
-}
-function parseTsObject(tsObjectStr) {
-  const source = `(${tsObjectStr})`;
-  const result = ts.transpileModule(source, {
-    compilerOptions: {
-      target: ts.ScriptTarget.ESNext,
-      module: ts.ModuleKind.None,
-      removeComments: true
-    }
-  });
-  const jsCode = result.outputText.trim();
-  const createObj = new Function(`return ${jsCode}`);
-  const object = createObj();
-  return { object, source: jsCode };
-}
-function falsy(value) {
-  return value !== null && value !== void 0;
-}
-const SFC_SCRIPT_RE = /<script(?<attrs>[^>]*)>(?<content>[\s\S]*?)<\/script[^>]*>/gi;
-function extractScriptContent(sfc) {
-  const contents = [];
-  let hasMatch = false;
-  for (const match of sfc.matchAll(SFC_SCRIPT_RE)) {
-    hasMatch = true;
-    if (match?.groups?.content) {
-      contents.push({
-        loader: match.groups.attrs && /[tj]sx/.test(match.groups.attrs) ? "tsx" : "ts",
-        code: match.groups.content.trim()
-      });
-    }
-  }
-  if (!hasMatch) {
-    contents.push({
-      loader: "ts",
-      code: sfc.trim()
-    });
-  }
-  return contents;
-}
-function extractObjectLiteral(fileContents, composables) {
-  if (!composables.some((composable) => fileContents.includes(composable))) {
-    return void 0;
-  }
-  const scripts = extractScriptContent(fileContents);
-  for (const script of scripts) {
-    try {
-      let result;
-      const filename = script.loader === "tsx" ? "temp.tsx" : "temp.ts";
-      parseAndWalk(script.code, filename, {
-        parseOptions: {
-          range: true
-        },
-        enter(node) {
-          if (result) return;
-          if (node.type === "CallExpression" && node.callee.type === "Identifier" && composables.includes(node.callee.name)) {
-            for (const arg of node.arguments) {
-              if (arg.type === "ObjectExpression" && arg.range) {
-                result = script.code.substring(arg.range[0], arg.range[1]);
-                break;
-              }
-            }
-          }
-        }
-      });
-      if (result) {
-        return result;
-      }
-    } catch (error) {
-      console.log(error);
-      continue;
-    }
-  }
-  return void 0;
-}
-function onlyUnique(value, index, self) {
-  return self.indexOf(value) === index;
-}
+const version = "2.0.0-alpha.40";
 
 function validateOption(optionKey, option, icons) {
   const errors = [];
@@ -854,7 +754,12 @@ const BlokkliEditingPlugin = (nuxt) => {
         if (search && pathname.endsWith(".vue")) {
           const query = parseQuery(search);
           if (query.blokkliEditing === "true") {
-            return pathname.replace(/\.vue$/, `${EDITING_MARKER}.vue`);
+            let resolved = pathname;
+            if (importer && pathname.startsWith(".")) {
+              const importerBase2 = importer.split("?")[0] || "";
+              resolved = resolve(dirname(importerBase2), pathname);
+            }
+            return resolved.replace(/\.vue$/, `${EDITING_MARKER}.vue`);
           }
         }
         if (!importer || !importer.includes(EDITING_MARKER) || !id.endsWith(".vue")) {
@@ -1527,6 +1432,8 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_check_box_outline_blank",
   "bk_mdi_chevron_backward",
   "bk_mdi_chevron_forward",
+  "bk_mdi_chevron_left",
+  "bk_mdi_chevron_right",
   "bk_mdi_close",
   "bk_mdi_collapse_all",
   "bk_mdi_comment",
@@ -1541,6 +1448,7 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_donut_large",
   "bk_mdi_drag_pan",
   "bk_mdi_edit",
+  "bk_mdi_error",
   "bk_mdi_exit_to_app",
   "bk_mdi_expand_all",
   "bk_mdi_extension",
@@ -1551,6 +1459,7 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_help",
   "bk_mdi_help-fill",
   "bk_mdi_history",
+  "bk_mdi_hourglass_empty",
   "bk_mdi_image",
   "bk_mdi_info-fill",
   "bk_mdi_ink_selection",
@@ -1591,6 +1500,7 @@ const USED_MATERIAL_ICONS = [
   "bk_mdi_speed",
   "bk_mdi_stack_group",
   "bk_mdi_stop",
+  "bk_mdi_stream",
   "bk_mdi_swap_horiz",
   "bk_mdi_swap_horizontal_circle",
   "bk_mdi_text_compare",

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

@@ -11,6 +11,7 @@ type AgentModelDefinition = {
     name: string;
     label: string;
     isDefault?: boolean;
+    routing?: boolean;
     pricing?: {
         input: number;
         cacheWrite: number;

package/dist/modules/agent/index.mjs

@@ -3,12 +3,14 @@ import { fileURLToPath } from 'node:url';
 import * as path from 'node:path';
 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 { C as Collector, a as CollectedFile, e as extractStringProperty } from '../../shared/editor.9vf8ZnOp.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';
+import 'typescript';
+import 'oxc-walker';
 
 function toImportName(prefix, fileName) {
   const name = fileName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
@@ -30,9 +32,15 @@ class CollectedAgentFile extends CollectedFile {
     const fileName = path.basename(this.filePath, ext);
     const baseName = fileName === "index" ? path.basename(path.dirname(this.filePath)) : fileName;
     const importName = toImportName(this.importPrefix, baseName);
+    const name = extractStringProperty(
+      this.fileContents,
+      [this.composable],
+      "name"
+    );
     this.item = {
       filePath: this.filePath,
-      importName
+      importName,
+      name
     };
     return true;
   }
@@ -93,9 +101,15 @@ class AgentCollector extends Collector {
   getItems() {
     return [...this.files.values()].filter((v) => v.isValid()).map((v) => v.getItem());
   }
+  /**
+   * Get the extracted `name` values from all valid items.
+   */
+  getNames() {
+    return this.getItems().filter((item) => item.name !== void 0).map((item) => item.name);
+  }
 }
 
-function createClientTemplate(toolCollector, promptCollector, options) {
+function createClientTemplate(toolCollector, promptCollector, skillsCollector, options) {
   return defineCodeTemplate(
     "agent-client",
     (ctx) => {
@@ -140,6 +154,12 @@ function createClientTemplate(toolCollector, promptCollector, options) {
       exports$1.push(
         `export const hasWebFetch = ${JSON.stringify(!!options.allowedFetchOrigins)}`
       );
+      exports$1.push(
+        `export const toolNames = ${JSON.stringify(toolCollector.getNames())}`
+      );
+      exports$1.push(
+        `export const skillNames = ${JSON.stringify(skillsCollector.getNames())}`
+      );
       const parts = [];
       if (imports.length > 0) {
         parts.push(imports.join("\n"));
@@ -147,16 +167,50 @@ function createClientTemplate(toolCollector, promptCollector, options) {
       parts.push(exports$1.join("\n"));
       return parts.join("\n\n") + "\n";
     },
-    () => {
-      return `import type { McpToolDefinition, AgentPromptItem } from '#blokkli/agent/app/types'
+    (ctx) => {
+      const tools = toolCollector.getItems();
+      const skillNamesList = skillsCollector.getNames();
+      const rel = (p) => ctx.helper.toModuleBuildRelative(p).replace(/\.ts$/, "");
+      const agentSkillNameType = skillNamesList.length > 0 ? skillNamesList.map((n) => `'${n}'`).join(" | ") : "string";
+      const toolsWithNames = tools.filter((t) => t.name !== void 0);
+      let toolMapBlock;
+      let agentToolNameType;
+      if (toolsWithNames.length > 0) {
+        const entries = toolsWithNames.map((t) => {
+          const importPath = rel(t.filePath);
+          return `  '${t.name}': {
+    params: _ToolParams<typeof import('${importPath}')['default']>
+    result: _ToolResult<typeof import('${importPath}')['default']>
+  }`;
+        }).join("\n");
+        toolMapBlock = `export interface AgentToolMap {
+${entries}
+}`;
+        agentToolNameType = "keyof AgentToolMap";
+      } else {
+        toolMapBlock = `export type AgentToolMap = Record<string, { params: Record<string, unknown>; result: unknown }>`;
+        agentToolNameType = "string";
+      }
+      return `import type { z } from 'zod'
+import type { McpToolDefinition, AgentPromptItem } from '#blokkli/agent/app/types'
 import type { AgentModelDefinition } from '#blokkli/agent/shared/types'
 
+type _ToolParams<T> = T extends { paramsSchema: infer P extends z.ZodType } ? z.infer<P> : never
+type _ToolResult<T> = T extends { resultSchema: infer R extends z.ZodType } ? z.infer<R> : never
+
+${toolMapBlock}
+
+export type AgentToolName = ${agentToolNameType}
+export type AgentSkillName = ${agentSkillNameType}
+
 export const mcpTools: McpToolDefinition[]
 export const agentPrompts: AgentPromptItem[]
 export const defaultPrompts: string[]
 export const agentName: string
 export const models: AgentModelDefinition[]
 export const hasWebFetch: boolean
+export const toolNames: readonly AgentToolName[]
+export const skillNames: readonly AgentSkillName[]
 `;
     }
   );
@@ -494,6 +548,8 @@ function transformToolSource(source, filePath) {
 
 const AGENT_ROUTE = "/api/blokkli/agent";
 const FETCH_ROUTE = "/api/blokkli/agent/fetch";
+const STREAM_ROUTE = "/api/blokkli/agent/stream";
+const ROUTE_ROUTE = "/api/blokkli/agent/route";
 const index = defineBlokkliModule({
   alterOptions: (options) => {
     options.featureImports ||= [];
@@ -561,6 +617,7 @@ export default defineNuxtConfig({
       ]
     });
     ctx.context.addCollector(mcpTools);
+    const modulePromptsDir = moduleResolver.resolve("./runtime/app/prompts");
     const projectPromptsDir = path.resolve(
       nuxt.options.rootDir,
       "blokkli/prompts"
@@ -570,14 +627,12 @@ export default defineNuxtConfig({
       importPrefix: "prompt",
       dependency: "agent-prompts",
       dirs: [
+        modulePromptsDir,
         projectPromptsDir,
         ...moduleBlokkliDirs.map((d) => path.join(d, "prompts"))
       ]
     });
     ctx.context.addCollector(promptsCollector);
-    ctx.context.addTemplate(
-      createClientTemplate(mcpTools, promptsCollector, options)
-    );
     const relativeToolsDir = path.relative(
       nuxt.options.buildDir,
       projectToolsDir
@@ -613,6 +668,14 @@ export default defineNuxtConfig({
       ]
     });
     ctx.context.addCollector(skillsCollector);
+    ctx.context.addTemplate(
+      createClientTemplate(
+        mcpTools,
+        promptsCollector,
+        skillsCollector,
+        options
+      )
+    );
     const moduleSystemPromptsDir = moduleResolver.resolve(
       "./runtime/server/default-system-prompts"
     );
@@ -656,6 +719,14 @@ export default defineNuxtConfig({
       route: FETCH_ROUTE,
       handler: moduleResolver.resolve("./runtime/server/fetch")
     });
+    addServerHandler({
+      route: STREAM_ROUTE,
+      handler: moduleResolver.resolve("./runtime/server/stream")
+    });
+    addServerHandler({
+      route: ROUTE_ROUTE,
+      handler: moduleResolver.resolve("./runtime/server/route")
+    });
     const relativeSkillsDir = path.relative(
       nuxt.options.buildDir,
       projectSkillsDir
@@ -687,6 +758,8 @@ export default defineNuxtConfig({
       nitro.hooks.hook("types:extend", (types) => {
         Reflect.deleteProperty(types.routes, AGENT_ROUTE);
         Reflect.deleteProperty(types.routes, FETCH_ROUTE);
+        Reflect.deleteProperty(types.routes, STREAM_ROUTE);
+        Reflect.deleteProperty(types.routes, ROUTE_ROUTE);
       });
     });
   }

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

@@ -1,7 +1,8 @@
 import { type Ref } from '#imports';
-import { type Attachment, type ConversationItem, type ActiveItem, type MutationAction } from '#blokkli/agent/app/types';
-import type { ClientPlanState, UsageTurn, Transcript } from '#blokkli/agent/shared/types';
+import { type Attachment, type ConversationItem, type ActiveItem, type MutationAction, type PreSeededToolResult, type AutoExecuteTool } from '#blokkli/agent/app/types';
+import type { ClientPlanState, UsageTurn, PageContext, Transcript } from '#blokkli/agent/shared/types';
 import type { AgentConversationSummary } from '#blokkli/agent/app/features/agent/types';
+import type { AgentToolName, AgentToolMap } from '#blokkli-build/agent-client';
 import type { BlokkliApp } from '#blokkli/editor/types/app';
 import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
 export type PendingMutationState = {
@@ -34,7 +35,10 @@ export type AgentProvider = {
     approvePlan: () => void;
     rejectPlan: () => void;
     usageTurns: Ref<UsageTurn[]>;
-    sendPrompt: (text: string, displayPrompt?: string, selectedUuids?: string[], attachments?: Attachment[]) => void;
+    sendPrompt: (text: string, displayPrompt?: string, selectedUuids?: string[], attachments?: Attachment[], autoLoadTools?: string[], autoLoadSkills?: string[], preSeededResults?: PreSeededToolResult[], autoExecuteTools?: AutoExecuteTool[]) => void;
+    runToolForPrompt: <T extends AgentToolName>(toolName: T, params: AgentToolMap[T]['params']) => Promise<PreSeededToolResult & {
+        result: AgentToolMap[T]['result'];
+    }>;
     retry: () => void;
     approve: () => void;
     reject: () => void;
@@ -52,5 +56,6 @@ export type AgentProvider = {
     switchConversation: (id: string) => void;
     deleteConversation: (id: string) => void;
     refreshConversationList: () => Promise<void>;
+    pageContext: Ref<PageContext | null>;
 };
 export default function (app: BlokkliApp, adapter: FullBlokkliAdapter<any>, agentName: string): AgentProvider;

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

@@ -1,4 +1,4 @@
-import { ref, readonly, reactive, watch } from "#imports";
+import { ref, shallowRef, readonly, reactive, watch } from "#imports";
 import {
   conversationItemSchema
 } from "#blokkli/agent/app/types";
@@ -29,6 +29,8 @@ export default function(app, adapter, agentName) {
   let pendingPrompt = null;
   let pendingInit = null;
   let toolMap = {};
+  let sentToolNames = [];
+  const storedPageContext = shallowRef(null);
   const isProcessing = ref(false);
   const isThinking = ref(false);
   const usageTurns = ref([]);
@@ -302,17 +304,21 @@ export default function(app, adapter, agentName) {
           disconnect();
           return;
         }
-        const pageContext = await buildPageContext(contentSearchTabs);
-        pendingInit = { toolNames, pageContext };
+        const pageContext2 = await buildPageContext(contentSearchTabs);
+        storedPageContext.value = pageContext2;
+        pendingInit = { toolNames, pageContext: pageContext2 };
         send({ type: "authenticate", authToken });
         return;
       } catch (e) {
         console.error("Failed to obtain agent auth token:", e);
       }
     }
-    sendInit(toolNames, await buildPageContext(contentSearchTabs));
+    const pageContext = await buildPageContext(contentSearchTabs);
+    storedPageContext.value = pageContext;
+    sendInit(toolNames, pageContext);
   }
   async function sendInit(toolNames, pageContext) {
+    sentToolNames = toolNames;
     send({ type: "init", toolNames, pageContext });
     isReady.value = true;
     hasBeenReady.value = true;
@@ -333,9 +339,27 @@ export default function(app, adapter, agentName) {
       }
     }
     if (pendingPrompt) {
-      const { prompt, displayPrompt, selectedUuids, attachments } = pendingPrompt;
+      const {
+        prompt,
+        displayPrompt,
+        selectedUuids,
+        attachments,
+        autoLoadTools,
+        autoLoadSkills,
+        preSeededResults,
+        autoExecuteTools
+      } = pendingPrompt;
       pendingPrompt = null;
-      sendPrompt(prompt, displayPrompt, selectedUuids, attachments);
+      sendPrompt(
+        prompt,
+        displayPrompt,
+        selectedUuids,
+        attachments,
+        autoLoadTools,
+        autoLoadSkills,
+        preSeededResults,
+        autoExecuteTools
+      );
     }
   }
   async function buildPageContext(contentSearchTabs) {
@@ -621,8 +645,12 @@ export default function(app, adapter, agentName) {
         }
         let resultForServer = result;
         if (typeof result === "object" && result !== null) {
-          if ("_details" in result) {
-            const { _details: _, ...rest } = result;
+          const rec = result;
+          if ("_usage" in rec && rec._usage) {
+            usageTurns.value = [...usageTurns.value, rec._usage];
+          }
+          if ("_details" in rec || "_usage" in rec) {
+            const { _details: _, _usage: __, ...rest } = rec;
             resultForServer = rest;
           }
         }
@@ -667,9 +695,18 @@ export default function(app, adapter, agentName) {
     return {
       app,
       itemEntityType,
-      adapter
+      adapter,
+      pageContext: storedPageContext.value
     };
   }
+  async function runToolForPrompt(toolName, params) {
+    const ctx = createToolContext();
+    const toolDef = getToolDefinition(toolMap, toolName);
+    const rawResult = await executeTool(toolMap, toolName, ctx, params);
+    const label = isQueryResult(rawResult) ? rawResult.label : toolDef.label($t);
+    const result = isQueryResult(rawResult) ? rawResult.result : rawResult;
+    return { toolName, params, result, label };
+  }
   function waitForToolComponent(toolName, params) {
     return new Promise((resolve) => {
       pendingToolCall.value = { toolName, params };
@@ -774,16 +811,62 @@ export default function(app, adapter, agentName) {
       pendingMutation.value = { action, resolve };
     });
   }
-  function sendPrompt(prompt, displayPrompt, selectedUuids, attachments) {
+  async function sendPrompt(prompt, displayPrompt, selectedUuids, attachments, autoLoadTools, autoLoadSkills, preSeededResults, autoExecuteTools) {
     if (!prompt.trim() || isProcessing.value) return;
     if (!isReady.value) {
-      pendingPrompt = { prompt, displayPrompt, selectedUuids, attachments };
+      pendingPrompt = {
+        prompt,
+        displayPrompt,
+        selectedUuids,
+        attachments,
+        autoLoadTools,
+        autoLoadSkills,
+        preSeededResults,
+        autoExecuteTools
+      };
       return;
     }
     isProcessing.value = true;
     if (!activeConversationId.value) {
       activeConversationId.value = generateUUID();
     }
+    const isFirstMessage = !conversation.value.some(
+      (item2) => item2.type === "user"
+    );
+    const hasClientDirectives = !!(autoLoadTools?.length || autoLoadSkills?.length);
+    let resolvedAutoLoadTools = autoLoadTools;
+    let resolvedAutoLoadSkills = autoLoadSkills;
+    if (isFirstMessage && !hasClientDirectives && storedPageContext.value) {
+      try {
+        const routingResult = await fetch("/api/blokkli/agent/route", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            prompt,
+            toolNames: sentToolNames,
+            pageContext: storedPageContext.value
+          })
+        }).then(
+          (r) => r.json()
+        );
+        if (routingResult.usage) {
+          usageTurns.value = [...usageTurns.value, routingResult.usage];
+        }
+        if (routingResult.tools?.length) {
+          resolvedAutoLoadTools = [
+            ...resolvedAutoLoadTools || [],
+            ...routingResult.tools
+          ];
+        }
+        if (routingResult.skills?.length) {
+          resolvedAutoLoadSkills = [
+            ...resolvedAutoLoadSkills || [],
+            ...routingResult.skills
+          ];
+        }
+      } catch {
+      }
+    }
     const item = {
       type: "user",
       id: generateId(),
@@ -795,10 +878,19 @@ export default function(app, adapter, agentName) {
       item.attachments = attachments;
     }
     conversation.value.push(item);
+    const serverPreSeeded = preSeededResults?.length ? preSeededResults.map(({ toolName, params, result }) => ({
+      toolName,
+      params,
+      result
+    })) : void 0;
     send({
       type: "start",
       prompt,
-      selectedUuids: selectedUuids?.length ? selectedUuids : void 0
+      selectedUuids: selectedUuids?.length ? selectedUuids : void 0,
+      autoLoadTools: resolvedAutoLoadTools?.length ? resolvedAutoLoadTools : void 0,
+      autoLoadSkills: resolvedAutoLoadSkills?.length ? resolvedAutoLoadSkills : void 0,
+      preSeededResults: serverPreSeeded,
+      autoExecuteTools: autoExecuteTools?.length ? autoExecuteTools : void 0
     });
   }
   function retry() {
@@ -912,6 +1004,7 @@ export default function(app, adapter, agentName) {
     usageTurns,
     // Actions
     sendPrompt,
+    runToolForPrompt,
     retry,
     approve,
     reject,
@@ -931,6 +1024,8 @@ export default function(app, adapter, agentName) {
     activeConversationId: readonly(activeConversationId),
     switchConversation,
     deleteConversation,
-    refreshConversationList
+    refreshConversationList,
+    // Page context (built once during connection)
+    pageContext: storedPageContext
   };
 }

package/dist/modules/agent/runtime/app/features/agent/Panel/DebugGallery/index.vue

@@ -51,7 +51,8 @@ import { mcpTools } from "#blokkli-build/agent-client";
 const mockContext = {
   app: null,
   itemEntityType: "paragraph",
-  adapter: {}
+  adapter: {},
+  pageContext: null
 };
 const mockHistory = [
   {
@@ -145,12 +146,12 @@ const mockMutations = [
     type: "move",
     label: "Move card block after hero section",
     apply: () => void 0
-  },
-  {
-    type: "rewrite",
-    label: "Rewrite title field content",
-    apply: () => void 0
   }
+  // {
+  //   type: 'rewrite',
+  //   label: 'Rewrite title field content',
+  //   apply: () => undefined,
+  // },
 ];
 const toolsWithMockParams = computed(
   () => mcpTools.filter(

package/dist/modules/agent/runtime/app/features/agent/Panel/index.d.vue.ts

@@ -1,10 +1,9 @@
 import type { AgentConversationSummary, PendingMutationState, PendingToolCall } from '#blokkli/agent/app/composables';
 import type { ConversationItem, ActiveItem } from '#blokkli/agent/app/types';
-import type { ClientPlanState, UsageTurn } from '#blokkli/agent/shared/types';
+import type { ClientPlanState, PageContext, UsageTurn } from '#blokkli/agent/shared/types';
 type __VLS_Props = {
     agentName: string;
     isShown: boolean;
-    debugStyling?: boolean;
     conversation: ConversationItem[];
     activeItem: ActiveItem | null;
     isThinking: boolean;
@@ -19,6 +18,7 @@ type __VLS_Props = {
     showConversationList: boolean;
     plan: ClientPlanState | null;
     usageTurns: UsageTurn[];
+    pageContext: PageContext | null;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     cancel: () => any;