@arcote.tech/arc-chat 0.7.20 → 0.7.21

package/src/ordering.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "bun:test";
+import { orderMessages } from "./ordering";
+
+let t0 = 1_750_000_000_000;
+const at = (offsetMs: number) => new Date(t0 + offsetMs);
+
+const row = (
+  _id: string,
+  role: string,
+  sessionId: string,
+  offsetMs: number,
+) => ({ _id, role, sessionId, createdAt: at(offsetMs) });
+
+describe("orderMessages — kanoniczna kolejność konwersacji", () => {
+  it("sortuje po createdAt", () => {
+    const rows = [
+      row("c", "user", "s2", 200),
+      row("a", "user", "s1", 0),
+      row("b", "assistant", "s1", 100),
+    ];
+    expect(orderMessages(rows).map((r) => r._id)).toEqual(["a", "b", "c"]);
+  });
+
+  it("pre-utworzony assistant placeholder ląduje ZA user rowem (sendMessage)", () => {
+    // assistantTurnStarted emitowany PRZED messageSent → wcześniejszy timestamp.
+    const rows = [
+      row("a1", "assistant", "s1", 0),
+      row("u1", "user", "s1", 2),
+    ];
+    expect(orderMessages(rows).map((r) => r._id)).toEqual(["u1", "a1"]);
+  });
+
+  it("pre-utworzony assistant ląduje ZA tool_result (respondToTool)", () => {
+    const rows = [
+      row("a2", "assistant", "s2", 100),
+      row("tr1", "tool_result", "s2", 101),
+    ];
+    expect(orderMessages(rows).map((r) => r._id)).toEqual(["tr1", "a2"]);
+  });
+
+  it("multi-turn tool loop zachowuje kolejność iteracji", () => {
+    const rows = [
+      row("a1", "assistant", "s1", 0), // placeholder (pre-created)
+      row("u1", "user", "s1", 1),
+      row("tr1", "tool_result", "s1", 5000), // wynik server toola
+      row("a2", "assistant", "s1", 5100), // iteracja 2 (startAssistantTurn)
+      row("tr2", "tool_result", "s1", 9000),
+      row("a3", "assistant", "s1", 9100),
+    ];
+    expect(orderMessages(rows).map((r) => r._id)).toEqual([
+      "u1",
+      "a1",
+      "tr1",
+      "a2",
+      "tr2",
+      "a3",
+    ]);
+  });
+
+  it("tie-break rolą w tej samej milisekundzie", () => {
+    const rows = [
+      row("a1", "assistant", "s1", 0),
+      row("u1", "user", "s1", 0),
+    ];
+    expect(orderMessages(rows).map((r) => r._id)).toEqual(["u1", "a1"]);
+
+    const rows2 = [
+      row("a2", "assistant", "s2", 0),
+      row("tr1", "tool_result", "s2", 0),
+    ];
+    expect(orderMessages(rows2).map((r) => r._id)).toEqual(["tr1", "a2"]);
+  });
+
+  it("wiele sesji z fix-upem naraz (każda para lokalnie naprawiona)", () => {
+    const rows = [
+      row("a1", "assistant", "s1", 0),
+      row("u1", "user", "s1", 2),
+      row("a2", "assistant", "s2", 60_000),
+      row("u2", "user", "s2", 60_002),
+    ];
+    expect(orderMessages(rows).map((r) => r._id)).toEqual([
+      "u1",
+      "a1",
+      "u2",
+      "a2",
+    ]);
+  });
+
+  it("system row (startStage) zachowuje się jak user", () => {
+    const rows = [
+      row("a1", "assistant", "s1", 0),
+      row("sys1", "system", "s1", 1),
+    ];
+    expect(orderMessages(rows).map((r) => r._id)).toEqual(["sys1", "a1"]);
+  });
+
+  it("retry: fresh assistant bez trigger rowa w sesji zostaje na miejscu", () => {
+    const rows = [
+      row("u1", "user", "s1", 0),
+      row("a1", "assistant", "s1", 1),
+      // retryGeneration: nowa sesja zawiera TYLKO assistant row
+      row("a2", "assistant", "s_retry", 30_000),
+    ];
+    expect(orderMessages(rows).map((r) => r._id)).toEqual(["u1", "a1", "a2"]);
+  });
+
+  it("nie mutuje wejścia i jest stabilne dla identycznych wywołań", () => {
+    const rows = [
+      row("a1", "assistant", "s1", 0),
+      row("u1", "user", "s1", 2),
+    ];
+    const snapshot = JSON.stringify(rows);
+    const first = orderMessages(rows).map((r) => r._id);
+    const second = orderMessages(rows).map((r) => r._id);
+    expect(JSON.stringify(rows)).toBe(snapshot);
+    expect(first).toEqual(second);
+  });
+});

package/src/ordering.ts

@@ -0,0 +1,88 @@
+// ─── Deterministyczne porządkowanie rzędów wiadomości ────────────
+//
+// Wspólne dla klienta (derywacja timeline'u) i serwera (buildHistory w
+// listenerze) — oba muszą widzieć IDENTYCZNĄ kolejność konwersacji.
+//
+// Dlaczego samo `orderBy: { createdAt: "asc" }` nie wystarcza: mutacje
+// `sendMessage` / `respondToTool` / `startStage` / `systemMessage`
+// emitują `assistantTurnStarted` PRZED rzędem triggerującym (user /
+// system / tool_result) — celowo, żeby async listener widział assistant
+// row w DB. `createdAt` powstaje per emit, więc pre-utworzony placeholder
+// asystenta ma timestamp WCZEŚNIEJSZY niż pytanie, na które odpowiada.
+// Po samym sortowaniu czasowym odpowiedź wylądowałaby przed pytaniem
+// (i w timeline, i w historii wysyłanej do LLM).
+
+const ROLE_PRIORITY: Record<string, number> = {
+  user: 0,
+  system: 0,
+  tool_result: 1,
+  assistant: 2,
+};
+
+interface OrderableMessage {
+  _id: string;
+  role: string;
+  sessionId?: string;
+  createdAt: string | Date;
+}
+
+function ts(value: string | Date): number {
+  return value instanceof Date ? value.getTime() : new Date(value).getTime();
+}
+
+/**
+ * Zwraca NOWĄ tablicę rzędów w kanonicznej kolejności konwersacji:
+ *
+ * 1. `createdAt` rosnąco,
+ * 2. tie-break rolą (user/system → tool_result → assistant) — pokrywa
+ *    rzędy emitowane w tej samej milisekundzie w jednej mutacji,
+ * 3. tie-break `_id` (stabilność),
+ * 4. fix-up: PIERWSZY assistant row każdej sesji (pre-utworzony
+ *    placeholder) jest przesuwany tuż ZA najwcześniejszy nie-assistant
+ *    row tej samej sesji, jeśli wylądował przed nim. Kolejne assistant
+ *    rows sesji (iteracje tool-loopa) powstają już po realnych awaitach,
+ *    więc sortowanie czasowe je pokrywa.
+ */
+export function orderMessages<T extends OrderableMessage>(rows: T[]): T[] {
+  const sorted = [...rows].sort((a, b) => {
+    const dt = ts(a.createdAt) - ts(b.createdAt);
+    if (dt !== 0) return dt;
+    const dp =
+      (ROLE_PRIORITY[a.role] ?? 0) - (ROLE_PRIORITY[b.role] ?? 0);
+    if (dp !== 0) return dp;
+    return a._id < b._id ? -1 : a._id > b._id ? 1 : 0;
+  });
+
+  // Fix-up pre-utworzonych placeholderów.
+  const firstAssistantIdx = new Map<string, number>();
+  const firstTriggerIdx = new Map<string, number>();
+  for (let i = 0; i < sorted.length; i++) {
+    const row = sorted[i];
+    if (!row.sessionId) continue;
+    if (row.role === "assistant") {
+      if (!firstAssistantIdx.has(row.sessionId)) {
+        firstAssistantIdx.set(row.sessionId, i);
+      }
+    } else if (!firstTriggerIdx.has(row.sessionId)) {
+      firstTriggerIdx.set(row.sessionId, i);
+    }
+  }
+
+  // Przesunięcia wykonujemy od końca, żeby wcześniejsze splice'y nie
+  // unieważniały zapamiętanych indeksów kolejnych par.
+  const moves: Array<{ from: number; to: number }> = [];
+  for (const [sessionId, aIdx] of firstAssistantIdx) {
+    const tIdx = firstTriggerIdx.get(sessionId);
+    if (tIdx === undefined || aIdx > tIdx) continue;
+    moves.push({ from: aIdx, to: tIdx });
+  }
+  moves.sort((a, b) => b.from - a.from);
+  for (const { from, to } of moves) {
+    const [row] = sorted.splice(from, 1);
+    // Po usunięciu `from` (które było < to) trigger jest na `to - 1`;
+    // wstawiamy ZA niego.
+    sorted.splice(to, 0, row);
+  }
+
+  return sorted;
+}