@truefoundry/assistant-ui-runtime 0.1.14 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truefoundry/assistant-ui-runtime",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "TrueFoundry Gateway agent runtime adapter for assistant-ui",
   "license": "Apache-2.0",
   "repository": {

package/src/convertTurnMessages.test.ts

@@ -2434,7 +2434,7 @@ describe("buildSnapshotFromSessionEvents", () => {
         expect(progressSnapshots).toEqual([1, 2]);
     });
 
-    it("only inspects the newest listTurns page for a running turn", async () => {
+    it("falls back to listTurns({ limit: 1 }) when listEvents omits the running tip", async () => {
         const listTurns = vi.fn(async () => ({
             data: [
                 {
@@ -2460,6 +2460,300 @@ describe("buildSnapshotFromSessionEvents", () => {
         expect(snapshot.pendingUser?.content).toBe("now");
     });
 
+    it("attaches an open tip from events when listTurns is oldest-first and clears answered ask-user", async () => {
+        // Trueforge listTurns is ASC: limit:1 returns the oldest done turn even
+        // while a later tip is still running. Tip detection must use the open
+        // turn.created in listEvents (which includes running turns).
+        const oldestDoneTurn = {
+            id: "t-pause",
+            sessionId: SESSION_ID,
+            state: {
+                status: "done",
+                requiredActions: [
+                    {
+                        id: "resp-req-1",
+                        type: "tool.response_required",
+                        threadId: ROOT_THREAD_ID,
+                        createdAt,
+                        toolCalls: [{ id: "question-1", sourceEventId: "model-1" }],
+                    },
+                ],
+                completedAt: createdAt,
+            },
+            input: [{ type: "user.message", content: "please research" }],
+            createdAt,
+        } as unknown as Turn;
+
+        const runningTip = {
+            id: "t-running",
+            sessionId: SESSION_ID,
+            state: { status: "running" },
+            input: [
+                {
+                    type: "user.tool_response",
+                    threadId: ROOT_THREAD_ID,
+                    toolCallId: "question-1",
+                    content: "AI-native / LLM-powered SaaS",
+                },
+            ],
+            createdAt,
+        } as unknown as Turn;
+
+        const items: SessionEventItem[] = [
+            {
+                turnId: "t-pause",
+                event: {
+                    type: "turn.created",
+                    id: "evt-c-pause",
+                    turnId: "t-pause",
+                    input: oldestDoneTurn.input,
+                    state: { status: "running" },
+                    createdAt,
+                },
+            },
+            {
+                turnId: "t-pause",
+                event: modelMessage({
+                    id: "model-1",
+                    threadId: ROOT_THREAD_ID,
+                    content: "One calibration question:",
+                    toolCalls: [
+                        {
+                            id: "question-1",
+                            type: "function",
+                            function: {
+                                name: "ask_user_question",
+                                arguments: JSON.stringify({
+                                    question: "Which direction should I focus on?",
+                                    options: [
+                                        "General B2B SaaS",
+                                        "AI-native / LLM-powered SaaS",
+                                    ],
+                                }),
+                            },
+                            toolInfo: {
+                                type: "truefoundry-system",
+                                name: "ask_user_question",
+                            },
+                        },
+                    ],
+                }),
+            },
+            {
+                turnId: "t-pause",
+                event: responseRequired({
+                    id: "resp-req-1",
+                    threadId: ROOT_THREAD_ID,
+                    toolCalls: [{ id: "question-1", sourceEventId: "model-1" }],
+                }),
+            },
+            {
+                turnId: "t-pause",
+                event: {
+                    type: "turn.done",
+                    id: "evt-d-pause",
+                    state: oldestDoneTurn.state as TurnDoneEvent["state"],
+                    createdAt,
+                } as TurnDoneEvent,
+            },
+            {
+                turnId: "t-running",
+                event: {
+                    type: "turn.created",
+                    id: "evt-c-running",
+                    turnId: "t-running",
+                    previousTurnId: "t-pause",
+                    input: runningTip.input,
+                    state: { status: "running" },
+                    createdAt,
+                },
+            },
+            {
+                turnId: "t-running",
+                event: modelMessage({
+                    id: "model-2",
+                    threadId: ROOT_THREAD_ID,
+                    content: "Locked in — starting deep research.",
+                }),
+            },
+        ];
+
+        const listTurns = vi.fn(async () => ({
+            data: [oldestDoneTurn],
+            nextPageToken: "eyJvZmZzZXQiOjF9",
+        }));
+        const getTurn = vi.fn(async () => runningTip);
+        const server = {
+            listTurns,
+            getTurn,
+            listEvents: sessionEventsPage(items),
+            listTurnEvents: async () => ({ data: [] }),
+        } as unknown as AgentChatServer;
+
+        const snapshot = await buildSnapshotFromSessionEvents(server, SESSION_ID);
+
+        expect(getTurn).toHaveBeenCalledWith({
+            sessionId: SESSION_ID,
+            turnId: "t-running",
+        });
+        expect(listTurns).not.toHaveBeenCalled();
+        expect(snapshot.runningTurn?.id).toBe("t-running");
+        expect(snapshot.unstable_resume).toBe(true);
+
+        const messages = projectSessionMessages(snapshot);
+        expect(collectPendingToolResponses(messages)).toHaveLength(0);
+
+        const assistant = messages.find((message) => message.role === "assistant");
+        expect(assistant).toBeDefined();
+        const toolCall = assistant?.content.find(
+            (part) => part.type === "tool-call" && part.toolCallId === "question-1",
+        );
+        expect(toolCall).toMatchObject({
+            type: "tool-call",
+            toolCallId: "question-1",
+            result: "AI-native / LLM-powered SaaS",
+        });
+        if (toolCall?.type === "tool-call") {
+            expect(toolCall.interrupt).toBeUndefined();
+        }
+    });
+
+    it("keeps an answered ask-user answered when the open tip finished before getTurn", async () => {
+        // The tip can complete between listEvents and getTurn. There is nothing
+        // left to resume, but its user.tool_response input never reached the
+        // fold via ingestion (no turn.done in the window), so it must still be
+        // applied — otherwise the answered prompt resurfaces as pending.
+        const finishedTip = {
+            id: "t-tip",
+            sessionId: SESSION_ID,
+            state: { status: "done", requiredActions: [], completedAt: createdAt },
+            input: [
+                {
+                    type: "user.tool_response",
+                    threadId: ROOT_THREAD_ID,
+                    toolCallId: "question-1",
+                    content: "AI-native / LLM-powered SaaS",
+                },
+            ],
+            createdAt,
+        } as unknown as Turn;
+
+        const items: SessionEventItem[] = [
+            {
+                turnId: "t-pause",
+                event: {
+                    type: "turn.created",
+                    id: "evt-c-pause",
+                    turnId: "t-pause",
+                    input: [{ type: "user.message", content: "please research" }],
+                    state: { status: "running" },
+                    createdAt,
+                },
+            },
+            {
+                turnId: "t-pause",
+                event: modelMessage({
+                    id: "model-1",
+                    threadId: ROOT_THREAD_ID,
+                    content: "One calibration question:",
+                    toolCalls: [
+                        {
+                            id: "question-1",
+                            type: "function",
+                            function: {
+                                name: "ask_user_question",
+                                arguments: JSON.stringify({
+                                    question: "Which direction should I focus on?",
+                                    options: [
+                                        "General B2B SaaS",
+                                        "AI-native / LLM-powered SaaS",
+                                    ],
+                                }),
+                            },
+                            toolInfo: {
+                                type: "truefoundry-system",
+                                name: "ask_user_question",
+                            },
+                        },
+                    ],
+                }),
+            },
+            {
+                turnId: "t-pause",
+                event: responseRequired({
+                    id: "resp-req-1",
+                    threadId: ROOT_THREAD_ID,
+                    toolCalls: [{ id: "question-1", sourceEventId: "model-1" }],
+                }),
+            },
+            {
+                turnId: "t-pause",
+                event: {
+                    type: "turn.done",
+                    id: "evt-d-pause",
+                    state: {
+                        status: "done",
+                        requiredActions: [
+                            {
+                                id: "resp-req-1",
+                                type: "tool.response_required",
+                                threadId: ROOT_THREAD_ID,
+                                createdAt,
+                                toolCalls: [
+                                    { id: "question-1", sourceEventId: "model-1" },
+                                ],
+                            },
+                        ],
+                        completedAt: createdAt,
+                    },
+                    createdAt,
+                } as unknown as TurnDoneEvent,
+            },
+            {
+                turnId: "t-tip",
+                event: {
+                    type: "turn.created",
+                    id: "evt-c-tip",
+                    turnId: "t-tip",
+                    previousTurnId: "t-pause",
+                    input: finishedTip.input,
+                    state: { status: "running" },
+                    createdAt,
+                },
+            },
+        ];
+
+        const listTurns = vi.fn(async () => ({ data: [], nextPageToken: undefined }));
+        const getTurn = vi.fn(async () => finishedTip);
+        const server = {
+            listTurns,
+            getTurn,
+            listEvents: sessionEventsPage(items),
+            listTurnEvents: async () => ({ data: [] }),
+        } as unknown as AgentChatServer;
+
+        const snapshot = await buildSnapshotFromSessionEvents(server, SESSION_ID);
+
+        expect(snapshot.runningTurn).toBeUndefined();
+        expect(snapshot.unstable_resume).toBeFalsy();
+
+        const messages = projectSessionMessages(snapshot);
+        expect(collectPendingToolResponses(messages)).toHaveLength(0);
+
+        const assistant = messages.find((message) => message.role === "assistant");
+        const toolCall = assistant?.content.find(
+            (part) => part.type === "tool-call" && part.toolCallId === "question-1",
+        );
+        expect(toolCall).toMatchObject({
+            type: "tool-call",
+            toolCallId: "question-1",
+            result: "AI-native / LLM-powered SaaS",
+        });
+        if (toolCall?.type === "tool-call") {
+            expect(toolCall.interrupt).toBeUndefined();
+        }
+    });
+
     it("loads only the newest event page and exposes an older-history cursor", async () => {
         const makeTurnItems = (id: string, text: string): SessionEventItem[] => [
             {

package/src/convertTurnMessages.ts

@@ -516,10 +516,6 @@ function attachRunningTurn(
     if (runningTurn == null) {
         return snapshot;
     }
-    // Session-level history excludes the running turn. Apply continuation inputs
-    // from the turn listing so answered approvals / ask-user prompts are not
-    // restored as pending while reconnecting to that turn after a refresh.
-    applyUserToolResponsesToFold(snapshot.fold, runningTurn.input ?? []);
     const pendingUserText = extractTurnUserText(runningTurn.input);
     return replaceSessionSnapshot(snapshot, {
         runningTurn,
@@ -537,13 +533,117 @@ function attachRunningTurn(
     });
 }
 
+/**
+ * Last `turn.created` in ASC event order with no following `turn.done` — the
+ * open tip of the active branch in this window.
+ */
+function findOpenTurnCreated(
+    itemsAsc: readonly GatewaySessionEventItem[],
+): { turnId: string; event: TurnCreatedEvent } | undefined {
+    let open: { turnId: string; event: TurnCreatedEvent } | undefined;
+    for (const item of itemsAsc) {
+        if (item.event.type === "turn.created") {
+            open = { turnId: item.turnId, event: item.event };
+        } else if (item.event.type === "turn.done") {
+            open = undefined;
+        }
+    }
+    return open;
+}
+
+function turnFromCreatedEvent(options: {
+    sessionId: string;
+    turnId: string;
+    event: TurnCreatedEvent;
+}): Turn {
+    const { sessionId, turnId, event } = options;
+    return {
+        id: turnId,
+        sessionId,
+        state: { status: "running" },
+        createdAt: event.createdAt,
+        ...(event.input != null ? { input: event.input } : {}),
+        ...(event.previousTurnId === undefined
+            ? {}
+            : { previousTurnId: event.previousTurnId }),
+    };
+}
+
+type SessionTip = {
+    /** Turn to resume and subscribe to; absent once the tip has finished. */
+    runningTurn?: Turn;
+    /**
+     * Tip input that event ingestion could not apply, because it only folds a
+     * turn's input once that turn's `turn.done` arrives. Answered ask-user
+     * prompts and approvals live here, so this must be folded even when the tip
+     * is no longer running.
+     */
+    continuationInput: readonly TurnInputItem[];
+};
+
+/**
+ * Resolves the tip turn of the active branch for resume/subscribe.
+ *
+ * Prefer an open tip from the events window (works when listTurns is
+ * oldest-first and when listEvents includes the running turn). Fall back to
+ * `listTurns({ limit: 1 })` for hosts that omit the running turn from
+ * listEvents and put the tip first.
+ */
+async function resolveSessionTip(options: {
+    server: AgentChatServer;
+    sessionId: string;
+    itemsAsc: readonly GatewaySessionEventItem[];
+}): Promise<SessionTip> {
+    const { server, sessionId, itemsAsc } = options;
+    const open = findOpenTurnCreated(itemsAsc);
+    if (open != null) {
+        const continuationInput = open.event.input ?? [];
+        if (typeof server.getTurn === "function") {
+            try {
+                const turn = await server.getTurn({
+                    sessionId,
+                    turnId: open.turnId,
+                });
+                if (turn.state.status === "running") {
+                    return {
+                        runningTurn: turn,
+                        continuationInput: turn.input ?? continuationInput,
+                    };
+                }
+                // Tip finished between listEvents and getTurn: nothing to
+                // resume, but its answers still belong in the fold.
+                return { continuationInput: turn.input ?? continuationInput };
+            } catch {
+                // getTurn failed; synthesize from the open turn.created below.
+            }
+        }
+        return {
+            runningTurn: turnFromCreatedEvent({
+                sessionId,
+                turnId: open.turnId,
+                event: open.event,
+            }),
+            continuationInput,
+        };
+    }
+
+    // Hosts that exclude the running turn from listEvents still surface it as
+    // the first row of listTurns when that API is tip-first.
+    const turnsPage = await server.listTurns({ sessionId, limit: 1 });
+    const tip = turnsPage.data[0] as Turn | undefined;
+    return tip?.state?.status === "running"
+        ? { runningTurn: tip, continuationInput: tip.input ?? [] }
+        : { continuationInput: [] };
+}
+
 /**
  * Builds a session snapshot using the session-level `listEvents` API.
  *
  * Loads the newest event page (extending only when a page boundary splits a
  * turn group), then leaves older pages for `prependOlderSessionHistory`.
- * Only `listTurns({ limit: 1 })` is called first to detect a currently-running
- * turn (the session-level API does not return events for the running turn).
+ * Detects a currently-running tip from an open `turn.created` in that window
+ * when present; otherwise falls back to `listTurns({ limit: 1 })` for hosts
+ * that omit the running turn from listEvents.
  *
  * `onProgress` is called after each complete turn is ingested so callers can
  * update the UI progressively while the processing loop runs.
@@ -553,12 +653,6 @@ export async function buildSnapshotFromSessionEvents(
     sessionId: string,
     onProgress?: (snap: SessionSnapshot) => void,
 ): Promise<SessionSnapshot> {
-    // Detect a running turn with a single listTurns page — do not drain pagination.
-    const turnsPage = await server.listTurns({ sessionId, limit: 1 });
-    const newestTurn = turnsPage.data[0] as Turn | undefined;
-    const runningTurn =
-        newestTurn?.state?.status === "running" ? newestTurn : undefined;
-
     const window = await fetchSessionEventsWindow(server, sessionId);
     const historyPagination: SessionHistoryPagination = {
         hasOlder: window.hasOlder,
@@ -575,7 +669,16 @@ export async function buildSnapshotFromSessionEvents(
         historyPagination,
     });
 
-    return attachRunningTurn(withHistory, runningTurn);
+    const tip = await resolveSessionTip({
+        server,
+        sessionId,
+        itemsAsc: window.itemsAsc,
+    });
+    // The tip has no turn.done in this window, so ingestion never folded its
+    // input. Apply it here so answered approvals / ask-user prompts are not
+    // restored as pending after a refresh.
+    applyUserToolResponsesToFold(withHistory.fold, tip.continuationInput);
+    return attachRunningTurn(withHistory, tip.runningTurn);
 }
 
 /**