@arcote.tech/arc-chat 0.7.20 → 0.7.21

package/src/react/derive-timeline.test.ts

@@ -0,0 +1,654 @@
+import { describe, expect, it } from "bun:test";
+import {
+  deriveTimeline,
+  isPendingSendSettled,
+  type AssistantOverlay,
+  type DeriveTimelineInput,
+} from "./derive-timeline";
+
+// Server tools w testach: nazwy zaczynające się od "srv".
+const isServerTool = (name: string) => name.startsWith("srv");
+
+const T0 = 1_750_000_000_000;
+const NOW = T0 + 30_000;
+
+function input(partial: Partial<DeriveTimelineInput>): DeriveTimelineInput {
+  return {
+    history: [],
+    overlays: new Map(),
+    pendingSends: [],
+    pendingToolResults: new Map(),
+    isServerTool,
+    now: NOW,
+    ...partial,
+  };
+}
+
+const userRow = (id: string, content: string, offset = 0, sessionId = "s1") => ({
+  _id: id,
+  role: "user",
+  content,
+  sessionId,
+  createdAt: new Date(T0 + offset),
+});
+
+const assistantRow = (
+  id: string,
+  opts: {
+    offset?: number;
+    sessionId?: string;
+    isGenerating?: boolean;
+    interrupted?: boolean;
+    blocks?: unknown[];
+    error?: string;
+  } = {},
+) => ({
+  _id: id,
+  role: "assistant",
+  sessionId: opts.sessionId ?? "s1",
+  isGenerating: opts.isGenerating ?? false,
+  interrupted: opts.interrupted,
+  blocks: opts.blocks ? JSON.stringify(opts.blocks) : undefined,
+  error: opts.error,
+  createdAt: new Date(T0 + (opts.offset ?? 0)),
+});
+
+const toolResultRow = (
+  id: string,
+  toolCallId: string,
+  toolName: string,
+  content: string,
+  offset = 0,
+  sessionId = "s1",
+) => ({
+  _id: id,
+  role: "tool_result",
+  toolCallId,
+  toolName,
+  content,
+  sessionId,
+  createdAt: new Date(T0 + offset),
+});
+
+const overlay = (
+  status: AssistantOverlay["status"],
+  blocks: any[] = [],
+): AssistantOverlay => ({ blocks, status });
+
+describe("deriveTimeline — podstawowy przepływ", () => {
+  it("generujący row bez overlaya → streaming placeholder, busy", () => {
+    const { items, busy } = deriveTimeline(
+      input({
+        history: [
+          // assistantTurnStarted emitowany PRZED messageSent — placeholder
+          // ma wcześniejszy timestamp; ordering musi dać user → assistant.
+          assistantRow("a1", { offset: 0, isGenerating: true }),
+          userRow("u1", "Cześć", 2),
+        ],
+      }),
+    );
+    expect(items.map((i) => i.id)).toEqual(["u1", "a1_t0"]);
+    expect(items[1]).toMatchObject({
+      type: "message",
+      role: "assistant",
+      content: "",
+      isStreaming: true,
+    });
+    expect(busy).toBe(true);
+  });
+
+  it("generujący row z overlayem live → bloki overlaya, caret na ostatnim", () => {
+    const { items, busy } = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", { offset: 0, isGenerating: true }),
+          userRow("u1", "Cześć", 2),
+        ],
+        overlays: new Map([
+          [
+            "a1",
+            overlay("live", [
+              { type: "text", text: "Już " },
+              { type: "tool_call", id: "tc1", name: "srvSearch", arguments: {} },
+              { type: "text", text: "sprawdzam" },
+            ]),
+          ],
+        ]),
+      }),
+    );
+    expect(items.map((i) => i.id)).toEqual(["u1", "a1_t0", "tc1", "a1_t1"]);
+    expect((items[1] as any).isStreaming).toBe(false); // nie ostatni blok
+    expect((items[3] as any).isStreaming).toBe(true); // ostatni blok
+    expect(items[2]).toMatchObject({
+      type: "tool",
+      status: "executing",
+      calling: true,
+    });
+    expect(busy).toBe(true);
+  });
+
+  it("overlay done → caret zdjęty, bubble zostaje do flipa DB", () => {
+    const { items } = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", { offset: 0, isGenerating: true }),
+          userRow("u1", "Cześć", 2),
+        ],
+        overlays: new Map([
+          ["a1", overlay("done", [{ type: "text", text: "Gotowe" }])],
+        ]),
+      }),
+    );
+    expect(items[1]).toMatchObject({
+      content: "Gotowe",
+      isStreaming: false,
+    });
+  });
+
+  it("zamknięty row renderuje finalne blocks z IDENTYCZNYMI kluczami co overlay", () => {
+    const blocks = [
+      { type: "text", text: "Odpowiedź" },
+      { type: "tool_call", id: "tc1", name: "srvSearch", arguments: { q: 1 } },
+    ];
+    const streaming = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", { offset: 0, isGenerating: true }),
+          userRow("u1", "Hej", 2),
+        ],
+        overlays: new Map([["a1", overlay("live", blocks)]]),
+      }),
+    );
+    const closed = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", { offset: 0, blocks }),
+          userRow("u1", "Hej", 2),
+        ],
+      }),
+    );
+    expect(streaming.items.map((i) => i.id)).toEqual(
+      closed.items.map((i) => i.id),
+    );
+  });
+});
+
+describe("deriveTimeline — dawne race'y jako zwykłe przypadki", () => {
+  it("flip DB wyprzedził SSE done (stary produkcyjny hang): stale overlay ignorowany", () => {
+    // Row już zamknięty z finalnymi blocks, ale overlay wciąż wisi w mapie
+    // (hook nie zdążył go GC-nąć). Derywacja MUSI brać DB.
+    const { items, busy } = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", {
+            offset: 0,
+            blocks: [{ type: "text", text: "Final z DB" }],
+          }),
+          userRow("u1", "Hej", 2),
+        ],
+        overlays: new Map([
+          ["a1", overlay("live", [{ type: "text", text: "Stare z SSE" }])],
+        ]),
+      }),
+    );
+    expect((items[1] as any).content).toBe("Final z DB");
+    expect((items[1] as any).isStreaming).toBeFalsy();
+    expect(busy).toBe(false);
+  });
+
+  it("zgubione done: row zamknięty, overlay nigdy nie dostał done → wynik identyczny", () => {
+    const withStale = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", { offset: 0, blocks: [{ type: "text", text: "X" }] }),
+        ],
+        overlays: new Map([
+          ["a1", overlay("live", [{ type: "text", text: "Częściowe" }])],
+        ]),
+      }),
+    );
+    const clean = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", { offset: 0, blocks: [{ type: "text", text: "X" }] }),
+        ],
+      }),
+    );
+    expect(withStale.items).toEqual(clean.items);
+    expect(withStale.busy).toBe(clean.busy);
+  });
+
+  it("backstop tool_result (askQuestions po odpowiedzi): wynik z DB widoczny mimo trwającego nowego turnu", () => {
+    // respondToTool: tool_result row + NOWY generujący row. Stary kod
+    // zamrażał timeline guardem isStreaming — derywacja bierze resultMap
+    // z DB zawsze.
+    const { items } = deriveTimeline(
+      input({
+        history: [
+          userRow("u1", "Hej", 0),
+          assistantRow("a1", {
+            offset: 100,
+            blocks: [
+              { type: "tool_call", id: "tc1", name: "askQuestions", arguments: {} },
+            ],
+          }),
+          assistantRow("a2", { offset: 5_000, sessionId: "s2", isGenerating: true }),
+          toolResultRow("tr1", "tc1", "askQuestions", '{"answer":"tak"}', 5_001, "s2"),
+        ],
+      }),
+    );
+    const toolItem = items.find((i) => i.type === "tool") as any;
+    expect(toolItem.calling).toBe(false);
+    expect(toolItem.status).toBe("complete");
+    expect(toolItem.result).toEqual({ answer: "tak" });
+  });
+});
+
+describe("deriveTimeline — interrupted i error", () => {
+  it("DB interrupted → item interrupted, nie busy", () => {
+    const { items, busy } = deriveTimeline(
+      input({
+        history: [
+          userRow("u1", "Hej", 0),
+          assistantRow("a1", { offset: 1, interrupted: true }),
+        ],
+      }),
+    );
+    expect(items[1]).toMatchObject({ type: "interrupted", messageId: "a1" });
+    expect(busy).toBe(false);
+  });
+
+  it("overlay gone + isGenerating (lazy repair jeszcze nie przeszedł) → interrupted, nie busy", () => {
+    const { items, busy } = deriveTimeline(
+      input({
+        history: [
+          userRow("u1", "Hej", 0),
+          assistantRow("a1", { offset: 1, isGenerating: true }),
+        ],
+        overlays: new Map([["a1", overlay("gone")]]),
+      }),
+    );
+    expect(items[1]).toMatchObject({ type: "interrupted", messageId: "a1" });
+    expect(busy).toBe(false);
+  });
+
+  it("persystowany błąd generacji renderuje się z DB (przeżywa F5)", () => {
+    const { items, busy } = deriveTimeline(
+      input({
+        history: [
+          userRow("u1", "Hej", 0),
+          assistantRow("a1", { offset: 1, blocks: [], error: "AI error: boom" }),
+        ],
+      }),
+    );
+    expect(items[1]).toMatchObject({
+      type: "message",
+      id: "a1_error",
+      content: "AI error: boom",
+    });
+    expect(busy).toBe(false);
+  });
+});
+
+describe("deriveTimeline — busy (multi-turn tool loop)", () => {
+  const closedWithServerCall = assistantRow("a1", {
+    offset: 0,
+    blocks: [
+      { type: "text", text: "Sprawdzam" },
+      { type: "tool_call", id: "tc1", name: "srvSearch", arguments: {} },
+    ],
+  });
+
+  it("Gap A: server tool bez wyniku → busy (świeże)", () => {
+    const { busy } = deriveTimeline(
+      input({ history: [userRow("u1", "Hej", -10), closedWithServerCall] }),
+    );
+    expect(busy).toBe(true);
+  });
+
+  it("Gap A: cutoff świeżości — stary turn bez wyniku nie blokuje inputu", () => {
+    const { busy } = deriveTimeline(
+      input({
+        history: [userRow("u1", "Hej", -10), closedWithServerCall],
+        now: T0 + 10 * 60_000,
+      }),
+    );
+    expect(busy).toBe(false);
+  });
+
+  it("Gap B: świeży tool_result server-toola jako ostatni row → busy", () => {
+    const { busy } = deriveTimeline(
+      input({
+        history: [
+          userRow("u1", "Hej", -10),
+          closedWithServerCall,
+          toolResultRow("tr1", "tc1", "srvSearch", "{}", 3_000),
+        ],
+      }),
+    );
+    expect(busy).toBe(true);
+  });
+
+  it("interactive tool bez wyniku NIE daje busy (czeka na użytkownika)", () => {
+    const { busy, hasWaitingInteractive } = deriveTimeline(
+      input({
+        history: [
+          userRow("u1", "Hej", -10),
+          assistantRow("a1", {
+            offset: 0,
+            blocks: [
+              { type: "tool_call", id: "tc1", name: "askQuestions", arguments: {} },
+            ],
+          }),
+        ],
+      }),
+    );
+    expect(busy).toBe(false);
+    expect(hasWaitingInteractive).toBe(true);
+  });
+});
+
+describe("deriveTimeline — optimistic state", () => {
+  it("pending send widoczny i busy dopóki row nie dotarł", () => {
+    const { items, busy } = deriveTimeline(
+      input({
+        pendingSends: [
+          { localId: "p1", content: "Nowa wiadomość", sentAt: NOW - 100 },
+        ],
+      }),
+    );
+    expect(items).toEqual([
+      { type: "message", id: "p1", role: "user", content: "Nowa wiadomość" },
+    ]);
+    expect(busy).toBe(true);
+  });
+
+  it("pending send znika gdy row dotarł (match po dbId i po treści)", () => {
+    const history = [userRow("u1", "Nowa wiadomość", 29_000)];
+    expect(
+      isPendingSendSettled(history, {
+        localId: "p1",
+        content: "Nowa wiadomość",
+        sentAt: NOW - 5_000,
+        dbId: "u1",
+      }),
+    ).toBe(true);
+    expect(
+      isPendingSendSettled(history, {
+        localId: "p1",
+        content: "Nowa wiadomość",
+        sentAt: NOW - 5_000,
+      }),
+    ).toBe(true);
+    const { items } = deriveTimeline(
+      input({
+        history,
+        pendingSends: [
+          { localId: "p1", content: "Nowa wiadomość", sentAt: NOW - 5_000 },
+        ],
+      }),
+    );
+    expect(items.filter((i) => i.id === "p1")).toEqual([]);
+  });
+
+  it("optimistic tool result → answer-view natychmiast, DB wygrywa gdy dotrze", () => {
+    const history = [
+      assistantRow("a1", {
+        offset: 0,
+        blocks: [
+          { type: "tool_call", id: "tc1", name: "askQuestions", arguments: {} },
+        ],
+      }),
+    ];
+    const optimistic = deriveTimeline(
+      input({
+        history,
+        pendingToolResults: new Map([["tc1", { answer: "tak" }]]),
+      }),
+    );
+    const tool = optimistic.items.find((i) => i.type === "tool") as any;
+    expect(tool.calling).toBe(false);
+    expect(tool.result).toEqual({ answer: "tak" });
+    expect(optimistic.hasWaitingInteractive).toBe(false);
+
+    const withDb = deriveTimeline(
+      input({
+        history: [
+          ...history,
+          toolResultRow("tr1", "tc1", "askQuestions", '{"answer":"nie"}', 5_000),
+        ],
+        pendingToolResults: new Map([["tc1", { answer: "tak" }]]),
+      }),
+    );
+    const dbTool = withDb.items.find((i) => i.type === "tool") as any;
+    expect(dbTool.result).toEqual({ answer: "nie" });
+  });
+});
+
+describe("deriveTimeline — interactive tool podczas streamowania", () => {
+  const generatingWithUser = [
+    assistantRow("a1", { offset: 0, isGenerating: true }),
+    userRow("u1", "Hej", 2),
+  ];
+
+  it("blok interactive toola z pustymi args (tool_call_pending) jest ukryty, a tekst trzyma caret", () => {
+    // View komponenty interactive tooli (registerInputOverride) muszą
+    // montować się z kompletem argumentów — jak w DB po zamknięciu turnu.
+    // W oknie streamowania argumentów wskaźnikiem aktywności jest caret
+    // na ostatnim WIDOCZNYM bloku (tekście) — zero martwej przerwy.
+    const { items, hasWaitingInteractive } = deriveTimeline(
+      input({
+        history: generatingWithUser,
+        overlays: new Map([
+          [
+            "a1",
+            overlay("live", [
+              { type: "text", text: "Mam pytania" },
+              { type: "tool_call", id: "tc1", name: "askQuestions", arguments: {} },
+            ]),
+          ],
+        ]),
+      }),
+    );
+    expect(items.some((i) => i.type === "tool")).toBe(false);
+    expect(hasWaitingInteractive).toBe(false);
+    const text = items.find((i) => i.id === "a1_t0") as any;
+    expect(text.content).toBe("Mam pytania");
+    expect(text.isStreaming).toBe(true);
+  });
+
+  it("turn z samym ukrytym interactive toolem → spinner-placeholder", () => {
+    const { items } = deriveTimeline(
+      input({
+        history: generatingWithUser,
+        overlays: new Map([
+          [
+            "a1",
+            overlay("live", [
+              { type: "tool_call", id: "tc1", name: "askQuestions", arguments: {} },
+            ]),
+          ],
+        ]),
+      }),
+    );
+    expect(items.find((i) => i.id === "a1_t0")).toMatchObject({
+      type: "message",
+      content: "",
+      isStreaming: true,
+    });
+    expect(items.some((i) => i.type === "tool")).toBe(false);
+  });
+
+  it("pojawia się gdy argumenty są kompletne", () => {
+    const { items, hasWaitingInteractive } = deriveTimeline(
+      input({
+        history: generatingWithUser,
+        overlays: new Map([
+          [
+            "a1",
+            overlay("live", [
+              {
+                type: "tool_call",
+                id: "tc1",
+                name: "askQuestions",
+                arguments: { questions: [{ id: "q1" }] },
+              },
+            ]),
+          ],
+        ]),
+      }),
+    );
+    const tool = items.find((i) => i.type === "tool") as any;
+    expect(tool).toBeDefined();
+    expect(tool.params).toEqual({ questions: [{ id: "q1" }] });
+    expect(hasWaitingInteractive).toBe(true);
+  });
+
+  it("server tool z pustymi args pokazuje loader od razu (stara semantyka)", () => {
+    const { items } = deriveTimeline(
+      input({
+        history: generatingWithUser,
+        overlays: new Map([
+          [
+            "a1",
+            overlay("live", [
+              { type: "tool_call", id: "tc1", name: "srvSearch", arguments: {} },
+            ]),
+          ],
+        ]),
+      }),
+    );
+    expect(items.find((i) => i.type === "tool")).toMatchObject({
+      status: "executing",
+      calling: true,
+    });
+  });
+
+  it("po zamknięciu turnu interactive tool widoczny także z pustymi args", () => {
+    const { items } = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", {
+            offset: 0,
+            blocks: [
+              { type: "tool_call", id: "tc1", name: "askQuestions", arguments: {} },
+            ],
+          }),
+        ],
+      }),
+    );
+    expect(items.some((i) => i.type === "tool")).toBe(true);
+  });
+});
+
+describe("deriveTimeline — kształty danych po hydracji z Postgresa", () => {
+  // Adapter Postgresa auto-parsuje kolumny tekstowe wyglądające jak JSON:
+  // po restarcie serwera `blocks` i JSON-owy `content` przychodzą jako
+  // sparsowane wartości, nie stringi. Regresja: zamknięte wiadomości
+  // asystenta znikały z timeline'u.
+  it("blocks jako sparsowana tablica (nie string) renderuje się normalnie", () => {
+    const { items, busy } = deriveTimeline(
+      input({
+        history: [
+          userRow("u1", "Hej", 0),
+          {
+            _id: "a1",
+            role: "assistant",
+            sessionId: "s1",
+            isGenerating: false,
+            // surowa tablica — jak z deserializeValue adaptera
+            blocks: [
+              { type: "text", text: "Odpowiedź z bazy" },
+              { type: "tool_call", id: "tc1", name: "srvSearch", arguments: {} },
+            ],
+            createdAt: new Date(T0 + 1),
+          },
+        ],
+      }),
+    );
+    expect(items.map((i) => i.id)).toEqual(["u1", "a1_t0", "tc1"]);
+    expect((items[1] as any).content).toBe("Odpowiedź z bazy");
+    expect(busy).toBe(true); // server tool bez wyniku — Gap A też widzi tablicę
+  });
+
+  it("tool_result content jako sparsowany obiekt", () => {
+    const { items } = deriveTimeline(
+      input({
+        history: [
+          {
+            _id: "a1",
+            role: "assistant",
+            sessionId: "s1",
+            isGenerating: false,
+            blocks: [
+              { type: "tool_call", id: "tc1", name: "srvSearch", arguments: {} },
+            ],
+            createdAt: new Date(T0),
+          },
+          {
+            ...toolResultRow("tr1", "tc1", "srvSearch", "", 100),
+            content: { ok: true }, // sparsowane przez adapter
+          },
+        ],
+      }),
+    );
+    const tool = items.find((i) => i.type === "tool") as any;
+    expect(tool.status).toBe("complete");
+    expect(tool.result).toEqual({ ok: true });
+  });
+
+  it("user content jako sparsowana wartość renderuje się jako string", () => {
+    const { items } = deriveTimeline(
+      input({
+        history: [
+          { ...userRow("u1", "", 0), content: { jsonowa: "wiadomość" } },
+        ],
+      }),
+    );
+    expect((items[0] as any).content).toBe('{"jsonowa":"wiadomość"}');
+  });
+});
+
+describe("deriveTimeline — porządek i widoczność", () => {
+  it("system rows ukryte", () => {
+    const { items } = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", { offset: 0, isGenerating: true }),
+          {
+            _id: "sys1",
+            role: "system",
+            content: "Rozpocznij etap",
+            sessionId: "s1",
+            createdAt: new Date(T0 + 1),
+          },
+        ],
+      }),
+    );
+    expect(items.map((i) => i.id)).toEqual(["a1_t0"]);
+  });
+
+  it("pełna sesja multi-turn w kanonicznej kolejności", () => {
+    const { items } = deriveTimeline(
+      input({
+        history: [
+          assistantRow("a1", {
+            offset: 0,
+            blocks: [
+              { type: "text", text: "Sprawdzam" },
+              { type: "tool_call", id: "tc1", name: "srvSearch", arguments: {} },
+            ],
+          }),
+          userRow("u1", "Hej", 2),
+          toolResultRow("tr1", "tc1", "srvSearch", '{"ok":true}', 5_000),
+          assistantRow("a2", {
+            offset: 5_100,
+            blocks: [{ type: "text", text: "Wynik: ok" }],
+          }),
+        ],
+      }),
+    );
+    expect(items.map((i) => i.id)).toEqual(["u1", "a1_t0", "tc1", "a2_t0"]);
+    expect((items[2] as any).status).toBe("complete");
+  });
+});