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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truefoundry/assistant-ui-runtime",
-  "version": "0.1.0-rc.1",
+  "version": "0.1.1",
   "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

@@ -8,6 +8,8 @@ import type {
     ToolApprovalRequiredEvent,
     ToolResponseRequiredEvent,
     Turn,
+    TurnCreatedEvent,
+    TurnDoneEvent,
     TurnEvent,
     TurnStreamData,
 } from "truefoundry-gateway-sdk/agents";
@@ -15,6 +17,8 @@ import type {
 import { ROOT_THREAD_ID } from "./constants.js";
 import { collectPendingToolResponses } from "./collectPending.js";
 import {
+    buildSnapshotBeforeTurnIndex,
+    buildSnapshotFromSessionEvents,
     buildTurnAssistantContent,
     buildUserMessageContent,
     buildUserMessageFromTurnInput,
@@ -132,9 +136,75 @@ 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 }) => {
+            const items = await sessionEventItemsFromTurns(turns, opts?.lastTurnId);
+            return {
+                async *[Symbol.asyncIterator]() {
+                    // session.listEvents yields newest-first.
+                    for (const item of [...items].reverse()) {
+                        yield item;
+                    }
+                },
+            };
+        },
     } as unknown as AgentSession;
 }
 
@@ -1113,6 +1183,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 +2097,257 @@ 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[]) {
+    return async (opts?: { lastTurnId?: string }) => {
+        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);
+        }
+        return {
+            async *[Symbol.asyncIterator]() {
+                for (const item of [...filtered].reverse()) {
+                    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]);
+    });
+});
+
+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);
+    });
+});
+