@truefoundry/assistant-ui-runtime 0.1.0-rc.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truefoundry/assistant-ui-runtime",
-  "version": "0.1.0-rc.1",
+  "version": "0.1.2",
   "description": "TrueFoundry Gateway agent runtime adapter for assistant-ui",
   "license": "Apache-2.0",
   "repository": {
@@ -50,7 +50,7 @@
   "peerDependencies": {
     "@types/react": "*",
     "react": "^18 || ^19",
-    "truefoundry-gateway-sdk": "^0.2.0"
+    "truefoundry-gateway-sdk": "^0.3.1"
   },
   "peerDependenciesMeta": {
     "@types/react": {

package/src/agentSessionModule.d.ts

@@ -18,8 +18,20 @@ declare module "truefoundry-gateway-sdk/dist/esm/agents/AgentSession.mjs" {
         }): PreparedTurn;
         listTurns(
             opts?: TrueFoundryGatewayApi.agents.SessionsListTurnsRequest,
+            requestOptions?: unknown,
         ): Promise<core.Page<unknown, TrueFoundryGatewayApi.ListTurnsResponse>>;
-        getTurn(opts: { turnId: string }): Promise<unknown>;
-        cancel(): Promise<void>;
+        /**
+         * Paginated session events across turns (newest first); subscribe to a
+         * running turn for live events.
+         *
+         * @param opts.lastTurnId - Newest turn in the listing window (initial load only).
+         *   Omit to use the session last turn. Running-turn events are excluded.
+         */
+        listEvents(
+            opts?: TrueFoundryGatewayApi.agents.SessionsListEventsRequest,
+            requestOptions?: unknown,
+        ): Promise<core.Page<TrueFoundryGatewayApi.SessionEventItem, TrueFoundryGatewayApi.ListSessionEventsResponse>>;
+        getTurn(opts: { turnId: string }, requestOptions?: unknown): Promise<unknown>;
+        cancel(requestOptions?: unknown): Promise<void>;
     }
 }

package/src/convertTurnMessages.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import type { AppendMessage } from "@assistant-ui/core";
 import type {
     AgentSession,
@@ -8,6 +8,8 @@ import type {
     ToolApprovalRequiredEvent,
     ToolResponseRequiredEvent,
     Turn,
+    TurnCreatedEvent,
+    TurnDoneEvent,
     TurnEvent,
     TurnStreamData,
 } from "truefoundry-gateway-sdk/agents";
@@ -15,11 +17,14 @@ import type {
 import { ROOT_THREAD_ID } from "./constants.js";
 import { collectPendingToolResponses } from "./collectPending.js";
 import {
+    buildSnapshotBeforeTurnIndex,
+    buildSnapshotFromSessionEvents,
     buildTurnAssistantContent,
     buildUserMessageContent,
     buildUserMessageFromTurnInput,
     convertTurnsToThreadMessages,
     getTurnMessageContent,
+    prependOlderSessionHistory,
     projectSessionMessages,
     repositoryItemsFromMessages,
     streamTurnEvents,
@@ -91,6 +96,12 @@ function eventsPage(events: TurnEvent[]) {
 
 function turnsPage(turns: Turn[]) {
     return async () => ({
+        data: turns,
+        response: {
+            data: turns,
+            pagination: { limit: turns.length || 1 },
+        },
+        hasNextPage: () => false,
         async *[Symbol.asyncIterator]() {
             for (const turn of turns) {
                 yield turn;
@@ -132,9 +143,81 @@ function mockTurn(
     };
 }
 
+async function collectTurnListEvents(
+    turn: Pick<Turn, "listEvents">,
+): Promise<TurnEvent[]> {
+    const events: TurnEvent[] = [];
+    for await (const event of await turn.listEvents()) {
+        events.push(event as TurnEvent);
+    }
+    return events;
+}
+
+/**
+ * Builds session-level event items from per-turn mocks — newest-first turns,
+ * running turns excluded (matches session.listEvents API contract).
+ */
+async function sessionEventItemsFromTurns(
+    turnsNewestFirst: ReturnType<typeof mockTurn>[],
+    lastTurnId?: string,
+): Promise<{ turnId: string; event: TurnCreatedEvent | TurnDoneEvent | TurnEvent }[]> {
+    let chain = turnsNewestFirst.filter((turn) => turn.state.status !== "running");
+    if (lastTurnId != null) {
+        const anchorIndex = chain.findIndex((turn) => turn.id === lastTurnId);
+        chain = anchorIndex === -1 ? [] : chain.slice(anchorIndex);
+    }
+
+    const items: { turnId: string; event: TurnCreatedEvent | TurnDoneEvent | TurnEvent }[] =
+        [];
+    for (const turn of [...chain].reverse()) {
+        items.push({
+            turnId: turn.id,
+            event: {
+                type: "turn.created",
+                id: `created-${turn.id}`,
+                turnId: turn.id,
+                input: turn.input,
+                state: { status: "running" },
+                createdBy: { subjectId: "u1", subjectType: "user" },
+                createdAt: turn.createdAt,
+            },
+        });
+        for (const event of await collectTurnListEvents(turn as Turn)) {
+            items.push({ turnId: turn.id, event });
+        }
+        items.push({
+            turnId: turn.id,
+            event: {
+                type: "turn.done",
+                id: `done-${turn.id}`,
+                state: turn.state as TurnDoneEvent["state"],
+                createdAt: turn.createdAt,
+            },
+        });
+    }
+    return items;
+}
+
 function mockSession(turns: ReturnType<typeof mockTurn>[]): AgentSession {
     return {
         listTurns: turnsPage(turns as Turn[]) as unknown as AgentSession["listTurns"],
+        listEvents: async (opts?: { lastTurnId?: string; pageToken?: string; limit?: number }) => {
+            const items = await sessionEventItemsFromTurns(turns, opts?.lastTurnId);
+            const newestFirst = [...items].reverse();
+            return {
+                data: newestFirst,
+                response: {
+                    data: newestFirst,
+                    pagination: { limit: newestFirst.length || 1 },
+                },
+                hasNextPage: () => false,
+                async *[Symbol.asyncIterator]() {
+                    for (const item of newestFirst) {
+                        yield item;
+                    }
+                },
+            };
+        },
     } as unknown as AgentSession;
 }
 
@@ -1113,6 +1196,44 @@ describe("convertTurnMessages", () => {
             expect(updates).toEqual([{ content: [{ type: "text", text: "streaming" }] }]);
         });
 
+        it("yields folded content after each ingested stream event", async () => {
+            const foldState = new PeerThreadFoldState();
+            const updates = await collectStream(
+                streamTurnEvents(
+                    streamFrom([
+                        modelMessage({
+                            id: "m1",
+                            threadId: ROOT_THREAD_ID,
+                            content: "first",
+                        }),
+                        modelMessage({
+                            id: "m2",
+                            threadId: ROOT_THREAD_ID,
+                            content: "second",
+                        }),
+                        modelMessage({
+                            id: "m3",
+                            threadId: ROOT_THREAD_ID,
+                            content: "third",
+                        }),
+                    ]),
+                    foldState,
+                ),
+            );
+
+            expect(updates).toHaveLength(3);
+            expect(updates[0]?.content).toEqual([{ type: "text", text: "first" }]);
+            expect(updates[1]?.content).toEqual([
+                { type: "text", text: "first" },
+                { type: "text", text: "second" },
+            ]);
+            expect(updates[2]?.content).toEqual([
+                { type: "text", text: "first" },
+                { type: "text", text: "second" },
+                { type: "text", text: "third" },
+            ]);
+        });
+
         it("scopes streamed content to ids after the group baseline", async () => {
             const foldState = new PeerThreadFoldState();
             foldState.getOrCreateBucket(ROOT_THREAD_ID);
@@ -1989,3 +2110,383 @@ describe("convertTurnMessages", () => {
         });
     });
 });
+
+// ---------------------------------------------------------------------------
+// buildSnapshotFromSessionEvents
+// ---------------------------------------------------------------------------
+
+type SessionEventItem = { turnId: string; event: TurnCreatedEvent | TurnDoneEvent | TurnEvent };
+
+/** Simulates session.listEvents — returns items in desc order (newest first). */
+function sessionEventsPage(
+    items: SessionEventItem[],
+    options?: { pageSize?: number },
+) {
+    return async (opts?: {
+        lastTurnId?: string;
+        pageToken?: string;
+        limit?: number;
+    }) => {
+        let filtered = items;
+        if (opts?.lastTurnId != null) {
+            // Chronological items: keep through lastTurnId, drop later turns.
+            const lastIndex = filtered.findLastIndex(
+                (item) => item.turnId === opts.lastTurnId,
+            );
+            filtered = lastIndex === -1 ? [] : filtered.slice(0, lastIndex + 1);
+        }
+        const newestFirst = [...filtered].reverse();
+        // Prefer fixture pageSize so pagination tests are not forced to the API default limit.
+        const pageSize =
+            options?.pageSize ?? opts?.limit ?? (newestFirst.length || 1);
+        const pageIndex = opts?.pageToken != null ? Number(opts.pageToken) : 0;
+        const start = pageIndex * pageSize;
+        const slice = newestFirst.slice(start, start + pageSize);
+        const hasMore = start + pageSize < newestFirst.length;
+        const nextPageToken = hasMore ? String(pageIndex + 1) : undefined;
+        return {
+            data: slice,
+            response: {
+                data: slice,
+                pagination: {
+                    limit: pageSize,
+                    ...(nextPageToken != null ? { nextPageToken } : {}),
+                },
+            },
+            hasNextPage: () => hasMore,
+            async *[Symbol.asyncIterator]() {
+                // Full drain for rewind paths that still iterate all pages.
+                for (const item of newestFirst) {
+                    yield item;
+                }
+            },
+        };
+    };
+}
+
+/** Builds a mock AgentSession with listTurns and listEvents. */
+function mockSessionWithEvents(
+    turns: Turn[],
+    eventItems: SessionEventItem[],
+): AgentSession {
+    return {
+        listTurns: turnsPage(turns),
+        listEvents: sessionEventsPage(eventItems),
+    } as unknown as AgentSession;
+}
+
+describe("buildSnapshotFromSessionEvents", () => {
+    it("builds a snapshot from a single complete turn", async () => {
+        const items: SessionEventItem[] = [
+            {
+                turnId: "t1",
+                event: {
+                    type: "turn.created",
+                    id: "evt-c1",
+                    turnId: "t1",
+                    input: [{ type: "user.message", content: "hello" }],
+                    state: { status: "running" },
+                    createdBy: { subjectId: "u1", subjectType: "user" },
+                    createdAt,
+                },
+            },
+            {
+                turnId: "t1",
+                event: modelMessage({ id: "m1", threadId: ROOT_THREAD_ID, content: "hi there" }),
+            },
+            {
+                turnId: "t1",
+                event: {
+                    type: "turn.done",
+                    id: "evt-d1",
+                    state: { status: "done", requiredActions: [], completedAt: createdAt },
+                    createdAt,
+                } as TurnDoneEvent,
+            },
+        ];
+
+        const snapshot = await buildSnapshotFromSessionEvents(mockSessionWithEvents([], items));
+
+        expect(snapshot.turns).toHaveLength(1);
+        expect(snapshot.turns[0]?.id).toBe("t1");
+        expect(snapshot.turns[0]?.userText).toBe("hello");
+        expect(snapshot.turns[0]?.state).toEqual({
+            status: "done",
+            requiredActions: [],
+            completedAt: createdAt,
+        });
+        expect(snapshot.turns[0]?.rootModelMessageIds).toEqual(["m1"]);
+        expect(snapshot.runningTurn).toBeUndefined();
+
+        const messages = projectSessionMessages(snapshot);
+        expect(messages).toHaveLength(2);
+        expect(messages[0]?.role).toBe("user");
+        expect(messages[1]?.role).toBe("assistant");
+    });
+
+    it("detects and attaches the running turn without events", async () => {
+        const runningTurn = {
+            id: "t2",
+            state: { status: "running" },
+            input: [{ type: "user.message", content: "in progress" }],
+            createdAt,
+        } as unknown as Turn;
+
+        const items: SessionEventItem[] = [
+            {
+                turnId: "t1",
+                event: {
+                    type: "turn.created",
+                    id: "evt-c1",
+                    turnId: "t1",
+                    input: [{ type: "user.message", content: "first" }],
+                    state: { status: "running" },
+                    createdBy: { subjectId: "u1", subjectType: "user" },
+                    createdAt,
+                },
+            },
+            {
+                turnId: "t1",
+                event: modelMessage({ id: "m1", threadId: ROOT_THREAD_ID, content: "reply 1" }),
+            },
+            {
+                turnId: "t1",
+                event: {
+                    type: "turn.done",
+                    id: "evt-d1",
+                    state: { status: "done", requiredActions: [], completedAt: createdAt },
+                    createdAt,
+                } as TurnDoneEvent,
+            },
+            // t2 (running) has no events — it is excluded from session-level listEvents
+        ];
+
+        const snapshot = await buildSnapshotFromSessionEvents(
+            mockSessionWithEvents([runningTurn], items),
+        );
+
+        expect(snapshot.turns).toHaveLength(1);
+        expect(snapshot.turns[0]?.id).toBe("t1");
+        expect(snapshot.runningTurn).toBe(runningTurn);
+        expect(snapshot.unstable_resume).toBe(true);
+        expect(snapshot.groupRootBaseline).toBeDefined();
+        expect(snapshot.pendingUser).toMatchObject({
+            turnId: "t2",
+            content: "in progress",
+        });
+    });
+
+    it("calls onProgress after each completed turn", async () => {
+        const items: SessionEventItem[] = [
+            {
+                turnId: "t1",
+                event: {
+                    type: "turn.created",
+                    id: "evt-c1",
+                    turnId: "t1",
+                    input: [{ type: "user.message", content: "first" }],
+                    state: { status: "running" },
+                    createdBy: { subjectId: "u1", subjectType: "user" },
+                    createdAt,
+                },
+            },
+            {
+                turnId: "t1",
+                event: modelMessage({ id: "m1", threadId: ROOT_THREAD_ID, content: "reply 1" }),
+            },
+            {
+                turnId: "t1",
+                event: {
+                    type: "turn.done",
+                    id: "evt-d1",
+                    state: { status: "done", requiredActions: [], completedAt: createdAt },
+                    createdAt,
+                } as TurnDoneEvent,
+            },
+            {
+                turnId: "t2",
+                event: {
+                    type: "turn.created",
+                    id: "evt-c2",
+                    turnId: "t2",
+                    input: [{ type: "user.message", content: "second" }],
+                    state: { status: "running" },
+                    createdBy: { subjectId: "u1", subjectType: "user" },
+                    createdAt,
+                },
+            },
+            {
+                turnId: "t2",
+                event: modelMessage({ id: "m2", threadId: ROOT_THREAD_ID, content: "reply 2" }),
+            },
+            {
+                turnId: "t2",
+                event: {
+                    type: "turn.done",
+                    id: "evt-d2",
+                    state: { status: "done", requiredActions: [], completedAt: createdAt },
+                    createdAt,
+                } as TurnDoneEvent,
+            },
+        ];
+
+        const progressSnapshots: number[] = [];
+        await buildSnapshotFromSessionEvents(
+            mockSessionWithEvents([], items),
+            (snap) => progressSnapshots.push(snap.turns.length),
+        );
+
+        expect(progressSnapshots).toEqual([1, 2]);
+    });
+
+    it("only inspects the newest listTurns page for a running turn", async () => {
+        const listTurns = vi.fn(async () => ({
+            data: [
+                {
+                    id: "t-running",
+                    state: { status: "running" },
+                    input: [{ type: "user.message", content: "now" }],
+                    createdAt,
+                },
+            ],
+            response: { data: [], pagination: { limit: 1, nextPageToken: "more" } },
+            hasNextPage: () => true,
+            getNextPage: async () => {
+                throw new Error("listTurns must not paginate on initial load");
+            },
+            async *[Symbol.asyncIterator]() {
+                throw new Error("listTurns must not be fully iterated on initial load");
+            },
+        }));
+
+        const session = {
+            listTurns,
+            listEvents: sessionEventsPage([]),
+        } as unknown as AgentSession;
+
+        const snapshot = await buildSnapshotFromSessionEvents(session);
+        expect(listTurns).toHaveBeenCalledWith({ limit: 1 });
+        expect(snapshot.runningTurn?.id).toBe("t-running");
+        expect(snapshot.pendingUser?.content).toBe("now");
+    });
+
+    it("loads only the newest event page and exposes an older-history cursor", async () => {
+        const makeTurnItems = (id: string, text: string): SessionEventItem[] => [
+            {
+                turnId: id,
+                event: {
+                    type: "turn.created",
+                    id: `evt-c-${id}`,
+                    turnId: id,
+                    input: [{ type: "user.message", content: text }],
+                    state: { status: "running" },
+                    createdBy: { subjectId: "u1", subjectType: "user" },
+                    createdAt,
+                },
+            },
+            {
+                turnId: id,
+                event: modelMessage({
+                    id: `m-${id}`,
+                    threadId: ROOT_THREAD_ID,
+                    content: `reply ${text}`,
+                }),
+            },
+            {
+                turnId: id,
+                event: {
+                    type: "turn.done",
+                    id: `evt-d-${id}`,
+                    state: { status: "done", requiredActions: [], completedAt: createdAt },
+                    createdAt,
+                } as TurnDoneEvent,
+            },
+        ];
+
+        // 3 events per turn; pageSize 3 → one turn per page (newest first).
+        const items = [
+            ...makeTurnItems("t1", "first"),
+            ...makeTurnItems("t2", "second"),
+            ...makeTurnItems("t3", "third"),
+        ];
+        const listEvents = sessionEventsPage(items, { pageSize: 3 });
+        const listEventsSpy = vi.fn(listEvents);
+        const session = {
+            listTurns: turnsPage([]),
+            listEvents: listEventsSpy,
+        } as unknown as AgentSession;
+
+        const snapshot = await buildSnapshotFromSessionEvents(session);
+        expect(listEventsSpy).toHaveBeenCalledTimes(1);
+        expect(snapshot.turns.map((t) => t.id)).toEqual(["t3"]);
+        expect(snapshot.historyPagination).toEqual({
+            hasOlder: true,
+            olderPageToken: "1",
+        });
+
+        const withOlder = await prependOlderSessionHistory(session, snapshot);
+        expect(withOlder.turns.map((t) => t.id)).toEqual(["t2", "t3"]);
+        expect(projectSessionMessages(withOlder).map((m) => m.role)).toEqual([
+            "user",
+            "assistant",
+            "user",
+            "assistant",
+        ]);
+        expect(withOlder.historyPagination?.hasOlder).toBe(true);
+
+        const withAll = await prependOlderSessionHistory(session, withOlder);
+        expect(withAll.turns.map((t) => t.id)).toEqual(["t1", "t2", "t3"]);
+        expect(withAll.historyPagination?.hasOlder).toBe(false);
+    });
+});
+
+describe("buildSnapshotBeforeTurnIndex", () => {
+    it("rewinds via session.listEvents({ lastTurnId }) excluding the branch turn", async () => {
+        const t1 = mockTurn({
+            id: "t1",
+            createdAt,
+            input: [{ type: "user.message", content: "first" }],
+            listEvents: eventsPage([
+                modelMessage({ id: "m1", threadId: ROOT_THREAD_ID, content: "reply 1" }),
+            ]) as unknown as Turn["listEvents"],
+        });
+        const t2 = mockTurn({
+            id: "t2",
+            createdAt,
+            input: [{ type: "user.message", content: "second" }],
+            listEvents: eventsPage([
+                modelMessage({ id: "m2", threadId: ROOT_THREAD_ID, content: "reply 2" }),
+            ]) as unknown as Turn["listEvents"],
+        });
+        const t3 = mockTurn({
+            id: "t3",
+            createdAt,
+            input: [{ type: "user.message", content: "third" }],
+            listEvents: eventsPage([
+                modelMessage({ id: "m3", threadId: ROOT_THREAD_ID, content: "reply 3" }),
+            ]) as unknown as Turn["listEvents"],
+        });
+
+        // listTurns is newest-first.
+        const session = mockSession([t3, t2, t1]);
+        const snapshot = await buildSnapshotBeforeTurnIndex(session, 2);
+
+        expect(snapshot.turns.map((turn) => turn.id)).toEqual(["t1", "t2"]);
+        const messages = projectSessionMessages(snapshot);
+        expect(messages.map((message) => message.id)).toEqual([
+            "t1-user",
+            "t1-assistant",
+            "t2-user",
+            "t2-assistant",
+        ]);
+    });
+
+    it("returns an empty snapshot when branching from the first turn", async () => {
+        const session = mockSession([
+            mockTurn({ id: "t1", createdAt }),
+        ]);
+        const snapshot = await buildSnapshotBeforeTurnIndex(session, 0);
+        expect(snapshot.turns).toHaveLength(0);
+    });
+});
+