canopy-ui 0.2.0 → 0.4.0

package/src/chat/sessionReducer.test.ts

@@ -0,0 +1,284 @@
+import { describe, expect, it } from "vitest"
+
+import type { Draft, Message, SessionState, WsEvent } from "./protocol"
+import { sessionReducer } from "./sessionReducer"
+
+const baseDraft: Draft = {
+  id: "d1",
+  slot: "next",
+  status: "open",
+  body: "",
+  version: 0,
+  last_editor: 0,
+  last_edit_at: "",
+}
+
+function makeState(overrides: Partial<SessionState> = {}): SessionState {
+  return {
+    messages: [],
+    active_draft: null,
+    participants: [],
+    presence_user_ids: [],
+    current_user_id: 0,
+    ...overrides,
+  }
+}
+
+function makeMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    id: "1",
+    turn_index: 1,
+    role: "assistant",
+    content: {},
+    plaintext: "",
+    status: "pending",
+    error_detail: null,
+    started_at: null,
+    completed_at: null,
+    created_at: new Date().toISOString(),
+    ...overrides,
+  }
+}
+
+describe("sessionReducer — chat stream", () => {
+  it("session.state replaces the whole state", () => {
+    const prev = makeState({ messages: [makeMessage()] })
+    const replacement = makeState({ current_user_id: 42 })
+    const next = sessionReducer(prev, {
+      event: "session.state",
+      data: replacement,
+    } as WsEvent)
+    expect(next).toBe(replacement)
+  })
+
+  it("chat.stream_start flips a matching message to streaming", () => {
+    const m = makeMessage({ id: "7", status: "pending" })
+    const prev = makeState({ messages: [m] })
+    const next = sessionReducer(prev, {
+      event: "chat.stream_start",
+      data: { message_id: "7", turn_index: 3 },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(1)
+    expect(next.messages[0].status).toBe("streaming")
+  })
+
+  it("chat.stream_start for an unknown id CREATES the assistant message (upsert)", () => {
+    const m = makeMessage({ id: "7", role: "user", status: "complete" })
+    const prev = makeState({ messages: [m] })
+    const next = sessionReducer(prev, {
+      event: "chat.stream_start",
+      data: { message_id: "99", turn_index: 5 },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(2)
+    expect(next.messages[1]).toMatchObject({
+      id: "99",
+      role: "assistant",
+      status: "streaming",
+      plaintext: "",
+      turn_index: 5,
+    })
+  })
+
+  it("chat.delta appends text to plaintext", () => {
+    const m = makeMessage({ id: "7", plaintext: "Hello" })
+    const prev = makeState({ messages: [m] })
+    const next = sessionReducer(prev, {
+      event: "chat.delta",
+      data: { message_id: "7", text: " world" },
+    } as WsEvent)
+    expect(next.messages[0].plaintext).toBe("Hello world")
+  })
+
+  it("chat.stream_complete replaces plaintext and marks complete", () => {
+    const m = makeMessage({ id: "7", plaintext: "stale partial", status: "streaming" })
+    const prev = makeState({ messages: [m] })
+    const next = sessionReducer(prev, {
+      event: "chat.stream_complete",
+      data: { message_id: "7", plaintext: "final answer" },
+    } as WsEvent)
+    expect(next.messages[0].plaintext).toBe("final answer")
+    expect(next.messages[0].status).toBe("complete")
+  })
+
+  it("chat.stream_error sets error_detail and status=error", () => {
+    const m = makeMessage({ id: "7", status: "streaming" })
+    const prev = makeState({ messages: [m] })
+    const next = sessionReducer(prev, {
+      event: "chat.stream_error",
+      data: { message_id: "7", detail: "cancelled" },
+    } as WsEvent)
+    expect(next.messages[0].status).toBe("error")
+    expect(next.messages[0].error_detail).toBe("cancelled")
+  })
+
+  it("chat.stream_cancelled stamps a partial-length detail", () => {
+    const m = makeMessage({ id: "7", status: "streaming" })
+    const prev = makeState({ messages: [m] })
+    const next = sessionReducer(prev, {
+      event: "chat.stream_cancelled",
+      data: { message_id: "7", partial_len: 142 },
+    } as WsEvent)
+    expect(next.messages[0].status).toBe("error")
+    expect(next.messages[0].error_detail).toMatch(/142/)
+  })
+
+  it("chat.tool_use is a no-op", () => {
+    const prev = makeState({ messages: [makeMessage()] })
+    const next = sessionReducer(prev, {
+      event: "chat.tool_use",
+      data: { parent_message_id: null, tool_message_id: "t1", block: {} },
+    } as WsEvent)
+    expect(next).toBe(prev)
+  })
+})
+
+describe("sessionReducer — drafts", () => {
+  it("draft.updated keeps local body when echo's last_editor matches current_user_id", () => {
+    // Echo-suppression: server echo arrives stale relative to the user's
+    // own keystrokes; reducer must keep the local body and only accept
+    // metadata. This is the most subtle branch in the file.
+    const prev = makeState({
+      current_user_id: 5,
+      active_draft: { ...baseDraft, body: "local typing", version: 3 },
+    })
+    const next = sessionReducer(prev, {
+      event: "draft.updated",
+      data: {
+        ...baseDraft,
+        body: "stale server echo",
+        last_editor: 5,
+        version: 3,
+      } as Draft,
+    } as WsEvent)
+    expect(next.active_draft?.body).toBe("local typing")
+    expect(next.active_draft?.version).toBe(3)
+  })
+
+  it("draft.updated accepts the body when another user is editing", () => {
+    const prev = makeState({
+      current_user_id: 5,
+      active_draft: { ...baseDraft, body: "old", last_editor: 7 },
+    })
+    const next = sessionReducer(prev, {
+      event: "draft.updated",
+      data: {
+        ...baseDraft,
+        body: "their text",
+        last_editor: 7,
+        version: 2,
+      } as Draft,
+    } as WsEvent)
+    expect(next.active_draft?.body).toBe("their text")
+  })
+
+  it("draft.committed inserts the optimistic user message and clears the draft body", () => {
+    // canopy adaptation: NO assistant placeholder here (draft.committed has
+    // no assistant id) — only the user message is inserted; the assistant is
+    // upserted later on chat.stream_start.
+    const prev = makeState({
+      active_draft: { ...baseDraft, body: "the prompt" },
+      messages: [makeMessage({ id: "1", turn_index: 1 })],
+    })
+    const next = sessionReducer(prev, {
+      event: "draft.committed",
+      data: { user_message_id: "100", draft_id: "d1" },
+    } as WsEvent)
+    expect(next.messages).toHaveLength(2)
+    expect(next.messages[1]).toMatchObject({
+      id: "100",
+      role: "user",
+      plaintext: "the prompt",
+      turn_index: 2,
+    })
+    // active_draft.body cleared so Enter doesn't re-send the same turn.
+    expect(next.active_draft?.body).toBe("")
+  })
+
+  it("draft.committed then chat.stream_start makes the assistant reply visible", () => {
+    // The load-bearing sequence: commit inserts the user msg, stream_start
+    // upserts the assistant row, delta/complete fill it in.
+    let s = makeState({ active_draft: { ...baseDraft, body: "hi" } })
+    s = sessionReducer(s, {
+      event: "draft.committed",
+      data: { user_message_id: "u1", draft_id: "d1" },
+    } as WsEvent)
+    s = sessionReducer(s, {
+      event: "chat.stream_start",
+      data: { message_id: "a1", turn_index: 2 },
+    } as WsEvent)
+    s = sessionReducer(s, {
+      event: "chat.stream_complete",
+      data: { message_id: "a1", plaintext: "hello there" },
+    } as WsEvent)
+    expect(s.messages.map((m) => m.role)).toEqual(["user", "assistant"])
+    expect(s.messages[1].plaintext).toBe("hello there")
+    expect(s.messages[1].status).toBe("complete")
+  })
+
+  it("draft.discarded clears matching draft body", () => {
+    const prev = makeState({
+      active_draft: { ...baseDraft, id: "d1", body: "draft text" },
+    })
+    const next = sessionReducer(prev, {
+      event: "draft.discarded",
+      data: { draft_id: "d1" },
+    } as WsEvent)
+    expect(next.active_draft?.body).toBe("")
+  })
+})
+
+describe("sessionReducer — presence", () => {
+  it("presence.joined adds a user_id idempotently", () => {
+    const prev = makeState({ presence_user_ids: [1, 2] })
+    const next = sessionReducer(prev, {
+      event: "presence.joined",
+      data: { user_id: 3 },
+    } as WsEvent)
+    expect(next.presence_user_ids.sort()).toEqual([1, 2, 3])
+
+    // Second join is a no-op (Set semantics).
+    const after = sessionReducer(next, {
+      event: "presence.joined",
+      data: { user_id: 3 },
+    } as WsEvent)
+    expect(after.presence_user_ids.filter((id) => id === 3)).toHaveLength(1)
+  })
+
+  it("presence.left filters out the user_id", () => {
+    const prev = makeState({ presence_user_ids: [1, 2, 3] })
+    const next = sessionReducer(prev, {
+      event: "presence.left",
+      data: { user_id: 2 },
+    } as WsEvent)
+    expect(next.presence_user_ids).toEqual([1, 3])
+  })
+})
+
+describe("sessionReducer — session.error draft_version_mismatch", () => {
+  it("rolls active_draft back to the server's reported version + body", () => {
+    const prev = makeState({
+      active_draft: { ...baseDraft, version: 9, body: "stale local" },
+    })
+    const next = sessionReducer(prev, {
+      event: "session.error",
+      data: {
+        message: "version mismatch",
+        code: "draft_version_mismatch",
+        detail: { current_version: 11, current_body: "server body" },
+      },
+    } as WsEvent)
+    expect(next.active_draft?.version).toBe(11)
+    expect(next.active_draft?.body).toBe("server body")
+  })
+
+  it("non-version-mismatch errors are no-ops to state (side-effect handled by hook)", () => {
+    const prev = makeState({
+      active_draft: { ...baseDraft, body: "x" },
+    })
+    const next = sessionReducer(prev, {
+      event: "session.error",
+      data: { message: "something else", code: "other" },
+    } as WsEvent)
+    expect(next).toBe(prev)
+  })
+})

package/src/chat/sessionReducer.ts

@@ -0,0 +1,245 @@
+import type { Draft, Message, SessionState, WsEvent } from "./protocol";
+
+// Pure reducer for SessionState — extracted from useSessionSocket so it
+// can be unit-tested without WebSocket plumbing. Side-effect events
+// (session.title_updated → optional injected callback; session.error →
+// setLastError + clear draft debounce) stay in the hook itself.
+//
+// Keep this file dependency-free (no React) so a vitest run doesn't pull
+// jsdom or RTL.
+//
+// canopy adaptation vs ace: message/draft ids are STRINGS, and
+// `chat.stream_start` UPSERTS the assistant message — canopy's
+// `draft.committed` carries only `user_message_id` (no assistant id to
+// pre-insert), so the assistant row is created lazily when its first stream
+// frame arrives.
+export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState {
+  switch (frame.event) {
+    case "session.state":
+      return frame.data;
+
+    case "chat.stream_start": {
+      // Upsert: if the assistant message already exists (rare — a runner that
+      // pre-inserts it), flip it to streaming; otherwise create it. canopy's
+      // draft.committed cannot pre-send the assistant id, so this is the
+      // normal path for making the streamed reply visible.
+      const exists = prev.messages.some((m) => m.id === frame.data.message_id);
+      if (exists) {
+        return {
+          ...prev,
+          messages: prev.messages.map((m) =>
+            m.id === frame.data.message_id
+              ? { ...m, status: "streaming" as const }
+              : m,
+          ),
+        };
+      }
+      const nowIso = new Date().toISOString();
+      const assistant: Message = {
+        id: frame.data.message_id,
+        turn_index: frame.data.turn_index,
+        role: "assistant",
+        content: {},
+        plaintext: "",
+        status: "streaming",
+        error_detail: null,
+        started_at: nowIso,
+        completed_at: null,
+        created_at: nowIso,
+      };
+      return { ...prev, messages: [...prev.messages, assistant] };
+    }
+
+    case "chat.delta":
+      return {
+        ...prev,
+        messages: prev.messages.map((m) =>
+          m.id === frame.data.message_id
+            ? { ...m, plaintext: m.plaintext + frame.data.text }
+            : m,
+        ),
+      };
+
+    case "chat.stream_complete":
+      return {
+        ...prev,
+        messages: prev.messages.map((m) =>
+          m.id === frame.data.message_id
+            ? {
+                ...m,
+                plaintext: frame.data.plaintext,
+                status: "complete" as const,
+              }
+            : m,
+        ),
+      };
+
+    case "chat.stream_error":
+      // NOTE: backend emits chat.stream_error with detail="cancelled"
+      // for stop-driven cancellation; there's no separate
+      // chat.stream_cancelled event in practice. Distinguished by detail.
+      return {
+        ...prev,
+        messages: prev.messages.map((m) =>
+          m.id === frame.data.message_id
+            ? {
+                ...m,
+                status: "error" as const,
+                error_detail: frame.data.detail,
+              }
+            : m,
+        ),
+      };
+
+    case "chat.stream_cancelled":
+      return {
+        ...prev,
+        messages: prev.messages.map((m) =>
+          m.id === frame.data.message_id
+            ? {
+                ...m,
+                status: "error" as const,
+                error_detail: `cancelled (partial: ${frame.data.partial_len} chars)`,
+              }
+            : m,
+        ),
+      };
+
+    case "chat.tool_use":
+    case "chat.tool_result":
+      // Tool rows are their own Message rows on the server. A full
+      // refresh picks them up; for now, don't duplicate bookkeeping here.
+      return prev;
+
+    case "draft.updated": {
+      const incoming = frame.data as Draft;
+      // 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).
+      if (
+        prev.active_draft &&
+        incoming.last_editor === prev.current_user_id
+      ) {
+        return {
+          ...prev,
+          active_draft: {
+            ...prev.active_draft,
+            version: incoming.version,
+            last_editor: incoming.last_editor,
+            last_edit_at: incoming.last_edit_at,
+          },
+        };
+      }
+      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.committed": {
+      // Insert the optimistic USER message from the draft body that's about
+      // to be cleared. The assistant reply is NOT inserted here — canopy's
+      // draft.committed carries no assistant id; `chat.stream_start` upserts
+      // that row when the reply begins.
+      //
+      // Also clear active_draft.body here. The server creates a new empty
+      // draft with last_editor=sender, so the follow-up draft.updated hits
+      // the "keep local body" branch above and would otherwise leave the
+      // just-sent text in the textarea — which lets Enter re-send the same
+      // turn repeatedly.
+      const prevDraftBody = prev.active_draft?.body ?? "";
+      const maxTurnIndex = prev.messages.reduce(
+        (acc, msg) => Math.max(acc, msg.turn_index),
+        0,
+      );
+      const nowIso = new Date().toISOString();
+      const userMessage: Message = {
+        id: frame.data.user_message_id,
+        turn_index: maxTurnIndex + 1,
+        role: "user",
+        content: { text: prevDraftBody },
+        plaintext: prevDraftBody,
+        status: "complete",
+        error_detail: null,
+        started_at: null,
+        completed_at: nowIso,
+        created_at: nowIso,
+      };
+      return {
+        ...prev,
+        active_draft: prev.active_draft
+          ? { ...prev.active_draft, body: "" }
+          : prev.active_draft,
+        messages: [...prev.messages, userMessage],
+      };
+    }
+
+    case "draft.discarded":
+      if (prev.active_draft && prev.active_draft.id === frame.data.draft_id) {
+        return {
+          ...prev,
+          active_draft: { ...prev.active_draft, body: "" },
+        };
+      }
+      return prev;
+
+    case "presence.joined": {
+      const ids = new Set(prev.presence_user_ids);
+      ids.add(frame.data.user_id);
+      return { ...prev, presence_user_ids: [...ids] };
+    }
+
+    case "presence.left":
+      return {
+        ...prev,
+        presence_user_ids: prev.presence_user_ids.filter(
+          (id) => id !== frame.data.user_id,
+        ),
+      };
+
+    case "session.error": {
+      // Side effects (setLastError, clear draft debounce) are handled
+      // by the hook; the reducer only knows about the version-mismatch
+      // recovery, which mutates active_draft.
+      if (
+        frame.data.code === "draft_version_mismatch" &&
+        frame.data.detail &&
+        typeof frame.data.detail === "object"
+      ) {
+        const detail = frame.data.detail as {
+          current_version: number;
+          current_body: string;
+        };
+        return prev.active_draft
+          ? {
+              ...prev,
+              active_draft: {
+                ...prev.active_draft,
+                version: detail.current_version,
+                body: detail.current_body,
+              },
+            }
+          : prev;
+      }
+      return prev;
+    }
+
+    case "session.title_updated":
+      // Pure reducer leaves this alone — the hook calls its optional
+      // onTitleUpdated callback on receipt and short-circuits. Included
+      // here so an exhaustive switch type-checks.
+      return prev;
+
+    default:
+      return prev;
+  }
+}