@frockbot/plugin-shell 0.3.11 → 0.3.13

package/src/client/index.test.ts

@@ -572,7 +572,11 @@ describe("Bot selection", () => {
     await Promise.all([botLoad, olderLoad]);
 
     expect(provided.value.userSettings?.profile.name).toBe("Newer");
-    expect(provided.value.settingsError).toBe("Bot settings unavailable");
+    // The surface says what failed and what it was for; the thrown text
+    // ("Bot settings unavailable") stays in the console.
+    expect(provided.value.settingsError).toBe(
+      "Couldn't load this Bot's settings.",
+    );
   });
 
   test("says a deployment has no Catalog instead of relaying the gateway's sentence", async () => {
@@ -608,12 +612,14 @@ describe("Bot selection", () => {
       "No plugins are published for this deployment yet.",
     );
 
-    // A genuine fault still reaches the operator, labelled as one.
+    // A genuine fault is labelled as one — and says what failed rather than
+    // what the storage layer called it. "R2 is down" is for the console.
     failure = new Error("R2 is down");
     await provided.value.loadPackageCatalog();
     expect(provided.value.settingsError).toBe(
-      "Plugins could not be loaded: R2 is down",
+      "Couldn't load the plugin catalog.",
     );
+    expect(provided.value.settingsError).not.toContain("R2");
   });
 
   test("commits a catalog without overwriting newer User settings", async () => {
@@ -1258,14 +1264,20 @@ describe("detached Turn projection", () => {
       ],
     );
 
+    // The failure is a notice under the reply, never a bubble that reads as
+    // the Bot saying the provider's own words.
     expect(messages).toMatchObject([
       { role: "user", status: "completed" },
       {
         role: "assistant",
-        text: "This Bot couldn't finish its reply. Try again.",
+        text: "",
+        notice: "This Bot couldn't finish its reply. Try again.",
         status: "error",
       },
     ]);
+    expect(JSON.stringify(messages)).not.toContain(
+      "Provider reconciliation is required",
+    );
   });
 });
 
@@ -1514,16 +1526,95 @@ describe("active durable Turn projection", () => {
       ],
     );
 
-    expect(state.messages[1]?.sends).toEqual([
+    // One message per send, in the order they were sent, and nothing merged:
+    // the last line is the Turn's own, and it carries no send at all.
+    expect(
+      state.messages.slice(1).map((message) => [message.id, message.sends]),
+    ).toEqual([
+      [
+        "run-send:send:0",
+        [{ kind: "payload", payload: { type: "text", text: "On it." } }],
+      ],
+      [
+        "run-send:send:1",
+        [
+          {
+            kind: "payload",
+            payload: {
+              type: "widget",
+              widget: { prompt: "Which day?", options: ["Tue"] },
+            },
+          },
+        ],
+      ],
+      ["run-send:send:2", [{ kind: "unsupported" }]],
+      ["run-send:assistant", []],
+    ]);
+  });
+
+  test("a second send is a new bubble, and never rewrites the first", () => {
+    const state: Pick<
+      FrockBotWebData,
+      "messages" | "activeRunId" | "activeRun"
+    > = { messages: [] };
+    const run = (
+      events: ClientRun["events"],
+      status: ClientRun["status"] = "running",
+    ): ClientRun => ({
+      runId: "run-stack",
+      input: "Book it",
+      admittedAt: "2026-09-04T00:00:00.000Z",
+      status,
+      events,
+    });
+
+    // The acknowledgement arrives first, on its own.
+    projectDurableRuns(state, [], [
+      run([
+        { type: "send/to-user", payload: { type: "text", text: "On it." } },
+      ]),
+    ] as ClientRun[]);
+    const acknowledgement = state.messages[1];
+    expect(acknowledgement?.sends).toEqual([
       { kind: "payload", payload: { type: "text", text: "On it." } },
-      {
-        kind: "payload",
-        payload: {
-          type: "widget",
-          widget: { prompt: "Which day?", options: ["Tue"] },
-        },
-      },
-      { kind: "unsupported" },
+    ]);
+
+    // The result follows in the same Turn. It appends: the first bubble is
+    // still the first bubble, still saying what it said.
+    projectDurableRuns(state, [], [
+      run(
+        [
+          {
+            type: "send/to-user",
+            payload: { type: "text", text: "On it." },
+          },
+          { type: "send/to-user", payload: { type: "text", text: "Booked." } },
+        ],
+        "completed",
+      ),
+    ] as ClientRun[]);
+
+    expect(
+      state.messages
+        .filter((message) => message.sends.length > 0)
+        .map((message) => [message.id, message.sends]),
+    ).toEqual([
+      [
+        "run-stack:send:0",
+        [{ kind: "payload", payload: { type: "text", text: "On it." } }],
+      ],
+      [
+        "run-stack:send:1",
+        [{ kind: "payload", payload: { type: "text", text: "Booked." } }],
+      ],
+    ]);
+    // The Turn's lines stay together and in order behind the prompt that
+    // started it, so a reload draws the thread that was watched being written.
+    expect(state.messages.map((message) => message.id)).toEqual([
+      "run-stack:user",
+      "run-stack:send:0",
+      "run-stack:send:1",
+      "run-stack:assistant",
     ]);
   });
 
@@ -1549,8 +1640,8 @@ describe("active durable Turn projection", () => {
       ],
     );
 
-    expect(state.messages[1]?.text).toBe("");
     expect(state.messages[1]?.sends).toHaveLength(1);
+    expect(state.messages[2]?.text).toBe("");
   });
 
   test("a Turn that sent nothing still draws the model's text", () => {
@@ -1700,8 +1791,8 @@ describe("active durable Turn projection", () => {
         },
       ],
     );
-    expect(state.messages[1]).toMatchObject({ text: "", status: "streaming" });
     expect(state.messages[1]?.sends).toHaveLength(1);
+    expect(state.messages[2]).toMatchObject({ text: "", status: "streaming" });
   });
 
   test("projects reconciliation-required recovery state", () => {
@@ -1726,6 +1817,9 @@ describe("active durable Turn projection", () => {
         },
       ],
     );
+    // One sentence of the product's own, and the raw provider text nowhere on
+    // screen — the banner, the bubble and the notice all read the same way
+    // whatever the provider called the failure.
     expect(reconciliation.activeRun).toEqual({
       runId: "run-reconciliation",
       status: "reconciliation-required",
@@ -1733,9 +1827,14 @@ describe("active durable Turn projection", () => {
       canResume: true,
     });
     expect(reconciliation.messages[1]).toMatchObject({
-      text: "This reply stopped partway. Try again to continue it.",
+      role: "assistant",
+      text: "",
+      notice: "This reply stopped partway. Try again to continue it.",
       status: "reconciliation-required",
     });
+    expect(JSON.stringify(reconciliation.messages)).not.toContain(
+      "Provider result needs confirmation",
+    );
   });
 
   test("keeps busy state until the durable run becomes terminal", () => {
@@ -3195,11 +3294,14 @@ describe("a message sent while a Turn is running", () => {
     expect(state.messages.every((message) => !message.pending)).toBe(true);
     expect(state.activeRunId).toBe("run-2");
     expect(state.runningRunId).toBe("run-2");
-    // The superseded Turn keeps the quiet treatment a stopped one gets.
-    expect(state.messages[1]).toMatchObject({
-      status: "aborted",
-      notice: "Interrupted by your next message.",
-    });
+    // The superseded Turn is left unlabelled: the message that replaced it is
+    // right underneath, and it says why the Turn ends there better than a
+    // notice of ours would.
+    expect(state.messages[1]).toMatchObject({ status: "aborted" });
+    expect(state.messages[1]?.notice).toBeUndefined();
+    expect(state.messages.some((message) => message.notice !== undefined)).toBe(
+      false,
+    );
   });
 
   test("a reload reconstructs the greyed state from durable runs alone", () => {
@@ -3234,6 +3336,11 @@ describe("a message sent while a Turn is running", () => {
       text: "second",
       pending: true,
     });
+    // The durable record still says why the Turn ended; the transcript does
+    // not repeat it at the reader.
+    expect(
+      reloaded.messages.some((message) => message.notice !== undefined),
+    ).toBe(false);
     expect(reloaded.runningRunId).toBeUndefined();
     expect(reloaded.activeRunId).toBe("run-2");
   });