@blokkli/editor 2.0.0-alpha.32 → 2.0.0-alpha.33

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

@@ -0,0 +1,875 @@
+import { ref, readonly, watch } from "#imports";
+import {
+  conversationItemSchema
+} from "#blokkli/agent/app/types";
+import {
+  createToolMap,
+  executeTool,
+  getToolCategory,
+  getToolsForServer,
+  getToolDefinition,
+  isMutationAction,
+  isQueryResult,
+  isToolError,
+  resolveTools
+} from "#blokkli/agent/app/helpers";
+import { mcpTools } 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 hasEverConnected = false;
+  const isConnected = ref(false);
+  const isReady = ref(false);
+  const hasBeenReady = ref(false);
+  let pendingPrompt = null;
+  let pendingInit = null;
+  let toolMap = {};
+  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("");
+  const showTranscript = ref(false);
+  const activeConversationId = ref(null);
+  const conversationList = ref([]);
+  const showConversationList = ref(false);
+  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 ?? [],
+        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;
+    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;
+    pingInterval = window.setInterval(() => {
+      send({ type: "ping" });
+    }, 3e4);
+    onConnect();
+  }
+  function onWebSocketClose() {
+    isConnected.value = false;
+    isReady.value = false;
+    isProcessing.value = false;
+    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 (hasEverConnected) return;
+    hasEverConnected = true;
+    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    const url = `${protocol}//${window.location.host}/api/blokkli/agent`;
+    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);
+    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;
+        }
+        send({ type: "authenticate", authToken });
+        pendingInit = {
+          tools: getToolsForServer(resolved, state.editMode.value, adapter),
+          pageContext: buildPageContext()
+        };
+        return;
+      } catch (e) {
+        console.error("Failed to obtain agent auth token:", e);
+      }
+    }
+    sendInit(
+      getToolsForServer(resolved, state.editMode.value, adapter),
+      buildPageContext()
+    );
+  }
+  async function sendInit(tools, pageContext) {
+    send({ type: "init", tools, pageContext });
+    isReady.value = true;
+    hasBeenReady.value = true;
+    if (adapter.agentConversations) {
+      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;
+            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 } = pendingPrompt;
+      pendingPrompt = null;
+      sendPrompt(prompt, displayPrompt, selectedUuids, attachments);
+    }
+  }
+  function buildPageContext() {
+    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
+      }))
+    ];
+    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
+    };
+    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.tools, 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.content;
+        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;
+        let resultForServer = result;
+        if (toolDef.prunedSummary && typeof result === "object" && result !== null) {
+          try {
+            const summary = toolDef.prunedSummary(result);
+            if (summary) {
+              resultForServer = {
+                ...result,
+                _summary: summary
+              };
+            }
+          } catch {
+          }
+        }
+        send({
+          type: "tool_result",
+          callId,
+          result: resultForServer
+        });
+      }
+    } 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
+    };
+  }
+  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 };
+    });
+  }
+  function sendPrompt(prompt, displayPrompt, selectedUuids, attachments) {
+    if (!prompt.trim() || isProcessing.value) return;
+    if (!isReady.value) {
+      pendingPrompt = { prompt, displayPrompt, selectedUuids, attachments };
+      return;
+    }
+    isProcessing.value = true;
+    if (!activeConversationId.value) {
+      activeConversationId.value = generateUUID();
+    }
+    const item = {
+      type: "user",
+      id: generateId(),
+      content: displayPrompt ?? prompt,
+      timestamp: Date.now()
+    };
+    if (attachments?.length) {
+      ;
+      item.attachments = attachments;
+    }
+    conversation.value.push(item);
+    send({
+      type: "start",
+      prompt,
+      selectedUuids: selectedUuids?.length ? selectedUuids : 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 = [];
+    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,
+    retry,
+    approve,
+    reject,
+    setAutoApprove,
+    cancel,
+    newConversation,
+    getTranscript,
+    onToolComponentDone,
+    // Transcript dialog state
+    transcriptContent,
+    showTranscript,
+    // Conversation list
+    conversationList,
+    showConversationList,
+    activeConversationId: readonly(activeConversationId),
+    switchConversation,
+    deleteConversation,
+    refreshConversationList
+  };
+}