@astralform/js 4.9.0 → 5.0.0

package/dist/index.js

@@ -1291,6 +1291,7 @@ function translateWireEvent(wire) {
 
 // src/session.ts
 var SSE_MAX_RECONNECTS = 6;
+var SSE_STALL_TIMEOUT_MS = 45e3;
 var TOOL_RESULT_MAX_RETRIES = 3;
 var CONVERSATION_PAGE_SIZE = 50;
 function sseReconnectDelayMs(attempt) {
@@ -1328,6 +1329,17 @@ var ChatSession = class {
     /** True while ``loadMoreConversations`` is in flight. */
     this.isLoadingConversations = false;
     this.messages = [];
+    /**
+     * Which conversation ``messages`` currently holds.
+     *
+     * Distinct from ``conversationId``, and the distinction is the point:
+     * ``loadConversation`` moves the POINTER synchronously and installs the LIST
+     * an await later, so for the whole duration of every load the two disagree.
+     * Anything pairing a message with a conversation — ``regenerate`` above all —
+     * has to read this one, or it will pair the previous conversation's last
+     * message with the new conversation's id.
+     */
+    this.messagesConversationId = null;
     this.isStreaming = false;
     this.agentStatus = null;
     this.agents = [];
@@ -1360,6 +1372,43 @@ var ChatSession = class {
      * is discarded instead.
      */
     this.conversationsGeneration = 0;
+    /**
+     * Bumped by every ``loadConversation`` call, so an out-of-order fetch can
+     * tell it is no longer the newest one and drop its result. Separate from
+     * ``conversationsGeneration``, which guards the conversation LIST.
+     */
+    this.loadGeneration = 0;
+    /**
+     * Ids of locally-created user messages the server has not acknowledged yet.
+     *
+     * Arrival time cannot answer "could the reply have included this?" on its
+     * own. Every `loadConversation` in `StreamManager` sits behind the
+     * active-job probe, so the ORDINARY ordering is that a send lands BEFORE the
+     * load starts — and an arrival-time rule drops exactly those, losing the
+     * prompt the user just sent while its stream is still running. Membership
+     * here is set by `send` and cleared when a server row turns up carrying the
+     * same turn, so the keep-decision no longer depends on which side of the
+     * fetch the push landed on.
+     *
+     * The value is `serverRowsKnown` as of the `message_stop` that proved the
+     * row committed, or 0 until then — including after the job response, which
+     * hands back the id but starts the loop as a background task and so proves
+     * nothing about the row. That stamp is what separates "the snapshot predates
+     * the row" from "the server does not have this row" — see
+     * `loadConversation`.
+     *
+     * It is an ANNOTATION ON `this.messages`: reconciliation only ever consults
+     * entries of that array, so an id whose message has left it is dead weight.
+     * `setMessages` is the single place the array is replaced, and it prunes.
+     */
+    this.pendingUserMessages = /* @__PURE__ */ new Map();
+    /**
+     * Bumped once per completed turn, at `message_stop`, so a fetch can record
+     * what was proven when it was ISSUED. A row proven committed before the
+     * fetch went out must appear in its snapshot; one proven after may
+     * legitimately be missing.
+     */
+    this.serverRowsKnown = 0;
     // Minimal in-session accumulation for the assistant message record.
     // Only top-level ``text`` blocks contribute; subagent / tool output
     // is tracked by the consumer's own block store.
@@ -1382,6 +1431,19 @@ var ChatSession = class {
     this.toolRegistry = new ToolRegistry();
     this.storage = storage ?? new InMemoryStorage();
   }
+  /**
+   * Replace the message list, keeping `pendingUserMessages` an annotation on
+   * it. Every removal from the array goes through here — `push` is the only
+   * other mutation and it cannot orphan an id.
+   */
+  setMessages(next) {
+    this.messages = next;
+    if (this.pendingUserMessages.size === 0) return;
+    const present = new Set(next.map((m) => m.id));
+    for (const id of this.pendingUserMessages.keys()) {
+      if (!present.has(id)) this.pendingUserMessages.delete(id);
+    }
+  }
   on(handler) {
     this.handlers.add(handler);
     return () => {
@@ -1430,6 +1492,22 @@ var ChatSession = class {
     }
     if (this.isStreaming) return;
     const conversationId = options?.conversationId ?? this.conversationId ?? void 0;
+    let relocatedFrom = null;
+    if (conversationId) {
+      if (conversationId !== this.conversationId) {
+        this.loadGeneration++;
+        relocatedFrom = {
+          messages: this.messages,
+          messagesId: this.messagesConversationId,
+          conversationId: this.conversationId,
+          generation: this.loadGeneration,
+          target: conversationId
+        };
+        this.setMessages([]);
+        this.messagesConversationId = null;
+      }
+      this.conversationId = conversationId;
+    }
     const userMessage = {
       id: generateId(),
       conversationId: conversationId ?? "",
@@ -1439,9 +1517,11 @@ var ChatSession = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (conversationId) {
-      await this.storage.addMessage(userMessage, conversationId);
+      await this.storage.addMessage(userMessage, conversationId).catch(() => {
+      });
     }
     this.messages.push(userMessage);
+    this.pendingUserMessages.set(userMessage.id, 0);
     const request = {
       message: content,
       conversation_id: conversationId,
@@ -1461,7 +1541,24 @@ var ChatSession = class {
       reasoning_effort: options?.reasoningEffort,
       temperature: options?.temperature
     };
-    await this.processStream(request);
+    const wire = { reached: false };
+    await this.processStream(request, wire);
+    if (!wire.reached) {
+      this.pendingUserMessages.delete(userMessage.id);
+      const at = this.messages.indexOf(userMessage);
+      if (at !== -1) this.messages.splice(at, 1);
+      if (conversationId) {
+        await this.storage.deleteMessage(userMessage.id).catch(() => {
+        });
+      }
+    }
+    if (relocatedFrom && wire.reached && this.loadGeneration === relocatedFrom.generation) {
+      this.messagesConversationId = relocatedFrom.target;
+    } else if (relocatedFrom && !wire.reached && this.loadGeneration === relocatedFrom.generation) {
+      this.setMessages(relocatedFrom.messages);
+      this.messagesConversationId = relocatedFrom.messagesId;
+      this.conversationId = relocatedFrom.conversationId;
+    }
   }
   async resendFromCheckpoint(messageId, newContent) {
     if (this.isStreaming) return;
@@ -1478,12 +1575,13 @@ var ChatSession = class {
     this.accumulatedText = "";
     this.currentTextPath = null;
   }
-  async processStream(request) {
+  async processStream(request, wire) {
     this.isStreaming = true;
     this.resetStreamingState();
-    this.abortController = new AbortController();
+    const controller = new AbortController();
+    this.abortController = controller;
     try {
-      await this.consumeJobStream(request);
+      await this.consumeJobStream(request, wire);
     } catch (err) {
       if (!(err instanceof DOMException && err.name === "AbortError")) {
         this.emit({
@@ -1494,16 +1592,20 @@ var ChatSession = class {
         });
       }
     } finally {
-      this.isStreaming = false;
-      this.abortController = null;
+      if (this.abortController === controller) {
+        this.isStreaming = false;
+        this.abortController = null;
+      }
     }
   }
-  async consumeJobStream(request) {
+  async consumeJobStream(request, wire) {
     const job = await this.client.createJob(request);
+    if (wire) wire.reached = true;
     this.currentJobId = job.job_id;
     const conversationId = job.conversation_id;
     if (!this.conversationId) {
       this.conversationId = conversationId;
+      this.messagesConversationId = conversationId;
     }
     if (!this.conversations.some((c) => c.id === conversationId)) {
       const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1524,13 +1626,29 @@ var ChatSession = class {
       await this.storage.addMessage(lastMsg, conversationId).catch(() => {
       });
     }
-    const messageId = job.message_id;
+    const promptMessageId = job.message_id;
+    if (promptMessageId && lastMsg?.role === "user" && this.pendingUserMessages.has(lastMsg.id)) {
+      this.pendingUserMessages.delete(lastMsg.id);
+      const clientMintedId = lastMsg.id;
+      lastMsg.id = promptMessageId;
+      this.pendingUserMessages.set(promptMessageId, 0);
+      if (conversationId && clientMintedId !== promptMessageId) {
+        await this.storage.deleteMessage(clientMintedId).catch(() => {
+        });
+        await this.storage.addMessage(lastMsg, conversationId).catch(() => {
+        });
+      }
+      const dupe = this.messages.findIndex(
+        (m) => m !== lastMsg && m.id === promptMessageId
+      );
+      if (dupe !== -1) this.messages.splice(dupe, 1);
+    }
     this.lastSeq = -1;
     this.submittedToolCallIds.clear();
     await this.consumeEventStream(
       job.job_id,
       conversationId,
-      messageId,
+      promptMessageId,
       true
       // executeClientTools
     );
@@ -1539,17 +1657,26 @@ var ChatSession = class {
    * Shared event consumption loop. Parses each wire event, updates
    * minimal session state, and emits typed ChatEvents to consumers.
    */
-  async consumeEventStream(jobId, conversationId, messageId, executeClientTools) {
+  async consumeEventStream(jobId, conversationId, promptMessageId, executeClientTools) {
     const signal = this.abortController?.signal;
     for (let attempt = 0; ; attempt++) {
-      const stream = this.client.streamJobEvents(jobId, this.lastSeq, signal);
+      if (signal?.aborted) return;
+      const attemptController = new AbortController();
+      const linkAbort = () => attemptController.abort();
+      signal?.addEventListener("abort", linkAbort);
       let sawTerminal;
       try {
+        const stream = this.client.streamJobEvents(
+          jobId,
+          this.lastSeq,
+          attemptController.signal
+        );
         sawTerminal = await this.pumpStream(
           stream,
           conversationId,
-          messageId,
-          executeClientTools
+          promptMessageId,
+          executeClientTools,
+          () => attemptController.abort()
         );
       } catch (err) {
         if (signal?.aborted) return;
@@ -1559,6 +1686,8 @@ var ChatSession = class {
         if (attempt >= SSE_MAX_RECONNECTS) throw err;
         await this.sleepUnlessAborted(sseReconnectDelayMs(attempt + 1), signal);
         continue;
+      } finally {
+        signal?.removeEventListener("abort", linkAbort);
       }
       if (sawTerminal || signal?.aborted) return;
       if (attempt >= SSE_MAX_RECONNECTS) {
@@ -1571,35 +1700,66 @@ var ChatSession = class {
    * Consume a single SSE stream to exhaustion. Returns whether a terminal
    * event (``message_stop`` / ``error``) was seen, so the caller can decide
    * whether an ended stream means "turn done" vs "dropped, reconnect".
+   *
+   * ``onStall`` aborts the per-attempt connection: if no event arrives within
+   * SSE_STALL_TIMEOUT_MS (backend keepalives land every 15s), the stream is a
+   * zombie — ``reader.read()`` will never settle — so we kill the fetch and
+   * throw a ConnectionError, feeding the caller's reconnect-from-lastSeq loop.
    */
-  async pumpStream(stream, conversationId, messageId, executeClientTools) {
+  async pumpStream(stream, conversationId, promptMessageId, executeClientTools, onStall) {
     let sawTerminal = false;
-    for await (const raw of stream) {
-      let parsed;
-      try {
-        const data = JSON.parse(raw.data);
-        if (typeof data !== "object" || data === null || typeof data.type !== "string") {
-          if (typeof data?.seq === "number") {
+    const iterator = stream[Symbol.asyncIterator]();
+    try {
+      while (true) {
+        const next = iterator.next();
+        let stallTimer;
+        const stall = new Promise((_, reject) => {
+          stallTimer = setTimeout(() => {
+            reject(
+              new ConnectionError(
+                `Stream stalled: no events for ${SSE_STALL_TIMEOUT_MS}ms`
+              )
+            );
+            onStall?.();
+          }, SSE_STALL_TIMEOUT_MS);
+        });
+        let result;
+        try {
+          result = await Promise.race([next, stall]);
+        } finally {
+          clearTimeout(stallTimer);
+        }
+        if (result.done) break;
+        const raw = result.value;
+        let parsed;
+        try {
+          const data = JSON.parse(raw.data);
+          if (typeof data !== "object" || data === null || typeof data.type !== "string") {
+            if (typeof data?.seq === "number") {
+              this.lastSeq = data.seq;
+            }
+            continue;
+          }
+          parsed = data;
+          if (typeof data.seq === "number") {
             this.lastSeq = data.seq;
           }
+        } catch {
           continue;
         }
-        parsed = data;
-        if (typeof data.seq === "number") {
-          this.lastSeq = data.seq;
+        if (parsed.type === "message_stop" || parsed.type === "error") {
+          sawTerminal = true;
         }
-      } catch {
-        continue;
-      }
-      if (parsed.type === "message_stop" || parsed.type === "error") {
-        sawTerminal = true;
+        await this.dispatchWireEvent(
+          parsed,
+          conversationId,
+          promptMessageId,
+          executeClientTools
+        );
       }
-      await this.dispatchWireEvent(
-        parsed,
-        conversationId,
-        messageId,
-        executeClientTools
-      );
+    } finally {
+      void iterator.return?.(void 0).catch(() => {
+      });
     }
     return sawTerminal;
   }
@@ -1635,8 +1795,8 @@ var ChatSession = class {
       }
     }
   }
-  async dispatchWireEvent(wire, conversationId, messageId, executeClientTools) {
-    this.applyWireSideEffects(wire, conversationId, messageId);
+  async dispatchWireEvent(wire, conversationId, promptMessageId, executeClientTools) {
+    this.applyWireSideEffects(wire, conversationId, promptMessageId, true);
     const event = translateWireEvent(wire);
     if (event) {
       this.emit(event);
@@ -1654,7 +1814,9 @@ var ChatSession = class {
         const results = await this.executeClientTools([request]);
         await this.submitToolResultWithRetry({
           conversation_id: conversationId,
-          message_id: messageId,
+          // The message that TRIGGERED the tool calls, which is what the
+          // backend stores it against — the prompt id, correctly.
+          message_id: promptMessageId,
           tool_results: results
         });
         this.submittedToolCallIds.add(callId);
@@ -1669,7 +1831,7 @@ var ChatSession = class {
    * instead of re-typing the whole conversation event by event.
    */
   replayWireEvent(wire, conversationId) {
-    this.applyWireSideEffects(wire, conversationId, "");
+    this.applyWireSideEffects(wire, conversationId, "", false);
     const event = translateWireEvent(wire);
     if (event) {
       this.emit(event);
@@ -1680,37 +1842,52 @@ var ChatSession = class {
    * the pure wire → ChatEvent mapping can live in translate.ts and be reused
    * by the replay path.
    *
-   * ``messageId`` is the server-assigned assistant message id for the current
-   * turn; empty in the reconnect and conversation-switch replay paths where
-   * messages have already been loaded from REST and shouldn't be re-pushed.
+   * ``promptMessageId`` is the id of the USER turn that started this job —
+   * `POST /v1/jobs` returns it and the backend tags the prompt with it
+   * (`HumanMessage(content=..., id=message_id)`), which is what lets a restore
+   * pair a job with its prompt by id instead of by position. It was previously
+   * documented here as the ASSISTANT's id and used as one; there is no
+   * server-assigned assistant id on the wire, so that row gets a local one.
+   * Empty in the reconnect and conversation-switch replay paths, where the
+   * messages have already been loaded from REST and must not be re-pushed —
+   * so it doubles as the "is this a live send?" gate.
    */
-  applyWireSideEffects(wire, conversationId, messageId) {
+  applyWireSideEffects(wire, conversationId, promptMessageId, live) {
+    const ownsTurnState = live || !this.isStreaming;
     switch (wire.type) {
       case "message_start":
-        this.resetStreamingState();
+        if (ownsTurnState) this.resetStreamingState();
         if (wire.model) {
           this.modelDisplayName = wire.model;
         }
         return;
       case "block_start":
-        if (wire.kind === "text" && (!wire.parent_path || wire.parent_path.length === 0)) {
+        if (ownsTurnState && wire.kind === "text" && (!wire.parent_path || wire.parent_path.length === 0)) {
           this.currentTextPath = wire.path;
         }
         return;
       case "block_delta":
-        if (wire.delta.channel === "text" && this.currentTextPath !== null && pathEquals(this.currentTextPath, wire.path)) {
+        if (ownsTurnState && wire.delta.channel === "text" && this.currentTextPath !== null && pathEquals(this.currentTextPath, wire.path)) {
           this.accumulatedText += wire.delta.text;
         }
         return;
       case "block_stop":
-        if (this.currentTextPath !== null && pathEquals(this.currentTextPath, wire.path)) {
+        if (ownsTurnState && this.currentTextPath !== null && pathEquals(this.currentTextPath, wire.path)) {
           this.currentTextPath = null;
         }
         return;
       case "message_stop":
-        if (messageId) {
+        if (promptMessageId && this.pendingUserMessages.has(promptMessageId)) {
+          this.pendingUserMessages.set(promptMessageId, ++this.serverRowsKnown);
+        }
+        if (promptMessageId) {
           const assistantMessage = {
-            id: messageId,
+            // NOT `promptMessageId` — that is the USER turn's id, which
+            // `consumeJobStream` stamps onto the user row. Sharing it puts two
+            // rows under one id, and `pendingUserMessages` is id-keyed. No
+            // server-assigned assistant id exists on the wire, so this row is
+            // local until a REST load replaces it.
+            id: generateId(),
             conversationId,
             role: "assistant",
             content: this.accumulatedText,
@@ -1721,8 +1898,10 @@ var ChatSession = class {
           this.storage.addMessage(assistantMessage, conversationId).catch(() => {
           });
         }
-        this.isStreaming = false;
-        this.currentJobId = null;
+        if (ownsTurnState) {
+          this.isStreaming = false;
+          this.currentJobId = null;
+        }
         return;
       case "custom":
         if (wire.name === "title_generated") {
@@ -1756,9 +1935,27 @@ var ChatSession = class {
    * Used before reconnectToJob — SSE replay handles event replay.
    */
   async loadConversation(id) {
+    const load = ++this.loadGeneration;
     this.conversationId = id;
-    this.resetStreamingState();
-    this.messages = await this.client.getMessages(id).catch(() => this.storage.fetchMessages(id));
+    if (!this.isStreaming) this.resetStreamingState();
+    const rowsKnownAtIssue = this.serverRowsKnown;
+    const messages = await this.client.getMessages(id).catch(() => this.storage.fetchMessages(id));
+    if (load !== this.loadGeneration) return;
+    const pending = this.messages.filter(
+      (m) => this.pendingUserMessages.has(m.id) && m.conversationId === id
+    );
+    const stillPending = pending.filter((m) => {
+      if (messages.some((f) => f.id === m.id)) return false;
+      const knownAt = this.pendingUserMessages.get(m.id) ?? 0;
+      return knownAt === 0 || knownAt > rowsKnownAtIssue;
+    });
+    for (const m of pending) {
+      if (!stillPending.includes(m)) this.pendingUserMessages.delete(m.id);
+    }
+    this.setMessages(
+      stillPending.length ? [...messages, ...stillPending] : messages
+    );
+    this.messagesConversationId = id;
   }
   /**
    * Reconnect to a running job's SSE stream (e.g. after page reload).
@@ -1771,7 +1968,8 @@ var ChatSession = class {
     this.lastSeq = -1;
     this.submittedToolCallIds.clear();
     this.resetStreamingState();
-    this.abortController = new AbortController();
+    const controller = new AbortController();
+    this.abortController = controller;
     try {
       await this.consumeEventStream(
         jobId,
@@ -1788,8 +1986,10 @@ var ChatSession = class {
         blockPath: null
       });
     } finally {
-      this.isStreaming = false;
-      this.abortController = null;
+      if (this.abortController === controller) {
+        this.isStreaming = false;
+        this.abortController = null;
+      }
     }
   }
   /** Detach from the SSE stream without cancelling the job. */
@@ -1800,25 +2000,54 @@ var ChatSession = class {
     this.resetStreamingState();
     this.emit({ type: "disconnected" });
   }
-  /** Stop the job and disconnect (explicit user action). */
-  disconnect() {
+  /**
+   * Cancel the running turn: stop the job server-side and tear the stream
+   * down, WITHOUT ending the session. A turn-level cancel is not a
+   * session-level teardown, so unlike `disconnect()` this leaves the protocol
+   * registry alone — the SDK never auto-registers adapters, so clearing them
+   * on a Stop press would silently kill embedded-resource rendering for the
+   * rest of the session with nothing to re-register it.
+   */
+  cancelTurn() {
     if (this.currentJobId) {
       this.client.cancelJob(this.currentJobId).catch(() => {
       });
     }
     this.detach();
     this.currentJobId = null;
+    for (const [id, knownAt] of this.pendingUserMessages) {
+      if (knownAt === 0) this.pendingUserMessages.delete(id);
+    }
+  }
+  /** Stop the job and end the session's activity (explicit user action). */
+  disconnect() {
+    this.cancelTurn();
     this.protocols.clear();
   }
+  /**
+   * A pointer move happened above this layer, so any `loadConversation` in
+   * flight must lose to it. `StreamManager` owns a pointer of its own and
+   * moves it before this one; without this the two halves would gate on
+   * counters that bump at different instants — `generation` synchronously in
+   * `setActiveConversation`, `loadGeneration` only once the switch's own load
+   * actually runs, which is behind the active-job probe.
+   */
+  invalidateLoadsInFlight() {
+    this.loadGeneration++;
+  }
   async createNewConversation() {
     const id = generateId();
+    const load = this.loadGeneration;
     const conversation = await this.storage.createConversation(
       id,
       "New Conversation"
     );
     this.conversations.unshift(conversation);
+    if (load !== this.loadGeneration) return id;
+    this.loadGeneration++;
     this.conversationId = id;
-    this.messages = [];
+    this.setMessages([]);
+    this.messagesConversationId = id;
     return id;
   }
   /**
@@ -1837,7 +2066,7 @@ var ChatSession = class {
    */
   replayTurn(id, events, userMessageContent, userMessageId, isSteer = false) {
     this.conversationId = id;
-    this.resetStreamingState();
+    if (!this.isStreaming) this.resetStreamingState();
     if (userMessageContent) {
       this.emit({
         type: "user_message",
@@ -1868,11 +2097,17 @@ var ChatSession = class {
    * job's events.
    */
   async switchConversation(id, jobId) {
-    const [messagesResult, eventsResult] = await Promise.allSettled([
-      this.client.getMessages(id).catch(() => this.storage.fetchMessages(id)),
+    const loading = this.loadConversation(id);
+    const token = this.loadGeneration;
+    const [loadResult, eventsResult] = await Promise.allSettled([
+      loading,
       this.client.getConversationEvents(id, jobId)
     ]);
-    this.messages = messagesResult.status === "fulfilled" ? messagesResult.value : [];
+    if (token !== this.loadGeneration) return;
+    if (loadResult.status === "rejected") {
+      this.setMessages([]);
+      this.messagesConversationId = id;
+    }
     this.replayTurn(
       id,
       eventsResult.status === "fulfilled" ? eventsResult.value : []
@@ -1963,8 +2198,10 @@ var ChatSession = class {
     }
     this.conversations = this.conversations.filter((c) => c.id !== id);
     if (this.conversationId === id) {
+      this.loadGeneration++;
       this.conversationId = null;
-      this.messages = [];
+      this.setMessages([]);
+      this.messagesConversationId = null;
     }
   }
   toggleClientTool(name) {
@@ -1980,6 +2217,11 @@ var ChatSession = class {
 // src/restore-plan.ts
 function planRestore(args) {
   const { completedJobs, userMessages } = args;
+  const claimed = new Set(
+    (args.claimedMessageIds ?? completedJobs.map((j) => j.message_id)).filter(
+      (id) => !!id
+    )
+  );
   const byId = /* @__PURE__ */ new Map();
   userMessages.forEach((m, i) => {
     if (m.id) byId.set(m.id, i);
@@ -2001,7 +2243,7 @@ function planRestore(args) {
     userMessages.slice(0, cutover)
   );
   let cursor = cutover;
-  const isSteer = (m) => !!m?.id && !completedJobs.some((j) => j.message_id === m.id);
+  const isSteer = (m) => !!m?.id && !claimed.has(m.id);
   const drainTo = (stopAt) => {
     while (cursor < stopAt) {
       const m = userMessages[cursor++];
@@ -2087,6 +2329,12 @@ var StreamManager = class {
     this._backgroundJobs = /* @__PURE__ */ new Map();
     this.handlers = [];
     this.unsub = null;
+    /**
+     * Bumped every time the active conversation moves. An async sequence that
+     * captures it can then tell, at each await boundary, whether it is still the
+     * one the user is waiting on — see ``restore``.
+     */
+    this.generation = 0;
     this.session = session;
     this.attach();
   }
@@ -2137,7 +2385,7 @@ var StreamManager = class {
       event
     });
     if (event.type === ChatEventType.MessageStop) {
-      if (this._state === "streaming") {
+      if (this._state === "streaming" && !this.session.isStreaming) {
         this.setState("idle");
       }
     }
@@ -2150,13 +2398,21 @@ var StreamManager = class {
       );
     }
     if (this._state === "streaming") return;
-    if (!this._activeConversationId) {
-      const id = await this.session.createNewConversation();
-      this.setActiveConversation(id);
+    let target = this._activeConversationId;
+    if (!target) {
+      target = await this.session.createNewConversation();
+      this.setActiveConversation(target);
     }
     this.setState("streaming");
     try {
       await this.session.send(content, {
+        // Address the send explicitly. `ChatSession.send` otherwise falls back
+        // to `session.conversationId`, which LAGS this pointer: a restore
+        // assigns it synchronously but only reaches the next switch's own
+        // `loadConversation` an await later, so between the two the session
+        // still names the conversation the user left. The manager's pointer
+        // moved the moment the user clicked; it is the authority.
+        conversationId: target ?? void 0,
         agentName: options?.agentName,
         uploadIds: options?.uploadIds,
         planMode: options?.planMode,
@@ -2175,6 +2431,9 @@ var StreamManager = class {
   // ── Regenerate ────────────────────────────────────────────────
   async regenerate() {
     if (this._state === "streaming") return;
+    if (this.session.messagesConversationId !== this._activeConversationId) {
+      return;
+    }
     const userMsgs = this.session.messages.filter(
       (m) => m.role === "user"
     );
@@ -2211,44 +2470,78 @@ var StreamManager = class {
   async switchTo(conversationId, opts) {
     if (conversationId === this._activeConversationId) return;
     const targetHadBackgroundJob = this._backgroundJobs.has(conversationId);
-    if (this._state === "streaming") {
-      const oldConvId = this._activeConversationId;
-      const jobId = this.session.currentJobId;
-      if (oldConvId && jobId) {
-        this._backgroundJobs.set(oldConvId, jobId);
-        this.emit({
-          type: "backgroundJobsChanged",
-          jobs: this._backgroundJobs
-        });
-      }
-      this.session.detach();
-    }
-    if (this._backgroundJobs.has(conversationId)) {
+    this.detachStreamingTurn();
+    const parkedJobId = this._backgroundJobs.get(conversationId);
+    if (parkedJobId !== void 0) {
       this._backgroundJobs.delete(conversationId);
       this.emit({
         type: "backgroundJobsChanged",
         jobs: this._backgroundJobs
       });
     }
-    this.setActiveConversation(conversationId);
+    const gen = this.setActiveConversation(conversationId);
     if (opts?.skipHistoryReplay && !targetHadBackgroundJob) {
       let activeJobId = null;
       try {
         activeJobId = (await this.session.client.getActiveJob(conversationId)).jobId;
       } catch {
       }
+      if (gen !== this.generation) return;
       if (!activeJobId) {
-        await this.session.loadConversation(conversationId);
-        this.setState("idle");
+        try {
+          await this.session.loadConversation(conversationId);
+        } finally {
+          if (gen === this.generation) this.settleIdle();
+        }
         return;
       }
     }
-    await this.restore(conversationId);
+    let tookOver = false;
+    try {
+      await this.restore(conversationId, gen);
+      tookOver = gen === this.generation;
+    } finally {
+      const supersededOntoSame = gen !== this.generation && this._activeConversationId === conversationId;
+      const stillExists = this.session.conversations.some(
+        (c) => c.id === conversationId
+      );
+      if (parkedJobId !== void 0 && !tookOver && !supersededOntoSame && stillExists) {
+        this._backgroundJobs.set(conversationId, parkedJobId);
+        this.emit({
+          type: "backgroundJobsChanged",
+          jobs: this._backgroundJobs
+        });
+      }
+      if (!tookOver && gen === this.generation && this._state === "restoring") {
+        this.settleIdle();
+      }
+    }
   }
   // ── Create / rename / delete conversation ─────────────────────
+  /**
+   * Create a conversation and make it active.
+   *
+   * The returned id is NOT guaranteed to be the active conversation: if a
+   * switch lands inside the storage round-trip, this declines the pointer move
+   * so the newer one wins, and no `conversationChanged` fires for the new id.
+   * A caller that routes on the return value should `switchTo(id)` rather than
+   * assume it is current — that call is not a no-op in the declined case.
+   */
   async createConversation() {
-    const id = await this.session.createNewConversation();
+    this.detachStreamingTurn();
+    let id;
+    try {
+      id = await this.session.createNewConversation();
+    } catch (err) {
+      this.settleIdle();
+      throw err;
+    }
+    if (this.session.conversationId !== id) {
+      this.settleIdle();
+      return id;
+    }
     this.setActiveConversation(id);
+    this.settleIdle();
     return id;
   }
   /**
@@ -2259,16 +2552,34 @@ var StreamManager = class {
     await this.session.renameConversation(id, title);
   }
   async deleteConversation(id) {
-    await this.session.deleteConversation(id);
-    this._backgroundJobs.delete(id);
+    const wasActive = this._activeConversationId === id;
+    const cancelled = wasActive && this._state === "streaming";
+    if (cancelled) {
+      this.session.cancelTurn();
+      this._state = "idle";
+    }
+    try {
+      await this.session.deleteConversation(id);
+    } catch (err) {
+      if (cancelled) this.setState("idle");
+      throw err;
+    }
     if (this._activeConversationId === id) {
-      this._activeConversationId = null;
-      this.emit({ type: "conversationChanged", conversationId: null });
+      this.setActiveConversation(null);
+      this.settleIdle();
+    }
+    const parkedJobId = this._backgroundJobs.get(id);
+    if (this._backgroundJobs.delete(id)) {
+      if (parkedJobId) {
+        this.session.client.cancelJob(parkedJobId).catch(() => {
+        });
+      }
+      this.emit({ type: "backgroundJobsChanged", jobs: this._backgroundJobs });
     }
   }
   // ── Stop (explicit cancel) ────────────────────────────────────
   stop() {
-    this.session.disconnect();
+    this.session.cancelTurn();
     this.setState("idle");
   }
   // ── Cleanup ───────────────────────────────────────────────────
@@ -2280,34 +2591,80 @@ var StreamManager = class {
     this.handlers = [];
   }
   // ── Internal: helpers ──────────────────────────────────────────
+  /**
+   * Park a streaming turn as a background job and detach from its SSE stream.
+   *
+   * Every method that relocates the active conversation has to do this before
+   * announcing a new state. Announcing `idle` while `session.isStreaming` is
+   * still true is worse than announcing nothing: `manager.send` no longer bails
+   * on the streaming state, calls `session.send`, and THAT bails on its own
+   * `isStreaming` — so the message is never posted, no error is emitted, and
+   * the composer looks ready the whole time.
+   */
+  detachStreamingTurn() {
+    if (this._state !== "streaming") return;
+    const oldConvId = this._activeConversationId;
+    const jobId = this.session.currentJobId;
+    if (oldConvId && jobId) {
+      this._backgroundJobs.set(oldConvId, jobId);
+      this.emit({ type: "backgroundJobsChanged", jobs: this._backgroundJobs });
+    }
+    this.session.detach();
+    this.session.currentJobId = null;
+    this._state = "idle";
+  }
+  /**
+   * Announce `idle` unless a turn is actually streaming.
+   *
+   * A `send` can land inside any of the switch paths — the fast path most
+   * easily, since it deliberately stays out of `restoring` and so leaves the
+   * composer live for the whole probe. `send` sets `streaming` and does not
+   * bump the generation, so the path resumes, passes its supersession check,
+   * and would announce a ready composer over a running stream. From there
+   * `finalizeStream` and the `message_stop` branch both no-op (they only act
+   * on `streaming`), so it stays `idle` for the whole turn — and the next send
+   * reaches `session.send`, which bails on its own `isStreaming`: message
+   * never posted, no error, composer ready throughout.
+   */
+  settleIdle() {
+    if (this._state === "streaming") return;
+    this.setState("idle");
+  }
   finalizeStream() {
     if (this._state === "streaming") {
       this.setState("idle");
     }
   }
   // ── Internal: restore ─────────────────────────────────────────
-  async restore(conversationId) {
-    this.setState("restoring");
+  async restore(conversationId, gen) {
+    const superseded = () => gen !== this.generation;
+    if (superseded()) return;
+    if (!this.session.isStreaming) this.setState("restoring");
     let activeJobId = null;
     try {
       const res = await this.session.client.getActiveJob(conversationId);
       activeJobId = res.jobId;
     } catch {
     }
+    if (superseded()) return;
     if (activeJobId) {
       await this.session.loadConversation(conversationId);
+      if (superseded()) return;
       this.setState("streaming");
       try {
         await this.session.reconnectToJob(activeJobId);
       } catch {
       }
-      if (this._state === "streaming") {
+      if (superseded()) return;
+      if (this._state === "streaming" && !this.session.isStreaming) {
         this.setState("idle");
       }
     } else {
       await this.session.loadConversation(conversationId);
+      if (superseded()) return;
       try {
         const jobs = await this.session.client.get(`/v1/conversations/${encodeURIComponent(conversationId)}/jobs`);
+        if (superseded()) return;
         const completedJobs = jobs.filter(
           (j) => j.status === "completed"
         );
@@ -2319,6 +2676,14 @@ var StreamManager = class {
             job_id: j.job_id,
             message_id: j.message_id
           })),
+          // Completed jobs PLUS the ones still going. A send landing in the
+          // probe window has a running job, so its prompt is claimed and does
+          // not read as a steer replayed over the bubble the live send already
+          // rendered. Failed and cancelled jobs are deliberately NOT claimed:
+          // they produce no `turn` step, so claiming them would delete the
+          // user's prompt from the restore entirely rather than show it as a
+          // steer.
+          claimedMessageIds: jobs.filter((j) => j.status !== "failed" && j.status !== "cancelled").map((j) => j.message_id),
           userMessages: userMessages.map((m) => ({
             id: m.id,
             content: m.content
@@ -2329,10 +2694,12 @@ var StreamManager = class {
             (job) => this.session.client.getConversationEvents(conversationId, job.job_id).catch(() => [])
           )
         );
+        if (superseded()) return;
         const eventsByJobId = new Map(
           completedJobs.map((job, i) => [job.job_id, eventLists[i] ?? []])
         );
         for (const step of plan) {
+          if (superseded()) return;
           if (step.kind === "steer") {
             this.session.replayTurn(
               conversationId,
@@ -2350,6 +2717,7 @@ var StreamManager = class {
             step.messageId
           );
         }
+        if (superseded()) return;
         if (completedJobs.length > 0) {
           this.emit({
             type: "versionsReady",
@@ -2359,13 +2727,17 @@ var StreamManager = class {
         }
       } catch {
       }
-      this.setState("idle");
+      if (superseded()) return;
+      this.settleIdle();
     }
   }
   // ── Internal: set active conversation ─────────────────────────
   setActiveConversation(id) {
     this._activeConversationId = id;
+    this.session.invalidateLoadsInFlight();
+    const claimed = ++this.generation;
     this.emit({ type: "conversationChanged", conversationId: id });
+    return claimed;
   }
 };