@steventsao/agent-session 0.1.23 → 0.1.25

package/dist/slice.js

@@ -1,816 +1,852 @@
-/**
- * AgentSession Redux Slice
- *
- * RTK-based state management for agent-session WebSocket.
- * Uses singleton pattern - socket lives outside React (no reconnection loops).
- *
- * Singleton socket pattern to avoid React reconnection loops
- */
-import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
-const initialState = {
-    isConnected: false,
-    clientId: null,
-    sessionId: null,
-    lastEventId: null,
-    lastServerInteraction: 0,
-    connectionHealth: 'healthy',
-    reconnectAttempts: 0,
-    sandboxStatus: 'idle',
-    sandboxId: null,
-    sandboxUrl: null,
-    lifecycle: 'idle',
-    lifecycleMessage: null,
-    agentStatus: 'idle',
-    agentSessionId: null,
-    messages: [],
-    uploadedFiles: [],
-    sandboxFiles: [],
-    error: null,
+// src/slice.ts
+import { createSlice, createAsyncThunk } from "@reduxjs/toolkit";
+var initialState = {
+  isConnected: false,
+  clientId: null,
+  sessionId: null,
+  lastEventId: null,
+  lastServerInteraction: 0,
+  connectionHealth: "healthy",
+  reconnectAttempts: 0,
+  sandboxStatus: "idle",
+  sandboxId: null,
+  sandboxUrl: null,
+  lifecycle: "idle",
+  lifecycleMessage: null,
+  agentStatus: "idle",
+  agentSessionId: null,
+  messages: [],
+  uploadedFiles: [],
+  sandboxFiles: [],
+  error: null
 };
-// Connection health constants (inspired by tldraw)
-const STALE_THRESHOLD_MS = 45_000; // 45s without server interaction = stale
-const DEAD_THRESHOLD_MS = 90_000; // 90s = dead, force reconnect
-const HEALTH_CHECK_INTERVAL_MS = 10_000; // Check every 10s
+var STALE_THRESHOLD_MS = 45e3;
+var DEAD_THRESHOLD_MS = 9e4;
+var HEALTH_CHECK_INTERVAL_MS = 1e4;
 function createClientMessageId() {
-    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
-        return crypto.randomUUID();
-    }
-    return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 }
-class SessionSocketManager {
-    ws = null;
-    dispatch = null;
-    baseUrl = null;
-    currentSessionId = null;
-    currentUserId = null;
-    pingInterval = null;
-    healthCheckInterval = null;
-    reconnectTimeout = null;
-    reconnectAttempts = 0;
-    maxReconnectAttempts = Infinity; // Unlimited retries (PartyKit pattern)
-    socketId = 0; // Prevents stale handlers
-    lastServerInteraction = 0; // Track last meaningful server response
-    lastEventId = null; // Track last event ID for session resumption
-    isReplaying = false; // True when replaying EVENTS_BATCH
-    pendingClientMessageIds = new Set();
-    pendingClientMessageTimers = new Map();
-    pendingClientMessages = new Map();
-    seenEventIds = new Set();
-    setDispatch(dispatch) {
-        this.dispatch = dispatch;
-    }
-    setBaseUrl(url) {
-        this.baseUrl = url.replace(/\/$/, '');
-    }
-    connect(sessionId, userId) {
-        if (!this.baseUrl) {
-            console.error('[SessionSocket] Base URL not set');
-            return;
-        }
-        // Already connected to same session
-        if (this.ws?.readyState === WebSocket.OPEN && this.currentSessionId === sessionId) {
-            console.log('[SessionSocket] Already connected to', sessionId);
-            return;
-        }
-        // Disconnect from previous if different session and reset state
-        if (this.currentSessionId && this.currentSessionId !== sessionId) {
-            console.log(`[SessionSocket] Switching from ${this.currentSessionId} to ${sessionId}, resetting state`);
-            this.disconnect();
-            // Reset all session-specific state when switching documents
-            // (OpenHands pattern: comprehensive state reset on conversation switch)
-            this.dispatch?.(resetSessionState());
-        }
-        this.currentSessionId = sessionId;
-        this.currentUserId = userId || null;
-        this.reconnectAttempts = 0;
-        // Load cursor from localStorage for THIS session's resumption
-        // Clear first to avoid leaking previous session's cursor
-        // (PartyKit pattern: clean slate before new room connection)
-        this.lastEventId = null;
-        if (typeof window !== 'undefined') {
-            const storedCursor = localStorage.getItem(`agent-session-cursor:${sessionId}`);
-            if (storedCursor) {
-                this.lastEventId = storedCursor;
-                console.log('[SessionSocket] Loaded cursor from localStorage:', storedCursor);
-            }
-        }
-        const thisSocketId = ++this.socketId;
-        const params = new URLSearchParams();
-        if (userId)
-            params.set('userId', userId);
-        const url = `${this.baseUrl}/session/${sessionId}/ws?${params}`;
-        console.log('[SessionSocket] Connecting to:', url);
-        this.ws = new WebSocket(url);
-        this.ws.onopen = () => {
-            if (thisSocketId !== this.socketId)
-                return;
-            console.log('[SessionSocket] Connected');
-            this.reconnectAttempts = 0;
-            this.dispatch?.(setReconnectAttempts(0));
-            this.lastServerInteraction = Date.now(); // Initialize on connect
-            this.startPing();
-            this.startHealthCheck();
-            // Send JOIN_SESSION for event resumption
-            this.send({
-                type: 'JOIN_SESSION',
-                lastEventId: this.lastEventId,
-            });
-            this.flushPendingMessages();
-        };
-        this.ws.onmessage = (event) => {
-            if (thisSocketId !== this.socketId)
-                return;
-            try {
-                const data = JSON.parse(event.data);
-                this.handleMessage(data);
-            }
-            catch (err) {
-                console.error('[SessionSocket] Parse error:', err);
-            }
-        };
-        this.ws.onclose = (event) => {
-            if (thisSocketId !== this.socketId) {
-                console.log(`[SessionSocket] Ignoring stale onclose`);
-                return;
-            }
-            console.log('[SessionSocket] Disconnected:', event.code);
-            this.stopPing();
-            this.stopHealthCheck();
-            this.dispatch?.(setDisconnected());
-            this.maybeReconnect();
-        };
-        this.ws.onerror = (event) => {
-            if (thisSocketId !== this.socketId)
-                return;
-            console.error('[SessionSocket] Error:', event);
-        };
-    }
-    disconnect() {
-        this.stopPing();
-        this.stopHealthCheck();
-        this.clearReconnect();
-        this.socketId++;
-        this.ws?.close();
-        this.ws = null;
-        this.currentSessionId = null;
-        this.currentUserId = null;
-        this.lastEventId = null; // Clear cursor to prevent leaking to next session
-        for (const timer of this.pendingClientMessageTimers.values()) {
-            clearTimeout(timer);
-        }
-        this.pendingClientMessageTimers.clear();
-        this.pendingClientMessageIds.clear();
-        this.pendingClientMessages.clear();
-        this.seenEventIds.clear();
-        this.dispatch?.(setDisconnected());
-    }
-    get isConnected() {
-        return this.ws?.readyState === WebSocket.OPEN;
-    }
-    handleMessage(event) {
-        if (!this.dispatch)
-            return;
-        const eventType = event.type;
-        if (eventType === 'MESSAGE_ACK') {
-            const ackEvent = event;
-            this.confirmClientMessage(ackEvent.clientMessageId);
-            return;
-        }
-        if (eventType === 'MESSAGE_ERROR') {
-            const errorEvent = event;
-            this.pendingClientMessageIds.delete(errorEvent.clientMessageId);
-            this.clearAckTimer(errorEvent.clientMessageId);
-            this.pendingClientMessages.delete(errorEvent.clientMessageId);
-            this.dispatch(markMessageFailed({ clientMessageId: errorEvent.clientMessageId, error: errorEvent.error }));
-            return;
+var SessionSocketManager = class {
+  ws = null;
+  dispatch = null;
+  baseUrl = null;
+  currentSessionId = null;
+  currentUserId = null;
+  pingInterval = null;
+  healthCheckInterval = null;
+  reconnectTimeout = null;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = Infinity;
+  // Unlimited retries (PartyKit pattern)
+  socketId = 0;
+  // Prevents stale handlers
+  lastServerInteraction = 0;
+  // Track last meaningful server response
+  lastEventId = null;
+  // Track last event ID for session resumption
+  isReplaying = false;
+  // True when replaying EVENTS_BATCH
+  pendingClientMessageIds = /* @__PURE__ */ new Set();
+  pendingClientMessageTimers = /* @__PURE__ */ new Map();
+  pendingClientMessages = /* @__PURE__ */ new Map();
+  seenEventIds = /* @__PURE__ */ new Set();
+  setDispatch(dispatch) {
+    this.dispatch = dispatch;
+  }
+  setBaseUrl(url) {
+    this.baseUrl = url.replace(/\/$/, "");
+  }
+  connect(sessionId, userId) {
+    if (!this.baseUrl) {
+      console.error("[SessionSocket] Base URL not set");
+      return;
+    }
+    if (this.ws?.readyState === WebSocket.OPEN && this.currentSessionId === sessionId) {
+      console.log("[SessionSocket] Already connected to", sessionId);
+      return;
+    }
+    if (this.currentSessionId && this.currentSessionId !== sessionId) {
+      console.log(`[SessionSocket] Switching from ${this.currentSessionId} to ${sessionId}, resetting state`);
+      this.disconnect();
+      this.dispatch?.(resetSessionState());
+    }
+    this.currentSessionId = sessionId;
+    this.currentUserId = userId || null;
+    this.reconnectAttempts = 0;
+    this.lastEventId = null;
+    if (typeof window !== "undefined") {
+      const storedCursor = localStorage.getItem(`agent-session-cursor:${sessionId}`);
+      if (storedCursor) {
+        this.lastEventId = storedCursor;
+        console.log("[SessionSocket] Loaded cursor from localStorage:", storedCursor);
+      }
+    }
+    const thisSocketId = ++this.socketId;
+    const params = new URLSearchParams();
+    if (userId) params.set("userId", userId);
+    const url = `${this.baseUrl}/session/${sessionId}/ws?${params}`;
+    console.log("[SessionSocket] Connecting to:", url);
+    this.ws = new WebSocket(url);
+    this.ws.onopen = () => {
+      if (thisSocketId !== this.socketId) return;
+      console.log("[SessionSocket] Connected");
+      this.reconnectAttempts = 0;
+      this.dispatch?.(setReconnectAttempts(0));
+      this.lastServerInteraction = Date.now();
+      this.startPing();
+      this.startHealthCheck();
+      this.send({
+        type: "JOIN_SESSION",
+        lastEventId: this.lastEventId
+      });
+      this.flushPendingMessages();
+    };
+    this.ws.onmessage = (event) => {
+      if (thisSocketId !== this.socketId) return;
+      try {
+        const data = JSON.parse(event.data);
+        this.handleMessage(data);
+      } catch (err) {
+        console.error("[SessionSocket] Parse error:", err);
+      }
+    };
+    this.ws.onclose = (event) => {
+      if (thisSocketId !== this.socketId) {
+        console.log(`[SessionSocket] Ignoring stale onclose`);
+        return;
+      }
+      console.log("[SessionSocket] Disconnected:", event.code);
+      this.stopPing();
+      this.stopHealthCheck();
+      this.dispatch?.(setDisconnected());
+      this.maybeReconnect();
+    };
+    this.ws.onerror = (event) => {
+      if (thisSocketId !== this.socketId) return;
+      console.error("[SessionSocket] Error:", event);
+    };
+  }
+  disconnect() {
+    this.stopPing();
+    this.stopHealthCheck();
+    this.clearReconnect();
+    this.socketId++;
+    this.ws?.close();
+    this.ws = null;
+    this.currentSessionId = null;
+    this.currentUserId = null;
+    this.lastEventId = null;
+    for (const timer of this.pendingClientMessageTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.pendingClientMessageTimers.clear();
+    this.pendingClientMessageIds.clear();
+    this.pendingClientMessages.clear();
+    this.seenEventIds.clear();
+    this.dispatch?.(setDisconnected());
+  }
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  handleMessage(event) {
+    if (!this.dispatch) return;
+    const eventType = event.type;
+    if (eventType === "MESSAGE_ACK") {
+      const ackEvent = event;
+      this.confirmClientMessage(ackEvent.clientMessageId);
+      return;
+    }
+    if (eventType === "MESSAGE_ERROR") {
+      const errorEvent = event;
+      this.pendingClientMessageIds.delete(errorEvent.clientMessageId);
+      this.clearAckTimer(errorEvent.clientMessageId);
+      this.pendingClientMessages.delete(errorEvent.clientMessageId);
+      this.dispatch(markMessageFailed({ clientMessageId: errorEvent.clientMessageId, error: errorEvent.error }));
+      return;
+    }
+    this.recordServerInteraction();
+    const eventWithId = event;
+    if (eventWithId.clientMessageId) {
+      this.confirmClientMessage(eventWithId.clientMessageId);
+    }
+    if (eventWithId.eventId) {
+      const eventId = eventWithId.eventId;
+      if (this.seenEventIds.has(eventId)) {
+        return;
+      }
+      this.seenEventIds.add(eventId);
+      this.lastEventId = eventId;
+      this.dispatch(setLastEventId(eventId));
+      if (typeof window !== "undefined" && this.currentSessionId) {
+        localStorage.setItem(`agent-session-cursor:${this.currentSessionId}`, eventId);
+      }
+    }
+    switch (event.type) {
+      case "CONNECTED":
+        this.dispatch(setConnected({
+          clientId: event.clientId,
+          sessionId: event.sessionId
+        }));
+        break;
+      case "READY":
+        this.dispatch(setReady({
+          sandboxId: event.sandboxId ?? void 0,
+          sandboxUrl: event.sandboxUrl ?? void 0
+        }));
+        break;
+      case "SANDBOX_STATUS":
+        this.dispatch(setSandboxStatus({
+          status: event.status,
+          sandboxId: event.sandboxId,
+          sandboxUrl: event.sandboxUrl,
+          error: event.error
+        }));
+        break;
+      case "LIFECYCLE":
+        this.dispatch(setLifecycle({
+          phase: event.phase,
+          message: event.message
+        }));
+        break;
+      case "AGENT_STARTED": {
+        const agentStartedEvent = event;
+        const includePrompt = this.isReplaying || !!agentStartedEvent.author;
+        this.dispatch(agentStarted({
+          prompt: includePrompt ? agentStartedEvent.prompt : void 0,
+          clientMessageId: agentStartedEvent.clientMessageId,
+          author: agentStartedEvent.author
+        }));
+        break;
+      }
+      case "AGENT_MESSAGE":
+        if (event.message?.content) {
+          this.dispatch(updateAgentMessage({ content: event.message.content }));
+          break;
         }
-        // Record server interaction for ALL messages (health check)
-        this.recordServerInteraction();
-        // Extract and store eventId from any event that has it
-        const eventWithId = event;
-        if (eventWithId.clientMessageId) {
-            this.confirmClientMessage(eventWithId.clientMessageId);
+        if (typeof event.result === "string") {
+          this.dispatch(updateAgentMessage({
+            content: [{ type: "text", text: event.result }]
+          }));
+          break;
         }
-        if (eventWithId.eventId) {
-            const eventId = eventWithId.eventId;
-            if (this.seenEventIds.has(eventId)) {
-                return;
-            }
-            this.seenEventIds.add(eventId);
-            this.lastEventId = eventId;
-            this.dispatch(setLastEventId(eventId));
-            // Persist to localStorage
-            if (typeof window !== 'undefined' && this.currentSessionId) {
-                localStorage.setItem(`agent-session-cursor:${this.currentSessionId}`, eventId);
-            }
+        if (typeof event.content === "string") {
+          this.dispatch(updateAgentMessage({
+            content: [{ type: "text", text: event.content }]
+          }));
         }
-        switch (event.type) {
-            case 'CONNECTED':
-                this.dispatch(setConnected({
-                    clientId: event.clientId,
-                    sessionId: event.sessionId,
-                }));
-                break;
-            case 'READY':
-                this.dispatch(setReady({
-                    sandboxId: event.sandboxId ?? undefined,
-                    sandboxUrl: event.sandboxUrl ?? undefined,
-                }));
-                break;
-            case 'SANDBOX_STATUS':
-                this.dispatch(setSandboxStatus({
-                    status: event.status,
-                    sandboxId: event.sandboxId,
-                    sandboxUrl: event.sandboxUrl,
-                    error: event.error,
-                }));
-                break;
-            case 'LIFECYCLE':
-                this.dispatch(setLifecycle({
-                    phase: event.phase,
-                    message: event.message,
-                }));
-                break;
-            case 'AGENT_STARTED': {
-                // Include prompt during replay (chat history restoration) OR when
-                // another client sent the message (author present = multi-client).
-                // For our own live messages, sendAgentMessage thunk already called addUserMessage.
-                const agentStartedEvent = event;
-                const includePrompt = this.isReplaying || !!agentStartedEvent.author;
-                this.dispatch(agentStarted({
-                    prompt: includePrompt ? agentStartedEvent.prompt : undefined,
-                    clientMessageId: agentStartedEvent.clientMessageId,
-                    author: agentStartedEvent.author,
-                }));
-                break;
-            }
-            case 'AGENT_MESSAGE':
-                if (event.message?.content) {
-                    this.dispatch(updateAgentMessage({ content: event.message.content }));
-                    break;
-                }
-                if (typeof event.result === 'string') {
-                    this.dispatch(updateAgentMessage({
-                        content: [{ type: 'text', text: event.result }],
-                    }));
-                    break;
-                }
-                if (typeof event.content === 'string') {
-                    this.dispatch(updateAgentMessage({
-                        content: [{ type: 'text', text: event.content }],
-                    }));
-                }
-                break;
-            case 'AGENT_DONE':
-                this.dispatch(agentDone({ sessionId: event.sessionId }));
-                break;
-            case 'AGENT_ERROR':
-                this.dispatch(agentError({ error: event.error }));
-                break;
-            case 'ERROR':
-                this.dispatch(setError(event.msg));
-                break;
-            case 'PONG':
-                // PONG already recorded above, nothing else to do
-                break;
-            case 'EVENTS_BATCH':
-                // Replay batched events to rebuild state
-                const batchEvent = event;
-                console.log('[SessionSocket] Replaying', batchEvent.events.length, 'batched events');
-                this.isReplaying = true;
-                for (const batchedEvent of batchEvent.events) {
-                    this.handleMessage(batchedEvent);
-                }
-                this.isReplaying = false;
-                if (batchEvent.lastEventId) {
-                    const lastEventId = batchEvent.lastEventId;
-                    this.lastEventId = lastEventId;
-                    this.dispatch(setLastEventId(lastEventId));
-                    // Persist to localStorage
-                    if (typeof window !== 'undefined' && this.currentSessionId) {
-                        localStorage.setItem(`agent-session-cursor:${this.currentSessionId}`, lastEventId);
-                    }
-                }
-                break;
-            case 'FILE_UPLOADED':
-                const fileEvent = event;
-                this.dispatch(addUploadedFile({
-                    path: fileEvent.path,
-                    filename: fileEvent.filename,
-                    url: fileEvent.url,
-                    mimeType: fileEvent.mimeType,
-                    description: fileEvent.description,
-                    sizeBytes: fileEvent.sizeBytes,
-                    timestamp: Date.now(),
-                }));
-                break;
-            case 'FILES_SYNC':
-                const syncEvent = event;
-                this.dispatch(setSandboxFiles(syncEvent.files));
-                break;
-            default:
-                console.log('[SessionSocket] Event:', event.type);
+        break;
+      case "AGENT_DONE":
+        this.dispatch(agentDone({ sessionId: event.sessionId }));
+        break;
+      case "AGENT_ERROR":
+        this.dispatch(agentError({ error: event.error }));
+        break;
+      case "ERROR":
+        this.dispatch(setError(event.msg));
+        break;
+      case "PONG":
+        break;
+      case "EVENTS_BATCH":
+        const batchEvent = event;
+        console.log("[SessionSocket] Replaying", batchEvent.events.length, "batched events");
+        this.isReplaying = true;
+        for (const batchedEvent of batchEvent.events) {
+          this.handleMessage(batchedEvent);
         }
-    }
-    send(message) {
-        if (this.ws?.readyState !== WebSocket.OPEN) {
-            console.warn('[SessionSocket] Not connected');
-            return false;
-        }
-        this.ws.send(JSON.stringify(message));
-        return true;
-    }
-    // Commands
-    init(metadata) {
-        this.send({ type: 'INIT', metadata });
-    }
-    startSandbox(template, bootstrap) {
-        this.send({ type: 'START_SANDBOX', template, bootstrap });
-    }
-    stopSandbox() {
-        this.send({ type: 'STOP_SANDBOX' });
-    }
-    exec(cmd, cwd) {
-        this.send({ type: 'EXEC', cmd, cwd });
-    }
-    sendAgentMessage(content, model, config, systemPrompt, agentType, clientMessageId, author) {
-        const effectiveClientMessageId = clientMessageId || createClientMessageId();
-        const message = {
-            type: 'AGENT_MESSAGE',
-            clientMessageId: effectiveClientMessageId,
-            content,
-            model,
-            config,
-            systemPrompt,
-            agentType,
-            author,
-        };
-        if (!this.pendingClientMessages.has(effectiveClientMessageId)) {
-            this.pendingClientMessages.set(effectiveClientMessageId, { message, attempts: 0 });
-        }
-        this.trySendPending(effectiveClientMessageId);
-        return effectiveClientMessageId;
-    }
-    trySendPending(clientMessageId) {
-        const pending = this.pendingClientMessages.get(clientMessageId);
-        if (!pending)
-            return;
-        if (this.pendingClientMessageIds.has(clientMessageId))
-            return;
-        const sent = this.send(pending.message);
-        if (!sent)
-            return;
-        pending.attempts += 1;
-        this.pendingClientMessageIds.add(clientMessageId);
-        this.startAckTimer(clientMessageId);
-    }
-    flushPendingMessages() {
-        for (const clientMessageId of this.pendingClientMessages.keys()) {
-            this.trySendPending(clientMessageId);
-        }
-    }
-    startAckTimer(clientMessageId) {
-        this.clearAckTimer(clientMessageId);
-        const dispatch = this.dispatch;
-        const timer = setTimeout(() => {
-            if (!this.pendingClientMessageIds.has(clientMessageId))
-                return;
-            const pending = this.pendingClientMessages.get(clientMessageId);
-            if (pending && pending.attempts < 2) {
-                this.pendingClientMessageIds.delete(clientMessageId);
-                this.trySendPending(clientMessageId);
-                return;
-            }
-            this.pendingClientMessageIds.delete(clientMessageId);
-            this.pendingClientMessages.delete(clientMessageId);
-            if (dispatch) {
-                dispatch(markMessageFailed({
-                    clientMessageId,
-                    error: 'Server did not acknowledge message',
-                }));
-            }
-        }, 2000);
-        this.pendingClientMessageTimers.set(clientMessageId, timer);
-    }
-    confirmClientMessage(clientMessageId) {
-        if (!this.pendingClientMessageIds.has(clientMessageId) && !this.pendingClientMessages.has(clientMessageId)) {
-            return;
+        this.isReplaying = false;
+        if (batchEvent.lastEventId) {
+          const lastEventId = batchEvent.lastEventId;
+          this.lastEventId = lastEventId;
+          this.dispatch(setLastEventId(lastEventId));
+          if (typeof window !== "undefined" && this.currentSessionId) {
+            localStorage.setItem(`agent-session-cursor:${this.currentSessionId}`, lastEventId);
+          }
         }
+        break;
+      case "FILE_UPLOADED":
+        const fileEvent = event;
+        this.dispatch(addUploadedFile({
+          path: fileEvent.path,
+          filename: fileEvent.filename,
+          url: fileEvent.url,
+          mimeType: fileEvent.mimeType,
+          description: fileEvent.description,
+          sizeBytes: fileEvent.sizeBytes,
+          timestamp: Date.now()
+        }));
+        break;
+      case "FILES_SYNC":
+        const syncEvent = event;
+        this.dispatch(setSandboxFiles(syncEvent.files));
+        break;
+      default:
+        console.log("[SessionSocket] Event:", event.type);
+    }
+  }
+  send(message) {
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      console.warn("[SessionSocket] Not connected");
+      return false;
+    }
+    this.ws.send(JSON.stringify(message));
+    return true;
+  }
+  // Commands
+  init(metadata) {
+    this.send({ type: "INIT", metadata });
+  }
+  startSandbox(template, bootstrap) {
+    this.send({ type: "START_SANDBOX", template, bootstrap });
+  }
+  stopSandbox() {
+    this.send({ type: "STOP_SANDBOX" });
+  }
+  exec(cmd, cwd) {
+    this.send({ type: "EXEC", cmd, cwd });
+  }
+  sendAgentMessage(content, model, config, systemPrompt, agentType, clientMessageId, author) {
+    const effectiveClientMessageId = clientMessageId || createClientMessageId();
+    const message = {
+      type: "AGENT_MESSAGE",
+      clientMessageId: effectiveClientMessageId,
+      content,
+      model,
+      config,
+      systemPrompt,
+      agentType,
+      author
+    };
+    if (!this.pendingClientMessages.has(effectiveClientMessageId)) {
+      this.pendingClientMessages.set(effectiveClientMessageId, { message, attempts: 0 });
+    }
+    this.trySendPending(effectiveClientMessageId);
+    return effectiveClientMessageId;
+  }
+  trySendPending(clientMessageId) {
+    const pending = this.pendingClientMessages.get(clientMessageId);
+    if (!pending) return;
+    if (this.pendingClientMessageIds.has(clientMessageId)) return;
+    const sent = this.send(pending.message);
+    if (!sent) return;
+    pending.attempts += 1;
+    this.pendingClientMessageIds.add(clientMessageId);
+    this.startAckTimer(clientMessageId);
+  }
+  flushPendingMessages() {
+    for (const clientMessageId of this.pendingClientMessages.keys()) {
+      this.trySendPending(clientMessageId);
+    }
+  }
+  startAckTimer(clientMessageId) {
+    this.clearAckTimer(clientMessageId);
+    const dispatch = this.dispatch;
+    const timer = setTimeout(() => {
+      if (!this.pendingClientMessageIds.has(clientMessageId)) return;
+      const pending = this.pendingClientMessages.get(clientMessageId);
+      if (pending && pending.attempts < 2) {
         this.pendingClientMessageIds.delete(clientMessageId);
-        this.pendingClientMessages.delete(clientMessageId);
-        this.clearAckTimer(clientMessageId);
-        this.dispatch?.(markMessageSent({ clientMessageId }));
-    }
-    clearAckTimer(clientMessageId) {
-        const timer = this.pendingClientMessageTimers.get(clientMessageId);
-        if (timer) {
-            clearTimeout(timer);
-            this.pendingClientMessageTimers.delete(clientMessageId);
-        }
-    }
-    stopAgent() {
-        this.send({ type: 'AGENT_STOP' });
-    }
-    resetAgent() {
-        this.send({ type: 'AGENT_RESET' });
-    }
-    startPing() {
-        this.stopPing();
-        this.pingInterval = setInterval(() => {
-            this.send({ type: 'PING' });
-        }, 30000);
-    }
-    stopPing() {
-        if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-            this.pingInterval = null;
-        }
-    }
-    /**
-     * Start health check interval (tldraw pattern)
-     * Monitors time since last server interaction and resets connection if stale
-     */
-    startHealthCheck() {
-        this.stopHealthCheck();
-        this.healthCheckInterval = setInterval(() => {
-            this.checkConnectionHealth();
-        }, HEALTH_CHECK_INTERVAL_MS);
-    }
-    stopHealthCheck() {
-        if (this.healthCheckInterval) {
-            clearInterval(this.healthCheckInterval);
-            this.healthCheckInterval = null;
-        }
-    }
-    /**
-     * Check connection health based on time since last server interaction
-     * Inspired by tldraw's MAX_TIME_TO_WAIT_FOR_SERVER_INTERACTION_BEFORE_RESETTING_CONNECTION
-     */
-    checkConnectionHealth() {
-        if (!this.isConnected)
-            return;
-        const now = Date.now();
-        const timeSinceLastInteraction = now - this.lastServerInteraction;
-        if (timeSinceLastInteraction > DEAD_THRESHOLD_MS) {
-            console.warn(`[SessionSocket] Connection dead (${timeSinceLastInteraction}ms since last interaction), forcing reconnect`);
-            this.dispatch?.(setConnectionHealth('dead'));
-            this.forceReconnect();
-        }
-        else if (timeSinceLastInteraction > STALE_THRESHOLD_MS) {
-            console.warn(`[SessionSocket] Connection stale (${timeSinceLastInteraction}ms since last interaction)`);
-            this.dispatch?.(setConnectionHealth('stale'));
-            // Send a ping to try to revive it
-            this.send({ type: 'PING' });
-        }
-        else {
-            this.dispatch?.(setConnectionHealth('healthy'));
-        }
-    }
-    /**
-     * Record server interaction timestamp
-     * Called on any meaningful server message (not just PONG)
-     */
-    recordServerInteraction() {
-        this.lastServerInteraction = Date.now();
-        this.dispatch?.(updateLastServerInteraction(this.lastServerInteraction));
-    }
-    /**
-     * Force reconnect - closes current socket and reconnects immediately
-     * Used when connection is detected as dead
-     */
-    forceReconnect() {
-        if (!this.currentSessionId)
-            return;
-        console.log('[SessionSocket] Force reconnecting...');
-        // Close current socket without triggering normal reconnect logic
-        this.stopPing();
-        this.stopHealthCheck();
-        this.socketId++;
-        this.ws?.close();
-        this.ws = null;
-        // Reset attempts and reconnect immediately
-        this.reconnectAttempts = 0;
-        this.dispatch?.(setReconnectAttempts(0));
-        this.connect(this.currentSessionId, this.currentUserId || undefined);
-    }
-    clearReconnect() {
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-            this.reconnectTimeout = null;
-        }
-    }
-    maybeReconnect() {
-        if (!this.currentSessionId)
-            return;
-        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-            console.error('[SessionSocket] Max reconnect attempts');
-            this.dispatch?.(setError('Max reconnect attempts reached'));
-            return;
-        }
-        this.reconnectAttempts++;
-        this.dispatch?.(setReconnectAttempts(this.reconnectAttempts));
-        // Exponential backoff with jitter (PartyKit pattern)
-        // Base delay: 1-5s, growth factor: 1.3, max: 10s
-        const baseDelay = 1000 + Math.random() * 4000; // 1-5s jitter
-        const delay = Math.min(baseDelay * Math.pow(1.3, this.reconnectAttempts - 1), 10000);
-        console.log(`[SessionSocket] Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts})`);
-        this.dispatch?.(setError(`Reconnecting... (attempt ${this.reconnectAttempts})`));
-        this.reconnectTimeout = setTimeout(() => {
-            if (this.currentSessionId) {
-                this.connect(this.currentSessionId, this.currentUserId || undefined);
-            }
-        }, delay);
-    }
-}
-// Singleton instance
-export const sessionSocketManager = new SessionSocketManager();
-// =============================================================================
-// Async Thunks
-// =============================================================================
-export const connectSession = createAsyncThunk('agentSession/connect', async ({ url, sessionId, userId }, { dispatch }) => {
-    sessionSocketManager.setDispatch(dispatch);
-    sessionSocketManager.setBaseUrl(url);
-    sessionSocketManager.connect(sessionId, userId);
+        this.trySendPending(clientMessageId);
+        return;
+      }
+      this.pendingClientMessageIds.delete(clientMessageId);
+      this.pendingClientMessages.delete(clientMessageId);
+      if (dispatch) {
+        dispatch(markMessageFailed({
+          clientMessageId,
+          error: "Server did not acknowledge message"
+        }));
+      }
+    }, 2e3);
+    this.pendingClientMessageTimers.set(clientMessageId, timer);
+  }
+  confirmClientMessage(clientMessageId) {
+    if (!this.pendingClientMessageIds.has(clientMessageId) && !this.pendingClientMessages.has(clientMessageId)) {
+      return;
+    }
+    this.pendingClientMessageIds.delete(clientMessageId);
+    this.pendingClientMessages.delete(clientMessageId);
+    this.clearAckTimer(clientMessageId);
+    this.dispatch?.(markMessageSent({ clientMessageId }));
+  }
+  clearAckTimer(clientMessageId) {
+    const timer = this.pendingClientMessageTimers.get(clientMessageId);
+    if (timer) {
+      clearTimeout(timer);
+      this.pendingClientMessageTimers.delete(clientMessageId);
+    }
+  }
+  stopAgent() {
+    this.send({ type: "AGENT_STOP" });
+  }
+  resetAgent() {
+    this.send({ type: "AGENT_RESET" });
+  }
+  startPing() {
+    this.stopPing();
+    this.pingInterval = setInterval(() => {
+      this.send({ type: "PING" });
+    }, 3e4);
+  }
+  stopPing() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  /**
+   * Start health check interval (tldraw pattern)
+   * Monitors time since last server interaction and resets connection if stale
+   */
+  startHealthCheck() {
+    this.stopHealthCheck();
+    this.healthCheckInterval = setInterval(() => {
+      this.checkConnectionHealth();
+    }, HEALTH_CHECK_INTERVAL_MS);
+  }
+  stopHealthCheck() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+  }
+  /**
+   * Check connection health based on time since last server interaction
+   * Inspired by tldraw's MAX_TIME_TO_WAIT_FOR_SERVER_INTERACTION_BEFORE_RESETTING_CONNECTION
+   */
+  checkConnectionHealth() {
+    if (!this.isConnected) return;
+    const now = Date.now();
+    const timeSinceLastInteraction = now - this.lastServerInteraction;
+    if (timeSinceLastInteraction > DEAD_THRESHOLD_MS) {
+      console.warn(`[SessionSocket] Connection dead (${timeSinceLastInteraction}ms since last interaction), forcing reconnect`);
+      this.dispatch?.(setConnectionHealth("dead"));
+      this.forceReconnect();
+    } else if (timeSinceLastInteraction > STALE_THRESHOLD_MS) {
+      console.warn(`[SessionSocket] Connection stale (${timeSinceLastInteraction}ms since last interaction)`);
+      this.dispatch?.(setConnectionHealth("stale"));
+      this.send({ type: "PING" });
+    } else {
+      this.dispatch?.(setConnectionHealth("healthy"));
+    }
+  }
+  /**
+   * Record server interaction timestamp
+   * Called on any meaningful server message (not just PONG)
+   */
+  recordServerInteraction() {
+    this.lastServerInteraction = Date.now();
+    this.dispatch?.(updateLastServerInteraction(this.lastServerInteraction));
+  }
+  /**
+   * Force reconnect - closes current socket and reconnects immediately
+   * Used when connection is detected as dead
+   */
+  forceReconnect() {
+    if (!this.currentSessionId) return;
+    console.log("[SessionSocket] Force reconnecting...");
+    this.stopPing();
+    this.stopHealthCheck();
+    this.socketId++;
+    this.ws?.close();
+    this.ws = null;
+    this.reconnectAttempts = 0;
+    this.dispatch?.(setReconnectAttempts(0));
+    this.connect(this.currentSessionId, this.currentUserId || void 0);
+  }
+  clearReconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+  maybeReconnect() {
+    if (!this.currentSessionId) return;
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("[SessionSocket] Max reconnect attempts");
+      this.dispatch?.(setError("Max reconnect attempts reached"));
+      return;
+    }
+    this.reconnectAttempts++;
+    this.dispatch?.(setReconnectAttempts(this.reconnectAttempts));
+    const baseDelay = 1e3 + Math.random() * 4e3;
+    const delay = Math.min(baseDelay * Math.pow(1.3, this.reconnectAttempts - 1), 1e4);
+    console.log(`[SessionSocket] Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts})`);
+    this.dispatch?.(setError(`Reconnecting... (attempt ${this.reconnectAttempts})`));
+    this.reconnectTimeout = setTimeout(() => {
+      if (this.currentSessionId) {
+        this.connect(this.currentSessionId, this.currentUserId || void 0);
+      }
+    }, delay);
+  }
+};
+var sessionSocketManager = new SessionSocketManager();
+var connectSession = createAsyncThunk("agentSession/connect", async ({ url, sessionId, userId }, { dispatch }) => {
+  sessionSocketManager.setDispatch(dispatch);
+  sessionSocketManager.setBaseUrl(url);
+  sessionSocketManager.connect(sessionId, userId);
 });
-export const disconnectSession = createAsyncThunk('agentSession/disconnect', async () => {
+var disconnectSession = createAsyncThunk(
+  "agentSession/disconnect",
+  async () => {
     sessionSocketManager.disconnect();
-});
-export const startSandbox = createAsyncThunk('agentSession/startSandbox', async (payload) => {
-    if (typeof payload === 'string') {
-        // Legacy: just template string
-        sessionSocketManager.startSandbox(payload);
-    }
-    else if (payload) {
-        // New: full payload with bootstrap options
-        sessionSocketManager.startSandbox(payload.template, payload.bootstrap);
-    }
-    else {
-        sessionSocketManager.startSandbox();
-    }
-});
-export const stopSandbox = createAsyncThunk('agentSession/stopSandbox', async () => {
+  }
+);
+var startSandbox = createAsyncThunk(
+  "agentSession/startSandbox",
+  async (payload) => {
+    if (typeof payload === "string") {
+      sessionSocketManager.startSandbox(payload);
+    } else if (payload) {
+      sessionSocketManager.startSandbox(payload.template, payload.bootstrap);
+    } else {
+      sessionSocketManager.startSandbox();
+    }
+  }
+);
+var stopSandbox = createAsyncThunk(
+  "agentSession/stopSandbox",
+  async () => {
     sessionSocketManager.stopSandbox();
-});
-export const execCommand = createAsyncThunk('agentSession/exec', async ({ cmd, cwd }) => {
+  }
+);
+var execCommand = createAsyncThunk(
+  "agentSession/exec",
+  async ({ cmd, cwd }) => {
     sessionSocketManager.exec(cmd, cwd);
+  }
+);
+var sendAgentMessage = createAsyncThunk("agentSession/sendMessage", async ({ content, model, config, systemPrompt, agentType, author }, { dispatch }) => {
+  const clientMessageId = createClientMessageId();
+  dispatch(addUserMessage({ content, clientMessageId, author }));
+  sessionSocketManager.sendAgentMessage(
+    content,
+    model,
+    config,
+    systemPrompt,
+    agentType,
+    clientMessageId,
+    author
+  );
 });
-export const sendAgentMessage = createAsyncThunk('agentSession/sendMessage', async ({ content, model, config, systemPrompt, agentType, author }, { dispatch }) => {
-    const clientMessageId = createClientMessageId();
-    dispatch(addUserMessage({ content, clientMessageId, author }));
-    sessionSocketManager.sendAgentMessage(content, model, config, systemPrompt, agentType, clientMessageId, author);
-});
-export const stopAgent = createAsyncThunk('agentSession/stopAgent', async () => {
+var stopAgent = createAsyncThunk(
+  "agentSession/stopAgent",
+  async () => {
     sessionSocketManager.stopAgent();
-});
-export const resetAgent = createAsyncThunk('agentSession/resetAgent', async (_, { dispatch }) => {
+  }
+);
+var resetAgent = createAsyncThunk(
+  "agentSession/resetAgent",
+  async (_, { dispatch }) => {
     sessionSocketManager.resetAgent();
     dispatch(clearAgentSession());
-});
-/**
- * Force reconnect - useful when connection is stale/dead
- * Inspired by tldraw's restart() method
- */
-export const forceReconnect = createAsyncThunk('agentSession/forceReconnect', async () => {
+  }
+);
+var forceReconnect = createAsyncThunk(
+  "agentSession/forceReconnect",
+  async () => {
     sessionSocketManager.forceReconnect();
-});
-// =============================================================================
-// Slice
-// =============================================================================
-const agentSessionSlice = createSlice({
-    name: 'agentSession',
-    initialState,
-    reducers: {
-        // Connection
-        setConnected: (state, action) => {
-            state.isConnected = true;
-            state.clientId = action.payload.clientId;
-            state.sessionId = action.payload.sessionId;
-            state.error = null;
-        },
-        setDisconnected: (state) => {
-            state.isConnected = false;
-            state.clientId = null;
-            state.connectionHealth = 'healthy'; // Reset health on disconnect
-        },
-        setLastEventId: (state, action) => {
-            state.lastEventId = action.payload;
-        },
-        // Connection health (tldraw pattern)
-        updateLastServerInteraction: (state, action) => {
-            state.lastServerInteraction = action.payload;
-        },
-        setConnectionHealth: (state, action) => {
-            state.connectionHealth = action.payload;
-        },
-        setReconnectAttempts: (state, action) => {
-            state.reconnectAttempts = action.payload;
-        },
-        // Sandbox
-        setReady: (state, action) => {
-            if (action.payload.sandboxId) {
-                state.sandboxId = action.payload.sandboxId;
-                // If sandbox already exists on reconnect, set status to ready immediately.
-                // This prevents the auto-start effect from firing unnecessarily.
-                //
-                // Trust relationship: Server validates sandbox health via checkSandboxHealth()
-                // before including sandboxId in READY message. If sandboxId is present, server
-                // already confirmed the sandbox is alive. See session-socket.ts constructor.
-                state.sandboxStatus = 'ready';
-            }
-            if (action.payload.sandboxUrl)
-                state.sandboxUrl = action.payload.sandboxUrl;
-        },
-        setSandboxStatus: (state, action) => {
-            state.sandboxStatus = action.payload.status;
-            if (action.payload.sandboxId)
-                state.sandboxId = action.payload.sandboxId;
-            if (action.payload.sandboxUrl)
-                state.sandboxUrl = action.payload.sandboxUrl;
-            if (action.payload.error)
-                state.error = action.payload.error;
-        },
-        setLifecycle: (state, action) => {
-            state.lifecycle = action.payload.phase;
-            state.lifecycleMessage = action.payload.message || null;
-        },
-        // Agent
-        agentStarted: (state, action) => {
-            state.agentStatus = 'streaming';
-            // Add user message if prompt provided (replay or another client's message).
-            // Skip if we already added it locally (deduplicate by clientMessageId).
-            if (action.payload?.prompt) {
-                const isDuplicate = action.payload.clientMessageId &&
-                    state.messages.some(m => m.clientMessageId === action.payload.clientMessageId);
-                if (!isDuplicate) {
-                    state.messages.push({
-                        id: `msg-user-${Date.now()}`,
-                        role: 'user',
-                        content: action.payload.prompt,
-                        timestamp: Date.now(),
-                        author: action.payload.author,
-                    });
-                }
-            }
-            const lastIdx = state.messages.length - 1;
-            if (lastIdx >= 0) {
-                const last = state.messages[lastIdx];
-                const lastContent = last.content;
-                const isEmptyAssistant = last.role === 'assistant' &&
-                    (lastContent === '' || (Array.isArray(lastContent) && lastContent.length === 0));
-                if (isEmptyAssistant)
-                    return;
-            }
-            state.messages.push({
-                id: `msg-${Date.now()}`,
-                role: 'assistant',
-                content: '',
-                timestamp: Date.now(),
-            });
-        },
-        updateAgentMessage: (state, action) => {
-            const lastIdx = state.messages.length - 1;
-            if (lastIdx >= 0 && state.messages[lastIdx].role === 'assistant') {
-                const existing = state.messages[lastIdx].content;
-                if (Array.isArray(existing) && existing.length > 0) {
-                    // Append new turn's content blocks to existing
-                    state.messages[lastIdx].content = [...existing, ...action.payload.content];
-                }
-                else {
-                    // First update (content was '' from agentStarted)
-                    state.messages[lastIdx].content = action.payload.content;
-                }
-                return;
-            }
-            state.messages.push({
-                id: `msg-${Date.now()}`,
-                role: 'assistant',
-                content: action.payload.content,
-                timestamp: Date.now(),
-            });
-        },
-        agentDone: (state, action) => {
-            state.agentStatus = 'idle';
-            if (action.payload.sessionId)
-                state.agentSessionId = action.payload.sessionId;
-        },
-        agentError: (state, action) => {
-            state.agentStatus = 'error';
-            state.error = action.payload.error;
-        },
-        addUserMessage: (state, action) => {
-            state.messages.push({
-                id: `msg-${Date.now()}`,
-                role: 'user',
-                content: action.payload.content,
-                timestamp: Date.now(),
-                clientMessageId: action.payload.clientMessageId,
-                status: action.payload.clientMessageId ? 'pending' : undefined,
-                author: action.payload.author,
-            });
-            state.error = null;
-        },
-        addAssistantPlaceholder: (state, action) => {
-            state.messages.push({
-                id: `msg-${Date.now()}`,
-                role: 'assistant',
-                content: '',
-                timestamp: Date.now(),
-                clientMessageId: action.payload.clientMessageId,
-                status: 'pending',
-            });
-        },
-        markMessageSent: (state, action) => {
-            const msg = state.messages.find((m) => m.clientMessageId === action.payload.clientMessageId);
-            if (msg) {
-                msg.status = 'sent';
-            }
-            const hasAssistant = state.messages.some((m) => m.role === 'assistant' && m.clientMessageId === action.payload.clientMessageId);
-            if (!hasAssistant) {
-                state.messages.push({
-                    id: `msg-${Date.now()}`,
-                    role: 'assistant',
-                    content: '',
-                    timestamp: Date.now(),
-                    clientMessageId: action.payload.clientMessageId,
-                    status: 'pending',
-                });
-            }
-        },
-        markMessageFailed: (state, action) => {
-            const msg = state.messages.find((m) => m.clientMessageId === action.payload.clientMessageId);
-            if (msg) {
-                msg.status = 'failed';
-            }
-            state.error = action.payload.error;
-            const lastIdx = state.messages.length - 1;
-            if (lastIdx >= 0 && state.messages[lastIdx].role === 'assistant') {
-                const lastContent = state.messages[lastIdx].content;
-                if (lastContent === '' || (Array.isArray(lastContent) && lastContent.length === 0)) {
-                    state.messages.pop();
-                }
-            }
-        },
-        // Files
-        addUploadedFile: (state, action) => {
-            state.uploadedFiles.push(action.payload);
-        },
-        clearUploadedFiles: (state) => {
-            state.uploadedFiles = [];
-        },
-        setSandboxFiles: (state, action) => {
-            state.sandboxFiles = action.payload;
-        },
-        // Error
-        setError: (state, action) => {
-            state.error = action.payload;
-        },
-        // Reset
-        clearMessages: (state) => {
-            state.messages = [];
-        },
-        clearAgentSession: (state) => {
-            state.agentSessionId = null;
-        },
-        resetState: () => initialState,
-        /**
-         * Reset session-specific state when switching documents.
-         * Clears sandbox, messages, agent state but preserves connection state.
-         * Called automatically when sessionId changes in connect().
-         */
-        resetSessionState: (state) => {
-            state.lastEventId = null; // Clear cursor to prevent cross-session contamination
-            state.sandboxStatus = 'idle';
-            state.sandboxId = null;
-            state.sandboxUrl = null;
-            state.lifecycle = 'idle';
-            state.lifecycleMessage = null;
-            state.agentStatus = 'idle';
-            state.agentSessionId = null;
-            state.messages = [];
-            state.uploadedFiles = [];
-            state.sandboxFiles = [];
-            state.error = null;
-        },
+  }
+);
+var agentSessionSlice = createSlice({
+  name: "agentSession",
+  initialState,
+  reducers: {
+    // Connection
+    setConnected: (state, action) => {
+      state.isConnected = true;
+      state.clientId = action.payload.clientId;
+      state.sessionId = action.payload.sessionId;
+      state.error = null;
+    },
+    setDisconnected: (state) => {
+      state.isConnected = false;
+      state.clientId = null;
+      state.connectionHealth = "healthy";
+    },
+    setLastEventId: (state, action) => {
+      state.lastEventId = action.payload;
+    },
+    // Connection health (tldraw pattern)
+    updateLastServerInteraction: (state, action) => {
+      state.lastServerInteraction = action.payload;
+    },
+    setConnectionHealth: (state, action) => {
+      state.connectionHealth = action.payload;
+    },
+    setReconnectAttempts: (state, action) => {
+      state.reconnectAttempts = action.payload;
     },
+    // Sandbox
+    setReady: (state, action) => {
+      if (action.payload.sandboxId) {
+        state.sandboxId = action.payload.sandboxId;
+        state.sandboxStatus = "ready";
+      }
+      if (action.payload.sandboxUrl) state.sandboxUrl = action.payload.sandboxUrl;
+    },
+    setSandboxStatus: (state, action) => {
+      state.sandboxStatus = action.payload.status;
+      if (action.payload.sandboxId) state.sandboxId = action.payload.sandboxId;
+      if (action.payload.sandboxUrl) state.sandboxUrl = action.payload.sandboxUrl;
+      if (action.payload.error) state.error = action.payload.error;
+    },
+    setLifecycle: (state, action) => {
+      state.lifecycle = action.payload.phase;
+      state.lifecycleMessage = action.payload.message || null;
+    },
+    // Agent
+    agentStarted: (state, action) => {
+      state.agentStatus = "streaming";
+      if (action.payload?.prompt) {
+        const isDuplicate = action.payload.clientMessageId && state.messages.some((m) => m.clientMessageId === action.payload.clientMessageId);
+        if (!isDuplicate) {
+          state.messages.push({
+            id: `msg-user-${Date.now()}`,
+            role: "user",
+            content: action.payload.prompt,
+            timestamp: Date.now(),
+            author: action.payload.author
+          });
+        }
+      }
+      const lastIdx = state.messages.length - 1;
+      if (lastIdx >= 0) {
+        const last = state.messages[lastIdx];
+        const lastContent = last.content;
+        const isEmptyAssistant = last.role === "assistant" && (lastContent === "" || Array.isArray(lastContent) && lastContent.length === 0);
+        if (isEmptyAssistant) return;
+      }
+      state.messages.push({
+        id: `msg-${Date.now()}`,
+        role: "assistant",
+        content: "",
+        timestamp: Date.now()
+      });
+    },
+    updateAgentMessage: (state, action) => {
+      const lastIdx = state.messages.length - 1;
+      if (lastIdx >= 0 && state.messages[lastIdx].role === "assistant") {
+        const existing = state.messages[lastIdx].content;
+        if (Array.isArray(existing) && existing.length > 0) {
+          state.messages[lastIdx].content = [...existing, ...action.payload.content];
+        } else {
+          state.messages[lastIdx].content = action.payload.content;
+        }
+        return;
+      }
+      state.messages.push({
+        id: `msg-${Date.now()}`,
+        role: "assistant",
+        content: action.payload.content,
+        timestamp: Date.now()
+      });
+    },
+    agentDone: (state, action) => {
+      state.agentStatus = "idle";
+      if (action.payload.sessionId) state.agentSessionId = action.payload.sessionId;
+    },
+    agentError: (state, action) => {
+      state.agentStatus = "error";
+      state.error = action.payload.error;
+    },
+    addUserMessage: (state, action) => {
+      state.messages.push({
+        id: `msg-${Date.now()}`,
+        role: "user",
+        content: action.payload.content,
+        timestamp: Date.now(),
+        clientMessageId: action.payload.clientMessageId,
+        status: action.payload.clientMessageId ? "pending" : void 0,
+        author: action.payload.author
+      });
+      state.error = null;
+    },
+    addAssistantPlaceholder: (state, action) => {
+      state.messages.push({
+        id: `msg-${Date.now()}`,
+        role: "assistant",
+        content: "",
+        timestamp: Date.now(),
+        clientMessageId: action.payload.clientMessageId,
+        status: "pending"
+      });
+    },
+    markMessageSent: (state, action) => {
+      const msg = state.messages.find((m) => m.clientMessageId === action.payload.clientMessageId);
+      if (msg) {
+        msg.status = "sent";
+      }
+      const hasAssistant = state.messages.some(
+        (m) => m.role === "assistant" && m.clientMessageId === action.payload.clientMessageId
+      );
+      if (!hasAssistant) {
+        state.messages.push({
+          id: `msg-${Date.now()}`,
+          role: "assistant",
+          content: "",
+          timestamp: Date.now(),
+          clientMessageId: action.payload.clientMessageId,
+          status: "pending"
+        });
+      }
+    },
+    markMessageFailed: (state, action) => {
+      const msg = state.messages.find((m) => m.clientMessageId === action.payload.clientMessageId);
+      if (msg) {
+        msg.status = "failed";
+      }
+      state.error = action.payload.error;
+      const lastIdx = state.messages.length - 1;
+      if (lastIdx >= 0 && state.messages[lastIdx].role === "assistant") {
+        const lastContent = state.messages[lastIdx].content;
+        if (lastContent === "" || Array.isArray(lastContent) && lastContent.length === 0) {
+          state.messages.pop();
+        }
+      }
+    },
+    // Files
+    addUploadedFile: (state, action) => {
+      state.uploadedFiles.push(action.payload);
+    },
+    clearUploadedFiles: (state) => {
+      state.uploadedFiles = [];
+    },
+    setSandboxFiles: (state, action) => {
+      state.sandboxFiles = action.payload;
+    },
+    // Error
+    setError: (state, action) => {
+      state.error = action.payload;
+    },
+    // Reset
+    clearMessages: (state) => {
+      state.messages = [];
+    },
+    clearAgentSession: (state) => {
+      state.agentSessionId = null;
+    },
+    resetState: () => initialState,
+    /**
+     * Reset session-specific state when switching documents.
+     * Clears sandbox, messages, agent state but preserves connection state.
+     * Called automatically when sessionId changes in connect().
+     */
+    resetSessionState: (state) => {
+      state.lastEventId = null;
+      state.sandboxStatus = "idle";
+      state.sandboxId = null;
+      state.sandboxUrl = null;
+      state.lifecycle = "idle";
+      state.lifecycleMessage = null;
+      state.agentStatus = "idle";
+      state.agentSessionId = null;
+      state.messages = [];
+      state.uploadedFiles = [];
+      state.sandboxFiles = [];
+      state.error = null;
+    }
+  }
 });
-export const { setConnected, setDisconnected, setLastEventId, updateLastServerInteraction, setConnectionHealth, setReconnectAttempts, setReady, setSandboxStatus, setLifecycle, agentStarted, updateAgentMessage, agentDone, agentError, addUserMessage, markMessageSent, markMessageFailed, addUploadedFile, clearUploadedFiles, setSandboxFiles, setError, clearMessages, clearAgentSession, resetState, resetSessionState, } = agentSessionSlice.actions;
-export const selectIsConnected = (state) => state.agentSession.isConnected;
-export const selectClientId = (state) => state.agentSession.clientId;
-export const selectSessionId = (state) => state.agentSession.sessionId;
-export const selectLastEventId = (state) => state.agentSession.lastEventId;
-export const selectLastServerInteraction = (state) => state.agentSession.lastServerInteraction;
-export const selectConnectionHealth = (state) => state.agentSession.connectionHealth;
-export const selectReconnectAttempts = (state) => state.agentSession.reconnectAttempts;
-export const selectSandboxStatus = (state) => state.agentSession.sandboxStatus;
-export const selectSandboxId = (state) => state.agentSession.sandboxId;
-export const selectSandboxUrl = (state) => state.agentSession.sandboxUrl;
-export const selectLifecycle = (state) => state.agentSession.lifecycle;
-export const selectLifecycleMessage = (state) => state.agentSession.lifecycleMessage;
-export const selectAgentStatus = (state) => state.agentSession.agentStatus;
-export const selectAgentSessionId = (state) => state.agentSession.agentSessionId;
-export const selectMessages = (state) => state.agentSession.messages;
-export const selectUploadedFiles = (state) => state.agentSession.uploadedFiles;
-export const selectSandboxFiles = (state) => state.agentSession.sandboxFiles;
-export const selectError = (state) => state.agentSession.error;
-export default agentSessionSlice.reducer;
-//# sourceMappingURL=slice.js.map
+var {
+  setConnected,
+  setDisconnected,
+  setLastEventId,
+  updateLastServerInteraction,
+  setConnectionHealth,
+  setReconnectAttempts,
+  setReady,
+  setSandboxStatus,
+  setLifecycle,
+  agentStarted,
+  updateAgentMessage,
+  agentDone,
+  agentError,
+  addUserMessage,
+  markMessageSent,
+  markMessageFailed,
+  addUploadedFile,
+  clearUploadedFiles,
+  setSandboxFiles,
+  setError,
+  clearMessages,
+  clearAgentSession,
+  resetState,
+  resetSessionState
+} = agentSessionSlice.actions;
+var selectIsConnected = (state) => state.agentSession.isConnected;
+var selectClientId = (state) => state.agentSession.clientId;
+var selectSessionId = (state) => state.agentSession.sessionId;
+var selectLastEventId = (state) => state.agentSession.lastEventId;
+var selectLastServerInteraction = (state) => state.agentSession.lastServerInteraction;
+var selectConnectionHealth = (state) => state.agentSession.connectionHealth;
+var selectReconnectAttempts = (state) => state.agentSession.reconnectAttempts;
+var selectSandboxStatus = (state) => state.agentSession.sandboxStatus;
+var selectSandboxId = (state) => state.agentSession.sandboxId;
+var selectSandboxUrl = (state) => state.agentSession.sandboxUrl;
+var selectLifecycle = (state) => state.agentSession.lifecycle;
+var selectLifecycleMessage = (state) => state.agentSession.lifecycleMessage;
+var selectAgentStatus = (state) => state.agentSession.agentStatus;
+var selectAgentSessionId = (state) => state.agentSession.agentSessionId;
+var selectMessages = (state) => state.agentSession.messages;
+var selectUploadedFiles = (state) => state.agentSession.uploadedFiles;
+var selectSandboxFiles = (state) => state.agentSession.sandboxFiles;
+var selectError = (state) => state.agentSession.error;
+var slice_default = agentSessionSlice.reducer;
+export {
+  addUploadedFile,
+  addUserMessage,
+  agentDone,
+  agentError,
+  agentStarted,
+  clearAgentSession,
+  clearMessages,
+  clearUploadedFiles,
+  connectSession,
+  slice_default as default,
+  disconnectSession,
+  execCommand,
+  forceReconnect,
+  markMessageFailed,
+  markMessageSent,
+  resetAgent,
+  resetSessionState,
+  resetState,
+  selectAgentSessionId,
+  selectAgentStatus,
+  selectClientId,
+  selectConnectionHealth,
+  selectError,
+  selectIsConnected,
+  selectLastEventId,
+  selectLastServerInteraction,
+  selectLifecycle,
+  selectLifecycleMessage,
+  selectMessages,
+  selectReconnectAttempts,
+  selectSandboxFiles,
+  selectSandboxId,
+  selectSandboxStatus,
+  selectSandboxUrl,
+  selectSessionId,
+  selectUploadedFiles,
+  sendAgentMessage,
+  sessionSocketManager,
+  setConnected,
+  setConnectionHealth,
+  setDisconnected,
+  setError,
+  setLastEventId,
+  setLifecycle,
+  setReady,
+  setReconnectAttempts,
+  setSandboxFiles,
+  setSandboxStatus,
+  startSandbox,
+  stopAgent,
+  stopSandbox,
+  updateAgentMessage,
+  updateLastServerInteraction
+};