@ai-accounts/vue-headless 0.3.0-alpha.2 → 0.3.0

package/dist/index.js

@@ -144,6 +144,7 @@ function useLoginSession() {
   const accountId = ref4(null);
   const urlPrompt = ref4(null);
   const textPrompt = ref4(null);
+  const menuPrompt = ref4(null);
   const stdoutLines = ref4([]);
   const errorCode = ref4(null);
   const errorMessage = ref4(null);
@@ -152,15 +153,33 @@ function useLoginSession() {
     status.value = "running";
     urlPrompt.value = null;
     textPrompt.value = null;
+    menuPrompt.value = null;
     stdoutLines.value = [];
     errorCode.value = null;
     errorMessage.value = null;
-    const { session_id } = await client.beginLogin(id, flow, inputs);
-    sessionId.value = session_id;
-    emit({ type: "login.started", sessionId: session_id, backendKind: "", flow });
-    for await (const event of client.streamLogin(id, session_id)) {
-      dispatch(event);
-      if (status.value !== "running") return;
+    try {
+      const { session_id } = await client.beginLogin(id, flow, inputs);
+      sessionId.value = session_id;
+      emit({ type: "login.started", sessionId: session_id, backendKind: "", flow });
+      for await (const event of client.streamLogin(id, session_id)) {
+        dispatch(event);
+        if (status.value !== "running") return;
+      }
+      if (status.value === "running") {
+        status.value = "failed";
+        errorCode.value = "stream_ended";
+        errorMessage.value = "Login stream ended unexpectedly";
+      }
+    } catch (err) {
+      status.value = "failed";
+      errorCode.value = "network_error";
+      errorMessage.value = err instanceof Error ? err.message : String(err);
+      emit({
+        type: "login.failed",
+        sessionId: sessionId.value ?? "",
+        code: "network_error",
+        message: errorMessage.value
+      });
     }
   }
   function dispatch(event) {
@@ -173,6 +192,10 @@ function useLoginSession() {
         textPrompt.value = event;
         emit({ type: "login.prompt", sessionId: sessionId.value, promptKind: "text" });
         break;
+      case "menu_prompt":
+        menuPrompt.value = event;
+        emit({ type: "login.prompt", sessionId: sessionId.value, promptKind: "menu" });
+        break;
       case "stdout":
         stdoutLines.value = [...stdoutLines.value, event.text];
         break;
@@ -201,9 +224,12 @@ function useLoginSession() {
     }
   }
   async function respond(answer) {
-    if (!sessionId.value || !accountId.value || !textPrompt.value) return;
-    const promptId = textPrompt.value.prompt_id;
+    if (!sessionId.value || !accountId.value) return;
+    const activePrompt = textPrompt.value ?? menuPrompt.value;
+    if (!activePrompt) return;
+    const promptId = activePrompt.prompt_id;
     textPrompt.value = null;
+    menuPrompt.value = null;
     await client.respondLogin(accountId.value, sessionId.value, promptId, answer);
   }
   async function cancel() {
@@ -217,6 +243,7 @@ function useLoginSession() {
     accountId,
     urlPrompt,
     textPrompt,
+    menuPrompt,
     stdoutLines,
     errorCode,
     errorMessage,
@@ -226,6 +253,595 @@ function useLoginSession() {
   };
 }
 
+// src/composables/useConversation.ts
+import { ref as ref5, shallowRef } from "vue";
+function useConversation(client) {
+  const sessionId = ref5(null);
+  const messages = shallowRef([]);
+  const isStreaming = ref5(false);
+  const streamingText = ref5("");
+  const error = ref5(null);
+  async function create(backendId, model) {
+    error.value = null;
+    const session = await client.createConversation({ backend_id: backendId, model });
+    sessionId.value = session.id;
+    messages.value = [];
+  }
+  async function load(id) {
+    error.value = null;
+    const detail = await client.getConversation(id);
+    sessionId.value = detail.id;
+    messages.value = detail.messages;
+  }
+  async function send(content) {
+    if (!sessionId.value) {
+      error.value = "No active session";
+      return;
+    }
+    error.value = null;
+    isStreaming.value = true;
+    streamingText.value = "";
+    const userMsg = {
+      id: `pending-${Date.now()}`,
+      role: "user",
+      content,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      model: null,
+      tokens_in: null,
+      tokens_out: null
+    };
+    messages.value = [...messages.value, userMsg];
+    try {
+      let accumulated = "";
+      for await (const delta of client.streamChat(sessionId.value, content)) {
+        if (delta.kind === "token" && delta.text) {
+          accumulated += delta.text;
+          streamingText.value = accumulated;
+        } else if (delta.kind === "error") {
+          error.value = delta.text ?? "Unknown error";
+        }
+      }
+      if (accumulated) {
+        const assistantMsg = {
+          id: `msg-${Date.now()}`,
+          role: "assistant",
+          content: accumulated,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          model: null,
+          tokens_in: null,
+          tokens_out: null
+        };
+        messages.value = [...messages.value, assistantMsg];
+      }
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : "Stream failed";
+    } finally {
+      isStreaming.value = false;
+      streamingText.value = "";
+    }
+  }
+  return { sessionId, messages, isStreaming, streamingText, error, create, send, load };
+}
+
+// src/composables/useSmartChat.ts
+import { ref as ref7, shallowRef as shallowRef2 } from "vue";
+
+// src/composables/useProcessGroups.ts
+import { ref as ref6 } from "vue";
+var AUTO_COLLAPSE_MS = {
+  tool_call: 4e3,
+  reasoning: 2e3,
+  code_execution: 2e3
+};
+function useProcessGroups() {
+  const groups = ref6(/* @__PURE__ */ new Map());
+  function _triggerReactivity() {
+    groups.value = new Map(groups.value);
+  }
+  function addGroup(group) {
+    groups.value.set(group.id, { ...group, isExpanded: true });
+    _triggerReactivity();
+  }
+  function removeGroup(id) {
+    groups.value.delete(id);
+    _triggerReactivity();
+  }
+  function toggleGroup(id) {
+    const g = groups.value.get(id);
+    if (g) {
+      g.isExpanded = !g.isExpanded;
+      _triggerReactivity();
+    }
+  }
+  function collapseGroup(id) {
+    const g = groups.value.get(id);
+    if (g) {
+      g.isExpanded = false;
+      _triggerReactivity();
+    }
+  }
+  function expandGroup(id) {
+    const g = groups.value.get(id);
+    if (g) {
+      g.isExpanded = true;
+      _triggerReactivity();
+    }
+  }
+  function updateGroupContent(id, content) {
+    const g = groups.value.get(id);
+    if (g) {
+      g.content += content;
+      _triggerReactivity();
+    }
+  }
+  function clearGroups() {
+    groups.value.clear();
+    _triggerReactivity();
+  }
+  function processToolCallDelta(delta) {
+    const existing = groups.value.get(delta.id);
+    if (existing) {
+      if (delta.arguments) {
+        existing.content += delta.arguments;
+        _triggerReactivity();
+      }
+      return;
+    }
+    const type = delta.group_type ?? "tool_call";
+    addGroup({
+      id: delta.id,
+      type,
+      label: delta.name ?? delta.id,
+      content: delta.arguments ?? "",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      autoCollapseMs: AUTO_COLLAPSE_MS[type]
+    });
+  }
+  return {
+    groups,
+    addGroup,
+    removeGroup,
+    toggleGroup,
+    collapseGroup,
+    expandGroup,
+    updateGroupContent,
+    clearGroups,
+    processToolCallDelta
+  };
+}
+
+// src/composables/useSmartChat.ts
+var HEARTBEAT_TIMEOUT_MS = 9e4;
+function useSmartChat() {
+  const { client } = useAiAccounts();
+  const sessionId = ref7(null);
+  const messages = shallowRef2([]);
+  const isStreaming = ref7(false);
+  const streamingContent = ref7("");
+  const error = ref7(null);
+  const chatMode = ref7("single");
+  const backendResponses = ref7(/* @__PURE__ */ new Map());
+  const synthesisState = ref7(null);
+  const selectedBackend = ref7(null);
+  const selectedAccount = ref7(null);
+  const selectedModel = ref7(null);
+  const processGroups = useProcessGroups();
+  const canFinalize = ref7(false);
+  const isFinalizing = ref7(false);
+  const detectedConfig = ref7(null);
+  let configParser = null;
+  function setConfigParser(parser) {
+    configParser = parser;
+  }
+  async function finalize() {
+    if (!canFinalize.value) return null;
+    isFinalizing.value = true;
+    try {
+      return detectedConfig.value;
+    } finally {
+      isFinalizing.value = false;
+    }
+  }
+  let lastSeq = 0;
+  let heartbeatTimer = null;
+  let activeAbort = null;
+  function clearHeartbeat() {
+    if (heartbeatTimer) {
+      clearTimeout(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  }
+  function resetHeartbeat() {
+    clearHeartbeat();
+    heartbeatTimer = setTimeout(() => {
+      error.value = "Connection lost \u2014 no activity from server";
+      isStreaming.value = false;
+      heartbeatTimer = null;
+      if (activeAbort) {
+        activeAbort.abort(new DOMException("heartbeat-timeout", "AbortError"));
+      }
+    }, HEARTBEAT_TIMEOUT_MS);
+  }
+  async function createSession(backendId, model) {
+    error.value = null;
+    const session = await client.createChatSession(backendId, model);
+    sessionId.value = session.id;
+    messages.value = [];
+  }
+  async function loadSession(id) {
+    error.value = null;
+    const detail = await client.getConversation(id);
+    sessionId.value = detail.id;
+    messages.value = detail.messages;
+  }
+  async function send(content) {
+    if (!sessionId.value) {
+      error.value = "No active session";
+      return;
+    }
+    error.value = null;
+    isStreaming.value = true;
+    streamingContent.value = "";
+    backendResponses.value = /* @__PURE__ */ new Map();
+    synthesisState.value = null;
+    canFinalize.value = false;
+    detectedConfig.value = null;
+    processGroups.clearGroups();
+    lastSeq = 0;
+    activeAbort = new AbortController();
+    resetHeartbeat();
+    const userMsg = {
+      id: `pending-${Date.now()}`,
+      role: "user",
+      content,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      model: null,
+      tokens_in: null,
+      tokens_out: null
+    };
+    messages.value = [...messages.value, userMsg];
+    try {
+      const req = { session_id: sessionId.value, content, mode: chatMode.value };
+      if (selectedBackend.value) req.backend_kind = selectedBackend.value;
+      if (selectedAccount.value) req.account_id = selectedAccount.value;
+      if (selectedModel.value) req.model = selectedModel.value;
+      for await (const event of client.sendChat(req, { signal: activeAbort.signal })) {
+        dispatch(event);
+      }
+      if (chatMode.value === "single" && streamingContent.value) {
+        const assistantMsg = {
+          id: `msg-${Date.now()}`,
+          role: "assistant",
+          content: streamingContent.value,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          model: null,
+          tokens_in: null,
+          tokens_out: null
+        };
+        messages.value = [...messages.value, assistantMsg];
+      }
+      if (configParser) {
+        const lastMsg = messages.value[messages.value.length - 1];
+        if (lastMsg && lastMsg.role === "assistant") {
+          try {
+            const cfg = configParser(lastMsg.content);
+            if (cfg) {
+              detectedConfig.value = cfg;
+              canFinalize.value = true;
+            }
+          } catch (e) {
+            console.error("[useSmartChat] configParser threw \u2014 canFinalize stays false", e);
+          }
+        }
+      }
+    } catch (e) {
+      if (e instanceof DOMException && e.name === "AbortError") {
+      } else if (e instanceof Error) {
+        error.value = `${e.name}: ${e.message}`;
+      } else {
+        error.value = `Chat failed: ${String(e)}`;
+      }
+    } finally {
+      clearHeartbeat();
+      activeAbort = null;
+      isStreaming.value = false;
+      streamingContent.value = "";
+    }
+  }
+  function dispatch(event) {
+    if (typeof event._seq === "number") {
+      if (event._seq <= lastSeq) return;
+      if (lastSeq > 0 && event._seq > lastSeq + 1) {
+        console.warn(
+          "[useSmartChat] seq gap detected: lastSeq=%d incoming=%d (lost %d events)",
+          lastSeq,
+          event._seq,
+          event._seq - lastSeq - 1
+        );
+      }
+      lastSeq = event._seq;
+    }
+    resetHeartbeat();
+    if (event.kind === "done" || event.kind === "error" || event.kind === "synthesis_complete" || event.kind === "synthesis_error") {
+      clearHeartbeat();
+    }
+    switch (event.kind) {
+      // Single mode
+      case "token":
+        streamingContent.value += event.payload;
+        break;
+      case "done":
+        break;
+      case "error":
+        error.value = event.payload ?? "Unknown error";
+        break;
+      case "tool_call": {
+        const delta = { id: event.id };
+        if (event.name !== void 0) delta.name = event.name;
+        if (event.arguments !== void 0) delta.arguments = event.arguments;
+        if (event.group_type !== void 0) delta.group_type = event.group_type;
+        processGroups.processToolCallDelta(delta);
+        break;
+      }
+      // All/compound mode — backend events
+      case "backend_delta": {
+        const existing = backendResponses.value.get(event.backend);
+        const updated = new Map(backendResponses.value);
+        updated.set(event.backend, {
+          backend: event.backend,
+          content: (existing?.content ?? "") + (event.text ?? ""),
+          status: "streaming"
+        });
+        backendResponses.value = updated;
+        break;
+      }
+      case "backend_complete": {
+        const existing = backendResponses.value.get(event.backend);
+        if (existing) {
+          const updated = new Map(backendResponses.value);
+          updated.set(event.backend, { ...existing, status: "complete" });
+          backendResponses.value = updated;
+        }
+        break;
+      }
+      case "backend_error": {
+        const existing = backendResponses.value.get(event.backend);
+        const updated = new Map(backendResponses.value);
+        updated.set(event.backend, {
+          backend: event.backend,
+          content: existing?.content ?? "",
+          status: "error",
+          error: event.error
+        });
+        backendResponses.value = updated;
+        break;
+      }
+      case "backend_timeout": {
+        const existing = backendResponses.value.get(event.backend);
+        const updated = new Map(backendResponses.value);
+        updated.set(event.backend, {
+          backend: event.backend,
+          content: existing?.content ?? "",
+          status: "timeout"
+        });
+        backendResponses.value = updated;
+        break;
+      }
+      // Compound synthesis
+      case "synthesis_start": {
+        synthesisState.value = {
+          status: "streaming",
+          content: "",
+          primaryBackend: event.primary_backend,
+          backendsCollected: event.backends_collected ?? []
+        };
+        break;
+      }
+      case "synthesis_delta": {
+        if (synthesisState.value) {
+          synthesisState.value = {
+            ...synthesisState.value,
+            content: synthesisState.value.content + (event.text ?? "")
+          };
+        }
+        break;
+      }
+      case "synthesis_complete":
+        if (synthesisState.value) {
+          synthesisState.value = { ...synthesisState.value, status: "complete" };
+        }
+        break;
+      case "synthesis_error": {
+        if (synthesisState.value) {
+          synthesisState.value = { ...synthesisState.value, status: "error", error: event.error };
+        } else {
+          synthesisState.value = {
+            status: "error",
+            content: "",
+            primaryBackend: "",
+            backendsCollected: [],
+            error: event.error
+          };
+        }
+        break;
+      }
+    }
+  }
+  function setMode(mode) {
+    chatMode.value = mode;
+  }
+  function selectBackend(kind) {
+    selectedBackend.value = kind;
+    selectedAccount.value = null;
+    selectedModel.value = null;
+  }
+  return {
+    sessionId,
+    messages,
+    isStreaming,
+    streamingContent,
+    error,
+    chatMode,
+    backendResponses,
+    synthesisState,
+    selectedBackend,
+    selectedAccount,
+    selectedModel,
+    createSession,
+    loadSession,
+    send,
+    setMode,
+    selectBackend,
+    processGroups,
+    canFinalize,
+    isFinalizing,
+    detectedConfig,
+    finalize,
+    setConfigParser
+  };
+}
+
+// src/composables/useSmartScroll.ts
+import { ref as ref8, onMounted, onUnmounted } from "vue";
+var THRESHOLD = 32;
+function useSmartScroll() {
+  const containerRef = ref8(null);
+  const isNearBottom = ref8(true);
+  const showScrollButton = ref8(false);
+  function check() {
+    const el = containerRef.value;
+    if (!el) return;
+    const near = el.scrollHeight - el.scrollTop - el.clientHeight < THRESHOLD;
+    isNearBottom.value = near;
+    showScrollButton.value = !near;
+  }
+  function scrollToBottom() {
+    containerRef.value?.scrollTo({ top: containerRef.value.scrollHeight, behavior: "smooth" });
+  }
+  let observer = null;
+  onMounted(() => {
+    const el = containerRef.value;
+    if (!el) return;
+    el.addEventListener("scroll", check, { passive: true });
+    observer = new MutationObserver(() => {
+      if (isNearBottom.value) scrollToBottom();
+    });
+    observer.observe(el, { childList: true, subtree: true });
+  });
+  onUnmounted(() => {
+    containerRef.value?.removeEventListener("scroll", check);
+    observer?.disconnect();
+  });
+  return { containerRef, isNearBottom, showScrollButton, scrollToBottom };
+}
+
+// src/composables/useStreamingParser.ts
+var DEFAULT_MAX_PENDING = 1e6;
+var smdResolutionWarned = false;
+async function resolveSmd() {
+  const injected = globalThis.__smd;
+  if (injected) return injected;
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      "streaming-markdown"
+    );
+    return mod;
+  } catch (err) {
+    if (!smdResolutionWarned) {
+      smdResolutionWarned = true;
+      console.warn(
+        '[useStreamingParser] Could not load "streaming-markdown" peer dep; markdown rendering disabled. Install it or inject globalThis.__smd.',
+        err
+      );
+    }
+    return null;
+  }
+}
+function useStreamingParser(options = {}) {
+  const maxPending = options.maxPendingChars ?? DEFAULT_MAX_PENDING;
+  let smd = null;
+  let parser = null;
+  let pending = [];
+  let pendingChars = 0;
+  let rafId = null;
+  let initToken = 0;
+  function flush() {
+    rafId = null;
+    if (!smd || !parser || pending.length === 0) return;
+    const text = pending.join("");
+    pending = [];
+    pendingChars = 0;
+    try {
+      smd.parser_write(parser, text);
+    } catch (err) {
+      console.error("[useStreamingParser] parser_write threw; chunk discarded", err);
+    }
+    options.onFlush?.();
+  }
+  function init(container) {
+    destroy();
+    container.textContent = "";
+    const token = ++initToken;
+    resolveSmd().then((resolved) => {
+      if (token !== initToken) return;
+      if (!resolved) return;
+      smd = resolved;
+      const renderer = resolved.default_renderer(container);
+      parser = resolved.parser(renderer);
+      if (pending.length > 0) {
+        const text = pending.join("");
+        pending = [];
+        pendingChars = 0;
+        try {
+          resolved.parser_write(parser, text);
+        } catch (err) {
+          console.error("[useStreamingParser] initial parser_write threw; buffered chunk discarded", err);
+        }
+      }
+    }).catch((err) => {
+      console.error("[useStreamingParser] resolveSmd unexpectedly rejected", err);
+    });
+  }
+  function write(text) {
+    if (initToken === 0) return;
+    if (pendingChars + text.length > maxPending) {
+      console.warn(
+        "[useStreamingParser] dropping write \u2014 pending buffer exceeded maxPendingChars (%d). smd may never have resolved.",
+        maxPending
+      );
+      return;
+    }
+    pending.push(text);
+    pendingChars += text.length;
+    if (rafId === null && typeof requestAnimationFrame !== "undefined") {
+      rafId = requestAnimationFrame(flush);
+    } else if (rafId === null) {
+      queueMicrotask(flush);
+    }
+  }
+  function finalize() {
+    if (rafId !== null) {
+      if (typeof cancelAnimationFrame !== "undefined") cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+    if (pending.length > 0) flush();
+    if (smd && parser) {
+      try {
+        smd.parser_end(parser);
+      } catch (err) {
+        console.error("[useStreamingParser] parser_end threw", err);
+      }
+    }
+    parser = null;
+    smd = null;
+  }
+  function destroy() {
+    finalize();
+  }
+  return { init, write, finalize, destroy };
+}
+
 // src/index.ts
 var version = "0.3.0-alpha.1";
 export {
@@ -234,7 +850,12 @@ export {
   useAccountWizard,
   useAiAccounts,
   useBackendRegistry,
+  useConversation,
   useLoginSession,
   useOnboarding,
+  useProcessGroups,
+  useSmartChat,
+  useSmartScroll,
+  useStreamingParser,
   version
 };