@blokkli/editor 2.0.0-alpha.58 → 2.0.0-alpha.59

package/dist/modules/agent/runtime/app/helpers/parseConversationData.d.ts

@@ -0,0 +1,27 @@
+import { type ConversationItem } from '#blokkli/agent/app/types';
+import type { ConversationStateSnapshot, UsageTurn } from '#blokkli/agent/shared/types';
+import type { AgentConversationData, AgentConversationFeedbackItem, AgentConversationHostInfo } from '#blokkli/agent/app/features/agent/types';
+import type { BlokkliUser } from '#blokkli/editor/types/user';
+export type ParsedConversation = {
+    uuid: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    host: AgentConversationHostInfo | null;
+    author: BlokkliUser | null;
+    conversation: ConversationItem[];
+    usageTurns: UsageTurn[];
+    serverState: ConversationStateSnapshot;
+    feedbackItemIds: string[];
+    feedback: AgentConversationFeedbackItem[];
+};
+/**
+ * Parse a stored conversation into the runtime shape used by the conversation
+ * rendering. Pure — does not touch any reactive state — so it can be reused by
+ * both the live editor session (which then applies it via the provider) and
+ * the admin moderation modal (which renders it read-only).
+ *
+ * Returns null if the stored data is missing required pieces or fails to
+ * parse; callers should treat that as "unrenderable".
+ */
+export declare function parseConversationData(data: AgentConversationData): ParsedConversation | null;

package/dist/modules/agent/runtime/app/helpers/parseConversationData.js

@@ -0,0 +1,42 @@
+import {
+  conversationItemSchema
+} from "#blokkli/agent/app/types";
+import { generateId } from "#blokkli/agent/app/helpers/id";
+export function parseConversationData(data) {
+  try {
+    const parsed = JSON.parse(data.clientState);
+    if (!parsed.conversation?.length) return null;
+    const clientConversation = parsed.conversation.map(
+      (item) => {
+        const result = conversationItemSchema.safeParse(item);
+        if (result.success) return result.data;
+        return {
+          type: "unknown",
+          id: generateId(),
+          timestamp: Date.now()
+        };
+      }
+    );
+    const serverParsed = JSON.parse(data.serverState);
+    if (!serverParsed?.messages?.length) return null;
+    return {
+      uuid: data.uuid,
+      title: data.title,
+      createdAt: data.createdAt,
+      updatedAt: data.updatedAt,
+      host: data.host,
+      author: data.author,
+      conversation: clientConversation,
+      usageTurns: parsed.usageTurns ?? [],
+      feedbackItemIds: data.feedbackItemIds ?? [],
+      feedback: data.feedback ?? [],
+      serverState: {
+        messages: serverParsed.messages,
+        activatedLazyTools: serverParsed.activatedLazyTools,
+        hash: data.hash
+      }
+    };
+  } catch {
+    return null;
+  }
+}

package/dist/modules/agent/runtime/app/prompts/fixReadability.js

@@ -5,14 +5,16 @@ export default defineBlokkliAgentPrompt({
     return [
       {
         id: "fix_readability",
-        skills: ["rewrite-and-translate", "asses-and-fix-readability"],
+        skills: ["rewrite-and-translate", "assess-and-fix-readability"],
         tools: [
           "get_readability_issues",
           "check_readability_for_texts",
           "delegate_text_rewrite"
         ],
         getLabel: ({ $t }) => {
-          return $t("agentPromptReadabilityLabel", "Fix readability...");
+          return $t("fixReadability", "Fix readability", {
+            more: true
+          });
         },
         getPrompt: ({ $t }) => {
           return $t(
@@ -42,8 +44,7 @@ export default defineBlokkliAgentPrompt({
               {
                 toolName: "delegate_text_rewrite",
                 params: {
-                  template: "fix_readability",
-                  templateParams: {},
+                  request: { template: "fix_readability" },
                   fields
                 }
               }

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

@@ -6,6 +6,27 @@ import type { SocketProvider } from './socketProvider.js';
 import type { ConversationProvider } from './conversationProvider.js';
 import type { PlanProvider } from './planProvider.js';
 import type { ToolsProvider } from './toolsProvider.js';
+export type SendPromptOptions = {
+    prompt: string;
+    displayPrompt?: string;
+    selectedUuids?: string[];
+    attachments?: Attachment[];
+    autoLoadTools?: string[];
+    autoLoadSkills?: string[];
+    preSeededResults?: PreSeededToolResult[];
+    autoExecuteTools?: AutoExecuteTool[];
+    /**
+     * When set, the server truncates Session.messages at the Nth real user
+     * turn (0-based) before processing this prompt. Used by retry/edit.
+     */
+    rollbackToUserMessageIndex?: number;
+    /**
+     * Id of the prompt definition that triggered this send, if any. Stored on
+     * the user message so retry can re-run `preExecute` against current
+     * (post-rollback) page state.
+     */
+    promptId?: string;
+};
 export type AgentOrchestrator = {
     isReady: Ref<boolean>;
     hasBeenReady: Ref<boolean>;
@@ -13,8 +34,9 @@ export type AgentOrchestrator = {
     isThinking: Ref<boolean>;
     connect: () => void;
     disconnect: () => void;
-    sendPrompt: (prompt: string, displayPrompt?: string, selectedUuids?: string[], attachments?: Attachment[], autoLoadTools?: string[], autoLoadSkills?: string[], preSeededResults?: PreSeededToolResult[], autoExecuteTools?: AutoExecuteTool[]) => void;
-    retry: () => void;
+    sendPrompt: (options: SendPromptOptions) => void;
+    retry: (targetItemId?: string) => void;
+    rollbackAndSend: (targetItemId: string, newPrompt?: string) => void;
     cancel: () => void;
     newConversation: () => void;
     getTranscript: () => void;

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

@@ -1,6 +1,46 @@
 import { ref, watch } from "#imports";
 import { routeRoute } from "#blokkli-build/agent-client";
 import { buildPageContext } from "#blokkli/agent/app/helpers/buildPageContext";
+import {
+  computeHistorySignature,
+  isHistorySnapshotReachable
+} from "#blokkli/agent/app/helpers/historySignature";
+function buildSendContext(options) {
+  const {
+    prompt,
+    displayPrompt,
+    selectedUuids,
+    autoLoadTools,
+    autoLoadSkills,
+    preSeededResults,
+    autoExecuteTools,
+    promptId
+  } = options;
+  const hasData = !!promptId || displayPrompt !== void 0 && displayPrompt !== prompt || !!selectedUuids?.length || !!autoLoadTools?.length || !!autoLoadSkills?.length || !!preSeededResults?.length || !!autoExecuteTools?.length;
+  if (!hasData) return void 0;
+  return {
+    promptId,
+    serverPrompt: displayPrompt !== void 0 && displayPrompt !== prompt ? prompt : void 0,
+    selectedUuids: selectedUuids?.length ? [...selectedUuids] : void 0,
+    autoLoadTools: autoLoadTools?.length ? [...autoLoadTools] : void 0,
+    autoLoadSkills: autoLoadSkills?.length ? [...autoLoadSkills] : void 0,
+    preSeededResults: preSeededResults?.length ? preSeededResults : void 0,
+    autoExecuteTools: autoExecuteTools?.length ? autoExecuteTools : void 0
+  };
+}
+async function fetchRouting(prompt, toolNames, pageContext) {
+  try {
+    return await fetch(routeRoute, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prompt, toolNames, pageContext })
+    }).then(
+      (r) => r.json()
+    );
+  } catch {
+    return { tools: [], skills: [], usage: null };
+  }
+}
 export default function agentProvider({
   app,
   adapter,
@@ -88,16 +128,7 @@ export default function agentProvider({
     if (pendingPrompt) {
       const queued = pendingPrompt;
       pendingPrompt = null;
-      sendPrompt(
-        queued.prompt,
-        queued.displayPrompt,
-        queued.selectedUuids,
-        queued.attachments,
-        queued.autoLoadTools,
-        queued.autoLoadSkills,
-        queued.preSeededResults,
-        queued.autoExecuteTools
-      );
+      sendPrompt(queued);
     }
   }
   function handleServerMessage(data) {
@@ -112,7 +143,6 @@ export default function agentProvider({
         conversation.setActive(null);
         isThinking.value = true;
         break;
-      case "text":
       case "text_delta":
         isThinking.value = false;
         conversation.appendToActive(data.content);
@@ -122,6 +152,7 @@ export default function agentProvider({
         tools.dispatch(data.callId, data.tool, data.params);
         break;
       case "usage":
+        conversation.finalizeActive();
         conversation.pushUsage(data.usage);
         break;
       case "done":
@@ -182,58 +213,63 @@ export default function agentProvider({
       conversation.pushError({ errorType: "connection" });
     }
   });
-  async function sendPrompt(prompt, displayPrompt, selectedUuids, attachments, autoLoadTools, autoLoadSkills, preSeededResults, autoExecuteTools) {
+  async function sendPrompt(options) {
+    const {
+      prompt,
+      displayPrompt,
+      selectedUuids,
+      attachments,
+      autoLoadTools,
+      autoLoadSkills,
+      preSeededResults,
+      autoExecuteTools,
+      rollbackToUserMessageIndex
+    } = options;
     if (!prompt.trim() || isProcessing.value) return;
     if (!isReady.value) {
-      pendingPrompt = {
-        prompt,
-        displayPrompt,
-        selectedUuids,
-        attachments,
-        autoLoadTools,
-        autoLoadSkills,
-        preSeededResults,
-        autoExecuteTools
-      };
+      pendingPrompt = options;
       return;
     }
     isProcessing.value = true;
     conversation.ensureConversationId();
-    conversation.pushUser(displayPrompt ?? prompt, attachments);
+    const historyMutations = app.state.mutations.value;
+    const historyIndex = app.state.currentMutationIndex.value;
+    const historySignature = computeHistorySignature(
+      historyMutations,
+      historyIndex
+    );
+    const sendContext = buildSendContext(options);
+    conversation.pushUser(
+      displayPrompt ?? prompt,
+      attachments,
+      { index: historyIndex, signature: historySignature },
+      sendContext
+    );
     isThinking.value = true;
     const isFirstMessage = conversation.items.value.filter((v) => v.type === "user").length === 1;
     const hasClientDirectives = !!(autoLoadTools?.length || autoLoadSkills?.length);
     let resolvedAutoLoadTools = autoLoadTools;
     let resolvedAutoLoadSkills = autoLoadSkills;
     if (isFirstMessage && !hasClientDirectives && tools.pageContext.value) {
-      try {
-        const routingResult = await fetch(routeRoute, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            prompt,
-            toolNames: sentToolNames,
-            pageContext: tools.pageContext.value
-          })
-        }).then(
-          (r) => r.json()
-        );
-        if (routingResult.usage) {
-          conversation.pushUsage(routingResult.usage);
-        }
-        if (routingResult.tools?.length) {
-          resolvedAutoLoadTools = [
-            ...resolvedAutoLoadTools || [],
-            ...routingResult.tools
-          ];
-        }
-        if (routingResult.skills?.length) {
-          resolvedAutoLoadSkills = [
-            ...resolvedAutoLoadSkills || [],
-            ...routingResult.skills
-          ];
-        }
-      } catch {
+      const routingResult = await fetchRouting(
+        prompt,
+        sentToolNames,
+        tools.pageContext.value
+      );
+      if (routingResult.usage) {
+        conversation.pushUsage(routingResult.usage);
+      }
+      if (routingResult.tools.length) {
+        resolvedAutoLoadTools = [
+          ...resolvedAutoLoadTools || [],
+          ...routingResult.tools
+        ];
+      }
+      if (routingResult.skills.length) {
+        resolvedAutoLoadSkills = [
+          ...resolvedAutoLoadSkills || [],
+          ...routingResult.skills
+        ];
       }
     }
     const serverPreSeeded = preSeededResults?.length ? preSeededResults.map(({ toolName, params, result }) => ({
@@ -248,11 +284,59 @@ export default function agentProvider({
       autoLoadTools: resolvedAutoLoadTools?.length ? resolvedAutoLoadTools : void 0,
       autoLoadSkills: resolvedAutoLoadSkills?.length ? resolvedAutoLoadSkills : void 0,
       preSeededResults: serverPreSeeded,
-      autoExecuteTools: autoExecuteTools?.length ? autoExecuteTools : void 0
+      autoExecuteTools: autoExecuteTools?.length ? autoExecuteTools : void 0,
+      rollbackToUserMessageIndex
+    });
+  }
+  async function rollbackAndSend(targetItemId, newPrompt) {
+    if (isProcessing.value || !isReady.value) return;
+    const items = conversation.items.value;
+    const targetIdx = items.findIndex((it) => it.id === targetItemId);
+    if (targetIdx < 0) return;
+    const target = items[targetIdx];
+    if (!target || target.type !== "user") return;
+    const userMessageIndex = items.slice(0, targetIdx).filter((it) => it.type === "user").length;
+    const setHistoryIndex = app.adapter.setHistoryIndex;
+    if (setHistoryIndex && isHistorySnapshotReachable(
+      app.state.mutations.value,
+      target.historyIndexAtSend,
+      target.historySignatureAtSend
+    ) && target.historyIndexAtSend !== app.state.currentMutationIndex.value) {
+      const targetIndex = target.historyIndexAtSend;
+      try {
+        await app.state.mutateWithLoadingState(
+          () => setHistoryIndex(targetIndex)
+        );
+      } catch (e) {
+        console.warn("[blokkli agent] Failed to restore editor history:", e);
+      }
+    }
+    conversation.items.value = items.slice(0, targetIdx);
+    conversation.setActive(null);
+    tools.cancelPending();
+    const ctx = target.sendContext;
+    const isEdit = newPrompt !== void 0;
+    const displayedText = newPrompt ?? target.content;
+    const serverPrompt = isEdit ? displayedText : ctx?.serverPrompt ?? displayedText;
+    await sendPrompt({
+      prompt: serverPrompt,
+      displayPrompt: isEdit ? void 0 : displayedText,
+      attachments: target.attachments,
+      rollbackToUserMessageIndex: userMessageIndex,
+      selectedUuids: ctx?.selectedUuids,
+      autoLoadTools: ctx?.autoLoadTools,
+      autoLoadSkills: ctx?.autoLoadSkills,
+      preSeededResults: isEdit ? void 0 : ctx?.preSeededResults,
+      autoExecuteTools: isEdit ? void 0 : ctx?.autoExecuteTools,
+      promptId: isEdit ? void 0 : ctx?.promptId
     });
   }
-  function retry() {
+  function retry(targetItemId) {
     if (isProcessing.value || !isReady.value) return;
+    if (targetItemId) {
+      rollbackAndSend(targetItemId);
+      return;
+    }
     const lastUserItem = [...conversation.items.value].reverse().find((item) => item.type === "user");
     if (!lastUserItem || lastUserItem.type !== "user") return;
     conversation.items.value = conversation.items.value.filter(
@@ -305,6 +389,7 @@ export default function agentProvider({
     disconnect,
     sendPrompt,
     retry,
+    rollbackAndSend,
     cancel,
     newConversation,
     getTranscript,

package/dist/modules/agent/runtime/app/providers/conversationProvider.d.ts

@@ -1,14 +1,10 @@
 import { type Ref } from '#imports';
-import { type ConversationItem, type ActiveItem, type ToolConversationItem, type ServerToolConversationItem, type ErrorConversationItem, type Attachment } from '#blokkli/agent/app/types';
+import type { ConversationItem, ActiveItem, ToolConversationItem, ServerToolConversationItem, ErrorConversationItem, Attachment, UserConversationItem } from '#blokkli/agent/app/types';
 import type { ConversationStateSnapshot, UsageTurn, Transcript } from '#blokkli/agent/shared/types';
-import type { AgentConversationData, AgentConversationSummary } from '#blokkli/agent/app/features/agent/types';
+import type { AgentConversationData, AgentConversationItemSummary } from '#blokkli/agent/app/features/agent/types';
 import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
-export type ParsedConversation = {
-    conversation: ConversationItem[];
-    usageTurns: UsageTurn[];
-    serverState: ConversationStateSnapshot;
-    feedbackItemIds: string[];
-};
+import { type ParsedConversation } from '#blokkli/agent/app/helpers/parseConversationData';
+export type { ParsedConversation };
 export type ConversationProvider = {
     items: Ref<ConversationItem[]>;
     activeItem: Ref<ActiveItem | null>;
@@ -16,11 +12,14 @@ export type ConversationProvider = {
     feedbackItemIds: Ref<Set<string>>;
     toolDetails: Map<string, unknown>;
     activeConversationId: Ref<string | null>;
-    conversationList: Ref<AgentConversationSummary[]>;
+    conversationList: Ref<AgentConversationItemSummary[]>;
     showConversationList: Ref<boolean>;
     transcriptContent: Ref<Transcript | null>;
     showTranscript: Ref<boolean>;
-    pushUser: (content: string, attachments?: Attachment[]) => void;
+    pushUser: (content: string, attachments?: Attachment[], history?: {
+        index: number;
+        signature: string;
+    }, sendContext?: UserConversationItem['sendContext']) => void;
     appendToActive: (text: string) => void;
     setActive: (item: ActiveItem | null) => void;
     finalizeActive: () => void;

package/dist/modules/agent/runtime/app/providers/conversationProvider.js

@@ -1,11 +1,9 @@
 import { ref, reactive } from "#imports";
-import {
-  conversationItemSchema
-} from "#blokkli/agent/app/types";
 import { generateUUID } from "#blokkli/editor/helpers/uuid";
-function generateId() {
-  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
+import { generateId } from "#blokkli/agent/app/helpers/id";
+import {
+  parseConversationData
+} from "#blokkli/agent/app/helpers/parseConversationData";
 export default function conversationProvider({
   adapter
 }) {
@@ -19,13 +17,16 @@ export default function conversationProvider({
   const showConversationList = ref(false);
   const transcriptContent = ref(null);
   const showTranscript = ref(false);
-  function pushUser(content, attachments) {
+  function pushUser(content, attachments, history, sendContext) {
     items.value.push({
       type: "user",
       id: generateId(),
       content,
       timestamp: Date.now(),
-      attachments: attachments?.length ? attachments : void 0
+      attachments: attachments?.length ? attachments : void 0,
+      historyIndexAtSend: history?.index,
+      historySignatureAtSend: history?.signature,
+      sendContext
     });
   }
   function appendToActive(text) {
@@ -118,37 +119,7 @@ export default function conversationProvider({
     transcriptContent.value = transcript;
     showTranscript.value = true;
   }
-  function parseFromAdapter(data) {
-    try {
-      const parsed = JSON.parse(data.clientState);
-      if (!parsed.conversation?.length) return null;
-      const clientConversation = parsed.conversation.map(
-        (item) => {
-          const result = conversationItemSchema.safeParse(item);
-          if (result.success) return result.data;
-          return {
-            type: "unknown",
-            id: generateId(),
-            timestamp: Date.now()
-          };
-        }
-      );
-      const serverParsed = JSON.parse(data.serverState);
-      if (!serverParsed?.messages?.length) return null;
-      return {
-        conversation: clientConversation,
-        usageTurns: parsed.usageTurns ?? [],
-        feedbackItemIds: data.feedbackItemIds ?? [],
-        serverState: {
-          messages: serverParsed.messages,
-          activatedLazyTools: serverParsed.activatedLazyTools,
-          hash: data.hash
-        }
-      };
-    } catch {
-      return null;
-    }
-  }
+  const parseFromAdapter = parseConversationData;
   function applyRestoredData(parsed) {
     items.value = parsed.conversation;
     usageTurns.value = parsed.usageTurns;

package/dist/modules/agent/runtime/app/providers/toolsProvider.js

@@ -8,15 +8,12 @@ import {
   isMutationAction,
   isQueryResult,
   isToolError,
-  resolveTools,
   asRecord,
   splitMeta
 } from "#blokkli/agent/app/helpers";
 import { mcpTools } from "#blokkli-build/agent-client";
 import { itemEntityType } from "#blokkli-build/config";
-function generateId() {
-  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
+import { generateId } from "#blokkli/agent/app/helpers/id";
 export default function toolsProvider({
   app,
   adapter,
@@ -39,11 +36,9 @@ export default function toolsProvider({
     };
   }
   async function init() {
-    const ctx = createToolContext();
-    const resolved = await resolveTools(mcpTools, ctx);
-    toolMap = createToolMap(resolved);
+    toolMap = createToolMap(mcpTools);
     const toolNames = await getToolInfoForServer(
-      resolved,
+      mcpTools,
       state.editMode.value,
       app,
       adapter
@@ -64,39 +59,34 @@ export default function toolsProvider({
       pendingMutation.value = { action, resolve };
     });
   }
-  async function executeLocally(toolName, params, setLabel) {
-    const ctx = createToolContext();
-    const toolDef = getToolDefinition(toolMap, toolName);
-    if (toolDef.component) {
-      const preparedParams = await executeTool(toolMap, toolName, ctx, params);
-      if (isToolError(preparedParams)) {
-        return { ok: false, error: preparedParams.error };
-      }
-      const raw = await waitForToolComponent(
-        toolDef.name,
-        preparedParams
-      );
-      const { payload, meta } = splitMeta(raw);
-      const payloadObj = asRecord(payload);
-      if (setLabel && payloadObj && typeof payloadObj.label === "string") {
-        setLabel(payloadObj.label);
-      }
-      return { ok: true, result: payload, meta };
+  async function executeComponentTool(toolDef, ctx, params, setLabel) {
+    const preparedParams = await executeTool(toolMap, toolDef.name, ctx, params);
+    if (isToolError(preparedParams)) {
+      return { ok: false, error: preparedParams.error };
     }
-    const category = getToolCategory(toolMap, toolName);
-    const result = await executeTool(toolMap, toolName, ctx, params);
-    if (isToolError(result)) return { ok: false, error: result.error };
-    if (category === "query") {
-      if (isQueryResult(result)) {
-        if (setLabel) setLabel(result.label);
-        if (result.affectedUuids?.length) {
-          app.eventBus.emit("select", result.affectedUuids);
-          app.eventBus.emit("scrollSelectionIntoView", {});
-        }
-        return { ok: true, result: result.result, meta: {} };
+    const raw = await waitForToolComponent(
+      toolDef.name,
+      preparedParams
+    );
+    const { payload, meta } = splitMeta(raw);
+    const payloadObj = asRecord(payload);
+    if (setLabel && payloadObj && typeof payloadObj.label === "string") {
+      setLabel(payloadObj.label);
+    }
+    return { ok: true, result: payload, meta };
+  }
+  function executeQueryTool(result, setLabel) {
+    if (isQueryResult(result)) {
+      if (setLabel) setLabel(result.label);
+      if (result.affectedUuids?.length) {
+        app.eventBus.emit("select", result.affectedUuids);
+        app.eventBus.emit("scrollSelectionIntoView", {});
       }
-      return { ok: true, result, meta: {} };
+      return { ok: true, result: result.result, meta: {} };
     }
+    return { ok: true, result, meta: {} };
+  }
+  async function executeMutationTool(result, toolDef, setLabel) {
     if (!isMutationAction(result)) {
       return { ok: false, error: "Invalid mutation tool result" };
     }
@@ -145,6 +135,20 @@ export default function toolsProvider({
     if (action.revert) action.revert();
     return { ok: true, result: { success: false, rejected: true }, meta: {} };
   }
+  async function executeLocally(toolName, params, setLabel) {
+    const ctx = createToolContext();
+    const toolDef = getToolDefinition(toolMap, toolName);
+    if (toolDef.component) {
+      return executeComponentTool(toolDef, ctx, params, setLabel);
+    }
+    const category = getToolCategory(toolMap, toolName);
+    const result = await executeTool(toolMap, toolName, ctx, params);
+    if (isToolError(result)) return { ok: false, error: result.error };
+    if (category === "query") {
+      return executeQueryTool(result, setLabel);
+    }
+    return executeMutationTool(result, toolDef, setLabel);
+  }
   async function dispatch(callId, tool, params) {
     const toolDef = getToolDefinition(toolMap, tool);
     const initialLabel = toolDef.label($t);
@@ -234,8 +238,7 @@ export default function toolsProvider({
   async function runForPrompt(toolName, params) {
     const ctx = createToolContext();
     if (!Object.keys(toolMap).length) {
-      const resolved = await resolveTools(mcpTools, ctx);
-      toolMap = createToolMap(resolved);
+      toolMap = createToolMap(mcpTools);
     }
     const toolDef = getToolDefinition(toolMap, toolName);
     const rawResult = await executeTool(toolMap, toolName, ctx, params);

package/dist/modules/agent/runtime/app/tools/{add_content_search_paragraph → add_content_search_paragraphs}/index.js

@@ -15,7 +15,7 @@ const paramsSchema = z.object({
 });
 export default defineBlokkliAgentTool({
   name: "add_content_search_paragraphs",
-  description: "Add a paragraph using a content item from search results. Use search_content first to find content items, then use this tool to add one to the page. Requires user approval.",
+  description: "Add a paragraph using a content item from search results. Use search_content first to find content items, then use this tool to add one to the page.",
   category: "mutation",
   prunedSummary: (r) => r.success ? "added content paragraph" : "rejected",
   modes: ["editing"],
@@ -23,7 +23,8 @@ export default defineBlokkliAgentTool({
   label($t) {
     return $t(
       "aiAgentAddContentSearchBlockRunning",
-      "Adding content paragraph..."
+      "Adding content paragraph",
+      { more: true }
     );
   },
   paramsSchema,

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

@@ -10,13 +10,13 @@ const paramsSchema = z.object({
 });
 export default defineBlokkliAgentTool({
   name: "add_fragment",
-  description: "Add a fragment paragraph to the page. Requires user approval before the fragment is actually added.",
+  description: "Add a fragment paragraph to the page.",
   category: "mutation",
   prunedSummary: (r) => r.success ? "added fragment" : "rejected",
   modes: ["editing"],
   lazy: true,
   label($t) {
-    return $t("aiAgentAddFragmentRunning", "Adding fragment...");
+    return $t("aiAgentAddFragmentRunning", "Adding fragment", { more: true });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,