@astralform/js 5.1.0 → 6.0.1

package/README.md

@@ -265,8 +265,13 @@ const id = await session.createNewConversation();
 // Switch to an existing conversation (loads messages from backend)
 await session.switchConversation("conversation-id");
 
-// Delete a conversation
-await session.deleteConversation("conversation-id");
+// Delete a conversation. Rejects if the server refused it — a 404 counts as
+// already deleted and resolves, anything else leaves the conversation in place.
+try {
+  await session.deleteConversation("conversation-id");
+} catch (err) {
+  // Still there: tell the user rather than removing it from your own UI.
+}
 
 // Edit and resend from a checkpoint
 await session.resendFromCheckpoint("message-id", "Updated message");
@@ -357,7 +362,7 @@ import {
   AuthenticationError, // 401 — invalid API key
   RateLimitError, // 429 — rate limit exceeded
   LLMNotConfiguredError, // LLM provider not set up
-  ServerError, // 5xx or unexpected errors
+  ServerError, // 5xx or unexpected errors — carries `status` when it came from a response
   ConnectionError, // Network failures
   StreamAbortedError, // Stream cancelled via disconnect()
 } from "@astralform/js";

package/dist/index.cjs

@@ -73,9 +73,10 @@ var LLMNotConfiguredError = class extends AstralformError {
   }
 };
 var ServerError = class extends AstralformError {
-  constructor(message = "Internal server error") {
+  constructor(message = "Internal server error", status) {
     super(message, "server_error");
     this.name = "ServerError";
+    if (status !== void 0) Object.assign(this, { status });
   }
 };
 var ConnectionError = class extends AstralformError {
@@ -105,6 +106,16 @@ function generateId() {
     return v.toString(16);
   });
 }
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function camelizeKeys(obj) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[snakeToCamel(key)] = obj[key];
+  }
+  return result;
+}
 
 // src/rate-limit.ts
 var DEFAULT_MESSAGE = "Rate limit exceeded";
@@ -255,7 +266,7 @@ async function* streamJobSSE(options) {
       case 429:
         throw createRateLimitErrorFromHttp(response, rawText);
       default:
-        throw new ServerError(text || `HTTP ${response.status}`);
+        throw new ServerError(text || `HTTP ${response.status}`, response.status);
     }
   }
   if (!response.body) {
@@ -526,7 +537,10 @@ var AstralformClient = class {
         throw createRateLimitErrorFromHttp(response, text);
       default: {
         const safeText = text ? sanitizeErrorText(text) : "";
-        throw new ServerError(safeText || `HTTP ${response.status}`);
+        throw new ServerError(
+          safeText || `HTTP ${response.status}`,
+          response.status
+        );
       }
     }
   }
@@ -563,13 +577,7 @@ var AstralformClient = class {
     const safeLimit = Math.max(1, Math.min(200, Math.floor(Number(limit))));
     const safeOffset = Math.max(0, Math.floor(Number(offset)));
     const raw = await this.get(`/v1/conversations?limit=${safeLimit}&offset=${safeOffset}`);
-    return raw.map((c) => ({
-      id: c.id,
-      title: c.title,
-      messageCount: c.message_count,
-      createdAt: c.created_at,
-      updatedAt: c.updated_at
-    }));
+    return raw.map((c) => camelizeKeys(c));
   }
   async getMessages(conversationId) {
     const raw = await this.get(`/v1/conversations/${encodeURIComponent(conversationId)}/messages`);
@@ -594,13 +602,7 @@ var AstralformClient = class {
    */
   async renameConversation(id, title) {
     const c = await this.patch(`/v1/conversations/${encodeURIComponent(id)}`, { title });
-    return {
-      id: c.id,
-      title: c.title,
-      messageCount: c.message_count,
-      createdAt: c.created_at,
-      updatedAt: c.updated_at
-    };
+    return camelizeKeys(c);
   }
   async deleteConversation(id) {
     await this.del(`/v1/conversations/${encodeURIComponent(id)}`);
@@ -613,14 +615,7 @@ var AstralformClient = class {
    */
   async getAgents() {
     const raw = await this.get("/v1/agents");
-    return raw.map((a) => ({
-      name: a.name,
-      displayName: a.display_name,
-      description: a.description,
-      isOrchestrator: a.is_orchestrator,
-      isEnabled: a.is_enabled,
-      avatarUrl: a.avatar_url
-    }));
+    return raw.map((a) => camelizeKeys(a));
   }
   /**
    * List the models the caller may pick this turn — expanded from the curated
@@ -647,12 +642,7 @@ var AstralformClient = class {
   }
   async getSkills() {
     const raw = await this.get("/v1/skills");
-    return raw.map((s) => ({
-      name: s.name,
-      displayName: s.display_name,
-      description: s.description,
-      isEnabled: s.is_enabled
-    }));
+    return raw.map((s) => camelizeKeys(s));
   }
   async getConversationEvents(conversationId, jobId) {
     let url = `/v1/conversations/${encodeURIComponent(conversationId)}/events`;
@@ -769,13 +759,7 @@ var AstralformClient = class {
   // sending them in API-key mode yields 401.
   async listTeams() {
     const raw = await this.get("/v1/teams");
-    return raw.map((t) => ({
-      id: t.id,
-      name: t.name,
-      slug: t.slug,
-      isDefault: t.is_default,
-      role: t.role
-    }));
+    return raw.map((t) => camelizeKeys(t));
   }
   /**
    * List the team-level agents (formerly "projects") the signed-in user can
@@ -784,14 +768,7 @@ var AstralformClient = class {
    */
   async listAgents(teamId) {
     const raw = await this.get(`/v1/teams/${encodeURIComponent(teamId)}/agents`);
-    return raw.map((a) => ({
-      id: a.id,
-      name: a.name,
-      teamId: a.team_id,
-      createdAt: a.created_at,
-      updatedAt: a.updated_at,
-      avatarUrl: a.avatar_url ?? null
-    }));
+    return raw.map((a) => camelizeKeys(a));
   }
   // --- Jobs API ---
   async createJob(request) {
@@ -828,13 +805,7 @@ var AstralformClient = class {
     };
     if (request.comment != null) body.comment = request.comment;
     const raw = await this.post(`/v1/jobs/${encodeURIComponent(jobId)}/feedback`, body);
-    return {
-      id: raw.id,
-      jobId: raw.job_id,
-      rating: raw.rating,
-      comment: raw.comment,
-      createdAt: raw.created_at
-    };
+    return camelizeKeys(raw);
   }
   async getActiveJob(conversationId) {
     const raw = await this.get(`/v1/conversations/${encodeURIComponent(conversationId)}/active-job`);
@@ -2222,11 +2193,12 @@ var ChatSession = class {
   /**
    * Rename a conversation, server first.
    *
-   * Deliberately NOT optimistic, unlike the delete below. A failed delete is
-   * self-correcting (the row is still there on the next page fetch), but a
-   * failed rename that had already been written locally would leave the
-   * sidebar showing a title the server never accepted — and nothing refetches
-   * a conversation that is already in the loaded list.
+   * Server first, like the delete below: a failed rename written locally would
+   * leave the sidebar showing a title the server never accepted, and nothing
+   * refetches a conversation that is already in the loaded list. (The delete
+   * used to be the counter-example here — it dropped the row whatever the
+   * server said, on the theory that a failed one was self-correcting. It was
+   * not: the row stayed deleted locally and alive on the server.)
    *
    * Mirrors the `title_generated` path: the entry in `conversations` is
    * mutated in place, which is what every consumer of the list reads.
@@ -2242,7 +2214,8 @@ var ChatSession = class {
   async deleteConversation(id) {
     try {
       await this.client.deleteConversation(id);
-    } catch {
+    } catch (err) {
+      if (!(err instanceof ServerError) || err.status !== 404) throw err;
     }
     await this.storage.deleteConversation(id);
     if (this.serverConversationIds.delete(id)) {
@@ -2268,9 +2241,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
     )
   );
@@ -2279,19 +2253,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;
@@ -2305,7 +2279,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);
@@ -2387,6 +2361,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();
   }
@@ -2455,6 +2436,7 @@ var StreamManager = class {
       target = await this.session.createNewConversation();
       this.setActiveConversation(target);
     }
+    this.turnCounter++;
     this.setState("streaming");
     try {
       await this.session.send(content, {
@@ -2491,6 +2473,7 @@ var StreamManager = class {
     );
     const lastUserMsg = userMsgs[userMsgs.length - 1];
     if (!lastUserMsg) return;
+    this.turnCounter++;
     this.setState("streaming");
     try {
       await this.session.resendFromCheckpoint(
@@ -2691,7 +2674,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);
@@ -2699,9 +2684,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);
@@ -2712,76 +2700,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) {