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

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

@@ -0,0 +1,110 @@
+import { ref, readonly } from "#imports";
+import { routeAgent } from "#blokkli-build/agent-client";
+const PING_INTERVAL_MS = 3e4;
+const RECONNECT_DELAY_MS = 3e3;
+const MAX_RECONNECT_ATTEMPTS = 10;
+export default function socketProvider() {
+  let ws = null;
+  let pingInterval = null;
+  let reconnectTimeout = null;
+  let reconnectAttempts = 0;
+  const isConnected = ref(false);
+  let messageHandler = null;
+  let lifecycle = {};
+  function setMessageHandler(handler) {
+    messageHandler = handler;
+  }
+  function setLifecycleHandlers(handlers) {
+    lifecycle = handlers;
+  }
+  function send(message) {
+    if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(message));
+    }
+  }
+  function detachListeners(socket) {
+    socket.removeEventListener("open", onWebSocketOpen);
+    socket.removeEventListener("close", onWebSocketClose);
+    socket.removeEventListener("error", onWebSocketError);
+    socket.removeEventListener("message", onWebSocketMessage);
+  }
+  function clearTimers() {
+    if (pingInterval) {
+      window.clearInterval(pingInterval);
+      pingInterval = null;
+    }
+    if (reconnectTimeout) {
+      window.clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+  }
+  function onWebSocketOpen() {
+    isConnected.value = true;
+    reconnectAttempts = 0;
+    pingInterval = window.setInterval(() => {
+      send({ type: "ping" });
+    }, PING_INTERVAL_MS);
+    lifecycle.onOpen?.();
+  }
+  function onWebSocketClose() {
+    if (pingInterval) {
+      window.clearInterval(pingInterval);
+      pingInterval = null;
+    }
+    isConnected.value = false;
+    lifecycle.onClose?.();
+    reconnectAttempts++;
+    if (reconnectAttempts > MAX_RECONNECT_ATTEMPTS) {
+      lifecycle.onMaxReconnects?.();
+      return;
+    }
+    reconnectTimeout = window.setTimeout(() => {
+      if (!isConnected.value) connect();
+    }, RECONNECT_DELAY_MS);
+  }
+  function onWebSocketError(error) {
+    console.error("WebSocket error:", error);
+    lifecycle.onError?.(error);
+  }
+  function onWebSocketMessage(event) {
+    try {
+      const data = JSON.parse(event.data);
+      messageHandler?.(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) {
+      detachListeners(ws);
+      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() {
+    clearTimers();
+    if (ws) {
+      detachListeners(ws);
+      ws.close();
+      ws = null;
+    }
+    isConnected.value = false;
+  }
+  return {
+    isConnected: readonly(isConnected),
+    send,
+    connect,
+    disconnect,
+    setMessageHandler,
+    setLifecycleHandlers
+  };
+}

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

@@ -0,0 +1,44 @@
+import { type Ref } from '#imports';
+import type { MutationAction } from '#blokkli/agent/app/types';
+import type { PageContext } from '#blokkli/agent/shared/types';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
+import type { AgentToolName, AgentToolMap } from '#blokkli-build/agent-client';
+import type { SocketProvider } from './socketProvider.js';
+import type { ConversationProvider } from './conversationProvider.js';
+export type PendingMutationState = {
+    action: MutationAction;
+    resolve: (approved: boolean) => void;
+};
+export type PendingToolCall = {
+    toolName: string;
+    params: Record<string, unknown>;
+};
+export type ToolsProvider = {
+    pendingMutation: Ref<PendingMutationState | null>;
+    pendingToolCall: Ref<PendingToolCall | null>;
+    autoApprove: Ref<boolean>;
+    pageContext: Readonly<Ref<PageContext | null>>;
+    init: () => Promise<{
+        toolNames: string[];
+    }>;
+    setPageContext: (ctx: PageContext) => void;
+    dispatch: (callId: string, tool: string, params: Record<string, unknown>) => Promise<void>;
+    runForPrompt: <T extends AgentToolName>(toolName: T, params: AgentToolMap[T]['params']) => Promise<{
+        toolName: T;
+        params: AgentToolMap[T]['params'];
+        result: AgentToolMap[T]['result'];
+        label: string;
+    }>;
+    approve: () => void;
+    reject: () => void;
+    setAutoApprove: (value: boolean) => void;
+    onComponentDone: (result: unknown) => void;
+    cancelPending: () => void;
+};
+export default function toolsProvider({ app, adapter, socket, conversation, }: {
+    app: BlokkliApp;
+    adapter: FullBlokkliAdapter<any>;
+    socket: SocketProvider;
+    conversation: ConversationProvider;
+}): ToolsProvider;

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

@@ -0,0 +1,298 @@
+import { ref, shallowRef, readonly } from "#imports";
+import {
+  createToolMap,
+  executeTool,
+  getToolCategory,
+  getToolDefinition,
+  getToolInfoForServer,
+  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)}`;
+}
+export default function toolsProvider({
+  app,
+  adapter,
+  socket,
+  conversation
+}) {
+  const { $t, state } = app;
+  const pendingMutation = ref(null);
+  const pendingToolCall = ref(null);
+  const autoApprove = ref(false);
+  const pageContext = shallowRef(null);
+  let toolMap = {};
+  let pendingToolCallResolve = null;
+  function createToolContext() {
+    return {
+      app,
+      itemEntityType,
+      adapter,
+      pageContext: pageContext.value
+    };
+  }
+  async function init() {
+    const ctx = createToolContext();
+    const resolved = await resolveTools(mcpTools, ctx);
+    toolMap = createToolMap(resolved);
+    const toolNames = await getToolInfoForServer(
+      resolved,
+      state.editMode.value,
+      app,
+      adapter
+    );
+    return { toolNames };
+  }
+  function setPageContext(ctx) {
+    pageContext.value = ctx;
+  }
+  function waitForToolComponent(toolName, params) {
+    return new Promise((resolve) => {
+      pendingToolCall.value = { toolName, params };
+      pendingToolCallResolve = resolve;
+    });
+  }
+  function waitForApproval(action) {
+    return new Promise((resolve) => {
+      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 };
+    }
+    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: {} };
+      }
+      return { ok: true, result, meta: {} };
+    }
+    if (!isMutationAction(result)) {
+      return { ok: false, 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 { ok: true, result: buildMutationResult(newUuids), meta: {} };
+    }
+    const approved = await waitForApproval(action);
+    if (approved) {
+      const newUuids = await applyMutation();
+      return { ok: true, result: buildMutationResult(newUuids), meta: {} };
+    }
+    if (action.revert) action.revert();
+    return { ok: true, result: { success: false, rejected: true }, meta: {} };
+  }
+  async function dispatch(callId, tool, params) {
+    const toolDef = getToolDefinition(toolMap, tool);
+    const initialLabel = toolDef.label($t);
+    const toolId = generateId();
+    const timestamp = Date.now();
+    let currentLabel = initialLabel;
+    conversation.setActive({
+      type: "tool",
+      id: toolId,
+      callId,
+      tool,
+      label: initialLabel,
+      status: "active",
+      timestamp
+    });
+    function finishItem(status) {
+      conversation.pushTool({
+        type: "tool",
+        id: toolId,
+        callId,
+        tool,
+        label: currentLabel,
+        status,
+        timestamp
+      });
+      conversation.setActive(null);
+    }
+    try {
+      const outcome = await executeLocally(tool, params, (label) => {
+        currentLabel = label;
+        const active = conversation.activeItem.value;
+        if (active?.type === "tool" && active.callId === callId) {
+          conversation.setActive({ ...active, label });
+        }
+      });
+      if (!outcome.ok) {
+        finishItem("error");
+        socket.send({
+          type: "tool_result",
+          callId,
+          result: null,
+          error: outcome.error
+        });
+        return;
+      }
+      finishItem("success");
+      if (toolDef.buildDetails) {
+        try {
+          const detailsSource = outcome.meta.details ?? outcome.result;
+          const details = toolDef.buildDetails(detailsSource);
+          if (details != null) {
+            conversation.setToolDetail(callId, details);
+          }
+        } catch {
+        }
+      }
+      if (outcome.meta.usage) {
+        conversation.pushUsage(outcome.meta.usage);
+      }
+      let resultForServer = outcome.result;
+      const resultObj = asRecord(resultForServer);
+      if (toolDef.prunedSummary && resultObj) {
+        try {
+          const summary = toolDef.prunedSummary(resultObj);
+          if (summary) {
+            resultForServer = { ...resultObj, _summary: summary };
+          }
+        } catch {
+        }
+      }
+      socket.send({
+        type: "tool_result",
+        callId,
+        result: resultForServer,
+        skipLlmResponse: outcome.meta.skipLlmResponse
+      });
+    } catch (error) {
+      finishItem("error");
+      socket.send({
+        type: "tool_result",
+        callId,
+        result: null,
+        error: error.message
+      });
+    }
+  }
+  async function runForPrompt(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 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 onComponentDone(result) {
+    if (pendingToolCallResolve) {
+      pendingToolCallResolve(result);
+      pendingToolCallResolve = null;
+    }
+    pendingToolCall.value = null;
+  }
+  function cancelPending() {
+    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;
+  }
+  return {
+    pendingMutation,
+    pendingToolCall,
+    autoApprove,
+    pageContext: readonly(pageContext),
+    init,
+    setPageContext,
+    dispatch,
+    runForPrompt,
+    approve,
+    reject,
+    setAutoApprove,
+    onComponentDone,
+    cancelPending
+  };
+}

package/dist/modules/agent/runtime/app/types/index.d.ts

@@ -1,6 +1,7 @@
 import type { BlokkliApp } from '#blokkli/editor/types/app';
 import type { FullBlokkliAdapter, MutationResponseLike, AdapterMethods } from '#blokkli/editor/adapter';
 import type { EditMode } from '#blokkli/editor/types/state';
+import { type UsageTurn } from '#blokkli/agent/shared/types';
 import { z } from 'zod';
 import type { Component } from 'vue';
 import type { AgentToolName, AgentSkillName, AgentToolMap } from '#blokkli-build/agent-client';
@@ -55,6 +56,52 @@ export type QueryResult<T = unknown> = {
 export type ToolError = {
     error: string;
 };
+/**
+ * Side-channel data that interactive tool components can attach to their
+ * emitted result alongside the LLM-facing payload. The provider strips
+ * these underscore-prefixed properties at the boundary so they never reach
+ * the server: `details` feeds `buildDetails()`, `usage` is folded into the
+ * conversation usage display, and `skipLlmResponse` ends the agent loop
+ * without an LLM reply when the user fully accepted the changes.
+ */
+export type ToolMeta = {
+    details?: unknown;
+    usage?: UsageTurn;
+    skipLlmResponse?: boolean;
+};
+/**
+ * Shape an interactive tool component emits: the LLM-facing payload merged
+ * with optional side-channel metadata. Components can use this to type
+ * their `emit('done', ...)` payloads in a single place.
+ */
+export type ComponentToolResult<T = Record<string, unknown>> = T & {
+    _details?: ToolMeta['details'];
+    _usage?: ToolMeta['usage'];
+    _skipLlmResponse?: ToolMeta['skipLlmResponse'];
+};
+/**
+ * Discriminated outcome returned by `executeToolLocally`. Callers branch
+ * on `ok` instead of runtime-checking the shape of an `unknown` result.
+ */
+export type ToolOutcome = {
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    result: unknown;
+    meta: ToolMeta;
+};
+/**
+ * Hierarchical API surface exposed via `provide(INJECT_AGENT_APP, ...)`.
+ * Mirrors `BlokkliApp` for the editor — each member is a provider, and the
+ * orchestrator's flat state/actions sit at the top level.
+ */
+export type AgentApp = {
+    socket: import('../providers/socketProvider').SocketProvider;
+    conversation: import('../providers/conversationProvider').ConversationProvider;
+    plan: import('../providers/planProvider').PlanProvider;
+    tools: import('../providers/toolsProvider').ToolsProvider;
+} & import('../providers/agentProvider').AgentOrchestrator;
 /**
  * Makes specified adapter methods required (non-optional).
  */

package/dist/modules/agent/runtime/app/types/index.js

@@ -1,4 +1,6 @@
-import { agentErrorTypeSchema } from "#blokkli/agent/shared/types";
+import {
+  agentErrorTypeSchema
+} from "#blokkli/agent/shared/types";
 import { z } from "zod";
 const conversationItemBase = z.object({
   id: z.string(),

package/dist/modules/agent/runtime/server/helpers.js

@@ -197,6 +197,7 @@ export function pruneMessages(messages, keepRecentTurns, toolMetadata) {
       }
       continue;
     }
+    const hasToolResult = content.some((b) => b.type === "tool_result");
     for (let j = content.length - 1; j >= 0; j--) {
       const block = content[j];
       if (block.type === "tool_result") {
@@ -207,7 +208,7 @@ export function pruneMessages(messages, keepRecentTurns, toolMetadata) {
         } else {
           block.content = compressToolResult(block.content);
         }
-      } else if (block.type === "text" || block.type === "skill") {
+      } else if (hasToolResult && (block.type === "text" || block.type === "skill")) {
         content.splice(j, 1);
       }
     }

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

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

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

@@ -1,4 +1,4 @@
-import { B as BlokkliModule } from '../../shared/editor.BTOBvmaz.mjs';
+import { B as BlokkliModule } from '../../shared/editor.Bpw1EP57.mjs';
 import 'nuxt/schema';
 import 'consola';
 import '../../../dist/global/types/definitions.js';
@@ -14,7 +14,7 @@ declare const _default: (options?: {
      * template entity.
      */
     templateEditRouteName?: string;
-}) => BlokkliModule<{
+} | undefined) => BlokkliModule<{
     /**
      * The name of the route that is used for editing template entities.
      *

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

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

package/dist/modules/index.d.mts

@@ -1,4 +1,4 @@
-export { b as Blokkli, B as BlokkliModule, d as defineBlokkliModule } from '../shared/editor.BTOBvmaz.mjs';
+export { b as Blokkli, B as BlokkliModule, d as defineBlokkliModule } from '../shared/editor.Bpw1EP57.mjs';
 import 'nuxt/schema';
 import 'consola';
 import '../../dist/global/types/definitions.js';

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

@@ -1,4 +1,4 @@
-import { B as BlokkliModule } from '../../shared/editor.BTOBvmaz.mjs';
+import { B as BlokkliModule } from '../../shared/editor.Bpw1EP57.mjs';
 import 'nuxt/schema';
 import 'consola';
 import '../../../dist/global/types/definitions.js';
@@ -6,6 +6,6 @@ import '../../../dist/global/types/theme.js';
 import '@nuxt/kit';
 import '../../../dist/global/types/features.js';
 
-declare const _default: (options?: object) => BlokkliModule<object>;
+declare const _default: (options?: object | undefined) => BlokkliModule<object>;
 
 export { _default as default };

package/dist/modules/table-of-contents/index.d.mts

@@ -1,4 +1,4 @@
-import { B as BlokkliModule } from '../../shared/editor.BTOBvmaz.mjs';
+import { B as BlokkliModule } from '../../shared/editor.Bpw1EP57.mjs';
 import 'nuxt/schema';
 import 'consola';
 import '../../../dist/global/types/definitions.js';
@@ -6,6 +6,6 @@ import '../../../dist/global/types/theme.js';
 import '@nuxt/kit';
 import '../../../dist/global/types/features.js';
 
-declare const _default: (options?: object) => BlokkliModule<object>;
+declare const _default: (options?: object | undefined) => BlokkliModule<object>;
 
 export { _default as default };