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

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

@@ -0,0 +1,315 @@
+import { ref, watch } from "#imports";
+import { routeRoute } from "#blokkli-build/agent-client";
+import { buildPageContext } from "#blokkli/agent/app/helpers/buildPageContext";
+export default function agentProvider({
+  app,
+  adapter,
+  agentName,
+  socket,
+  conversation,
+  plan,
+  tools
+}) {
+  const { ui } = app;
+  const isReady = ref(false);
+  const hasBeenReady = ref(false);
+  const isProcessing = ref(false);
+  const isThinking = ref(false);
+  let pendingPrompt = null;
+  let pendingInit = null;
+  let sentToolNames = [];
+  watch(isProcessing, (processing) => {
+    ui.setTransform(processing ? agentName : null);
+  });
+  function resetActivityFlags() {
+    isProcessing.value = false;
+    isThinking.value = false;
+  }
+  function teardown() {
+    isReady.value = false;
+    resetActivityFlags();
+    ui.setTransform(null);
+    tools.cancelPending();
+  }
+  function connect() {
+    socket.connect();
+  }
+  function disconnect() {
+    socket.disconnect();
+    teardown();
+  }
+  async function onSocketOpen() {
+    const { toolNames } = await tools.init();
+    sentToolNames = toolNames;
+    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.pushError({ errorType: "unauthorized" });
+          disconnect();
+          return;
+        }
+        const pageContext2 = await buildPageContext(app, contentSearchTabs);
+        tools.setPageContext(pageContext2);
+        pendingInit = { toolNames, pageContext: pageContext2 };
+        socket.send({ type: "authenticate", authToken });
+        return;
+      } catch (e) {
+        console.error("Failed to obtain agent auth token:", e);
+      }
+    }
+    const pageContext = await buildPageContext(app, contentSearchTabs);
+    tools.setPageContext(pageContext);
+    sendInit(toolNames, pageContext);
+  }
+  async function sendInit(toolNames, pageContext) {
+    socket.send({ type: "init", toolNames, pageContext });
+    isReady.value = true;
+    hasBeenReady.value = true;
+    if (adapter.agentConversations && !pendingPrompt) {
+      const latest = await conversation.loadLatestFromAdapter();
+      if (latest) {
+        conversation.activeConversationId.value = latest.uuid;
+        conversation.applyRestoredData(latest.parsed);
+        socket.send({
+          type: "restore_conversation",
+          state: latest.parsed.serverState
+        });
+      }
+    }
+    if (pendingPrompt) {
+      const queued = pendingPrompt;
+      pendingPrompt = null;
+      sendPrompt(
+        queued.prompt,
+        queued.displayPrompt,
+        queued.selectedUuids,
+        queued.attachments,
+        queued.autoLoadTools,
+        queued.autoLoadSkills,
+        queued.preSeededResults,
+        queued.autoExecuteTools
+      );
+    }
+  }
+  function handleServerMessage(data) {
+    switch (data.type) {
+      case "authenticated":
+        if (pendingInit) {
+          sendInit(pendingInit.toolNames, pendingInit.pageContext);
+          pendingInit = null;
+        }
+        break;
+      case "thinking":
+        conversation.setActive(null);
+        isThinking.value = true;
+        break;
+      case "text":
+      case "text_delta":
+        isThinking.value = false;
+        conversation.appendToActive(data.content);
+        break;
+      case "tool_call":
+        conversation.finalizeActive();
+        tools.dispatch(data.callId, data.tool, data.params);
+        break;
+      case "usage":
+        conversation.pushUsage(data.usage);
+        break;
+      case "done":
+        conversation.finalizeActive();
+        resetActivityFlags();
+        if (data.message) {
+          conversation.pushAssistantUnlessDuplicate(data.message);
+        }
+        break;
+      case "error":
+        conversation.finalizeActive();
+        resetActivityFlags();
+        if (data.detail) {
+          console.warn(`[blokkli agent] ${data.errorType} error:`, data.detail);
+        }
+        conversation.pushError({
+          errorType: data.errorType,
+          retryable: data.retryable
+        });
+        break;
+      case "server_tool_result":
+        conversation.finalizeActive();
+        conversation.pushServerTool({ tool: data.tool, label: data.label });
+        break;
+      case "plan_update":
+        plan.applyUpdate(data.plan);
+        break;
+      case "transcript":
+        conversation.setTranscript(data.transcript);
+        break;
+      case "conversation_state":
+        conversation.saveToAdapter(data.state);
+        break;
+      case "conversation_restored":
+        break;
+      case "conversation_restore_failed": {
+        console.warn(
+          "[blokkli agent] Conversation restore failed:",
+          data.reason
+        );
+        const failedId = conversation.activeConversationId.value;
+        conversation.clearAll();
+        if (failedId) {
+          conversation.deleteFromAdapter(failedId).catch(() => {
+          });
+        }
+        break;
+      }
+    }
+  }
+  socket.setMessageHandler(handleServerMessage);
+  socket.setLifecycleHandlers({
+    onOpen: () => {
+      onSocketOpen();
+    },
+    onClose: teardown,
+    onMaxReconnects: () => {
+      conversation.pushError({ errorType: "connection" });
+    }
+  });
+  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;
+    conversation.ensureConversationId();
+    conversation.pushUser(displayPrompt ?? prompt, attachments);
+    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 serverPreSeeded = preSeededResults?.length ? preSeededResults.map(({ toolName, params, result }) => ({
+      toolName,
+      params,
+      result
+    })) : void 0;
+    socket.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.items.value].reverse().find((item) => item.type === "user");
+    if (!lastUserItem || lastUserItem.type !== "user") return;
+    conversation.items.value = conversation.items.value.filter(
+      (item) => !(item.type === "error" && "retryable" in item && item.retryable)
+    );
+    isProcessing.value = true;
+    socket.send({ type: "start", prompt: lastUserItem.content });
+  }
+  function cancel() {
+    tools.cancelPending();
+    conversation.setActive(null);
+    socket.send({ type: "cancel" });
+    resetActivityFlags();
+    conversation.pushAssistant(app.$t("aiAgentCancelled", "Cancelled"));
+  }
+  function newConversation() {
+    tools.cancelPending();
+    conversation.clearAll();
+    plan.clear();
+    resetActivityFlags();
+    socket.send({ type: "new_conversation" });
+  }
+  function getTranscript() {
+    socket.send({ type: "get_transcript" });
+  }
+  async function switchConversation(id) {
+    if (isProcessing.value) return;
+    const parsed = await conversation.loadFromAdapter(id);
+    if (!parsed) return;
+    conversation.applyRestoredData(parsed);
+    conversation.activeConversationId.value = id;
+    socket.send({ type: "restore_conversation", state: parsed.serverState });
+    conversation.showConversationList.value = false;
+  }
+  async function deleteConversation(id) {
+    await conversation.deleteFromAdapter(id);
+    if (conversation.activeConversationId.value === id) {
+      conversation.clearAll();
+      resetActivityFlags();
+      socket.send({ type: "new_conversation" });
+    }
+    await conversation.refreshList();
+  }
+  return {
+    isReady,
+    hasBeenReady,
+    isProcessing,
+    isThinking,
+    connect,
+    disconnect,
+    sendPrompt,
+    retry,
+    cancel,
+    newConversation,
+    getTranscript,
+    switchConversation,
+    deleteConversation,
+    refreshConversationList: conversation.refreshList
+  };
+}

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

@@ -0,0 +1,50 @@
+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 { ConversationStateSnapshot, UsageTurn, Transcript } from '#blokkli/agent/shared/types';
+import type { AgentConversationData, AgentConversationSummary } 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[];
+};
+export type ConversationProvider = {
+    items: Ref<ConversationItem[]>;
+    activeItem: Ref<ActiveItem | null>;
+    usageTurns: Ref<UsageTurn[]>;
+    feedbackItemIds: Ref<Set<string>>;
+    toolDetails: Map<string, unknown>;
+    activeConversationId: Ref<string | null>;
+    conversationList: Ref<AgentConversationSummary[]>;
+    showConversationList: Ref<boolean>;
+    transcriptContent: Ref<Transcript | null>;
+    showTranscript: Ref<boolean>;
+    pushUser: (content: string, attachments?: Attachment[]) => void;
+    appendToActive: (text: string) => void;
+    setActive: (item: ActiveItem | null) => void;
+    finalizeActive: () => void;
+    pushAssistant: (content: string) => void;
+    pushAssistantUnlessDuplicate: (content: string) => void;
+    pushTool: (item: ToolConversationItem) => void;
+    pushServerTool: (item: Pick<ServerToolConversationItem, 'tool' | 'label'>) => void;
+    pushError: (item: Pick<ErrorConversationItem, 'errorType' | 'retryable'>) => void;
+    pushUsage: (turn: UsageTurn) => void;
+    setToolDetail: (callId: string, details: unknown) => void;
+    clearAll: () => void;
+    ensureConversationId: () => string;
+    setTranscript: (transcript: Transcript) => void;
+    applyRestoredData: (parsed: ParsedConversation) => void;
+    parseFromAdapter: (data: AgentConversationData) => ParsedConversation | null;
+    saveToAdapter: (serverState: ConversationStateSnapshot) => Promise<void>;
+    loadFromAdapter: (uuid: string) => Promise<ParsedConversation | null>;
+    loadLatestFromAdapter: () => Promise<{
+        parsed: ParsedConversation;
+        uuid: string;
+    } | null>;
+    deleteFromAdapter: (uuid: string) => Promise<void>;
+    refreshList: () => Promise<void>;
+};
+export default function conversationProvider({ adapter, }: {
+    adapter: FullBlokkliAdapter<any>;
+}): ConversationProvider;

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

@@ -0,0 +1,263 @@
+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)}`;
+}
+export default function conversationProvider({
+  adapter
+}) {
+  const items = ref([]);
+  const activeItem = ref(null);
+  const usageTurns = ref([]);
+  const feedbackItemIds = ref(/* @__PURE__ */ new Set());
+  const toolDetails = reactive(/* @__PURE__ */ new Map());
+  const activeConversationId = ref(null);
+  const conversationList = ref([]);
+  const showConversationList = ref(false);
+  const transcriptContent = ref(null);
+  const showTranscript = ref(false);
+  function pushUser(content, attachments) {
+    items.value.push({
+      type: "user",
+      id: generateId(),
+      content,
+      timestamp: Date.now(),
+      attachments: attachments?.length ? attachments : void 0
+    });
+  }
+  function appendToActive(text) {
+    if (activeItem.value?.type === "assistant") {
+      activeItem.value = {
+        ...activeItem.value,
+        content: activeItem.value.content + text
+      };
+    } else {
+      activeItem.value = {
+        type: "assistant",
+        id: generateId(),
+        content: text,
+        timestamp: Date.now()
+      };
+    }
+  }
+  function setActive(item) {
+    activeItem.value = item;
+  }
+  function finalizeActive() {
+    const item = activeItem.value;
+    if (!item) return;
+    if (item.type === "assistant" && item.content) {
+      const finalized = {
+        type: "assistant",
+        id: item.id,
+        content: item.content,
+        timestamp: item.timestamp
+      };
+      items.value.push(finalized);
+    }
+    activeItem.value = null;
+  }
+  function pushAssistant(content) {
+    items.value.push({
+      type: "assistant",
+      id: generateId(),
+      content,
+      timestamp: Date.now()
+    });
+  }
+  function pushAssistantUnlessDuplicate(content) {
+    const last = items.value[items.value.length - 1];
+    if (last?.type === "assistant" && last.content === content) return;
+    pushAssistant(content);
+  }
+  function pushTool(item) {
+    items.value.push(item);
+  }
+  function pushServerTool(item) {
+    items.value.push({
+      type: "server_tool",
+      id: generateId(),
+      timestamp: Date.now(),
+      tool: item.tool,
+      label: item.label
+    });
+  }
+  function pushError(item) {
+    items.value.push({
+      type: "error",
+      id: generateId(),
+      timestamp: Date.now(),
+      errorType: item.errorType,
+      ...item.retryable ? { retryable: true } : {}
+    });
+  }
+  function pushUsage(turn) {
+    usageTurns.value = [...usageTurns.value, turn];
+  }
+  function setToolDetail(callId, details) {
+    toolDetails.set(callId, details);
+  }
+  function clearAll() {
+    items.value = [];
+    activeItem.value = null;
+    activeConversationId.value = null;
+    usageTurns.value = [];
+    feedbackItemIds.value = /* @__PURE__ */ new Set();
+    toolDetails.clear();
+  }
+  function ensureConversationId() {
+    if (!activeConversationId.value) {
+      activeConversationId.value = generateUUID();
+    }
+    return activeConversationId.value;
+  }
+  function setTranscript(transcript) {
+    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;
+    }
+  }
+  function applyRestoredData(parsed) {
+    items.value = parsed.conversation;
+    usageTurns.value = parsed.usageTurns;
+    feedbackItemIds.value = new Set(parsed.feedbackItemIds);
+    activeItem.value = null;
+  }
+  async function saveToAdapter(serverState) {
+    if (!adapter.agentConversations) return;
+    if (!items.value.length) return;
+    const id = ensureConversationId();
+    const firstUser = items.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: id,
+        title,
+        clientState: JSON.stringify({
+          conversation: items.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);
+    }
+  }
+  async function loadFromAdapter(uuid) {
+    if (!adapter.agentConversations) return null;
+    try {
+      const data = await adapter.agentConversations.load(uuid);
+      if (!data) return null;
+      return parseFromAdapter(data);
+    } catch (e) {
+      console.warn("[blokkli agent] Failed to load conversation:", e);
+      return null;
+    }
+  }
+  async function loadLatestFromAdapter() {
+    if (!adapter.agentConversations) return null;
+    try {
+      const latest = await adapter.agentConversations.loadLatest();
+      if (!latest) return null;
+      const parsed = parseFromAdapter(latest);
+      if (!parsed) return null;
+      return { parsed, uuid: latest.uuid };
+    } catch (e) {
+      console.warn("[blokkli agent] Failed to load latest conversation:", e);
+      return null;
+    }
+  }
+  async function deleteFromAdapter(uuid) {
+    if (!adapter.agentConversations) return;
+    try {
+      await adapter.agentConversations.delete(uuid);
+    } catch (e) {
+      console.warn("[blokkli agent] Failed to delete conversation:", e);
+    }
+  }
+  async function refreshList() {
+    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 = [];
+    }
+  }
+  return {
+    items,
+    activeItem,
+    usageTurns,
+    feedbackItemIds,
+    toolDetails,
+    activeConversationId,
+    conversationList,
+    showConversationList,
+    transcriptContent,
+    showTranscript,
+    pushUser,
+    appendToActive,
+    setActive,
+    finalizeActive,
+    pushAssistant,
+    pushAssistantUnlessDuplicate,
+    pushTool,
+    pushServerTool,
+    pushError,
+    pushUsage,
+    setToolDetail,
+    clearAll,
+    ensureConversationId,
+    setTranscript,
+    applyRestoredData,
+    parseFromAdapter,
+    saveToAdapter,
+    loadFromAdapter,
+    loadLatestFromAdapter,
+    deleteFromAdapter,
+    refreshList
+  };
+}

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

@@ -0,0 +1,15 @@
+import { type Ref } from '#imports';
+import type { ClientPlanState } from '#blokkli/agent/shared/types';
+import type { SocketProvider } from './socketProvider.js';
+import type { ConversationProvider } from './conversationProvider.js';
+export type PlanProvider = {
+    plan: Ref<ClientPlanState | null>;
+    approve: () => void;
+    reject: () => void;
+    applyUpdate: (state: ClientPlanState | null) => void;
+    clear: () => void;
+};
+export default function planProvider({ socket, conversation, }: {
+    socket: SocketProvider;
+    conversation: ConversationProvider;
+}): PlanProvider;

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

@@ -0,0 +1,34 @@
+import { ref } from "#imports";
+export default function planProvider({
+  socket,
+  conversation
+}) {
+  const plan = ref(null);
+  function approve() {
+    socket.send({ type: "plan_approve" });
+  }
+  function reject() {
+    socket.send({ type: "plan_reject" });
+  }
+  function applyUpdate(state) {
+    if (state && state.steps.length > 0 && state.steps.every((s) => s.status === "completed")) {
+      conversation.pushServerTool({
+        tool: "plan_completed",
+        label: state.title
+      });
+      plan.value = null;
+      return;
+    }
+    plan.value = state;
+  }
+  function clear() {
+    plan.value = null;
+  }
+  return {
+    plan,
+    approve,
+    reject,
+    applyUpdate,
+    clear
+  };
+}

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

@@ -0,0 +1,17 @@
+import { type Ref } from '#imports';
+import type { ClientMessage, ServerMessage } from '#blokkli/agent/shared/types';
+export type SocketLifecycleHandlers = {
+    onOpen?: () => void;
+    onClose?: () => void;
+    onError?: (e: Event) => void;
+    onMaxReconnects?: () => void;
+};
+export type SocketProvider = {
+    isConnected: Readonly<Ref<boolean>>;
+    send: (msg: ClientMessage) => void;
+    connect: () => void;
+    disconnect: () => void;
+    setMessageHandler: (handler: (data: ServerMessage) => void) => void;
+    setLifecycleHandlers: (handlers: SocketLifecycleHandlers) => void;
+};
+export default function socketProvider(): SocketProvider;