@astralform/js 6.0.0 → 6.0.1

package/dist/index.d.cts

@@ -1532,6 +1532,13 @@ declare class StreamManager {
      * one the user is waiting on — see ``restore``.
      */
     private generation;
+    /**
+     * Bumped every time a turn STARTS. `generation` does not move for a send
+     * (only a pointer move does), and the streaming state returns to idle when a
+     * turn ends — so neither can tell a restore that a turn ran inside one of
+     * its awaits. This can.
+     */
+    private turnCounter;
     constructor(session: ChatSession);
     get state(): StreamState;
     get activeConversationId(): string | null;
@@ -1608,6 +1615,45 @@ declare class StreamManager {
     private settleIdle;
     private finalizeStream;
     private restore;
+    /**
+     * Has a live turn taken the block view over?
+     *
+     * ``_state`` is the SYNCHRONOUS authority and ``session.isStreaming`` lags it
+     * by an await: ``send`` sets ``_state = "streaming"`` before its first await,
+     * while the session only raises its flag inside ``processStream``, behind the
+     * ``storage.addMessage`` write. For that whole window a send is underway —
+     * composer cleared, optimistic bubble drawn — and the session flag still
+     * reads false. Reading both closes the window from either end, since
+     * ``reconnectToJob`` is the mirror case: it raises the session flag without
+     * ever moving ``_state``.
+     */
+    private viewTakenOverByLiveTurn;
+    /**
+     * Has a turn STARTED since ``turn`` was captured?
+     *
+     * ``viewTakenOverByLiveTurn`` reads the current state, so it cannot see a
+     * turn that both started and ENDED inside one of the restore's awaits — a
+     * send that fails fast (auth, rate limit) resolves in about the time the job
+     * list takes, and leaves `_state` back at idle with its blocks already
+     * rendered. A monotonic count is the only thing that survives a state that
+     * has returned to where it started.
+     */
+    private turnStarted;
+    /**
+     * Replay a conversation's persisted history into the consumer's block view.
+     *
+     * Returns false when this restore lost the right to finish — a newer switch
+     * superseded it, or a send took the view over — in which case the caller
+     * must stop rather than finish. See ``restore``.
+     *
+     * ``activeJobId`` names the turn that is still running, if any. Its events
+     * are NOT fetched here: they are the live stream the caller reconnects to
+     * straight after. It is passed so ``planRestore`` can pair it with the prompt
+     * that started it, which is emitted as a bubble with no events — the whole
+     * reason a conversation reopened mid-turn now shows the message that started
+     * that turn.
+     */
+    private replayHistory;
     private setActiveConversation;
 }
 

package/dist/index.d.ts

@@ -1532,6 +1532,13 @@ declare class StreamManager {
      * one the user is waiting on — see ``restore``.
      */
     private generation;
+    /**
+     * Bumped every time a turn STARTS. `generation` does not move for a send
+     * (only a pointer move does), and the streaming state returns to idle when a
+     * turn ends — so neither can tell a restore that a turn ran inside one of
+     * its awaits. This can.
+     */
+    private turnCounter;
     constructor(session: ChatSession);
     get state(): StreamState;
     get activeConversationId(): string | null;
@@ -1608,6 +1615,45 @@ declare class StreamManager {
     private settleIdle;
     private finalizeStream;
     private restore;
+    /**
+     * Has a live turn taken the block view over?
+     *
+     * ``_state`` is the SYNCHRONOUS authority and ``session.isStreaming`` lags it
+     * by an await: ``send`` sets ``_state = "streaming"`` before its first await,
+     * while the session only raises its flag inside ``processStream``, behind the
+     * ``storage.addMessage`` write. For that whole window a send is underway —
+     * composer cleared, optimistic bubble drawn — and the session flag still
+     * reads false. Reading both closes the window from either end, since
+     * ``reconnectToJob`` is the mirror case: it raises the session flag without
+     * ever moving ``_state``.
+     */
+    private viewTakenOverByLiveTurn;
+    /**
+     * Has a turn STARTED since ``turn`` was captured?
+     *
+     * ``viewTakenOverByLiveTurn`` reads the current state, so it cannot see a
+     * turn that both started and ENDED inside one of the restore's awaits — a
+     * send that fails fast (auth, rate limit) resolves in about the time the job
+     * list takes, and leaves `_state` back at idle with its blocks already
+     * rendered. A monotonic count is the only thing that survives a state that
+     * has returned to where it started.
+     */
+    private turnStarted;
+    /**
+     * Replay a conversation's persisted history into the consumer's block view.
+     *
+     * Returns false when this restore lost the right to finish — a newer switch
+     * superseded it, or a send took the view over — in which case the caller
+     * must stop rather than finish. See ``restore``.
+     *
+     * ``activeJobId`` names the turn that is still running, if any. Its events
+     * are NOT fetched here: they are the live stream the caller reconnects to
+     * straight after. It is passed so ``planRestore`` can pair it with the prompt
+     * that started it, which is emitted as a bubble with no events — the whole
+     * reason a conversation reopened mid-turn now shows the message that started
+     * that turn.
+     */
+    private replayHistory;
     private setActiveConversation;
 }
 

package/dist/index.js

@@ -2194,9 +2194,10 @@ var ChatSession = class {
 
 // src/restore-plan.ts
 function planRestore(args) {
-  const { completedJobs, userMessages } = args;
+  const { completedJobs, runningJob, userMessages } = args;
+  const jobs = runningJob ? [...completedJobs, runningJob] : completedJobs;
   const claimed = new Set(
-    (args.claimedMessageIds ?? completedJobs.map((j) => j.message_id)).filter(
+    (args.claimedMessageIds ?? jobs.map((j) => j.message_id)).filter(
       (id) => !!id
     )
   );
@@ -2205,19 +2206,19 @@ function planRestore(args) {
     if (m.id) byId.set(m.id, i);
   });
   const linkOf = (j) => j.message_id ? byId.get(j.message_id) : void 0;
-  const positional = (jobs, msgs) => jobs.map((job, i) => ({
+  const positional = (slice, msgs) => slice.map((job, i) => ({
     kind: "turn",
     jobId: job.job_id,
     content: msgs[i]?.content,
     messageId: msgs[i]?.id
   }));
-  const firstLinked = completedJobs.findIndex((j) => linkOf(j) !== void 0);
+  const firstLinked = jobs.findIndex((j) => linkOf(j) !== void 0);
   if (firstLinked === -1) {
-    return positional(completedJobs, userMessages);
+    return positional(jobs, userMessages);
   }
-  const cutover = linkOf(completedJobs[firstLinked]);
+  const cutover = linkOf(jobs[firstLinked]);
   const steps = positional(
-    completedJobs.slice(0, firstLinked),
+    jobs.slice(0, firstLinked),
     userMessages.slice(0, cutover)
   );
   let cursor = cutover;
@@ -2231,7 +2232,7 @@ function planRestore(args) {
     }
     cursor = stopAt + 1;
   };
-  for (const job of completedJobs.slice(firstLinked)) {
+  for (const job of jobs.slice(firstLinked)) {
     const at = linkOf(job);
     if (at !== void 0) {
       drainTo(at);
@@ -2313,6 +2314,13 @@ var StreamManager = class {
      * one the user is waiting on — see ``restore``.
      */
     this.generation = 0;
+    /**
+     * Bumped every time a turn STARTS. `generation` does not move for a send
+     * (only a pointer move does), and the streaming state returns to idle when a
+     * turn ends — so neither can tell a restore that a turn ran inside one of
+     * its awaits. This can.
+     */
+    this.turnCounter = 0;
     this.session = session;
     this.attach();
   }
@@ -2381,6 +2389,7 @@ var StreamManager = class {
       target = await this.session.createNewConversation();
       this.setActiveConversation(target);
     }
+    this.turnCounter++;
     this.setState("streaming");
     try {
       await this.session.send(content, {
@@ -2417,6 +2426,7 @@ var StreamManager = class {
     );
     const lastUserMsg = userMsgs[userMsgs.length - 1];
     if (!lastUserMsg) return;
+    this.turnCounter++;
     this.setState("streaming");
     try {
       await this.session.resendFromCheckpoint(
@@ -2617,7 +2627,9 @@ var StreamManager = class {
   async restore(conversationId, gen) {
     const superseded = () => gen !== this.generation;
     if (superseded()) return;
-    if (!this.session.isStreaming) this.setState("restoring");
+    const turn = this.turnCounter;
+    const announcedRestoring = !this.session.isStreaming;
+    if (announcedRestoring) this.setState("restoring");
     let activeJobId = null;
     try {
       const res = await this.session.client.getActiveJob(conversationId);
@@ -2625,9 +2637,12 @@ var StreamManager = class {
     } catch {
     }
     if (superseded()) return;
+    await this.session.loadConversation(conversationId);
+    if (superseded()) return;
+    if (announcedRestoring && this.viewTakenOverByLiveTurn()) return;
+    if (announcedRestoring && !await this.replayHistory(conversationId, gen, activeJobId, turn))
+      return;
     if (activeJobId) {
-      await this.session.loadConversation(conversationId);
-      if (superseded()) return;
       this.setState("streaming");
       try {
         await this.session.reconnectToJob(activeJobId);
@@ -2638,76 +2653,125 @@ var StreamManager = class {
         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"
-        );
-        const userMessages = this.session.messages.filter(
-          (m) => m.role === "user"
-        );
-        const plan = planRestore({
-          completedJobs: completedJobs.map((j) => ({
-            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
-          }))
-        });
-        const eventLists = await Promise.all(
-          completedJobs.map(
-            (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,
-              [],
-              step.content,
-              step.messageId,
-              true
-            );
-            continue;
-          }
+      this.settleIdle();
+    }
+  }
+  /**
+   * Has a live turn taken the block view over?
+   *
+   * ``_state`` is the SYNCHRONOUS authority and ``session.isStreaming`` lags it
+   * by an await: ``send`` sets ``_state = "streaming"`` before its first await,
+   * while the session only raises its flag inside ``processStream``, behind the
+   * ``storage.addMessage`` write. For that whole window a send is underway —
+   * composer cleared, optimistic bubble drawn — and the session flag still
+   * reads false. Reading both closes the window from either end, since
+   * ``reconnectToJob`` is the mirror case: it raises the session flag without
+   * ever moving ``_state``.
+   */
+  viewTakenOverByLiveTurn() {
+    return this._state === "streaming" || this.session.isStreaming;
+  }
+  /**
+   * Has a turn STARTED since ``turn`` was captured?
+   *
+   * ``viewTakenOverByLiveTurn`` reads the current state, so it cannot see a
+   * turn that both started and ENDED inside one of the restore's awaits — a
+   * send that fails fast (auth, rate limit) resolves in about the time the job
+   * list takes, and leaves `_state` back at idle with its blocks already
+   * rendered. A monotonic count is the only thing that survives a state that
+   * has returned to where it started.
+   */
+  turnStarted(since) {
+    return this.turnCounter !== since;
+  }
+  /**
+   * Replay a conversation's persisted history into the consumer's block view.
+   *
+   * Returns false when this restore lost the right to finish — a newer switch
+   * superseded it, or a send took the view over — in which case the caller
+   * must stop rather than finish. See ``restore``.
+   *
+   * ``activeJobId`` names the turn that is still running, if any. Its events
+   * are NOT fetched here: they are the live stream the caller reconnects to
+   * straight after. It is passed so ``planRestore`` can pair it with the prompt
+   * that started it, which is emitted as a bubble with no events — the whole
+   * reason a conversation reopened mid-turn now shows the message that started
+   * that turn.
+   */
+  async replayHistory(conversationId, gen, activeJobId, turn) {
+    const stopReplay = () => gen !== this.generation || this.viewTakenOverByLiveTurn() || this.turnStarted(turn);
+    try {
+      const jobs = await this.session.client.get(`/v1/conversations/${encodeURIComponent(conversationId)}/jobs`);
+      if (stopReplay()) return false;
+      const completedJobs = jobs.filter(
+        (j) => j.status === "completed" && j.job_id !== activeJobId
+      );
+      const userMessages = this.session.messages.filter(
+        (m) => m.role === "user"
+      );
+      const runningJob = activeJobId ? jobs.find((j) => j.job_id === activeJobId) : void 0;
+      const plan = planRestore({
+        completedJobs: completedJobs.map((j) => ({
+          job_id: j.job_id,
+          message_id: j.message_id
+        })),
+        runningJob: runningJob && {
+          job_id: runningJob.job_id,
+          message_id: runningJob.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
+        }))
+      });
+      const eventLists = await Promise.all(
+        completedJobs.map(
+          (job) => this.session.client.getConversationEvents(conversationId, job.job_id).catch(() => [])
+        )
+      );
+      if (stopReplay()) return false;
+      const eventsByJobId = new Map(
+        completedJobs.map((job, i) => [job.job_id, eventLists[i] ?? []])
+      );
+      for (const step of plan) {
+        if (stopReplay()) return false;
+        if (step.kind === "steer") {
           this.session.replayTurn(
             conversationId,
-            eventsByJobId.get(step.jobId) ?? [],
+            [],
             step.content,
-            step.messageId
+            step.messageId,
+            true
           );
+          continue;
         }
-        if (superseded()) return;
-        if (completedJobs.length > 0) {
-          this.emit({
-            type: "versionsReady",
-            conversationId,
-            count: completedJobs.length
-          });
-        }
-      } catch {
+        this.session.replayTurn(
+          conversationId,
+          eventsByJobId.get(step.jobId) ?? [],
+          step.content,
+          step.messageId
+        );
       }
-      if (superseded()) return;
-      this.settleIdle();
+      if (stopReplay()) return false;
+      if (completedJobs.length > 0) {
+        this.emit({
+          type: "versionsReady",
+          conversationId,
+          count: completedJobs.length
+        });
+      }
+    } catch {
     }
+    return !stopReplay();
   }
   // ── Internal: set active conversation ─────────────────────────
   setActiveConversation(id) {