@raisindb/client 0.2.3 → 0.2.5

package/dist/vue.js

@@ -0,0 +1,1460 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/integrations/vue/index.ts
+var vue_exports = {};
+__export(vue_exports, {
+  createRaisinVue: () => createRaisinVue
+});
+module.exports = __toCommonJS(vue_exports);
+
+// src/integrations/svelte/svelte-auth.ts
+function createAuthAdapter(client) {
+  let snapshot = {
+    user: client.getStoredUser(),
+    isAuthenticated: client.getStoredUser() !== null,
+    isLoading: false
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  function emit() {
+    for (const cb of listeners) cb(snapshot);
+  }
+  function update(partial) {
+    snapshot = { ...snapshot, ...partial };
+    emit();
+  }
+  const unsubAuth = client.onAuthStateChange(({ event, session }) => {
+    if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED" || event === "USER_UPDATED") {
+      update({ user: session.user, isAuthenticated: true });
+    } else if (event === "SIGNED_OUT" || event === "SESSION_EXPIRED") {
+      update({ user: null, isAuthenticated: false });
+    }
+  });
+  const unsubUser = client.onUserChange(({ node }) => {
+    if (!snapshot.user) return;
+    update({
+      user: {
+        ...snapshot.user,
+        home: node.path,
+        displayName: node.properties.display_name ?? snapshot.user.displayName,
+        avatarUrl: node.properties.avatar_url ?? snapshot.user.avatarUrl
+      }
+    });
+  });
+  return {
+    subscribe(cb) {
+      listeners.add(cb);
+      return () => {
+        listeners.delete(cb);
+      };
+    },
+    getSnapshot: () => snapshot,
+    async login(email, password, repository) {
+      update({ isLoading: true });
+      try {
+        return await client.loginWithEmail(email, password, repository);
+      } finally {
+        update({ isLoading: false });
+      }
+    },
+    async register(email, password, repository, displayName) {
+      update({ isLoading: true });
+      try {
+        return await client.registerWithEmail(email, password, repository, displayName);
+      } finally {
+        update({ isLoading: false });
+      }
+    },
+    async logout(options) {
+      update({ isLoading: true });
+      try {
+        await client.logout(options);
+      } finally {
+        update({ isLoading: false });
+      }
+    },
+    async initSession(repository) {
+      update({ isLoading: true });
+      try {
+        return await client.initSession(repository);
+      } finally {
+        update({ isLoading: false });
+      }
+    },
+    destroy() {
+      unsubAuth();
+      unsubUser();
+      listeners.clear();
+    }
+  };
+}
+
+// src/integrations/vue/vue-auth.ts
+function createUseAuth(vue) {
+  return function useAuth(client) {
+    const adapter = createAuthAdapter(client);
+    const snapshot = vue.ref(adapter.getSnapshot());
+    const unsubscribe = adapter.subscribe((s) => {
+      snapshot.value = s;
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      adapter.destroy();
+    });
+    return {
+      user: vue.computed(() => snapshot.value.user),
+      isAuthenticated: vue.computed(() => snapshot.value.isAuthenticated),
+      isLoading: vue.computed(() => snapshot.value.isLoading),
+      login: adapter.login,
+      register: adapter.register,
+      logout: adapter.logout,
+      initSession: adapter.initSession
+    };
+  };
+}
+
+// src/connection.ts
+var import_events = require("events");
+
+// src/logger.ts
+var config = {
+  level: 1 /* Error */,
+  prefix: "[RaisinDB]"
+};
+function setLogLevel(level) {
+  config.level = level;
+}
+function getLogLevel() {
+  return config.level;
+}
+var logger = {
+  /**
+   * Log debug message (only shown when level >= Debug)
+   */
+  debug(...args) {
+    if (config.level >= 4 /* Debug */) {
+      console.log(config.prefix, ...args);
+    }
+  },
+  /**
+   * Log info message (only shown when level >= Info)
+   */
+  info(...args) {
+    if (config.level >= 3 /* Info */) {
+      console.log(config.prefix, ...args);
+    }
+  },
+  /**
+   * Log warning message (only shown when level >= Warn)
+   */
+  warn(...args) {
+    if (config.level >= 2 /* Warn */) {
+      console.warn(config.prefix, ...args);
+    }
+  },
+  /**
+   * Log error message (only shown when level >= Error)
+   */
+  error(...args) {
+    if (config.level >= 1 /* Error */) {
+      console.error(config.prefix, ...args);
+    }
+  }
+};
+if (typeof globalThis !== "undefined") {
+  globalThis.__raisinDebug = (enable = true) => {
+    setLogLevel(enable ? 4 /* Debug */ : 1 /* Error */);
+    console.log(`[RaisinDB] Debug logging ${enable ? "ENABLED" : "DISABLED"} (includes server handler logs)`);
+  };
+}
+
+// src/integrations/svelte/svelte-connection.ts
+function createConnectionAdapter(client) {
+  let snapshot = {
+    state: client.getConnectionState(),
+    isConnected: client.getConnectionState() === "connected" /* Connected */,
+    isReady: client.isReady()
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  function emit() {
+    for (const cb of listeners) cb(snapshot);
+  }
+  const unsubConn = client.onConnectionStateChange((newState) => {
+    snapshot = {
+      state: newState,
+      isConnected: newState === "connected" /* Connected */,
+      isReady: snapshot.isReady
+    };
+    emit();
+  });
+  const unsubReady = client.onReadyStateChange((ready) => {
+    snapshot = { ...snapshot, isReady: ready };
+    emit();
+  });
+  return {
+    subscribe(cb) {
+      listeners.add(cb);
+      return () => {
+        listeners.delete(cb);
+      };
+    },
+    getSnapshot: () => snapshot,
+    async connect() {
+      await client.connect();
+    },
+    disconnect() {
+      client.disconnect();
+    },
+    destroy() {
+      unsubConn();
+      unsubReady();
+      listeners.clear();
+    }
+  };
+}
+
+// src/integrations/vue/vue-connection.ts
+function createUseConnection(vue) {
+  return function useConnection(client) {
+    const adapter = createConnectionAdapter(client);
+    const snapshot = vue.ref(adapter.getSnapshot());
+    const unsubscribe = adapter.subscribe((s) => {
+      snapshot.value = s;
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      adapter.destroy();
+    });
+    return {
+      state: vue.computed(() => snapshot.value.state),
+      isConnected: vue.computed(() => snapshot.value.isConnected),
+      isReady: vue.computed(() => snapshot.value.isReady),
+      connect: adapter.connect,
+      disconnect: adapter.disconnect
+    };
+  };
+}
+
+// src/integrations/svelte/svelte-sql.ts
+function rowsToObjects(result) {
+  return result.rows;
+}
+function createSqlAdapter(database, sql, params, options) {
+  let snapshot = {
+    data: null,
+    isLoading: false,
+    error: null
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  let destroyed = false;
+  function emit() {
+    for (const cb of listeners) cb(snapshot);
+  }
+  function update(partial) {
+    snapshot = { ...snapshot, ...partial };
+    emit();
+  }
+  async function fetchData() {
+    if (destroyed) return;
+    update({ isLoading: true, error: null });
+    try {
+      const result = await database.executeSql(sql, params);
+      if (!destroyed) {
+        update({ data: rowsToObjects(result), isLoading: false });
+      }
+    } catch (err) {
+      if (!destroyed) {
+        update({
+          error: err instanceof Error ? err : new Error(String(err)),
+          isLoading: false
+        });
+      }
+    }
+  }
+  const cleanups = [];
+  const enabled = options?.enabled !== false;
+  if (enabled) {
+    fetchData();
+  }
+  const refetchOnReconnect = options?.refetchOnReconnect !== false;
+  if (enabled && refetchOnReconnect) {
+    const client = database._client;
+    if (client?.onReconnected) {
+      const unsub = client.onReconnected(() => {
+        fetchData();
+      });
+      cleanups.push(unsub);
+    }
+  }
+  const realtime = options?.realtime;
+  if (enabled && realtime) {
+    let unsubscribe;
+    let cancelled = false;
+    database.events().subscribe(
+      {
+        workspace: realtime.workspace,
+        event_types: realtime.eventTypes,
+        path: realtime.path,
+        node_type: realtime.nodeType
+      },
+      () => {
+        fetchData();
+      }
+    ).then((sub) => {
+      if (cancelled) {
+        sub.unsubscribe();
+      } else {
+        unsubscribe = () => sub.unsubscribe();
+      }
+    });
+    cleanups.push(() => {
+      cancelled = true;
+      unsubscribe?.();
+    });
+  }
+  return {
+    subscribe(cb) {
+      listeners.add(cb);
+      return () => {
+        listeners.delete(cb);
+      };
+    },
+    getSnapshot: () => snapshot,
+    refetch: fetchData,
+    destroy() {
+      destroyed = true;
+      for (const cleanup of cleanups) cleanup();
+      listeners.clear();
+    }
+  };
+}
+
+// src/integrations/vue/vue-sql.ts
+function createUseSql(vue) {
+  return function useSql(database, sql, params, options) {
+    const adapter = createSqlAdapter(database, sql, params, options);
+    const snapshot = vue.ref(adapter.getSnapshot());
+    const unsubscribe = adapter.subscribe((s) => {
+      snapshot.value = s;
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      adapter.destroy();
+    });
+    return {
+      data: vue.computed(() => snapshot.value.data),
+      isLoading: vue.computed(() => snapshot.value.isLoading),
+      error: vue.computed(() => snapshot.value.error),
+      refetch: adapter.refetch
+    };
+  };
+}
+
+// src/integrations/svelte/svelte-subscription.ts
+function createSubscriptionAdapter(database, filters, callback) {
+  let unsubscribe;
+  let cancelled = false;
+  database.events().subscribe(filters, (event) => {
+    if (!cancelled) callback(event);
+  }).then((sub) => {
+    if (cancelled) {
+      sub.unsubscribe();
+    } else {
+      unsubscribe = () => sub.unsubscribe();
+    }
+  });
+  return {
+    destroy() {
+      cancelled = true;
+      unsubscribe?.();
+    }
+  };
+}
+
+// src/integrations/vue/vue-subscription.ts
+function createUseSubscription(vue) {
+  return function useSubscription(database, filters, callback) {
+    const adapter = createSubscriptionAdapter(database, filters, callback);
+    vue.onUnmounted(() => adapter.destroy());
+    return {
+      unsubscribe: () => adapter.destroy()
+    };
+  };
+}
+
+// src/utils/plan-projection.ts
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function parsePlanTasks(rawTasks) {
+  if (!Array.isArray(rawTasks)) return [];
+  return rawTasks.map((rawTask, index) => {
+    if (typeof rawTask === "string") {
+      return {
+        title: rawTask,
+        status: "pending"
+      };
+    }
+    const task = asRecord(rawTask);
+    if (!task) return null;
+    return {
+      taskId: asString(task.task_id) ?? asString(task.id),
+      title: asString(task.title) ?? `Task ${index + 1}`,
+      status: asString(task.status) ?? "pending",
+      description: asString(task.description),
+      priority: asString(task.priority)
+    };
+  }).filter((task) => task !== null);
+}
+var TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled"]);
+var TERMINAL_PLAN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function setPlanStatus(plan, nextStatus) {
+  if (!nextStatus) return;
+  if (TERMINAL_PLAN_STATUSES.has(plan.status) && !TERMINAL_PLAN_STATUSES.has(nextStatus)) {
+    return;
+  }
+  plan.status = nextStatus;
+}
+function upsertTask(plan, nextTask) {
+  const existingIndex = plan.tasks.findIndex(
+    (task) => nextTask.taskId && task.taskId === nextTask.taskId || !nextTask.taskId && task.title === nextTask.title
+  );
+  if (existingIndex === -1) {
+    plan.tasks.push(nextTask);
+    return;
+  }
+  const existing = plan.tasks[existingIndex];
+  if (TERMINAL_TASK_STATUSES.has(existing.status) && !TERMINAL_TASK_STATUSES.has(nextTask.status)) {
+    return;
+  }
+  plan.tasks[existingIndex] = {
+    ...existing,
+    ...nextTask
+  };
+}
+function ensurePlan(plans, key, fallbackTitle, timestamp) {
+  const existing = plans.get(key);
+  if (existing) {
+    if (timestamp) existing.updatedAt = timestamp;
+    return existing;
+  }
+  const created = {
+    key,
+    title: fallbackTitle,
+    status: "pending_approval",
+    requiresApproval: true,
+    tasks: [],
+    updatedAt: timestamp
+  };
+  plans.set(key, created);
+  return created;
+}
+function projectPlansFromMessages(messages) {
+  const ordered = [...messages].sort((a, b) => {
+    const aTime = Date.parse(a.timestamp || "");
+    const bTime = Date.parse(b.timestamp || "");
+    return (Number.isNaN(aTime) ? 0 : aTime) - (Number.isNaN(bTime) ? 0 : bTime);
+  });
+  const plans = /* @__PURE__ */ new Map();
+  for (const message of ordered) {
+    const timestamp = message.timestamp;
+    const data = asRecord(message.data);
+    if (message.messageType === "ai_plan" && data) {
+      const planPath = asString(data.plan_path);
+      const planId = asString(data.plan_id);
+      const key = planPath || planId || message.path || message.id || `plan:${timestamp}`;
+      const plan = ensurePlan(
+        plans,
+        key,
+        asString(data.title) || message.content || "Plan",
+        timestamp
+      );
+      plan.planPath = planPath ?? plan.planPath;
+      plan.planId = planId ?? plan.planId;
+      plan.title = asString(data.title) || plan.title;
+      setPlanStatus(plan, asString(data.status));
+      plan.requiresApproval = Boolean(data.requires_approval) || plan.status === "pending_approval";
+      plan.sourceMessagePath = message.path ?? plan.sourceMessagePath;
+      const parsedTasks = parsePlanTasks(data.tasks);
+      if (parsedTasks.length > 0) {
+        plan.tasks = parsedTasks;
+      }
+    }
+    if (message.messageType === "ai_task_update" && data) {
+      const planPath = asString(data.plan_path);
+      const planId = asString(data.plan_id);
+      const key = planPath || planId;
+      if (!key) continue;
+      const plan = ensurePlan(plans, key, "Plan", timestamp);
+      plan.planPath = planPath ?? plan.planPath;
+      plan.planId = planId ?? plan.planId;
+      setPlanStatus(plan, asString(data.plan_status));
+      plan.requiresApproval = plan.status === "pending_approval";
+      const taskUpdate = {
+        taskId: asString(data.task_id),
+        title: asString(data.task_title) || asString(data.title) || "Task",
+        status: asString(data.status) || "pending"
+      };
+      upsertTask(plan, taskUpdate);
+    }
+    if (Array.isArray(message.children)) {
+      for (const child of message.children) {
+        if (child.type !== "plan") continue;
+        const key = child.path || message.path || message.id || `plan-child:${child.id}:${timestamp}`;
+        const plan = ensurePlan(plans, key, child.planTitle || message.content || "Plan", timestamp);
+        plan.title = child.planTitle || plan.title;
+        plan.status = child.status || plan.status;
+        plan.requiresApproval = plan.status === "pending_approval";
+        if (Array.isArray(child.tasks) && child.tasks.length > 0) {
+          plan.tasks = child.tasks.map((task) => ({
+            taskId: task.id,
+            title: task.title,
+            status: task.status
+          }));
+        }
+      }
+    }
+  }
+  for (const plan of plans.values()) {
+    if (!TERMINAL_PLAN_STATUSES.has(plan.status) && plan.tasks.length > 0 && plan.tasks.every((task) => TERMINAL_TASK_STATUSES.has(task.status))) {
+      plan.status = "completed";
+      plan.requiresApproval = false;
+    }
+  }
+  return [...plans.values()].sort((a, b) => {
+    const aTime = Date.parse(a.updatedAt || "");
+    const bTime = Date.parse(b.updatedAt || "");
+    return (Number.isNaN(bTime) ? 0 : bTime) - (Number.isNaN(aTime) ? 0 : aTime);
+  });
+}
+
+// src/utils/chat-events.ts
+function isRecoveredDoneEvent(event) {
+  if (event.type !== "done") return false;
+  const done = event;
+  if (done.recovered !== true) return false;
+  return typeof done.content !== "string" || done.content.trim().length === 0;
+}
+
+// src/stores/conversation-store.ts
+var ConversationStore = class {
+  constructor(options) {
+    this.subscribers = /* @__PURE__ */ new Set();
+    // Persistent SSE subscription
+    this.subscription = null;
+    this._messages = [];
+    this._isStreaming = false;
+    this._isWaiting = false;
+    this._streamingText = "";
+    this._error = null;
+    this._activeToolCalls = [];
+    this._isLoading = false;
+    this._conversationType = null;
+    this._streamingTimer = null;
+    this._watchdogTimer = null;
+    this.manager = options.database.conversations;
+    this._conversationPath = options.conversationPath ?? null;
+    this.createOptions = options.createOptions;
+    this.onEvent = options.onEvent;
+    this._streamingTimeoutMs = options.streamingTimeoutMs ?? 12e4;
+    this._watchdogIntervalMs = options.watchdogIntervalMs ?? 3e4;
+    if (this._conversationPath) {
+      this.ensureSubscription();
+    }
+  }
+  // ==========================================================================
+  // Subscription
+  // ==========================================================================
+  /**
+   * Subscribe to state changes.
+   * Returns an unsubscribe function.
+   */
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.getSnapshot());
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  /**
+   * Get the current state snapshot.
+   */
+  getSnapshot() {
+    return {
+      conversation: this._conversationPath ? { conversationPath: this._conversationPath, type: this._conversationType || "ai_chat" } : null,
+      messages: [...this._messages],
+      isStreaming: this._isStreaming,
+      isWaiting: this._isWaiting,
+      streamingText: this._streamingText,
+      error: this._error,
+      activeToolCalls: [...this._activeToolCalls],
+      plans: projectPlansFromMessages(this._messages),
+      isLoading: this._isLoading,
+      conversationPath: this._conversationPath
+    };
+  }
+  // ==========================================================================
+  // Actions
+  // ==========================================================================
+  /**
+   * Send a user message and stream the AI response.
+   *
+   * If no conversation exists yet and `createOptions` was provided,
+   * the conversation is created automatically on the first call.
+   */
+  async sendMessage(content) {
+    if (this._isStreaming) {
+      logger.warn("[ConversationStore] Cannot send message while streaming");
+      return;
+    }
+    logger.info("[ConversationStore] Sending message", { path: this._conversationPath });
+    this._error = null;
+    if (!this._conversationPath) {
+      if (!this.createOptions) {
+        throw new Error("No conversationPath and no createOptions provided");
+      }
+      try {
+        const convo = await this.manager.create({
+          participant: this.createOptions.participant,
+          input: this.createOptions.input
+        });
+        this._conversationPath = convo.conversationPath;
+        this._conversationType = convo.type;
+        for (const event of convo.initialEvents ?? []) {
+          this.onEvent?.(event);
+          this.handleEvent(event);
+        }
+        this.notify();
+      } catch (err) {
+        this._error = err instanceof Error ? err.message : String(err);
+        this.notify();
+        return;
+      }
+    }
+    const userMessage = {
+      role: "user",
+      content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._messages.push(userMessage);
+    this._isStreaming = true;
+    this._isWaiting = false;
+    this._streamingText = "";
+    this._activeToolCalls = [];
+    this.resetStreamingTimer();
+    this.startWatchdog();
+    this.notify();
+    try {
+      this.ensureSubscription();
+      await this.subscription.waitUntilConnected();
+      await this.manager.createUserMessage(this._conversationPath, content);
+    } catch (err) {
+      logger.error("[ConversationStore] Send failed", err);
+      this._error = err instanceof Error ? err.message : String(err);
+      this._isStreaming = false;
+      this.clearStreamingTimer();
+      this.stopWatchdog();
+      this.notify();
+    }
+  }
+  /**
+   * Load messages from the persisted node tree.
+   * Useful for loading history on page reload.
+   */
+  async loadMessages() {
+    if (!this._conversationPath) return [];
+    this._isLoading = true;
+    this.notify();
+    try {
+      const messages = await this.manager.getMessages(this._conversationPath);
+      logger.debug(`[ConversationStore] Loaded ${messages.length} messages`);
+      if (messages.length > 0) {
+        this._messages = messages;
+        this._activeToolCalls = [];
+      }
+      return messages;
+    } finally {
+      this._isLoading = false;
+      this.notify();
+    }
+  }
+  /**
+   * Approve a pending plan.
+   */
+  async approvePlan(planPath) {
+    await this.manager.approvePlan(planPath);
+  }
+  /**
+   * Reject a pending plan.
+   */
+  async rejectPlan(planPath, feedback) {
+    await this.manager.rejectPlan(planPath, feedback);
+  }
+  /**
+   * Mark a single message as read.
+   */
+  async markMessageAsRead(messagePath) {
+    await this.manager.markMessageAsRead(messagePath);
+  }
+  /**
+   * Stop the current streaming response.
+   */
+  stop() {
+    this._isStreaming = false;
+    this.clearStreamingTimer();
+    this.stopWatchdog();
+    this.notify();
+  }
+  /**
+   * Clean up the store and release resources.
+   */
+  destroy() {
+    this.stop();
+    this.clearStreamingTimer();
+    this.stopWatchdog();
+    this.subscription?.unsubscribe();
+    this.subscription = null;
+    this.subscribers.clear();
+  }
+  /**
+   * Get the conversation path.
+   */
+  getConversationPath() {
+    return this._conversationPath;
+  }
+  // ==========================================================================
+  // Internal
+  // ==========================================================================
+  ensureSubscription() {
+    if (this.subscription) return;
+    if (!this._conversationPath) return;
+    this.subscription = this.manager.subscribe(
+      this._conversationPath,
+      (event) => {
+        this.onEvent?.(event);
+        this.handleEvent(event);
+      }
+    );
+  }
+  handleEvent(event) {
+    logger.debug("[ConversationStore] SSE:", event.type);
+    if (this._isStreaming) {
+      this.resetStreamingTimer();
+    }
+    switch (event.type) {
+      case "text_chunk":
+        this.markStreamingActivity();
+        this._streamingText += event.text;
+        this.notify();
+        break;
+      case "thought_chunk":
+        this.markStreamingActivity();
+        this.notify();
+        break;
+      case "assistant_message":
+        this._messages.push(event.message);
+        this._streamingText = "";
+        this.notify();
+        break;
+      case "tool_call_started": {
+        this.markStreamingActivity();
+        logger.debug("[ConversationStore] Tool started:", event.functionName);
+        const info = {
+          id: event.toolCallId,
+          functionName: event.functionName,
+          arguments: event.arguments,
+          status: "running"
+        };
+        this._activeToolCalls.push(info);
+        this.notify();
+        break;
+      }
+      case "tool_call_completed": {
+        this.markStreamingActivity();
+        logger.debug("[ConversationStore] Tool completed:", event.toolCallId);
+        const idx = this._activeToolCalls.findIndex((tc) => tc.id === event.toolCallId);
+        if (idx >= 0) {
+          this._activeToolCalls[idx] = {
+            ...this._activeToolCalls[idx],
+            status: event.error ? "failed" : "completed",
+            result: event.result,
+            durationMs: event.durationMs
+          };
+        }
+        this.notify();
+        break;
+      }
+      case "waiting": {
+        logger.info("[ConversationStore] Waiting for input");
+        this.flushStreamingText(event.timestamp);
+        this._isStreaming = false;
+        this._isWaiting = true;
+        this._activeToolCalls = [];
+        this.clearStreamingTimer();
+        this.stopWatchdog();
+        this.notify();
+        this.deferredReload();
+        break;
+      }
+      case "done": {
+        if (isRecoveredDoneEvent(event)) {
+          logger.debug("[ConversationStore] Ignoring recovered done event");
+          this.reconcileRecoveredDone();
+          break;
+        }
+        const doneEvent = event;
+        if (doneEvent.dispatchPhase && doneEvent.dispatchPhase !== "terminal") {
+          logger.debug("[ConversationStore] Ignoring non-terminal done event");
+          break;
+        }
+        logger.info("[ConversationStore] Turn done");
+        this.flushStreamingText(event.timestamp);
+        if (doneEvent.content && !this.lastMessageIsAssistant()) {
+          this._messages.push({
+            role: doneEvent.role || "assistant",
+            content: doneEvent.content,
+            timestamp: event.timestamp,
+            senderDisplayName: doneEvent.senderDisplayName,
+            finishReason: doneEvent.finishReason
+          });
+        }
+        this._isStreaming = false;
+        this._isWaiting = true;
+        this._activeToolCalls = [];
+        this.clearStreamingTimer();
+        this.stopWatchdog();
+        this.notify();
+        this.deferredReload();
+        break;
+      }
+      case "completed": {
+        this.flushStreamingText(event.timestamp);
+        if (event.messages && event.messages.length > 0) {
+          this._messages = event.messages;
+        }
+        this._isStreaming = false;
+        this._isWaiting = false;
+        this._activeToolCalls = [];
+        this.clearStreamingTimer();
+        this.stopWatchdog();
+        this.notify();
+        this.deferredReload();
+        break;
+      }
+      case "failed":
+        logger.error("[ConversationStore] Turn failed", event.error);
+        this._error = event.error;
+        this._isStreaming = false;
+        this._isWaiting = false;
+        this._streamingText = "";
+        this._activeToolCalls = [];
+        this.clearStreamingTimer();
+        this.stopWatchdog();
+        this.notify();
+        break;
+      case "conversation_created":
+        this._conversationPath = event.conversationPath;
+        this.notify();
+        break;
+      case "message_saved":
+        this.silentReload().catch(() => {
+        });
+        this.notify();
+        break;
+      case "message_delivered":
+        this._messages.push(event.message);
+        this.notify();
+        break;
+      case "log": {
+        const logEvent = event;
+        const currentLevel = getLogLevel();
+        const levelMap = {
+          debug: 4 /* Debug */,
+          info: 3 /* Info */,
+          warn: 2 /* Warn */,
+          error: 1 /* Error */
+        };
+        const eventLevel = levelMap[logEvent.level] ?? 4 /* Debug */;
+        if (currentLevel >= eventLevel) {
+          const fn = logEvent.level === "error" ? console.error : logEvent.level === "warn" ? console.warn : logEvent.level === "debug" ? console.debug : console.info;
+          fn("[server]", logEvent.message);
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * Agent activity observed while the store thought the turn was over.
+   *
+   * This happens when execution continues WITHOUT a user message — plan
+   * approval in approve_then_auto / step_by_step (approvePlan() returns an
+   * enqueue receipt and the agent starts executing), or agent-initiated
+   * follow-ups. The events arrive over the persistent live subscription
+   * (no history replay), so activity is always "now": re-enter streaming
+   * state so UIs show progress and the end-of-turn handling (done/waiting
+   * → deferred reload) runs again for this continuation.
+   */
+  markStreamingActivity() {
+    if (this._isStreaming) return;
+    logger.debug("[ConversationStore] Agent activity while idle \u2014 re-entering streaming state");
+    this._isStreaming = true;
+    this._isWaiting = false;
+    this._streamingText = "";
+    this.resetStreamingTimer();
+    this.startWatchdog();
+  }
+  /**
+   * If accumulated streaming text hasn't been captured in an assistant_message,
+   * synthesize one.
+   */
+  flushStreamingText(timestamp) {
+    if (this._streamingText && !this.lastMessageIsAssistant()) {
+      this._messages.push({
+        role: "assistant",
+        content: this._streamingText,
+        timestamp
+      });
+    }
+    this._streamingText = "";
+  }
+  lastMessageIsAssistant() {
+    const last = this._messages[this._messages.length - 1];
+    return last?.role === "assistant";
+  }
+  /**
+   * After a turn completes, reload canonical messages from the node tree
+   * to catch any events missed during SSE gaps.
+   */
+  deferredReload() {
+    if (!this._conversationPath) return;
+    logger.debug("[ConversationStore] Scheduling deferred reload");
+    const attemptReload = (delay, retriesLeft) => {
+      setTimeout(async () => {
+        try {
+          const prevCount = this._messages.length;
+          await this.silentReload();
+          if (this._messages.length === prevCount && retriesLeft > 0) {
+            attemptReload(delay * 2, retriesLeft - 1);
+          }
+        } catch {
+        }
+      }, delay);
+    };
+    attemptReload(500, 2);
+  }
+  async silentReload() {
+    if (!this._conversationPath) return;
+    try {
+      const fresh = await this.manager.getMessages(this._conversationPath);
+      if (fresh.length === 0) return;
+      let matchCount = 0;
+      const limit = Math.min(this._messages.length, fresh.length);
+      for (let i = 0; i < limit; i++) {
+        if (this._messages[i].role !== fresh[i].role || this._messages[i].content !== fresh[i].content) break;
+        matchCount++;
+      }
+      if (matchCount === this._messages.length && fresh.length === matchCount) {
+        for (let i = 0; i < matchCount; i++) {
+          const f = fresh[i];
+          const e = this._messages[i];
+          if (f.id) e.id = f.id;
+          if (f.path) e.path = f.path;
+          if (f.messageType) e.messageType = f.messageType;
+          if (f.data) e.data = f.data;
+          if (f.children) e.children = f.children;
+          if (f.finishReason) e.finishReason = f.finishReason;
+        }
+        await this.rebuildToolCallState();
+        return;
+      }
+      if (matchCount === this._messages.length && fresh.length > matchCount) {
+        for (let i = matchCount; i < fresh.length; i++) {
+          this._messages.push(fresh[i]);
+        }
+        for (let i = 0; i < matchCount; i++) {
+          const f = fresh[i];
+          const e = this._messages[i];
+          if (f.id) e.id = f.id;
+          if (f.path) e.path = f.path;
+          if (f.messageType) e.messageType = f.messageType;
+          if (f.data) e.data = f.data;
+          if (f.children) e.children = f.children;
+        }
+        await this.rebuildToolCallState();
+        this.notify();
+        return;
+      }
+      if (matchCount === fresh.length && fresh.length < this._messages.length) {
+        for (let i = 0; i < matchCount; i++) {
+          const f = fresh[i];
+          const e = this._messages[i];
+          if (f.id) e.id = f.id;
+          if (f.path) e.path = f.path;
+          if (f.messageType) e.messageType = f.messageType;
+          if (f.data) e.data = f.data;
+          if (f.children) e.children = f.children;
+        }
+        await this.rebuildToolCallState();
+        return;
+      }
+      this._messages = fresh;
+      await this.rebuildToolCallState();
+      this.notify();
+    } catch (err) {
+      logger.debug("[ConversationStore] Silent reload failed:", err);
+    }
+  }
+  // ==========================================================================
+  // Streaming timeout (Fix A) — auto-recover on SSE inactivity
+  // ==========================================================================
+  resetStreamingTimer() {
+    this.clearStreamingTimer();
+    if (!this._isStreaming) return;
+    this._streamingTimer = setTimeout(() => {
+      if (this._isStreaming) {
+        logger.warn("[ConversationStore] Streaming timeout \u2014 no SSE activity for", this._streamingTimeoutMs, "ms");
+        this.recoverFromHang();
+      }
+    }, this._streamingTimeoutMs);
+  }
+  clearStreamingTimer() {
+    if (this._streamingTimer) {
+      clearTimeout(this._streamingTimer);
+      this._streamingTimer = null;
+    }
+  }
+  // ==========================================================================
+  // Activity watchdog (Fix B) — periodic backend health check
+  // ==========================================================================
+  startWatchdog() {
+    this.stopWatchdog();
+    if (!this._conversationPath) return;
+    this._watchdogTimer = setInterval(async () => {
+      if (!this._isStreaming || !this._conversationPath) {
+        this.stopWatchdog();
+        return;
+      }
+      try {
+        const health = await this.manager.checkTurnHealth(this._conversationPath);
+        if (health === "done" && this._isStreaming) {
+          logger.warn("[ConversationStore] Watchdog detected completed turn while still streaming \u2014 recovering");
+          this.recoverFromHang();
+        }
+      } catch {
+      }
+    }, this._watchdogIntervalMs);
+  }
+  stopWatchdog() {
+    if (this._watchdogTimer) {
+      clearInterval(this._watchdogTimer);
+      this._watchdogTimer = null;
+    }
+  }
+  // ==========================================================================
+  // Hang recovery (shared by timeout + watchdog)
+  // ==========================================================================
+  recoverFromHang() {
+    logger.info("[ConversationStore] Recovering from hang");
+    this.clearStreamingTimer();
+    this.stopWatchdog();
+    this._isStreaming = false;
+    this._isWaiting = true;
+    this._streamingText = "";
+    this.notify();
+    this.silentReload().catch(() => {
+    });
+  }
+  /**
+   * Reconcile a recovered done event against persisted state.
+   * If the backend turn is actually complete, finalize the local state.
+   * Otherwise keep streaming active and let normal events continue.
+   */
+  reconcileRecoveredDone() {
+    if (!this._conversationPath) return;
+    void this.manager.checkTurnHealth(this._conversationPath).then((health) => {
+      if (health !== "done") return;
+      if (!this._isStreaming) return;
+      this._isStreaming = false;
+      this._isWaiting = true;
+      this._activeToolCalls = [];
+      this.clearStreamingTimer();
+      this.stopWatchdog();
+      this.notify();
+      this.deferredReload();
+    }).catch(() => {
+    });
+  }
+  // ==========================================================================
+  // Tool call state rebuild (Fix C) — reconstruct from node tree on reload
+  // ==========================================================================
+  async rebuildToolCallState() {
+    if (!this._conversationPath) {
+      this._activeToolCalls = [];
+      return;
+    }
+    try {
+      const pendingCalls = await this.manager.getActiveToolCalls(this._conversationPath);
+      if (pendingCalls.length > 0) {
+        this._activeToolCalls = pendingCalls.map((tc) => ({
+          id: tc.id,
+          functionName: tc.name,
+          arguments: void 0,
+          status: "running"
+        }));
+        if (!this._isStreaming) {
+          this._isStreaming = true;
+          this.resetStreamingTimer();
+          this.startWatchdog();
+        }
+      } else {
+        this._activeToolCalls = [];
+        if (this._isStreaming) {
+          const lastMsg = this._messages[this._messages.length - 1];
+          const isLastAssistantDone = lastMsg?.role === "assistant" && (lastMsg.dispatchPhase ? lastMsg.dispatchPhase === "terminal" : !!lastMsg.finishReason && lastMsg.finishReason !== "tool_calls");
+          if (isLastAssistantDone) {
+            this._isStreaming = false;
+            this._isWaiting = true;
+            this.clearStreamingTimer();
+            this.stopWatchdog();
+          }
+        }
+      }
+    } catch {
+      this._activeToolCalls = [];
+    }
+  }
+  notify() {
+    const snapshot = this.getSnapshot();
+    for (const sub of this.subscribers) {
+      try {
+        sub(snapshot);
+      } catch (err) {
+        logger.error("Error in conversation store subscriber:", err);
+      }
+    }
+  }
+};
+
+// src/utils/home-path.ts
+var ACCESS_CONTROL_PREFIX = "/raisin:access_control";
+function normalizeHomePath(home) {
+  if (home === null || home === void 0) return null;
+  let path = home.trim();
+  if (path.length === 0) return null;
+  if (path === ACCESS_CONTROL_PREFIX) return "/";
+  if (path.startsWith(`${ACCESS_CONTROL_PREFIX}/`)) {
+    path = path.slice(ACCESS_CONTROL_PREFIX.length);
+  }
+  while (path.length > 1 && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  return path;
+}
+
+// src/stores/conversation-list-store.ts
+function buildChatsSubscriptionFilters(userHome) {
+  const home = normalizeHomePath(userHome) ?? userHome;
+  return {
+    workspace: "raisin:access_control",
+    path: `${home}/inbox/chats/**`,
+    event_types: ["node:created", "node:updated"]
+  };
+}
+var ConversationListStore = class {
+  constructor(options) {
+    this.subscribers = /* @__PURE__ */ new Set();
+    // Internal state
+    this._conversations = [];
+    this._isLoading = false;
+    this._error = null;
+    // Cached ConversationStore instances
+    this._stores = /* @__PURE__ */ new Map();
+    // Real-time subscription
+    this._realtimeSubscription = null;
+    this.database = options.database;
+    this.type = options.type;
+    this.realtime = options.realtime ?? false;
+  }
+  // ==========================================================================
+  // Subscription
+  // ==========================================================================
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.getSnapshot());
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  getSnapshot() {
+    return {
+      conversations: [...this._conversations],
+      totalUnreadCount: this._conversations.reduce((sum, c) => sum + (c.unreadCount ?? 0), 0),
+      isLoading: this._isLoading,
+      error: this._error
+    };
+  }
+  // ==========================================================================
+  // Actions
+  // ==========================================================================
+  /**
+   * Load conversations from the server.
+   */
+  async load() {
+    this._isLoading = true;
+    this._error = null;
+    this.notify();
+    try {
+      const conversations = await this.database.conversations.list({
+        type: this.type
+      });
+      logger.debug(`[ConversationListStore] Loaded ${conversations.length} conversations`);
+      this._conversations = conversations;
+      if (this.realtime) {
+        this.startRealtimeSubscription();
+      }
+    } catch (err) {
+      logger.error("[ConversationListStore] Failed to load conversations", err);
+      this._error = err instanceof Error ? err.message : String(err);
+    } finally {
+      this._isLoading = false;
+      this.notify();
+    }
+  }
+  /**
+   * Create a new conversation.
+   */
+  async createConversation(options) {
+    const convo = await this.database.conversations.create(options);
+    const listItem = {
+      id: convo.id,
+      type: convo.type,
+      conversationPath: convo.conversationPath,
+      conversationWorkspace: convo.conversationWorkspace,
+      agentRef: convo.agentRef,
+      participants: convo.participants,
+      unreadCount: 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._conversations = [listItem, ...this._conversations];
+    this.notify();
+    return listItem;
+  }
+  /**
+   * Delete a conversation.
+   */
+  async deleteConversation(conversationPath) {
+    const store = this._stores.get(conversationPath);
+    if (store) {
+      store.destroy();
+      this._stores.delete(conversationPath);
+    }
+    await this.database.conversations.delete(conversationPath);
+    this._conversations = this._conversations.filter((c) => c.conversationPath !== conversationPath);
+    this.notify();
+  }
+  /**
+   * Mark a conversation as read.
+   */
+  async markAsRead(conversationPath) {
+    await this.database.conversations.markAsRead(conversationPath);
+    this._conversations = this._conversations.map(
+      (c) => c.conversationPath === conversationPath ? { ...c, unreadCount: 0 } : c
+    );
+    this.notify();
+  }
+  /**
+   * Get or create a ConversationStore for a specific conversation.
+   * Caches instances so repeated calls return the same store.
+   */
+  getConversationStore(conversationPath, overrides) {
+    let store = this._stores.get(conversationPath);
+    if (!store) {
+      store = new ConversationStore({
+        database: this.database,
+        conversationPath,
+        ...overrides
+      });
+      this._stores.set(conversationPath, store);
+    }
+    return store;
+  }
+  /**
+   * Clean up all resources.
+   */
+  destroy() {
+    this._realtimeSubscription?.unsubscribe();
+    this._realtimeSubscription = null;
+    for (const store of this._stores.values()) {
+      store.destroy();
+    }
+    this._stores.clear();
+    this.subscribers.clear();
+  }
+  // ==========================================================================
+  // Internal
+  // ==========================================================================
+  async startRealtimeSubscription() {
+    if (this._realtimeSubscription) return;
+    logger.debug("[ConversationListStore] Starting realtime subscription");
+    try {
+      const workspace = this.database.workspace("raisin:access_control");
+      const events = workspace.events();
+      const result = await this.database.executeSql(
+        `SELECT RAISIN_CURRENT_USER()->>'path'::String as home`
+      );
+      const rows = result.rows;
+      const userHome = rows?.[0]?.home;
+      if (!userHome) return;
+      this._realtimeSubscription = await events.subscribe(
+        buildChatsSubscriptionFilters(userHome),
+        async (event) => {
+          const eventData = event;
+          const nodeId = eventData.payload?.node_id;
+          if (!nodeId) return;
+          try {
+            const nodeResult = await this.database.executeSql(
+              `SELECT id, path, node_type, properties, created_at, updated_at FROM 'raisin:access_control' WHERE id = $1 LIMIT 1`,
+              [nodeId]
+            );
+            const row = nodeResult.rows?.[0];
+            if (!row || row.node_type !== "raisin:Conversation") return;
+            const convPath = row.path;
+            const props = row.properties ?? {};
+            const item = {
+              id: row.id,
+              type: props.conversation_type ?? "ai_chat",
+              conversationPath: convPath,
+              conversationWorkspace: "raisin:access_control",
+              agentRef: props.agent_ref,
+              participants: props.participants,
+              unreadCount: props.unread_count ?? 0,
+              lastMessage: props.last_message,
+              updatedAt: row.updated_at ?? row.created_at
+            };
+            const existingIdx = this._conversations.findIndex((c) => c.conversationPath === convPath);
+            if (existingIdx >= 0) {
+              this._conversations.splice(existingIdx, 1);
+            }
+            this._conversations = [item, ...this._conversations];
+            this.notify();
+          } catch (err) {
+            logger.debug("Failed to process conversation event:", err);
+          }
+        }
+      );
+    } catch (err) {
+      logger.debug("Failed to start realtime subscription:", err);
+    }
+  }
+  notify() {
+    const snapshot = this.getSnapshot();
+    for (const sub of this.subscribers) {
+      try {
+        sub(snapshot);
+      } catch (err) {
+        logger.error("Error in conversation list store subscriber:", err);
+      }
+    }
+  }
+};
+
+// src/integrations/vue/vue-conversation.ts
+function createUseConversation(vue) {
+  return function useConversation(options) {
+    const store = new ConversationStore(options);
+    const snapshot = vue.ref(store.getSnapshot());
+    const unsubscribe = store.subscribe((s) => {
+      snapshot.value = s;
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      store.destroy();
+    });
+    return {
+      conversation: vue.computed(() => snapshot.value.conversation),
+      messages: vue.computed(() => snapshot.value.messages),
+      isStreaming: vue.computed(() => snapshot.value.isStreaming),
+      isWaiting: vue.computed(() => snapshot.value.isWaiting),
+      streamingText: vue.computed(() => snapshot.value.streamingText),
+      error: vue.computed(() => snapshot.value.error),
+      activeToolCalls: vue.computed(() => snapshot.value.activeToolCalls),
+      plans: vue.computed(() => snapshot.value.plans),
+      isLoading: vue.computed(() => snapshot.value.isLoading),
+      conversationPath: vue.computed(() => snapshot.value.conversationPath),
+      sendMessage: (content) => store.sendMessage(content),
+      approvePlan: async (planPath) => {
+        await store.approvePlan(planPath);
+      },
+      rejectPlan: async (planPath, feedback) => {
+        await store.rejectPlan(planPath, feedback);
+      },
+      stop: () => store.stop(),
+      loadMessages: () => store.loadMessages(),
+      store
+    };
+  };
+}
+function createUseConversationList(vue) {
+  return function useConversationList(options) {
+    const store = new ConversationListStore(options);
+    const snapshot = vue.ref(store.getSnapshot());
+    const unsubscribe = store.subscribe((s) => {
+      snapshot.value = s;
+    });
+    store.load().catch((err) => {
+      logger.error("[useConversationList] Initial load failed:", err);
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      store.destroy();
+    });
+    return {
+      conversations: vue.computed(() => snapshot.value.conversations),
+      totalUnreadCount: vue.computed(() => snapshot.value.totalUnreadCount),
+      isLoading: vue.computed(() => snapshot.value.isLoading),
+      error: vue.computed(() => snapshot.value.error),
+      createConversation: (opts) => store.createConversation(opts),
+      deleteConversation: (conversationPath) => store.deleteConversation(conversationPath),
+      markAsRead: (conversationPath) => store.markAsRead(conversationPath),
+      refresh: () => store.load(),
+      store
+    };
+  };
+}
+
+// src/integrations/vue/index.ts
+function createRaisinVue(vue) {
+  return {
+    useAuth: createUseAuth(vue),
+    useConnection: createUseConnection(vue),
+    useSql: createUseSql(vue),
+    useSubscription: createUseSubscription(vue),
+    useConversation: createUseConversation(vue),
+    useConversationList: createUseConversationList(vue)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRaisinVue
+});
+//# sourceMappingURL=vue.js.map