canopy-ui 0.12.2 → 0.14.0

package/src/chat/sessionReducer.test.ts

@@ -227,6 +227,29 @@ describe("sessionReducer — drafts", () => {
     expect(next.active_draft?.version).toBe(3)
   })
 
+  it("draft.updated carries the server's visibility into active_draft even while keeping the local body", () => {
+    // The drift check in useSessionSocket (`current.visibility !==
+    // typingVisibilityRef.current`) compares against THIS field — if the
+    // echo-suppression branch never updated it, that check would compare
+    // against a permanently stale value.
+    const prev = makeState({
+      current_user_id: 5,
+      active_draft: { ...baseDraft, body: "local typing", version: 3, visibility: "live" },
+    })
+    const next = sessionReducer(prev, {
+      event: "draft.updated",
+      data: {
+        ...baseDraft,
+        body: "stale server echo",
+        last_editor: 5,
+        version: 4,
+        visibility: "hidden",
+      } as Draft,
+    } as WsEvent)
+    expect(next.active_draft?.body).toBe("local typing")
+    expect(next.active_draft?.visibility).toBe("hidden")
+  })
+
   it("draft.updated accepts the body when another user is editing", () => {
     const prev = makeState({
       current_user_id: 5,
@@ -727,3 +750,148 @@ describe("session.stop — whether the stop actually landed", () => {
     expect(out.stopState).toBeUndefined();
   });
 });
+
+describe("per-person drafts", () => {
+  it("draft.typing upserts a peer by author and an empty body removes it", () => {
+    let s = sessionReducer(makeState(), {
+      event: "draft.typing",
+      data: { author: { id: 2, name: "Bo" }, body: "hi", at: null },
+    } as WsEvent);
+    s = sessionReducer(s, {
+      event: "draft.typing",
+      data: { author: { id: 2, name: "Bo" }, body: "hi there", at: null },
+    } as WsEvent);
+    expect(s.peer_drafts).toEqual([{ author: { id: 2, name: "Bo" }, body: "hi there", at: null }]);
+    s = sessionReducer(s, {
+      event: "draft.typing",
+      data: { author: { id: 2, name: "Bo" }, body: "", at: null },
+    } as WsEvent);
+    expect(s.peer_drafts).toEqual([]);
+  });
+
+  it("keeps an empty-body row when the server says the person is still typing", () => {
+    // `typing`/`hidden` visibility withholds the words but not the fact of
+    // typing — the row must survive rather than being read as "sent/cleared".
+    const s = sessionReducer(makeState(), {
+      event: "draft.typing",
+      data: { author: { id: 2, name: "Bo" }, body: "", at: null, typing: true },
+    } as WsEvent);
+    expect(s.peer_drafts).toEqual([
+      { author: { id: 2, name: "Bo" }, body: "", at: null, typing: true },
+    ]);
+  });
+
+  it("removes the row when the body is empty and typing is not true", () => {
+    let s = sessionReducer(makeState(), {
+      event: "draft.typing",
+      data: { author: { id: 2, name: "Bo" }, body: "", at: null, typing: true },
+    } as WsEvent);
+    s = sessionReducer(s, {
+      event: "draft.typing",
+      data: { author: { id: 2, name: "Bo" }, body: "", at: null, typing: false },
+    } as WsEvent);
+    expect(s.peer_drafts).toEqual([]);
+  });
+
+  it("presence.left drops that person's typing row", () => {
+    let s = sessionReducer(makeState(), {
+      event: "draft.typing",
+      data: { author: { id: 2, name: "Bo" }, body: "x", at: null },
+    } as WsEvent);
+    s = sessionReducer(s, { event: "presence.left", data: { user_id: 2 } } as WsEvent);
+    expect(s.peer_drafts).toEqual([]);
+  });
+
+  it("session.queued replaces the whole list", () => {
+    const q = {
+      turn_id: "t1",
+      client_id: "c1",
+      author: { name: "Bo", user_id: 2 },
+      text: "yo",
+      sent_at: "2026-09-26T00:00:00Z",
+      state: "queued" as const,
+    };
+    let s = sessionReducer(makeState(), {
+      event: "session.queued",
+      data: { queued: [q] },
+    } as WsEvent);
+    expect(s.queued).toEqual([q]);
+    s = sessionReducer(s, { event: "session.queued", data: { queued: [] } } as WsEvent);
+    expect(s.queued).toEqual([]);
+  });
+
+  it("chat.user_message keeps the author", () => {
+    const s = sessionReducer(makeState(), {
+      event: "chat.user_message",
+      data: { message_id: "m1", turn_index: 5, plaintext: "hi", author: { name: "Bo", user_id: 2 } },
+    } as WsEvent);
+    expect(s.messages.at(-1)?.author).toEqual({ name: "Bo", user_id: 2 });
+  });
+});
+
+describe("sessionReducer — two people saying the same thing (final review I5)", () => {
+  const yes = (over: Partial<Message>) =>
+    makeMessage({ role: "user", plaintext: "yes", status: "complete", ...over })
+
+  it("two confirmed 'yes' rows from different authors stay two", () => {
+    const seeded = makeState({
+      messages: [yes({ id: "a1", turn_index: 10, author: { name: "Alice", user_id: 1 } })],
+    })
+    const next = sessionReducer(seeded, {
+      event: "chat.user_message",
+      data: { message_id: "b1", turn_index: 20, plaintext: "yes", author: { name: "Bo", user_id: 2 } },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(2)
+    expect(next.messages.map((m) => m.author?.name)).toEqual(["Alice", "Bo"])
+  })
+
+  it("a confirmed unauthored row is not adopted by someone else's line", () => {
+    const seeded = makeState({ messages: [yes({ id: "a1", turn_index: 10 })] })
+    const next = sessionReducer(seeded, {
+      event: "chat.user_message",
+      data: { message_id: "b1", turn_index: 20, plaintext: "yes", author: { name: "Bo", user_id: 2 } },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(2)
+  })
+
+  it("an optimistic pending 'yes' still reconciles with its echo", () => {
+    const seeded = makeState({
+      current_user_id: 1,
+      messages: [yes({ id: "local:c1", turn_index: 3, status: "pending", content: { client_id: "c1" } })],
+    })
+    const next = sessionReducer(seeded, {
+      event: "chat.user_message",
+      data: { message_id: "901", turn_index: 144448, plaintext: "yes", author: { name: "Alice", user_id: 1 } },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(1)
+    expect(next.messages[0].id).toBe("901")
+    expect(next.messages[0].status).toBe("complete")
+  })
+
+  it("a receipted send (transient id) still reconciles with its transcript echo", () => {
+    // A transcript-sourced send writes no durable row; its receipt carries a
+    // `transient:` id, so the row is still waiting for the line the agent read.
+    const seeded = makeState({
+      current_user_id: 1,
+      messages: [yes({ id: "transient:abc", turn_index: 3, content: { client_id: "c1" } })],
+    })
+    const next = sessionReducer(seeded, {
+      event: "chat.user_message",
+      data: { message_id: "901", turn_index: 144448, plaintext: "yes", author: { name: "Alice", user_id: 1 } },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(1)
+  })
+
+  it("my pending 'yes' is not taken by a teammate's 'yes'", () => {
+    const seeded = makeState({
+      current_user_id: 1,
+      messages: [yes({ id: "local:c1", turn_index: 3, status: "pending", content: { client_id: "c1" } })],
+    })
+    const next = sessionReducer(seeded, {
+      event: "chat.user_message",
+      data: { message_id: "b1", turn_index: 20, plaintext: "yes", author: { name: "Bo", user_id: 2 } },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(2)
+    expect(next.messages[0].id).toBe("local:c1")
+  })
+})

package/src/chat/sessionReducer.ts

@@ -1,4 +1,5 @@
-import type { Draft, Message, SessionState, WsEvent } from "./protocol";
+import type { Draft, Message, MessageAuthor, SessionState, WsEvent } from "./protocol";
+import { isUnconfirmed, sameAuthor } from "./identity";
 
 // Pure reducer for SessionState — extracted from useSessionSocket so it
 // can be unit-tested without WebSocket plumbing. Side-effect events
@@ -39,10 +40,10 @@ const UNBLOCKING_FRAMES = new Set([
  */
 export const REDUCER_EVENTS: ReadonlySet<string> = new Set([
   "session.state", "session.activity", "session.stop", "session.menu",
-  "session.turn_status", "session.error", "session.title_updated",
+  "session.turn_status", "session.error", "session.title_updated", "session.queued",
   "chat.stream_start", "chat.user_message", "chat.delta", "chat.stream_complete",
   "chat.stream_error", "chat.stream_cancelled", "chat.tool_use", "chat.tool_result",
-  "draft.updated", "draft.lock_changed", "draft.committed", "draft.discarded",
+  "draft.updated", "draft.typing", "draft.committed", "draft.discarded",
   "presence.joined", "presence.left",
 ]);
 
@@ -151,11 +152,31 @@ export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState
       // Deliberately narrow: same role, same text, and only against the tail, so
       // a genuine repeat of a short message ("yes") sent much later still lands
       // as its own row.
+      //
+      // And only against a row that can still be THIS line (final review I5):
+      // two people answering "yes" are two lines, so the fallback never lets a
+      // different author's frame adopt a row. A row is a candidate while it is
+      // unconfirmed (an optimistic or receipted send still waiting for the line
+      // the agent read) or when it already names the same person — the ledger
+      // path's authored row meeting its transcript echo. An unauthored optimistic
+      // row is the viewer's own, so it is compared as the viewer.
       const RECENT_USER_ROWS = 6;
-      const sameText = (m: Message) =>
-        m.role === "user" &&
-        m.plaintext.trim() !== "" &&
-        m.plaintext.trim() === frame.data.plaintext.trim();
+      const incomingAuthor = frame.data.author ?? null;
+      const me: MessageAuthor | null =
+        prev.current_user_id != null
+          ? { name: "", user_id: prev.current_user_id }
+          : prev.current_contact_id != null
+            ? { name: "", contact_id: prev.current_contact_id }
+            : null;
+      const sameText = (m: Message) => {
+        if (
+          m.role !== "user" ||
+          m.plaintext.trim() === "" ||
+          m.plaintext.trim() !== frame.data.plaintext.trim()
+        ) return false;
+        if (isUnconfirmed(m)) return sameAuthor(m.author ?? me, incomingAuthor);
+        return m.author != null && incomingAuthor != null && sameAuthor(m.author, incomingAuthor);
+      };
       const recentUsers = prev.messages.filter((m) => m.role === "user").slice(-RECENT_USER_ROWS);
       const existing =
         prev.messages.find(
@@ -174,6 +195,12 @@ export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState
                   // is the durable one, so the row sorts where a reload puts it.
                   turn_index: frame.data.turn_index,
                   plaintext: frame.data.plaintext,
+                  // A transcript-sourced session's durable row carries no user
+                  // beyond the runner's own login, so this frame is the only
+                  // chance to say who actually typed it — keep it if we already
+                  // had it (an optimistic send knows its own author) and the
+                  // frame is silent, but let the frame win otherwise.
+                  author: frame.data.author ?? m.author ?? null,
                   // The agent read it, so a pending or unconfirmed row is sent.
                   ...(m.role === "user" ? { status: "complete" as const, error_detail: null } : {}),
                 }
@@ -186,13 +213,19 @@ export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState
         id: frame.data.message_id,
         turn_index: frame.data.turn_index,
         role: "user",
-        content: { text: frame.data.plaintext },
+        // `client_id` (when the caller has one — an HTTP send) lets
+        // `QueuedRows.hideClientIds` recognise the server's queued-turn
+        // projection as THIS row rather than a duplicate.
+        content: frame.data.client_id
+          ? { text: frame.data.plaintext, client_id: frame.data.client_id }
+          : { text: frame.data.plaintext },
         plaintext: frame.data.plaintext,
         status: "complete",
         error_detail: null,
         started_at: null,
         completed_at: null,
         created_at: nowIso,
+        author: frame.data.author ?? null,
       };
       return { ...prev, messages: [...prev.messages, user] };
     }
@@ -326,9 +359,13 @@ export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState
       // If we're the current editor, keep our local body — the server
       // echo is stale relative to keystrokes that happened since the
       // debounced send. Only accept metadata (version, last_editor, etc).
+      // This frame now only ever carries MY OWN draft (everyone else's live
+      // typing arrives as `draft.typing` instead), so `author_id` — the
+      // draft's actual owner — is the reliable field to compare; fall back to
+      // `last_editor` for a server that doesn't send it yet.
       if (
         prev.active_draft &&
-        incoming.last_editor === prev.current_user_id
+        (incoming.author_id ?? incoming.last_editor) === prev.current_user_id
       ) {
         return {
           ...prev,
@@ -337,23 +374,33 @@ export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState
             version: incoming.version,
             last_editor: incoming.last_editor,
             last_edit_at: incoming.last_edit_at,
+            // The server's CURRENT visibility, even while the body itself is
+            // kept local — `useSessionSocket`'s drift check compares against
+            // this field, and it must reflect what the server actually has,
+            // not a value frozen at whatever it was when this draft first
+            // loaded. `?? prev.active_draft.visibility` only for an older
+            // server that omits the field.
+            visibility: incoming.visibility ?? prev.active_draft.visibility,
           },
         };
       }
       return { ...prev, active_draft: incoming };
     }
 
-    case "draft.lock_changed":
-      if (prev.active_draft && prev.active_draft.id === frame.data.draft_id) {
-        return {
-          ...prev,
-          active_draft: {
-            ...prev.active_draft,
-            last_editor: frame.data.holder_user_id ?? prev.active_draft.last_editor,
-          },
-        };
-      }
-      return prev;
+    case "draft.typing": {
+      // Someone else's box, live. Keyed by author; an empty body means they
+      // sent, discarded or cleared it — UNLESS `typing` is true, which means
+      // the words are simply withheld (typing/hidden visibility) while the
+      // person is still mid-thought, so the row is kept rather than removed.
+      const rest = (prev.peer_drafts ?? []).filter((d) => d.author.id !== frame.data.author.id);
+      const keep = frame.data.body !== "" || frame.data.typing === true;
+      return { ...prev, peer_drafts: keep ? [...rest, frame.data] : rest };
+    }
+
+    case "session.queued":
+      // Wholesale, like session.turn_status: a client that just connected has
+      // no correct prior to merge a delta into.
+      return { ...prev, queued: frame.data.queued };
 
     case "draft.committed": {
       // The sender already shows its line (a pending row stamped with this
@@ -439,6 +486,10 @@ export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState
         presence_user_ids: prev.presence_user_ids.filter(
           (id) => id !== frame.data.user_id,
         ),
+        // A closed tab is the retirement path for its typing row too — without
+        // this a peer who left mid-keystroke leaves a stale "is typing" behind
+        // with nothing left to clear it.
+        peer_drafts: (prev.peer_drafts ?? []).filter((d) => d.author.id !== frame.data.user_id),
       };
 
     case "session.error": {

package/src/chat/useSessionSocket.http.test.tsx

@@ -44,7 +44,7 @@ describe('sending over HTTP', () => {
     act(() => hook.result.current.updateDraft('hello ace'))
     expect(hook.result.current.state.active_draft?.body).toBe('hello ace')
     await act(async () => hook.result.current.sendChat())
-    expect(sendOverHttp).toHaveBeenCalledWith('hello ace')
+    expect(sendOverHttp).toHaveBeenCalledWith('hello ace', expect.any(String))
     expect(FakeSocket.sent.filter((f) => f.includes('chat.send') || f.includes('draft.update'))).toEqual([])
   })
 
@@ -57,6 +57,23 @@ describe('sending over HTTP', () => {
     expect(hook.result.current.state.active_draft).toBeNull()
   })
 
+  it('stamps the SAME client_id on the optimistic row and the HTTP body', async () => {
+    // The server's queued-turn projection carries back whatever client_id the
+    // POST sent (apps/canopy_sessions/services.py::queued_messages parses it
+    // off the turn's idempotency_key). Without a matching id on this row's
+    // `content`, `QueuedRows.hideClientIds` cannot recognise the two as one
+    // send, and a contact's (or the widget's) own send rendered twice — once
+    // as their bubble, once as an unowned "queued" placeholder, since neither
+    // path gives a contact an `author.user_id` to compare against.
+    const { hook, sendOverHttp } = contact()
+    act(() => hook.result.current.updateDraft('please help'))
+    await act(async () => hook.result.current.sendChat())
+    const sentClientId = sendOverHttp.mock.calls[0][1] as string
+    expect(typeof sentClientId).toBe('string')
+    expect(sentClientId.length).toBeGreaterThan(0)
+    expect(hook.result.current.state.messages.at(-1)?.content?.client_id).toBe(sentClientId)
+  })
+
   it('a failed send puts the words back and says why', async () => {
     const { hook } = contact(vi.fn().mockRejectedValue(new Error('canopy said 429')))
     act(() => hook.result.current.updateDraft('keep me'))
@@ -69,6 +86,38 @@ describe('sending over HTTP', () => {
     expect(hook.result.current.awaitingReply).toBe(false)
   })
 
+  it('does not clobber newer typing with a stale failed send', async () => {
+    // 2026-09-26 review: contact sends "hello" (draft clears to null), starts
+    // typing "world" while the POST is still in flight, "hello"'s request
+    // fails — the restore must not overwrite "world" with "hello". The old
+    // `updateLocalDraft(body)` closed over "hello" at send time and always
+    // won; the fix (`restoreFailedLocalDraft`) only restores when nothing
+    // newer has been typed since (the draft is still null/empty).
+    let rejectSend!: (err: Error) => void
+    const pending: Promise<unknown> = new Promise((_resolve, reject) => {
+      rejectSend = reject
+    })
+    const sendOverHttp = vi.fn().mockReturnValue(pending)
+    const { hook } = contact(sendOverHttp)
+
+    act(() => hook.result.current.updateDraft('hello'))
+    act(() => {
+      hook.result.current.sendChat()
+    })
+    expect(hook.result.current.state.active_draft).toBeNull()
+
+    // Typed BEFORE the request resolves — this must win.
+    act(() => hook.result.current.updateDraft('world'))
+    expect(hook.result.current.state.active_draft?.body).toBe('world')
+
+    await act(async () => {
+      rejectSend(new Error('network blip'))
+      await pending.catch(() => undefined)
+    })
+
+    expect(hook.result.current.state.active_draft?.body).toBe('world')
+  })
+
   it('an empty draft sends nothing', async () => {
     const { hook, sendOverHttp } = contact()
     act(() => hook.result.current.updateDraft('   '))