@truefoundry/assistant-ui-runtime 0.1.13 → 0.1.15

package/dist/plugins/truefoundry-agent-server-adapter/index.d.ts

@@ -1,6 +1,6 @@
 import { AgentSessionClient } from 'truefoundry-gateway-sdk/agents';
 import { PrivateAgentSessionClient } from 'truefoundry-gateway-sdk/agents/private';
-import { A as AgentSpec, K as CreateSessionRequest, W as ListSessionsParams, S as Session, d as Turn, az as TurnState, a as AgentChatServer, aH as UpdateSessionRequest, i as AgentSelectorEntry, E as ConnectorSelectorEntry, a6 as ModelSelectorEntry, au as SkillSelectorEntry, g as AgentBuilderServer } from '../../types-BE-F3vCD.js';
+import { A as AgentSpec, N as CreateSessionRequest, Y as ListSessionsParams, S as Session, d as Turn, aC as TurnState, a as AgentChatServer, aK as UpdateSessionRequest, k as AgentSelectorEntry, G as ConnectorSelectorEntry, a8 as ModelSelectorEntry, ax as SkillSelectorEntry, g as AgentBuilderServer } from '../../types-VU3Fc17W.js';
 import { TruefoundryGatewayApi } from 'truefoundry-gateway-sdk';
 
 /**
@@ -29,8 +29,7 @@ type RuntimeSkillMount = NonNullable<NonNullable<AgentSpec["skills"]>[number]>;
 type RuntimeMcpServerMount = NonNullable<NonNullable<AgentSpec["mcpServers"]>[number]>;
 type TfySkillMount = RuntimeSkillMount & TruefoundryGatewayApi.SkillMount;
 type TfyMcpServerMount = RuntimeMcpServerMount & TruefoundryGatewayApi.McpServer;
-interface TfyAgentSpec extends AgentSpec<TruefoundryGatewayApi.Model, TfySkillMount, TfyMcpServerMount> {
-    config?: TruefoundryGatewayApi.RuntimeConfig;
+interface TfyAgentSpec extends AgentSpec<TruefoundryGatewayApi.Model, TfySkillMount, TfyMcpServerMount, TruefoundryGatewayApi.RuntimeConfig> {
     responseFormat?: TruefoundryGatewayApi.ResponseFormat;
     messages?: TruefoundryGatewayApi.AgentSpecUserMessage[];
 }

package/dist/plugins/truefoundry-agent-server-adapter/index.js

@@ -7,7 +7,7 @@ import {
   isTfyMcpToolInfo,
   isTfySystemToolInfo,
   isTfyToolInfo
-} from "../../chunk-XYGEKRA2.js";
+} from "../../chunk-S4SH2KT2.js";
 export {
   createTrueFoundryAgentUIServer,
   createTrueFoundryChatServer,

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
-import { aC as TurnStreamingEvent, aJ as DeltaEvents, T as TurnEvent } from '../types-BE-F3vCD.js';
-export { aK as ActionRequiredEvent, f as AgentBuilderCapabilitiesResponse, g as AgentBuilderServer, a as AgentChatServer, aL as AgentInfo, h as AgentLibraryEntry, aM as AgentParent, i as AgentSelectorEntry, j as AgentSkill, A as AgentSpec, k as AgentUIServer, l as AgentUIServerPort, m as ApprovalDecision, n as AuthenticateConnectorRequest, C as CatalogServer, aN as ChunkDeltaToolCall, o as ConnectorAuth, p as ConnectorAuthApiKey, q as ConnectorAuthNone, r as ConnectorAuthOAuth, s as ConnectorAuthPublic, t as ConnectorAuthPublicApiKey, u as ConnectorAuthPublicNone, v as ConnectorAuthPublicOAuth, w as ConnectorAuthType, x as ConnectorAuthenticationResult, y as ConnectorBase, z as ConnectorCatalogEntry, B as ConnectorCatalogServer, D as ConnectorConfigBase, E as ConnectorSelectorEntry, F as ConnectorState, G as CreateConnectorRequest, H as CreateModelProviderRequest, I as CreateSandboxProviderRequest, J as CreateSandboxRequest, K as CreateSessionRequest, L as CreateSkillRequest, N as CreateSkillRequestBase, O as DefinedSkill, P as GithubSkill, Q as ImportGithubSkillRequest, R as ListResult, V as ListSessionsOrder, W as ListSessionsParams, M as McpAuthRequiredEvent, aO as McpInitializeEvent, aP as McpServerAuthInfo, X as McpServerMount, Y as Model, Z as ModelCatalogServer, _ as ModelEntry, aQ as ModelMessageContentPart, aR as ModelMessageDeltaEvent, $ as ModelMessageEvent, a0 as ModelParams, a1 as ModelProperties, a2 as ModelProviderBase, a3 as ModelProviderCatalogEntry, a4 as ModelProviderConfigBase, a5 as ModelSelection, a6 as ModelSelectorEntry, a7 as PageParams, a8 as PreviousTurnIdInput, a9 as ProviderEntry, aa as ProviderType, ab as RegistrySkill, ac as SandboxBase, ad as SandboxCatalogEntry, ae as SandboxCatalogServer, af as SandboxConfig, ag as SandboxCreatedEvent, ah as SandboxProviderBase, ai as SandboxProviderCatalogEntry, aj as SandboxProviderConfig, ak as SaveAgentRequest, al as SearchAgentSelectorParams, am as SearchAgentsParams, an as SelectRegistrySkillRequest, S as Session, ao as SessionEventItem, ap as SkillBase, aq as SkillCatalogEntry, ar as SkillCatalogServer, as as SkillConfigBase, at as SkillMount, au as SkillSelectorEntry, b as ThreadCreatedEvent, aS as ThreadDoneEvent, av as ToolApprovalRequiredEvent, aw as ToolBase, ax as ToolCall, aT as ToolCallFunction, aU as ToolCallRef, aV as ToolInfo, aW as ToolResponseEvent, ay as ToolResponseRequiredEvent, d as Turn, aX as TurnCreatedEvent, aY as TurnDoneEvent, e as TurnInputItem, az as TurnState, aZ as TurnStateCancelled, aA as TurnStateDone, a_ as TurnStateError, a$ as TurnStateRunning, aB as TurnStreamData, aD as UpdateConnectorRequest, aE as UpdateModelProviderRequest, aF as UpdateSandboxProviderRequest, aG as UpdateSandboxRequest, aH as UpdateSessionRequest, aI as UserMessage, b0 as UserMessageContent, c as UserToolApprovalEvent, U as UserToolResponseEvent } from '../types-BE-F3vCD.js';
+import { aF as TurnStreamingEvent, aM as DeltaEvents, T as TurnEvent } from '../types-VU3Fc17W.js';
+export { aN as ActionRequiredEvent, f as AgentBuilderCapabilitiesResponse, g as AgentBuilderServer, h as AgentCapabilityConfig, a as AgentChatServer, aO as AgentInfo, i as AgentLibraryEntry, aP as AgentParent, j as AgentRuntimeConfig, k as AgentSelectorEntry, l as AgentSkill, A as AgentSpec, m as AgentUIServer, n as AgentUIServerPort, o as ApprovalDecision, p as AuthenticateConnectorRequest, C as CatalogServer, aQ as ChunkDeltaToolCall, q as ConnectorAuth, r as ConnectorAuthApiKey, s as ConnectorAuthNone, t as ConnectorAuthOAuth, u as ConnectorAuthPublic, v as ConnectorAuthPublicApiKey, w as ConnectorAuthPublicNone, x as ConnectorAuthPublicOAuth, y as ConnectorAuthType, z as ConnectorAuthenticationResult, B as ConnectorBase, D as ConnectorCatalogEntry, E as ConnectorCatalogServer, F as ConnectorConfigBase, G as ConnectorSelectorEntry, H as ConnectorState, I as CreateConnectorRequest, J as CreateModelProviderRequest, K as CreateSandboxProviderRequest, L as CreateSandboxRequest, N as CreateSessionRequest, O as CreateSkillRequest, P as CreateSkillRequestBase, Q as DefinedSkill, R as GithubSkill, V as ImportGithubSkillRequest, W as ListResult, X as ListSessionsOrder, Y as ListSessionsParams, M as McpAuthRequiredEvent, aR as McpInitializeEvent, aS as McpServerAuthInfo, Z as McpServerMount, _ as Model, $ as ModelCatalogServer, a0 as ModelEntry, aT as ModelMessageContentPart, aU as ModelMessageDeltaEvent, a1 as ModelMessageEvent, a2 as ModelParams, a3 as ModelProperties, a4 as ModelProviderBase, a5 as ModelProviderCatalogEntry, a6 as ModelProviderConfigBase, a7 as ModelSelection, a8 as ModelSelectorEntry, a9 as PageParams, aa as PreviousTurnIdInput, ab as ProviderEntry, ac as ProviderType, ad as RegistrySkill, ae as SandboxBase, af as SandboxCatalogEntry, ag as SandboxCatalogServer, ah as SandboxConfig, ai as SandboxCreatedEvent, aj as SandboxProviderBase, ak as SandboxProviderCatalogEntry, al as SandboxProviderConfig, am as SaveAgentRequest, an as SaveAgentResult, ao as SearchAgentSelectorParams, ap as SearchAgentsParams, aq as SelectRegistrySkillRequest, S as Session, ar as SessionEventItem, as as SkillBase, at as SkillCatalogEntry, au as SkillCatalogServer, av as SkillConfigBase, aw as SkillMount, ax as SkillSelectorEntry, b as ThreadCreatedEvent, aV as ThreadDoneEvent, ay as ToolApprovalRequiredEvent, az as ToolBase, aA as ToolCall, aW as ToolCallFunction, aX as ToolCallRef, aY as ToolInfo, aZ as ToolResponseEvent, aB as ToolResponseRequiredEvent, d as Turn, a_ as TurnCreatedEvent, a$ as TurnDoneEvent, e as TurnInputItem, aC as TurnState, b0 as TurnStateCancelled, aD as TurnStateDone, b1 as TurnStateError, b2 as TurnStateRunning, aE as TurnStreamData, aG as UpdateConnectorRequest, aH as UpdateModelProviderRequest, aI as UpdateSandboxProviderRequest, aJ as UpdateSandboxRequest, aK as UpdateSessionRequest, aL as UserMessage, b3 as UserMessageContent, c as UserToolApprovalEvent, U as UserToolResponseEvent } from '../types-VU3Fc17W.js';
 
 /**
  * Local implementations of streaming delta helpers.

package/dist/{types-BE-F3vCD.d.ts → types-VU3Fc17W.d.ts}

@@ -294,15 +294,24 @@ interface Model {
     name: string;
     params?: ModelParams;
 }
+interface AgentCapabilityConfig {
+    enabled?: boolean;
+}
+interface AgentRuntimeConfig {
+    generativeUi?: AgentCapabilityConfig;
+    dynamicSubAgents?: AgentCapabilityConfig;
+    askUserQuestions?: AgentCapabilityConfig;
+}
 /**
 * SDK-owned agent definition — fields the FE reads/writes.
-* Host widens `model` / `skills` / `mcpServers` via type params, and adds
-* extra fields via `TSpec extends AgentSpec<...>`.
+* Host widens `model` / `skills` / `mcpServers` / `config` via type params,
+* and adds extra fields via `TSpec extends AgentSpec<...>`.
 */
-interface AgentSpec<TModel extends Model = Model, TSkill extends SkillMount = SkillMount, TMcp extends McpServerMount = McpServerMount> {
+interface AgentSpec<TModel extends Model = Model, TSkill extends SkillMount = SkillMount, TMcp extends McpServerMount = McpServerMount, TConfig extends AgentRuntimeConfig = AgentRuntimeConfig> {
     model: TModel;
     skills?: TSkill[];
     mcpServers?: TMcp[];
+    config?: TConfig;
     instructions?: string;
     variables?: Record<string, string>;
 }
@@ -475,6 +484,15 @@ interface AgentChatServer<TSpec extends AgentSpec = AgentSpec, TSession extends
 interface SaveAgentRequest<TSpec extends AgentSpec = AgentSpec> {
     agentName: string;
     agentSpec: TSpec;
+    intent: "create" | "update";
+    /** Current mutable session to update atomically with the named agent. */
+    sessionId?: string;
+}
+interface SaveAgentResult {
+    /** Immutable id allocated by the host registry. */
+    agentId?: string;
+    /** Timestamp returned when the active mutable session was updated. */
+    sessionUpdatedAt?: string;
 }
 /**
  * Builder feature flags — atoms gate sandbox / skill / settings surfaces on these.
@@ -497,7 +515,7 @@ interface AgentBuilderCapabilitiesResponse {
 * Builder catalog + persist port — atoms call these.
 * Passed separately from the runtime's chat server.
 */
-interface AgentBuilderServer<TSpec extends AgentSpec = AgentSpec, TModel extends ModelSelectorEntry = ModelSelectorEntry, TSkill extends SkillSelectorEntry = SkillSelectorEntry, TMcp extends ConnectorSelectorEntry = ConnectorSelectorEntry, TAgent extends AgentSelectorEntry = AgentSelectorEntry, TSave = unknown, TCapabilities extends AgentBuilderCapabilitiesResponse = AgentBuilderCapabilitiesResponse> {
+interface AgentBuilderServer<TSpec extends AgentSpec = AgentSpec, TModel extends ModelSelectorEntry = ModelSelectorEntry, TSkill extends SkillSelectorEntry = SkillSelectorEntry, TMcp extends ConnectorSelectorEntry = ConnectorSelectorEntry, TAgent extends AgentSelectorEntry = AgentSelectorEntry, TSave = SaveAgentResult, TCapabilities extends AgentBuilderCapabilitiesResponse = AgentBuilderCapabilitiesResponse> {
     getCapabilities(): Promise<TCapabilities>;
     getModels(): Promise<TModel[]>;
     getSkills(): Promise<TSkill[]>;
@@ -815,4 +833,4 @@ type AgentUIServerPort<TChat extends AgentChatServer = AgentChatServer, TBuilder
 /** Host-facing alias used by trueforge-ui. */
 type AgentUIServer = AgentUIServerPort;
 
-export type { ModelMessageEvent as $, AgentSpec as A, ConnectorCatalogServer as B, CatalogServer as C, ConnectorConfigBase as D, ConnectorSelectorEntry as E, ConnectorState as F, CreateConnectorRequest as G, CreateModelProviderRequest as H, CreateSandboxProviderRequest as I, CreateSandboxRequest as J, CreateSessionRequest as K, CreateSkillRequest as L, McpAuthRequiredEvent as M, CreateSkillRequestBase as N, DefinedSkill as O, GithubSkill as P, ImportGithubSkillRequest as Q, ListResult as R, Session as S, TurnEvent as T, UserToolResponseEvent as U, ListSessionsOrder as V, ListSessionsParams as W, McpServerMount as X, Model as Y, ModelCatalogServer as Z, ModelEntry as _, AgentChatServer as a, TurnStateRunning as a$, ModelParams as a0, ModelProperties as a1, ModelProviderBase as a2, ModelProviderCatalogEntry as a3, ModelProviderConfigBase as a4, ModelSelection as a5, ModelSelectorEntry as a6, PageParams as a7, PreviousTurnIdInput as a8, ProviderEntry as a9, TurnStateDone as aA, TurnStreamData as aB, TurnStreamingEvent as aC, UpdateConnectorRequest as aD, UpdateModelProviderRequest as aE, UpdateSandboxProviderRequest as aF, UpdateSandboxRequest as aG, UpdateSessionRequest as aH, UserMessage as aI, DeltaEvents as aJ, ActionRequiredEvent as aK, AgentInfo as aL, AgentParent as aM, ChunkDeltaToolCall as aN, McpInitializeEvent as aO, McpServerAuthInfo as aP, ModelMessageContentPart as aQ, ModelMessageDeltaEvent as aR, ThreadDoneEvent as aS, ToolCallFunction as aT, ToolCallRef as aU, ToolInfo as aV, ToolResponseEvent as aW, TurnCreatedEvent as aX, TurnDoneEvent as aY, TurnStateCancelled as aZ, TurnStateError as a_, ProviderType as aa, RegistrySkill as ab, SandboxBase as ac, SandboxCatalogEntry as ad, SandboxCatalogServer as ae, SandboxConfig as af, SandboxCreatedEvent as ag, SandboxProviderBase as ah, SandboxProviderCatalogEntry as ai, SandboxProviderConfig as aj, SaveAgentRequest as ak, SearchAgentSelectorParams as al, SearchAgentsParams as am, SelectRegistrySkillRequest as an, SessionEventItem as ao, SkillBase as ap, SkillCatalogEntry as aq, SkillCatalogServer as ar, SkillConfigBase as as, SkillMount as at, SkillSelectorEntry as au, ToolApprovalRequiredEvent as av, ToolBase as aw, ToolCall as ax, ToolResponseRequiredEvent as ay, TurnState as az, ThreadCreatedEvent as b, UserMessageContent as b0, UserToolApprovalEvent as c, Turn as d, TurnInputItem as e, AgentBuilderCapabilitiesResponse as f, AgentBuilderServer as g, AgentLibraryEntry as h, AgentSelectorEntry as i, AgentSkill as j, AgentUIServer as k, AgentUIServerPort as l, ApprovalDecision as m, AuthenticateConnectorRequest as n, ConnectorAuth as o, ConnectorAuthApiKey as p, ConnectorAuthNone as q, ConnectorAuthOAuth as r, ConnectorAuthPublic as s, ConnectorAuthPublicApiKey as t, ConnectorAuthPublicNone as u, ConnectorAuthPublicOAuth as v, ConnectorAuthType as w, ConnectorAuthenticationResult as x, ConnectorBase as y, ConnectorCatalogEntry as z };
+export type { ModelCatalogServer as $, AgentSpec as A, ConnectorBase as B, CatalogServer as C, ConnectorCatalogEntry as D, ConnectorCatalogServer as E, ConnectorConfigBase as F, ConnectorSelectorEntry as G, ConnectorState as H, CreateConnectorRequest as I, CreateModelProviderRequest as J, CreateSandboxProviderRequest as K, CreateSandboxRequest as L, McpAuthRequiredEvent as M, CreateSessionRequest as N, CreateSkillRequest as O, CreateSkillRequestBase as P, DefinedSkill as Q, GithubSkill as R, Session as S, TurnEvent as T, UserToolResponseEvent as U, ImportGithubSkillRequest as V, ListResult as W, ListSessionsOrder as X, ListSessionsParams as Y, McpServerMount as Z, Model as _, AgentChatServer as a, TurnDoneEvent as a$, ModelEntry as a0, ModelMessageEvent as a1, ModelParams as a2, ModelProperties as a3, ModelProviderBase as a4, ModelProviderCatalogEntry as a5, ModelProviderConfigBase as a6, ModelSelection as a7, ModelSelectorEntry as a8, PageParams as a9, ToolCall as aA, ToolResponseRequiredEvent as aB, TurnState as aC, TurnStateDone as aD, TurnStreamData as aE, TurnStreamingEvent as aF, UpdateConnectorRequest as aG, UpdateModelProviderRequest as aH, UpdateSandboxProviderRequest as aI, UpdateSandboxRequest as aJ, UpdateSessionRequest as aK, UserMessage as aL, DeltaEvents as aM, ActionRequiredEvent as aN, AgentInfo as aO, AgentParent as aP, ChunkDeltaToolCall as aQ, McpInitializeEvent as aR, McpServerAuthInfo as aS, ModelMessageContentPart as aT, ModelMessageDeltaEvent as aU, ThreadDoneEvent as aV, ToolCallFunction as aW, ToolCallRef as aX, ToolInfo as aY, ToolResponseEvent as aZ, TurnCreatedEvent as a_, PreviousTurnIdInput as aa, ProviderEntry as ab, ProviderType as ac, RegistrySkill as ad, SandboxBase as ae, SandboxCatalogEntry as af, SandboxCatalogServer as ag, SandboxConfig as ah, SandboxCreatedEvent as ai, SandboxProviderBase as aj, SandboxProviderCatalogEntry as ak, SandboxProviderConfig as al, SaveAgentRequest as am, SaveAgentResult as an, SearchAgentSelectorParams as ao, SearchAgentsParams as ap, SelectRegistrySkillRequest as aq, SessionEventItem as ar, SkillBase as as, SkillCatalogEntry as at, SkillCatalogServer as au, SkillConfigBase as av, SkillMount as aw, SkillSelectorEntry as ax, ToolApprovalRequiredEvent as ay, ToolBase as az, ThreadCreatedEvent as b, TurnStateCancelled as b0, TurnStateError as b1, TurnStateRunning as b2, UserMessageContent as b3, UserToolApprovalEvent as c, Turn as d, TurnInputItem as e, AgentBuilderCapabilitiesResponse as f, AgentBuilderServer as g, AgentCapabilityConfig as h, AgentLibraryEntry as i, AgentRuntimeConfig as j, AgentSelectorEntry as k, AgentSkill as l, AgentUIServer as m, AgentUIServerPort as n, ApprovalDecision as o, AuthenticateConnectorRequest as p, ConnectorAuth as q, ConnectorAuthApiKey as r, ConnectorAuthNone as s, ConnectorAuthOAuth as t, ConnectorAuthPublic as u, ConnectorAuthPublicApiKey as v, ConnectorAuthPublicNone as w, ConnectorAuthPublicOAuth as x, ConnectorAuthType as y, ConnectorAuthenticationResult as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truefoundry/assistant-ui-runtime",
-  "version": "0.1.13",
+  "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);
 }
 
 /**