@raisindb/client 0.2.4 → 0.2.5

package/dist/chunk-3KMOXRTK.mjs

@@ -0,0 +1,1377 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/utils/reconnect.ts
+var ReconnectManager = class {
+  constructor(options = {}) {
+    this.attempts = 0;
+    this.isReconnecting = false;
+    this.initialDelay = options.initialDelay ?? 1e3;
+    this.maxDelay = options.maxDelay ?? 3e4;
+    this.backoffMultiplier = options.backoffMultiplier ?? 2;
+    this.maxAttempts = options.maxAttempts ?? Infinity;
+    this.jitter = options.jitter ?? true;
+    this.currentDelay = this.initialDelay;
+  }
+  /**
+   * Schedule a reconnection attempt
+   *
+   * @param callback - Function to call when it's time to reconnect
+   * @returns true if reconnection was scheduled, false if max attempts reached
+   */
+  scheduleReconnect(callback) {
+    if (this.attempts >= this.maxAttempts) {
+      return false;
+    }
+    this.cancelReconnect();
+    this.isReconnecting = true;
+    this.attempts++;
+    let delay = this.currentDelay;
+    if (this.jitter) {
+      const jitterRange = delay * 0.25;
+      delay += (Math.random() * 2 - 1) * jitterRange;
+      delay = Math.max(0, Math.round(delay));
+    }
+    this.reconnectTimeout = setTimeout(async () => {
+      try {
+        await callback();
+        this.reset();
+      } catch (error) {
+        this.currentDelay = Math.min(
+          this.currentDelay * this.backoffMultiplier,
+          this.maxDelay
+        );
+      }
+    }, delay);
+    return true;
+  }
+  /**
+   * Cancel any pending reconnection attempt
+   */
+  cancelReconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = void 0;
+    }
+    this.isReconnecting = false;
+  }
+  /**
+   * Reset the reconnection state (call after successful connection)
+   */
+  reset() {
+    this.cancelReconnect();
+    this.currentDelay = this.initialDelay;
+    this.attempts = 0;
+  }
+  /**
+   * Check if currently in reconnection mode
+   */
+  isActive() {
+    return this.isReconnecting;
+  }
+  /**
+   * Get the current number of reconnection attempts
+   */
+  getAttempts() {
+    return this.attempts;
+  }
+  /**
+   * Get the current delay in milliseconds
+   */
+  getCurrentDelay() {
+    return this.currentDelay;
+  }
+  /**
+   * Check if max attempts have been reached
+   */
+  hasReachedMaxAttempts() {
+    return this.attempts >= this.maxAttempts;
+  }
+};
+
+// src/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Silent"] = 0] = "Silent";
+  LogLevel2[LogLevel2["Error"] = 1] = "Error";
+  LogLevel2[LogLevel2["Warn"] = 2] = "Warn";
+  LogLevel2[LogLevel2["Info"] = 3] = "Info";
+  LogLevel2[LogLevel2["Debug"] = 4] = "Debug";
+  return LogLevel2;
+})(LogLevel || {});
+var config = {
+  level: 1 /* Error */,
+  prefix: "[RaisinDB]"
+};
+function configureLogger(options) {
+  config = { ...config, ...options };
+}
+function getLoggerConfig() {
+  return { ...config };
+}
+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/connection.ts
+import { EventEmitter } from "events";
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["Disconnected"] = "disconnected";
+  ConnectionState2["Connecting"] = "connecting";
+  ConnectionState2["Connected"] = "connected";
+  ConnectionState2["Reconnecting"] = "reconnecting";
+  ConnectionState2["Closed"] = "closed";
+  return ConnectionState2;
+})(ConnectionState || {});
+function getWebSocketImpl() {
+  if (typeof WebSocket !== "undefined") {
+    return WebSocket;
+  }
+  try {
+    const ws = __require("ws");
+    return ws.WebSocket || ws.default || ws;
+  } catch (error) {
+    throw new Error(
+      'WebSocket implementation not found. In Node.js, please install the "ws" package: npm install ws'
+    );
+  }
+}
+var Connection = class extends EventEmitter {
+  constructor(url, options = {}) {
+    super();
+    this.state = "disconnected" /* Disconnected */;
+    this.manualClose = false;
+    this.url = url.replace(/^raisin:\/\//, "ws://").replace(/^raisins:\/\//, "wss://");
+    this.options = {
+      autoReconnect: options.autoReconnect ?? true,
+      heartbeatInterval: options.heartbeatInterval ?? 3e4,
+      heartbeatTimeout: options.heartbeatTimeout ?? 5e3,
+      protocols: options.protocols,
+      headers: options.headers
+    };
+    this.reconnectManager = new ReconnectManager(options.reconnectOptions);
+    this.WebSocketImpl = getWebSocketImpl();
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  async connect() {
+    if (this.state === "connected" /* Connected */ || this.state === "connecting" /* Connecting */) {
+      return;
+    }
+    this.manualClose = false;
+    this.setState("connecting" /* Connecting */);
+    return new Promise((resolve, reject) => {
+      try {
+        const isBrowserWebSocket = typeof WebSocket !== "undefined" && this.WebSocketImpl === WebSocket;
+        this.ws = isBrowserWebSocket || !this.options.headers ? new this.WebSocketImpl(this.url, this.options.protocols) : new this.WebSocketImpl(this.url, this.options.protocols, {
+          headers: this.options.headers
+        });
+        this.ws.binaryType = "arraybuffer";
+        this.ws.onopen = () => {
+          this.setState("connected" /* Connected */);
+          this.reconnectManager.reset();
+          this.startHeartbeat();
+          resolve();
+        };
+        this.ws.onmessage = (event) => {
+          logger.debug(`WebSocket onmessage fired - data type: ${typeof event.data}, is ArrayBuffer: ${event.data instanceof ArrayBuffer}`);
+          this.resetHeartbeat();
+          const data = event.data;
+          logger.debug(`Received binary message - size: ${data.byteLength} bytes`);
+          logger.debug(`Emitting 'message' event to client handlers`);
+          this.emit("message", data);
+        };
+        this.ws.onerror = () => {
+          const error = new Error("WebSocket error occurred");
+          this.emit("error", error);
+          if (this.state === "connecting" /* Connecting */) {
+            reject(error);
+          }
+        };
+        this.ws.onclose = (event) => {
+          this.stopHeartbeat();
+          this.emit("close", event);
+          if (!this.manualClose && this.options.autoReconnect) {
+            this.setState("reconnecting" /* Reconnecting */);
+            this.reconnect();
+          } else {
+            this.setState("disconnected" /* Disconnected */);
+          }
+          if (this.state === "connecting" /* Connecting */) {
+            reject(new Error(`Connection closed: ${event.reason || "Unknown reason"}`));
+          }
+        };
+      } catch (error) {
+        this.setState("disconnected" /* Disconnected */);
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    this.manualClose = true;
+    this.reconnectManager.cancelReconnect();
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = void 0;
+    }
+    this.setState("closed" /* Closed */);
+  }
+  /**
+   * Send data through the WebSocket
+   *
+   * @param data - Data to send (Uint8Array for MessagePack)
+   */
+  send(data) {
+    if (this.state !== "connected" /* Connected */ || !this.ws) {
+      throw new Error("Cannot send data: not connected");
+    }
+    if (this.ws.readyState !== 1) {
+      logger.error(`WebSocket not open - readyState: ${this.ws.readyState} (0=CONNECTING, 1=OPEN, 2=CLOSING, 3=CLOSED)`);
+      throw new Error(`Cannot send data: WebSocket not open (readyState: ${this.ws.readyState})`);
+    }
+    logger.debug(`Sending message - size: ${data.length} bytes, readyState: ${this.ws.readyState}`);
+    try {
+      this.ws.send(data);
+      logger.debug(`Message sent successfully`);
+    } catch (error) {
+      logger.error(`Failed to send message:`, error);
+      throw new Error(`Failed to send data: ${error}`);
+    }
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.state === "connected" /* Connected */;
+  }
+  /**
+   * Whether auto-reconnect is enabled for this connection.
+   *
+   * Used by the client to decide whether requests issued while the
+   * connection is down can be queued (the connection will come back) or
+   * should fail immediately.
+   */
+  isAutoReconnectEnabled() {
+    return this.options.autoReconnect;
+  }
+  /**
+   * Reconnect to the server
+   */
+  reconnect() {
+    const success = this.reconnectManager.scheduleReconnect(async () => {
+      try {
+        await this.connect();
+      } catch (error) {
+      }
+    });
+    if (!success) {
+      this.setState("disconnected" /* Disconnected */);
+      this.emit("error", new Error("Max reconnection attempts reached"));
+    }
+  }
+  /**
+   * Set connection state and emit event
+   */
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.emit("stateChange", state);
+    }
+  }
+  /**
+   * Start heartbeat mechanism
+   */
+  startHeartbeat() {
+    if (this.options.heartbeatInterval <= 0) {
+      return;
+    }
+    this.stopHeartbeat();
+  }
+  /**
+   * Stop heartbeat mechanism
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+    if (this.heartbeatTimeoutTimer) {
+      clearTimeout(this.heartbeatTimeoutTimer);
+      this.heartbeatTimeoutTimer = void 0;
+    }
+  }
+  /**
+   * Reset heartbeat timeout (called when message received)
+   */
+  resetHeartbeat() {
+    if (this.heartbeatTimeoutTimer) {
+      clearTimeout(this.heartbeatTimeoutTimer);
+      this.heartbeatTimeoutTimer = void 0;
+    }
+  }
+};
+
+// 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/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/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);
+      }
+    }
+  }
+};
+
+export {
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  ReconnectManager,
+  LogLevel,
+  configureLogger,
+  getLoggerConfig,
+  setLogLevel,
+  getLogLevel,
+  logger,
+  ConnectionState,
+  Connection,
+  isRecoveredDoneEvent,
+  normalizeHomePath,
+  projectPlansFromMessages,
+  ConversationStore,
+  ConversationListStore
+};
+//# sourceMappingURL=chunk-3KMOXRTK.mjs.map