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

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

@@ -1,1048 +0,0 @@
-import { ref, shallowRef, readonly, reactive, watch } from "#imports";
-import {
-  conversationItemSchema
-} from "#blokkli/agent/app/types";
-import {
-  createToolMap,
-  executeTool,
-  getToolCategory,
-  getToolInfoForServer,
-  getToolDefinition,
-  isMutationAction,
-  isQueryResult,
-  isToolError,
-  resolveTools
-} from "#blokkli/agent/app/helpers";
-import { mcpTools, routeAgent, routeRoute } from "#blokkli-build/agent-client";
-import { generateUUID } from "#blokkli/editor/helpers/uuid";
-import { itemEntityType } from "#blokkli-build/config";
-export default function(app, adapter, agentName) {
-  const { $t, state, ui, context } = app;
-  let ws = null;
-  let reconnectTimeout = null;
-  let pingInterval = null;
-  let reconnectAttempts = 0;
-  const MAX_RECONNECT_ATTEMPTS = 10;
-  const isConnected = ref(false);
-  const isReady = ref(false);
-  const hasBeenReady = ref(false);
-  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([]);
-  const conversation = ref([]);
-  const activeItem = ref(null);
-  const autoApprove = ref(false);
-  const pendingMutation = ref(null);
-  const pendingToolCall = ref(null);
-  let pendingToolCallResolve = null;
-  const plan = ref(null);
-  const transcriptContent = ref(null);
-  const showTranscript = ref(false);
-  const activeConversationId = ref(null);
-  const conversationList = ref([]);
-  const showConversationList = ref(false);
-  const feedbackItemIds = ref(/* @__PURE__ */ new Set());
-  const toolDetails = reactive(/* @__PURE__ */ new Map());
-  async function saveCurrentConversation(serverState) {
-    if (!adapter.agentConversations) return;
-    if (!conversation.value.length) return;
-    if (!activeConversationId.value) {
-      activeConversationId.value = generateUUID();
-    }
-    const firstUser = conversation.value.find((item) => item.type === "user");
-    const titleText = firstUser && "content" in firstUser ? firstUser.content : "";
-    const title = titleText.length > 80 ? titleText.slice(0, 80) + "\u2026" : titleText;
-    try {
-      await adapter.agentConversations.upsert({
-        uuid: activeConversationId.value,
-        title,
-        clientState: JSON.stringify({
-          conversation: conversation.value.filter(
-            (item) => item.type !== "error"
-          ),
-          usageTurns: usageTurns.value
-        }),
-        serverState: JSON.stringify({
-          messages: serverState.messages,
-          activatedLazyTools: serverState.activatedLazyTools
-        }),
-        hash: serverState.hash
-      });
-    } catch (e) {
-      console.warn("[blokkli agent] Failed to save conversation:", e);
-    }
-  }
-  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 {
-        conversation: clientConversation,
-        usageTurns: parsed.usageTurns ?? [],
-        feedbackItemIds: data.feedbackItemIds ?? [],
-        serverState: {
-          messages: serverParsed.messages,
-          activatedLazyTools: serverParsed.activatedLazyTools,
-          hash: data.hash
-        }
-      };
-    } catch {
-      return null;
-    }
-  }
-  async function loadConversation(uuid) {
-    if (!adapter.agentConversations) return null;
-    try {
-      const data = await adapter.agentConversations.load(uuid);
-      if (!data) return null;
-      return parseConversationData(data);
-    } catch (e) {
-      console.warn("[blokkli agent] Failed to load conversation:", e);
-      return null;
-    }
-  }
-  async function deleteConversation(id) {
-    if (adapter.agentConversations) {
-      try {
-        await adapter.agentConversations.delete(id);
-      } catch (e) {
-        console.warn("[blokkli agent] Failed to delete conversation:", e);
-      }
-    }
-    if (activeConversationId.value === id) {
-      activeConversationId.value = null;
-      conversation.value = [];
-      activeItem.value = null;
-      isProcessing.value = false;
-      isThinking.value = false;
-      send({ type: "new_conversation" });
-    }
-    await refreshConversationList();
-  }
-  async function switchConversation(id) {
-    if (isProcessing.value) return;
-    const loaded = await loadConversation(id);
-    if (!loaded) return;
-    conversation.value = loaded.conversation;
-    usageTurns.value = loaded.usageTurns;
-    feedbackItemIds.value = new Set(loaded.feedbackItemIds);
-    activeItem.value = null;
-    activeConversationId.value = id;
-    send({ type: "restore_conversation", state: loaded.serverState });
-    showConversationList.value = false;
-  }
-  async function refreshConversationList() {
-    if (!adapter.agentConversations) {
-      conversationList.value = [];
-      return;
-    }
-    try {
-      const list = await adapter.agentConversations.list();
-      conversationList.value = list.sort(
-        (a, b) => b.updatedAt.localeCompare(a.updatedAt)
-      );
-    } catch (e) {
-      console.warn("[blokkli agent] Failed to list conversations:", e);
-      conversationList.value = [];
-    }
-  }
-  watch(isProcessing, (processing) => {
-    if (processing) {
-      ui.setTransform(agentName);
-    } else {
-      ui.setTransform(null);
-    }
-  });
-  function send(message) {
-    if (ws?.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify(message));
-    }
-  }
-  function onWebSocketOpen() {
-    isConnected.value = true;
-    reconnectAttempts = 0;
-    pingInterval = window.setInterval(() => {
-      send({ type: "ping" });
-    }, 3e4);
-    onConnect();
-  }
-  function onWebSocketClose() {
-    if (pingInterval) {
-      window.clearInterval(pingInterval);
-      pingInterval = null;
-    }
-    isConnected.value = false;
-    isReady.value = false;
-    isProcessing.value = false;
-    reconnectAttempts++;
-    if (reconnectAttempts > MAX_RECONNECT_ATTEMPTS) {
-      conversation.value.push({
-        type: "error",
-        id: generateId(),
-        errorType: "connection",
-        timestamp: Date.now()
-      });
-      return;
-    }
-    reconnectTimeout = window.setTimeout(() => {
-      if (!isConnected.value) {
-        connect();
-      }
-    }, 3e3);
-  }
-  function onWebSocketError(error) {
-    console.error("WebSocket error:", error);
-  }
-  function onWebSocketMessage(event) {
-    try {
-      const data = JSON.parse(event.data);
-      handleServerMessage(data);
-    } catch (error) {
-      console.error("Failed to parse WebSocket message:", error);
-    }
-  }
-  function connect() {
-    if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
-      return;
-    }
-    if (ws) {
-      ws.removeEventListener("open", onWebSocketOpen);
-      ws.removeEventListener("close", onWebSocketClose);
-      ws.removeEventListener("error", onWebSocketError);
-      ws.removeEventListener("message", onWebSocketMessage);
-      ws = null;
-    }
-    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-    const url = `${protocol}//${window.location.host}${routeAgent}`;
-    ws = new WebSocket(url);
-    ws.addEventListener("open", onWebSocketOpen);
-    ws.addEventListener("close", onWebSocketClose);
-    ws.addEventListener("error", onWebSocketError);
-    ws.addEventListener("message", onWebSocketMessage);
-  }
-  function disconnect() {
-    if (pingInterval) {
-      window.clearInterval(pingInterval);
-      pingInterval = null;
-    }
-    if (reconnectTimeout) {
-      window.clearTimeout(reconnectTimeout);
-      reconnectTimeout = null;
-    }
-    if (ws) {
-      ws.removeEventListener("open", onWebSocketOpen);
-      ws.removeEventListener("close", onWebSocketClose);
-      ws.removeEventListener("error", onWebSocketError);
-      ws.removeEventListener("message", onWebSocketMessage);
-      ws.close();
-      ws = null;
-    }
-    isConnected.value = false;
-    isReady.value = false;
-    ui.setTransform(null);
-    if (pendingMutation.value) {
-      if (pendingMutation.value.action.revert) {
-        pendingMutation.value.action.revert();
-      }
-      pendingMutation.value.resolve(false);
-      pendingMutation.value = null;
-    }
-    if (pendingToolCallResolve) {
-      pendingToolCallResolve({ cancelled: true });
-      pendingToolCallResolve = null;
-    }
-    pendingToolCall.value = null;
-  }
-  async function onConnect() {
-    const ctx = createToolContext();
-    const resolved = await resolveTools(mcpTools, ctx);
-    toolMap = createToolMap(resolved);
-    const toolNames = await getToolInfoForServer(
-      resolved,
-      state.editMode.value,
-      app,
-      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();
-        if (!authToken) {
-          conversation.value.push({
-            type: "error",
-            id: generateId(),
-            errorType: "unauthorized",
-            timestamp: Date.now()
-          });
-          disconnect();
-          return;
-        }
-        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);
-      }
-    }
-    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;
-    if (adapter.agentConversations && !pendingPrompt) {
-      try {
-        const latest = await adapter.agentConversations.loadLatest();
-        if (latest) {
-          const parsed = parseConversationData(latest);
-          if (parsed) {
-            activeConversationId.value = latest.uuid;
-            conversation.value = parsed.conversation;
-            usageTurns.value = parsed.usageTurns;
-            feedbackItemIds.value = new Set(parsed.feedbackItemIds);
-            send({ type: "restore_conversation", state: parsed.serverState });
-          }
-        }
-      } catch (e) {
-        console.warn("[blokkli agent] Failed to load latest conversation:", e);
-      }
-    }
-    if (pendingPrompt) {
-      const {
-        prompt,
-        displayPrompt,
-        selectedUuids,
-        attachments,
-        autoLoadTools,
-        autoLoadSkills,
-        preSeededResults,
-        autoExecuteTools
-      } = pendingPrompt;
-      pendingPrompt = null;
-      sendPrompt(
-        prompt,
-        displayPrompt,
-        selectedUuids,
-        attachments,
-        autoLoadTools,
-        autoLoadSkills,
-        preSeededResults,
-        autoExecuteTools
-      );
-    }
-  }
-  async function buildPageContext(contentSearchTabs) {
-    const { types, definitions } = app;
-    const bundles = [];
-    for (const bundle of types.generallyAvailableBundles) {
-      const contentFields = [
-        ...types.editableFieldConfig.forEntityTypeAndBundle(itemEntityType, bundle.id).filter((f) => f.type !== "table").map((f) => ({
-          name: f.name,
-          label: f.label,
-          type: f.type === "frame" || f.type === "markup" ? "markup" : "plain"
-        })),
-        ...types.droppableFieldConfig.forEntityTypeAndBundle(itemEntityType, bundle.id).map((f) => ({
-          name: f.name,
-          label: f.label,
-          type: f.type,
-          allowed: f.allowed
-        }))
-      ];
-      const paragraphFields = types.fieldConfig.forEntityTypeAndBundle(itemEntityType, bundle.id).map((f) => ({
-        name: f.name,
-        label: f.label,
-        allowedBundles: f.allowedBundles,
-        cardinality: f.cardinality
-      }));
-      bundles.push({
-        id: bundle.id,
-        label: bundle.label,
-        description: bundle.description,
-        contentFields,
-        paragraphFields
-      });
-    }
-    const fragments = definitions.fragmentDefinitions.value.map((f) => ({
-      name: f.name,
-      label: f.label,
-      description: f.description
-    }));
-    const entityContentFields = [
-      ...types.editableFieldConfig.forEntityTypeAndBundle(
-        context.value.entityType,
-        context.value.entityBundle
-      ).filter((f) => f.type !== "table").map((f) => ({
-        name: f.name,
-        label: f.label,
-        type: f.type === "frame" || f.type === "markup" ? "markup" : "plain"
-      })),
-      ...types.droppableFieldConfig.forEntityTypeAndBundle(
-        context.value.entityType,
-        context.value.entityBundle
-      ).map((f) => ({
-        name: f.name,
-        label: f.label,
-        type: f.type,
-        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, $t) : a.label,
-      description: typeof a.description === "function" ? a.description(context.value.language, $t) : a.description
-    }));
-    const pageContext = {
-      title: state.entity.value.label || "",
-      entityType: context.value.entityType,
-      entityUuid: context.value.entityUuid,
-      entityBundle: context.value.entityBundle,
-      bundleLabel: state.entity.value.bundleLabel || "",
-      itemEntityType,
-      bundles,
-      interfaceLanguage: ui.interfaceLanguage.value,
-      entityLanguage: context.value.language,
-      isPublished: state.entity.value.status ?? null,
-      editMode: state.editMode.value,
-      fragments,
-      entityContentFields,
-      ...contentSearchTabs?.length ? { contentSearchTabs } : {},
-      ...analyzersList.length ? { analyzers: analyzersList } : {}
-    };
-    return pageContext;
-  }
-  function generateId() {
-    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-  }
-  function finalizeActiveItem() {
-    const item = activeItem.value;
-    if (!item) return;
-    if (item.type === "assistant" && item.content) {
-      conversation.value.push({
-        type: "assistant",
-        id: item.id,
-        content: item.content,
-        timestamp: item.timestamp
-      });
-    }
-    activeItem.value = null;
-  }
-  function handleTextContent(content) {
-    if (activeItem.value?.type === "assistant") {
-      activeItem.value = {
-        ...activeItem.value,
-        content: activeItem.value.content + content
-      };
-    } else {
-      activeItem.value = {
-        type: "assistant",
-        id: generateId(),
-        content,
-        timestamp: Date.now()
-      };
-    }
-  }
-  function handleServerMessage(data) {
-    switch (data.type) {
-      case "authenticated":
-        if (pendingInit) {
-          sendInit(pendingInit.toolNames, pendingInit.pageContext);
-          pendingInit = null;
-        }
-        break;
-      case "thinking":
-        activeItem.value = null;
-        isThinking.value = true;
-        break;
-      case "text":
-        isThinking.value = false;
-        handleTextContent(data.content);
-        break;
-      case "text_delta":
-        isThinking.value = false;
-        handleTextContent(data.content);
-        break;
-      case "tool_call":
-        finalizeActiveItem();
-        handleToolCall(data.callId, data.tool, data.params);
-        break;
-      case "usage":
-        usageTurns.value = [...usageTurns.value, data.usage];
-        break;
-      case "done":
-        finalizeActiveItem();
-        isThinking.value = false;
-        isProcessing.value = false;
-        if (data.message) {
-          const lastItem = conversation.value[conversation.value.length - 1];
-          const isDuplicate = lastItem?.type === "assistant" && lastItem.content === data.message;
-          if (!isDuplicate) {
-            conversation.value.push({
-              type: "assistant",
-              id: generateId(),
-              content: data.message,
-              timestamp: Date.now()
-            });
-          }
-        }
-        break;
-      case "error":
-        finalizeActiveItem();
-        isThinking.value = false;
-        isProcessing.value = false;
-        if (data.detail) {
-          console.warn(`[blokkli agent] ${data.errorType} error:`, data.detail);
-        }
-        conversation.value.push({
-          type: "error",
-          id: generateId(),
-          errorType: data.errorType,
-          timestamp: Date.now(),
-          ...data.retryable ? { retryable: true } : {}
-        });
-        break;
-      case "server_tool_result":
-        finalizeActiveItem();
-        conversation.value.push({
-          type: "server_tool",
-          id: generateId(),
-          tool: data.tool,
-          label: data.label,
-          timestamp: Date.now()
-        });
-        break;
-      case "plan_update":
-        if (data.plan && data.plan.steps.length > 0 && data.plan.steps.every((s) => s.status === "completed")) {
-          conversation.value.push({
-            type: "server_tool",
-            id: generateId(),
-            tool: "plan_completed",
-            label: data.plan.title,
-            timestamp: Date.now()
-          });
-          plan.value = null;
-        } else {
-          plan.value = data.plan;
-        }
-        break;
-      case "transcript":
-        transcriptContent.value = data.transcript;
-        showTranscript.value = true;
-        break;
-      case "conversation_state":
-        saveCurrentConversation(data.state);
-        break;
-      case "conversation_restored":
-        break;
-      case "conversation_restore_failed":
-        console.warn(
-          "[blokkli agent] Conversation restore failed:",
-          data.reason
-        );
-        conversation.value = [];
-        if (activeConversationId.value) {
-          const failedId = activeConversationId.value;
-          activeConversationId.value = null;
-          if (adapter.agentConversations) {
-            adapter.agentConversations.delete(failedId).catch(() => {
-            });
-          }
-        }
-        break;
-    }
-  }
-  async function handleToolCall(callId, tool, params) {
-    const toolDef = getToolDefinition(toolMap, tool);
-    const initialLabel = toolDef.label($t);
-    const toolId = generateId();
-    const timestamp = Date.now();
-    let currentLabel = initialLabel;
-    activeItem.value = {
-      type: "tool",
-      id: toolId,
-      callId,
-      tool,
-      label: initialLabel,
-      status: "active",
-      timestamp
-    };
-    try {
-      const result = await executeToolLocally(tool, params, (label) => {
-        currentLabel = label;
-        if (activeItem.value?.type === "tool" && activeItem.value.callId === callId) {
-          activeItem.value = { ...activeItem.value, label };
-        }
-      });
-      if (isToolError(result)) {
-        conversation.value.push({
-          type: "tool",
-          id: toolId,
-          callId,
-          tool,
-          label: currentLabel,
-          status: "error",
-          timestamp
-        });
-        activeItem.value = null;
-        send({
-          type: "tool_result",
-          callId,
-          result: null,
-          error: result.error
-        });
-      } else {
-        conversation.value.push({
-          type: "tool",
-          id: toolId,
-          callId,
-          tool,
-          label: currentLabel,
-          status: "success",
-          timestamp
-        });
-        activeItem.value = null;
-        if (toolDef.buildDetails) {
-          try {
-            const detailsSource = typeof result === "object" && result !== null && "_details" in result ? result._details : result;
-            const details = toolDef.buildDetails(detailsSource);
-            if (details != null) {
-              toolDetails.set(callId, details);
-            }
-          } catch {
-          }
-        }
-        let resultForServer = result;
-        let skipLlmResponse;
-        if (typeof result === "object" && result !== null) {
-          const rec = result;
-          if ("_usage" in rec && rec._usage) {
-            usageTurns.value = [...usageTurns.value, rec._usage];
-          }
-          if (rec._skipLlmResponse === true) {
-            skipLlmResponse = true;
-          }
-          if ("_details" in rec || "_usage" in rec || "_skipLlmResponse" in rec) {
-            const {
-              _details: _,
-              _usage: __,
-              _skipLlmResponse: ___,
-              ...rest
-            } = rec;
-            resultForServer = rest;
-          }
-        }
-        if (toolDef.prunedSummary && typeof resultForServer === "object" && resultForServer !== null) {
-          try {
-            const summary = toolDef.prunedSummary(resultForServer);
-            if (summary) {
-              resultForServer = {
-                ...resultForServer,
-                _summary: summary
-              };
-            }
-          } catch {
-          }
-        }
-        send({
-          type: "tool_result",
-          callId,
-          result: resultForServer,
-          skipLlmResponse
-        });
-      }
-    } catch (error) {
-      conversation.value.push({
-        type: "tool",
-        id: toolId,
-        callId,
-        tool,
-        label: currentLabel,
-        status: "error",
-        timestamp
-      });
-      activeItem.value = null;
-      send({
-        type: "tool_result",
-        callId,
-        result: null,
-        error: error.message
-      });
-    }
-  }
-  function createToolContext() {
-    return {
-      app,
-      itemEntityType,
-      adapter,
-      pageContext: storedPageContext.value
-    };
-  }
-  async function runToolForPrompt(toolName, params) {
-    const ctx = createToolContext();
-    if (!Object.keys(toolMap).length) {
-      const resolved = await resolveTools(mcpTools, ctx);
-      toolMap = createToolMap(resolved);
-    }
-    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 };
-      pendingToolCallResolve = resolve;
-    });
-  }
-  async function executeToolLocally(toolName, params, setLabel) {
-    const toolContext = createToolContext();
-    const toolDef = getToolDefinition(toolMap, toolName);
-    if (toolDef.component) {
-      const preparedParams = await executeTool(
-        toolMap,
-        toolName,
-        toolContext,
-        params
-      );
-      if (typeof preparedParams === "object" && preparedParams !== null && "error" in preparedParams) {
-        return preparedParams;
-      }
-      const result2 = await waitForToolComponent(
-        toolDef.name,
-        preparedParams
-      );
-      if (setLabel && typeof result2 === "object" && result2 !== null && "label" in result2) {
-        setLabel(result2.label);
-      }
-      return result2;
-    }
-    const category = getToolCategory(toolMap, toolName);
-    const result = await executeTool(toolMap, toolName, toolContext, params);
-    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 result.result;
-      }
-      return result;
-    }
-    if (typeof result === "object" && result !== null && "error" in result) {
-      return result;
-    }
-    if (!isMutationAction(result)) {
-      return { error: "Invalid mutation tool result" };
-    }
-    const action = result;
-    if (setLabel) {
-      setLabel(action.label);
-    }
-    async function applyMutation() {
-      const uuidsBefore = state.getAllUuids();
-      await state.mutateWithLoadingState(() => action.apply(adapter));
-      const newUuids = state.getAllUuids().filter((uuid) => !uuidsBefore.includes(uuid));
-      const selectUuids = newUuids.length ? newUuids : action.affectedUuids || [];
-      if (selectUuids.length) {
-        app.eventBus.emit("select", selectUuids);
-        app.eventBus.emit("scrollSelectionIntoView", {});
-      }
-      return newUuids;
-    }
-    function buildMutationResult(newUuids) {
-      const newParagraphs = action.type === "add" && newUuids.length ? newUuids.map((uuid) => {
-        const block = app.blocks.getBlock(uuid);
-        if (!block) return null;
-        const blockFieldNames = app.types.fieldConfig.forEntityTypeAndBundle(itemEntityType, block.bundle).map((f) => f.name);
-        return {
-          uuid,
-          bundle: block.bundle,
-          ...blockFieldNames.length ? { paragraphFields: blockFieldNames } : {}
-        };
-      }).filter(
-        (b) => b !== null
-      ) : void 0;
-      return {
-        success: true,
-        historyIndex: state.currentMutationIndex.value,
-        newParagraphs: newParagraphs?.length ? newParagraphs : void 0,
-        ...action.result
-      };
-    }
-    if (autoApprove.value || !toolDef.requiresApproval) {
-      const newUuids = await applyMutation();
-      return buildMutationResult(newUuids);
-    }
-    const approved = await waitForApproval(action);
-    if (approved) {
-      const newUuids = await applyMutation();
-      return buildMutationResult(newUuids);
-    } else {
-      if (action.revert) {
-        action.revert();
-      }
-      return { success: false, rejected: true };
-    }
-  }
-  function waitForApproval(action) {
-    return new Promise((resolve) => {
-      pendingMutation.value = { action, resolve };
-    });
-  }
-  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,
-        autoLoadTools,
-        autoLoadSkills,
-        preSeededResults,
-        autoExecuteTools
-      };
-      return;
-    }
-    isProcessing.value = true;
-    if (!activeConversationId.value) {
-      activeConversationId.value = generateUUID();
-    }
-    conversation.value.push({
-      type: "user",
-      id: generateId(),
-      content: displayPrompt ?? prompt,
-      timestamp: Date.now(),
-      attachments: attachments?.length ? attachments : void 0
-    });
-    isThinking.value = true;
-    const isFirstMessage = conversation.value.filter((v) => v.type === "user").length === 1;
-    const hasClientDirectives = !!(autoLoadTools?.length || autoLoadSkills?.length);
-    let resolvedAutoLoadTools = autoLoadTools;
-    let resolvedAutoLoadSkills = autoLoadSkills;
-    if (isFirstMessage && !hasClientDirectives && storedPageContext.value) {
-      try {
-        const routingResult = await fetch(routeRoute, {
-          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 serverPreSeeded = preSeededResults?.length ? preSeededResults.map(({ toolName, params, result }) => ({
-      toolName,
-      params,
-      result
-    })) : void 0;
-    send({
-      type: "start",
-      prompt,
-      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() {
-    if (isProcessing.value || !isReady.value) return;
-    const lastUserItem = [...conversation.value].reverse().find((item) => item.type === "user");
-    if (!lastUserItem || lastUserItem.type !== "user") return;
-    conversation.value = conversation.value.filter(
-      (item) => !(item.type === "error" && "retryable" in item && item.retryable)
-    );
-    isProcessing.value = true;
-    send({
-      type: "start",
-      prompt: lastUserItem.content
-    });
-  }
-  function approve() {
-    if (pendingMutation.value) {
-      pendingMutation.value.resolve(true);
-      pendingMutation.value = null;
-    }
-  }
-  function reject() {
-    if (pendingMutation.value) {
-      pendingMutation.value.resolve(false);
-      pendingMutation.value = null;
-    }
-  }
-  function setAutoApprove(value) {
-    autoApprove.value = value;
-    if (value) {
-      approve();
-    }
-  }
-  function cancel() {
-    if (pendingMutation.value) {
-      pendingMutation.value.resolve(false);
-      pendingMutation.value = null;
-    }
-    if (pendingToolCallResolve) {
-      pendingToolCallResolve({ cancelled: true });
-      pendingToolCallResolve = null;
-    }
-    pendingToolCall.value = null;
-    activeItem.value = null;
-    send({ type: "cancel" });
-    isProcessing.value = false;
-    conversation.value.push({
-      type: "assistant",
-      id: generateId(),
-      content: $t("aiAgentCancelled", "Cancelled"),
-      timestamp: Date.now()
-    });
-  }
-  function approvePlan() {
-    send({ type: "plan_approve" });
-  }
-  function rejectPlan() {
-    send({ type: "plan_reject" });
-  }
-  function newConversation() {
-    if (pendingMutation.value) {
-      pendingMutation.value.resolve(false);
-      pendingMutation.value = null;
-    }
-    if (pendingToolCallResolve) {
-      pendingToolCallResolve({ cancelled: true });
-      pendingToolCallResolve = null;
-    }
-    pendingToolCall.value = null;
-    conversation.value = [];
-    activeItem.value = null;
-    isProcessing.value = false;
-    isThinking.value = false;
-    activeConversationId.value = null;
-    plan.value = null;
-    usageTurns.value = [];
-    feedbackItemIds.value = /* @__PURE__ */ new Set();
-    toolDetails.clear();
-    send({ type: "new_conversation" });
-  }
-  function getTranscript() {
-    send({ type: "get_transcript" });
-  }
-  function onToolComponentDone(result) {
-    if (pendingToolCallResolve) {
-      pendingToolCallResolve(result);
-      pendingToolCallResolve = null;
-    }
-    pendingToolCall.value = null;
-  }
-  return {
-    // Connection state
-    isConnected: readonly(isConnected),
-    isReady: readonly(isReady),
-    hasBeenReady: readonly(hasBeenReady),
-    connect,
-    disconnect,
-    // Conversation state
-    conversation,
-    activeItem,
-    isProcessing,
-    isThinking,
-    // Mutation/tool approval state
-    autoApprove,
-    pendingMutation,
-    pendingToolCall,
-    // Plan state
-    plan,
-    approvePlan,
-    rejectPlan,
-    // Token usage
-    usageTurns,
-    // Actions
-    sendPrompt,
-    runToolForPrompt,
-    retry,
-    approve,
-    reject,
-    setAutoApprove,
-    cancel,
-    newConversation,
-    getTranscript,
-    onToolComponentDone,
-    // Tool details (ephemeral)
-    toolDetails,
-    // Transcript dialog state
-    transcriptContent,
-    showTranscript,
-    // Conversation list
-    conversationList,
-    showConversationList,
-    activeConversationId: readonly(activeConversationId),
-    switchConversation,
-    deleteConversation,
-    refreshConversationList,
-    // Feedback
-    feedbackItemIds,
-    // Page context (built once during connection)
-    pageContext: storedPageContext
-  };
-}