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

package/src/convertTurnMessages.ts

@@ -10,12 +10,15 @@ import type {
     AgentSession,
     McpAuthRequiredEvent,
     Turn,
+    TurnCreatedEvent,
+    TurnDoneEvent,
     TurnEvent,
     TurnInputItem,
     TurnStreamData,
 } from "truefoundry-gateway-sdk/agents";
 
 import { ROOT_THREAD_ID } from "./constants.js";
+import { extractTurnUserText } from "./extractTurnUserText.js";
 import {
     buildRootAssistantContent,
     buildRootAssistantContentForIds,
@@ -42,6 +45,7 @@ import {
     createEmptySessionSnapshot,
     emptyRequiredActionsOverlay,
     replaceSessionSnapshot,
+    sessionEventsToSessionRecord,
     turnToSessionRecord,
 } from "./sessionSnapshot.js";
 import {
@@ -186,12 +190,23 @@ import {
  *   `user.message`.
  * - Tool-call identity is stable via `toolCallId` across events, fold state, and
  *   assistant-ui parts.
- * - Reload (`buildSnapshotFromSession`) and live paths must produce the same
+ * - Reload (`buildSnapshotFromSessionEvents`) and live paths must produce the same
  *   per-group scoping; history uses cumulative `groupRootIds` per turn index,
  *   live uses `groupRootBaseline`.
  */
 
 const TURN_EVENTS_PAGE_SIZE = 25;
+const SESSION_EVENTS_PAGE_SIZE = 100;
+
+/**
+ * Session-level event item — structurally equivalent to
+ * `TrueFoundryGateway.SessionEventItem` from
+ * `AgentSession.listEvents` (not re-exported from agents subpath).
+ */
+type GatewaySessionEventItem = {
+    turnId: string;
+    event: TurnCreatedEvent | TurnDoneEvent | TurnEvent;
+};
 
 export type ConvertTurnsResult = {
     messages: ThreadMessage[];
@@ -731,6 +746,163 @@ export function projectSessionMessages(
 
 const DEFAULT_LIST_EVENTS_CONCURRENCY = 5;
 
+type FetchSessionEventsOptions = {
+    /**
+     * Newest turn in the listing window (initial load only). Lists that turn and
+     * its ancestors. Omit to use the session last turn. Running-turn events are
+     * excluded by the API — subscribe to that turn for live events.
+     */
+    lastTurnId?: string;
+};
+
+/**
+ * Fetches session-level events via `session.listEvents()`. The API returns pages
+ * in desc order (newest first); the collected array is reversed before returning
+ * so callers receive events in chronological (asc) order.
+ */
+async function fetchAllSessionEvents(
+    session: AgentSession,
+    options?: FetchSessionEventsOptions,
+): Promise<GatewaySessionEventItem[]> {
+    const items: GatewaySessionEventItem[] = [];
+    for await (const item of await session.listEvents({
+        limit: SESSION_EVENTS_PAGE_SIZE,
+        ...(options?.lastTurnId != null ? { lastTurnId: options.lastTurnId } : {}),
+    })) {
+        items.push(item as GatewaySessionEventItem);
+    }
+    items.reverse();
+    return items;
+}
+
+/**
+ * Ingests a chronologically ordered list of session-level event items into the
+ * snapshot. `turn.created` marks the start of a turn (provides user input),
+ * content events are folded as usual, and `turn.done` finalises the turn record
+ * and pushes it to `snapshot.turns`.
+ *
+ * `onTurnComplete` is called after each `turn.done` with the partially-built
+ * snapshot so callers can update UI progressively. The fold state is correct at
+ * that point for every turn up to and including the just-completed one.
+ */
+function ingestSessionEventsIntoSnapshot(
+    snapshot: SessionSnapshot,
+    items: GatewaySessionEventItem[],
+    onTurnComplete?: (snap: SessionSnapshot) => void,
+): void {
+    let currentTurnId: string | null = null;
+    let currentCreatedEvent: TurnCreatedEvent | null = null;
+    let currentContentEvents: TurnEvent[] = [];
+    let beforeCount = 0;
+
+    for (const item of items) {
+        const { turnId, event } = item;
+
+        if (event.type === "turn.created") {
+            currentTurnId = turnId;
+            currentCreatedEvent = event;
+            currentContentEvents = [];
+            beforeCount =
+                snapshot.fold.threads.get(ROOT_THREAD_ID)?.modelMessageIds.length ?? 0;
+        } else if (event.type === "turn.done") {
+            if (currentTurnId == null || currentCreatedEvent == null) {
+                continue;
+            }
+
+            const afterBucket = snapshot.fold.threads.get(ROOT_THREAD_ID);
+            const rootModelMessageIds = (afterBucket?.modelMessageIds ?? []).slice(
+                beforeCount,
+            );
+
+            const sandboxEvent = currentContentEvents.find(
+                (ev): ev is Extract<TurnEvent, { type: "sandbox.created" }> =>
+                    ev.type === "sandbox.created",
+            );
+
+            applyUserToolResponsesToFold(
+                snapshot.fold,
+                currentCreatedEvent.input ?? [],
+            );
+            snapshot.turns.push(
+                sessionEventsToSessionRecord(
+                    currentTurnId,
+                    currentCreatedEvent,
+                    event,
+                    rootModelMessageIds,
+                    sandboxEvent?.sandboxId,
+                ),
+            );
+
+            // Pass a new object reference so React's Object.is check in
+            // useState sees a changed value and schedules a re-render.
+            // The snapshot is mutated in place throughout this loop, so
+            // passing `snapshot` directly would make every tick look identical
+            // to React after the first setSnapshot call.
+            onTurnComplete?.(replaceSessionSnapshot(snapshot, {}));
+
+            currentTurnId = null;
+            currentCreatedEvent = null;
+            currentContentEvents = [];
+        } else {
+            if (currentTurnId != null) {
+                ingestTurnEvent(snapshot.fold, event as TurnEvent);
+                currentContentEvents.push(event as TurnEvent);
+            }
+        }
+    }
+}
+
+/**
+ * Builds a session snapshot using the session-level `listEvents` API.
+ *
+ * Compared to `buildSnapshotFromSession`, this makes a single paginated request
+ * for all history events instead of one per turn. 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).
+ *
+ * `onProgress` is called after each complete turn is ingested so callers can
+ * update the UI progressively while the processing loop runs.
+ */
+export async function buildSnapshotFromSessionEvents(
+    session: AgentSession,
+    onProgress?: (snap: SessionSnapshot) => void,
+): Promise<SessionSnapshot> {
+    // Detect a running turn with a single minimal listTurns call.
+    let runningTurn: Turn | undefined;
+    for await (const turn of await session.listTurns({ limit: 1 })) {
+        if ((turn as Turn).state?.status === "running") {
+            runningTurn = turn as Turn;
+        }
+    }
+
+    const items = await fetchAllSessionEvents(session);
+
+    const snapshot = createEmptySessionSnapshot();
+    ingestSessionEventsIntoSnapshot(snapshot, items, onProgress);
+
+    if (runningTurn == null) {
+        return snapshot;
+    }
+
+    // Session listEvents excludes the running turn. Seed its user message so
+    // reconnect UI can show the in-flight bubble before subscribe yields.
+    const pendingUserText = extractTurnUserText(runningTurn.input);
+    return replaceSessionSnapshot(snapshot, {
+        runningTurn,
+        unstable_resume: true as const,
+        groupRootBaseline: computeGroupRootBaseline(snapshot.turns),
+        ...(pendingUserText
+            ? {
+                  pendingUser: {
+                      turnId: runningTurn.id,
+                      content: extractTurnUserMessageContent(runningTurn.input),
+                      createdAt: new Date(runningTurn.createdAt),
+                  },
+              }
+            : {}),
+    });
+}
+
 function ingestTurnsIntoSnapshot(
     snapshot: SessionSnapshot,
     turns: Turn[],
@@ -775,25 +947,22 @@ export async function buildSnapshotFromSession(
     session: AgentSession,
     concurrency: number = DEFAULT_LIST_EVENTS_CONCURRENCY,
 ): Promise<SessionSnapshot> {
-    const turns: Turn[] = [];
-    for await (const turn of await session.listTurns()) {
-        turns.push(turn);
+    // Completed history comes from session-level listEvents. The session API
+    // excludes the running turn — hydrate that turn via turn.listEvents so
+    // convertTurnsToThreadMessages still surfaces in-flight content.
+    const snapshot = await buildSnapshotFromSessionEvents(session);
+    if (snapshot.runningTurn == null) {
+        return snapshot;
     }
-    turns.reverse();
 
-    const eventArrays = await fetchAllTurnEventsWithConcurrency(turns, concurrency);
-
-    const snapshot = createEmptySessionSnapshot();
-    const runningTurn = ingestTurnsIntoSnapshot(snapshot, turns, eventArrays);
+    const turn = snapshot.runningTurn;
+    const eventArrays = await fetchAllTurnEventsWithConcurrency([turn], concurrency);
+    ingestTurnsIntoSnapshot(snapshot, [turn], eventArrays);
 
     return replaceSessionSnapshot(snapshot, {
-        ...(runningTurn != null
-            ? {
-                  runningTurn,
-                  unstable_resume: true as const,
-                  groupRootBaseline: computeGroupRootBaseline(snapshot.turns),
-              }
-            : {}),
+        runningTurn: turn,
+        unstable_resume: true as const,
+        groupRootBaseline: computeGroupRootBaseline(snapshot.turns),
     });
 }
 
@@ -803,11 +972,7 @@ export async function buildSnapshotBeforeTurn(
     beforeTurnId: string,
     concurrency: number = DEFAULT_LIST_EVENTS_CONCURRENCY,
 ): Promise<SessionSnapshot> {
-    const turns: Turn[] = [];
-    for await (const turn of await session.listTurns()) {
-        turns.push(turn);
-    }
-    turns.reverse();
+    const turns = await listSessionTurnsOrdered(session);
 
     const beforeIndex = turns.findIndex((turn) => turn.id === beforeTurnId);
     if (beforeIndex === -1) {
@@ -821,7 +986,7 @@ export async function buildSnapshotBeforeTurn(
 export async function buildSnapshotBeforeTurnIndex(
     session: AgentSession,
     turnIndex: number,
-    concurrency: number = DEFAULT_LIST_EVENTS_CONCURRENCY,
+    _concurrency: number = DEFAULT_LIST_EVENTS_CONCURRENCY,
     orderedTurns?: Turn[],
 ): Promise<SessionSnapshot> {
     if (turnIndex <= 0) {
@@ -830,16 +995,16 @@ export async function buildSnapshotBeforeTurnIndex(
 
     const turns = orderedTurns ?? (await listSessionTurnsOrdered(session));
     const turnsToInclude = turns.slice(0, turnIndex);
-    if (turnsToInclude.length === 0) {
+    const lastTurnId = turnsToInclude.at(-1)?.id;
+    if (lastTurnId == null) {
         return createEmptySessionSnapshot();
     }
 
-    const eventArrays = await fetchAllTurnEventsWithConcurrency(
-        turnsToInclude,
-        concurrency,
-    );
+    // Anchor the session events window at the newest included turn so the
+    // ancestor chain matches `[turns[0], …, turns[turnIndex - 1]]`.
+    const items = await fetchAllSessionEvents(session, { lastTurnId });
     const snapshot = createEmptySessionSnapshot();
-    ingestTurnsIntoSnapshot(snapshot, turnsToInclude, eventArrays);
+    ingestSessionEventsIntoSnapshot(snapshot, items);
     return snapshot;
 }
 

package/src/createSubAgent.ts

@@ -1,8 +1,16 @@
 import type { ToolCall } from "truefoundry-gateway-sdk/agents";
 
-export function isCreateSubAgentToolCall(toolCall: Pick<ToolCall, "toolInfo">): boolean {
-    return (
-        toolCall.toolInfo.type === "truefoundry-system" &&
-        toolCall.toolInfo.name === "create_sub_agent"
-    );
+export function isCreateSubAgentToolCall(
+    toolCall: Pick<ToolCall, "toolInfo" | "function">,
+): boolean {
+    // Gateway may attach truefoundry-system toolInfo on persisted turns, but streamed
+    // model.message tool calls often only carry function.name. Without the fallback,
+    // foldPeerThreads never nests child threads under the spawning tool call.
+    if (
+        toolCall.toolInfo?.type === "truefoundry-system" &&
+        toolCall.toolInfo?.name === "create_sub_agent"
+    ) {
+        return true;
+    }
+    return toolCall.function?.name === "create_sub_agent";
 }

package/src/draftAgentConfig.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { mergeAgentSpec } from "./agentSpec.js";
+import { mergeAgentSpec } from "./private/agentSpec.js";
 import { resolveTrueFoundryAgentConfig } from "./types.js";
 
 describe("resolveTrueFoundryAgentConfig", () => {

package/src/foldPeerThreads.test.ts

@@ -129,6 +129,62 @@ describe("foldPeerThreads", () => {
         });
     });
 
+    it("attaches sub-agent artifact from thread.created before child model messages arrive", () => {
+        const state = new PeerThreadFoldState();
+
+        ingestTurnEvent(
+            state,
+            modelMessage({
+                id: "root-msg",
+                threadId: ROOT_THREAD_ID,
+                toolCalls: [
+                    {
+                        id: "spawn-1",
+                        type: "function",
+                        function: { name: "create_sub_agent", arguments: "{}" },
+                    },
+                ],
+            }),
+        );
+
+        ingestTurnEvent(
+            state,
+            threadCreated({
+                id: "t-created",
+                threadId: "child-1",
+                title: "gateway-usage-7d",
+                agentInfo: {
+                    type: "dynamic",
+                    name: "gateway-usage-7d",
+                    input: "run queries",
+                },
+                parent: { threadId: ROOT_THREAD_ID, toolCallId: "spawn-1" },
+            }),
+        );
+
+        const parts = buildRootAssistantContent(state);
+        const spawn = parts.find((part) => part.type === "tool-call");
+        expect(spawn?.type).toBe("tool-call");
+        if (spawn?.type !== "tool-call") {
+            return;
+        }
+
+        expect(spawn.messages).toBeUndefined();
+        expect(spawn.artifact).toEqual({
+            subAgents: [
+                {
+                    threadId: "child-1",
+                    title: "gateway-usage-7d",
+                    agentInfo: {
+                        type: "dynamic",
+                        name: "gateway-usage-7d",
+                        input: "run queries",
+                    },
+                },
+            ],
+        });
+    });
+
     it("classifies stream events by thread id", () => {
         const state = new PeerThreadFoldState();
         expect(

package/src/foldPeerThreads.ts

@@ -389,11 +389,17 @@ function attachSubAgentMessages(
                 });
             }
         }
-        if (messages.length === 0) {
+        if (messages.length === 0 && subAgents.length === 0) {
             return part;
         }
 
         const artifact: SubAgentArtifact = { subAgents };
+        // thread.created (title, agentInfo) arrives before the child's first model.message.
+        // Attach artifact-only so UI can render the sub-agent header immediately; see README
+        // SubAgentArtifact / MessagePartPrimitive.Messages in agent-ui ToolCallContainer.
+        if (messages.length === 0) {
+            return { ...part, artifact };
+        }
         return { ...part, messages, artifact };
     });
 }

package/src/hooks.ts

@@ -98,6 +98,12 @@ export const useTrueFoundryCancel = () => {
     return () => trueFoundryExtras.get(aui).cancel();
 };
 
+/** Returns a function to reload (retry) the current session from any render context. */
+export const useTrueFoundryReload = () => {
+    const aui = useAui();
+    return () => trueFoundryExtras.get(aui).reload();
+};
+
 /** Returns a function to reset (re-submit) a user turn from any render context. */
 export const useTrueFoundryResetFromTurn = () => {
     const aui = useAui();

package/src/index.ts

@@ -13,11 +13,11 @@ export {
 export type { ConvertTurnsResult, UserMessageContent } from "./convertTurnMessages.js";
 export { ROOT_THREAD_ID } from "./constants.js";
 export type { UseTrueFoundryAgentRuntimeOptions, NamedAgentConfig, DraftAgentConfig, TrueFoundryAgentConfig } from "./types.js";
-export type { AgentSpec, AgentSpecUpdate, DraftSession } from "./agentSpec.js";
-export { mergeAgentSpec, draftSessionTitle } from "./agentSpec.js";
-export { createTrueFoundryDraftThreadListAdapter } from "./truefoundryDraftThreadListAdapter.js";
-export { createDraftSessionBridge } from "./draftSessionBridge.js";
-export type { DraftSessionBridge } from "./draftSessionBridge.js";
+export type { AgentSpec, AgentSpecUpdate, DraftSession } from "./private/agentSpec.js";
+export { mergeAgentSpec, draftSessionTitle } from "./private/agentSpec.js";
+export { createTrueFoundryDraftThreadListAdapter } from "./private/truefoundryDraftThreadListAdapter.js";
+export { createDraftSessionBridge } from "./private/draftSessionBridge.js";
+export type { DraftSessionBridge } from "./private/draftSessionBridge.js";
 export {
     useTrueFoundryAgentSpec,
     useTrueFoundryUpdateAgentSpec,
@@ -47,6 +47,7 @@ export {
     useTrueFoundryDownloadSandboxFile,
     useTrueFoundryCancel,
     useTrueFoundryResetFromTurn,
+    useTrueFoundryReload,
 } from "./hooks.js";
 export {
     collectApprovalInputs,

package/src/loadSessionSnapshot.test.ts

@@ -11,11 +11,11 @@ vi.mock("./convertTurnMessages.js", async (importOriginal) => {
     const actual = await importOriginal<typeof import("./convertTurnMessages.js")>();
     return {
         ...actual,
-        buildSnapshotFromSession: vi.fn(),
+        buildSnapshotFromSessionEvents: vi.fn(),
     };
 });
 
-import { buildSnapshotFromSession } from "./convertTurnMessages.js";
+import { buildSnapshotFromSessionEvents } from "./convertTurnMessages.js";
 import { loadSessionSnapshot } from "./loadSessionSnapshot.js";
 import { getSession } from "./sessions.js";
 
@@ -28,7 +28,7 @@ describe("loadSessionSnapshot", () => {
 
     it("deduplicates concurrent loads for the same session", async () => {
         vi.mocked(getSession).mockResolvedValue({} as never);
-        vi.mocked(buildSnapshotFromSession).mockResolvedValue(
+        vi.mocked(buildSnapshotFromSessionEvents).mockResolvedValue(
             createEmptySessionSnapshot(),
         );
 
@@ -39,12 +39,12 @@ describe("loadSessionSnapshot", () => {
 
         expect(first).toBe(second);
         expect(getSession).toHaveBeenCalledTimes(1);
-        expect(buildSnapshotFromSession).toHaveBeenCalledTimes(1);
+        expect(buildSnapshotFromSessionEvents).toHaveBeenCalledTimes(1);
     });
 
     it("allows a new load after the previous one settles", async () => {
         vi.mocked(getSession).mockResolvedValue({} as never);
-        vi.mocked(buildSnapshotFromSession).mockResolvedValue(
+        vi.mocked(buildSnapshotFromSessionEvents).mockResolvedValue(
             createEmptySessionSnapshot(),
         );
 
@@ -52,6 +52,21 @@ describe("loadSessionSnapshot", () => {
         await loadSessionSnapshot(mockClient, "session-1");
 
         expect(getSession).toHaveBeenCalledTimes(2);
-        expect(buildSnapshotFromSession).toHaveBeenCalledTimes(2);
+        expect(buildSnapshotFromSessionEvents).toHaveBeenCalledTimes(2);
+    });
+
+    it("forwards onProgress to buildSnapshotFromSessionEvents", async () => {
+        vi.mocked(getSession).mockResolvedValue({} as never);
+        vi.mocked(buildSnapshotFromSessionEvents).mockResolvedValue(
+            createEmptySessionSnapshot(),
+        );
+
+        const onProgress = vi.fn();
+        await loadSessionSnapshot(mockClient, "session-1", undefined, onProgress);
+
+        expect(buildSnapshotFromSessionEvents).toHaveBeenCalledWith(
+            {},
+            onProgress,
+        );
     });
 });

package/src/loadSessionSnapshot.ts

@@ -1,7 +1,6 @@
 import type { AgentSessionClient } from "truefoundry-gateway-sdk/agents";
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
 
-import { buildSnapshotFromSession } from "./convertTurnMessages.js";
+import { buildSnapshotFromSessionEvents } from "./convertTurnMessages.js";
 import { getSession, type GetSessionOptions } from "./sessions.js";
 import type { SessionSnapshot } from "./sessionSnapshot.js";
 
@@ -10,20 +9,25 @@ const inflightBySessionId = new Map<string, Promise<SessionSnapshot>>();
 /**
  * Loads a session snapshot once per concurrent burst for a given session id.
  * React Strict Mode and overlapping fetch/load paths share the same in-flight
- * request instead of duplicating getSession + listTurns calls.
+ * request instead of duplicating getSession + listEvents calls.
+ *
+ * `onProgress` is called after each complete turn is ingested so the caller
+ * can update the UI progressively while history is being processed.
  */
 export function loadSessionSnapshot(
     client: AgentSessionClient,
     sessionId: string,
-    concurrency?: number,
     sessionOptions?: GetSessionOptions,
+    onProgress?: (snap: SessionSnapshot) => void,
 ): Promise<SessionSnapshot> {
     const cacheKey =
         sessionOptions?.draftGateway != null ? `draft:${sessionId}` : sessionId;
     let inflight = inflightBySessionId.get(cacheKey);
     if (inflight == null) {
         inflight = getSession(client, sessionId, sessionOptions)
-            .then((session) => buildSnapshotFromSession(session, concurrency))
+            .then((session) =>
+                buildSnapshotFromSessionEvents(session, onProgress),
+            )
             .finally(() => {
                 if (inflightBySessionId.get(cacheKey) === inflight) {
                     inflightBySessionId.delete(cacheKey);

package/src/{truefoundryDraftThreadListAdapter.ts → private/truefoundryDraftThreadListAdapter.ts}

@@ -2,7 +2,7 @@ import type { RemoteThreadListAdapter } from "@assistant-ui/core";
 import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
 
 import { draftSessionTitle, type AgentSpec } from "./agentSpec.js";
-import { sessionListStartTimestamp } from "./sessionListStartTimestamp.js";
+import { sessionListStartTimestamp } from "../sessionListStartTimestamp.js";
 
 const THREAD_LIST_PAGE_SIZE = 20;
 

package/src/sessionSnapshot.ts

@@ -1,4 +1,10 @@
-import type { McpAuthRequiredEvent, Turn, TurnInputItem } from "truefoundry-gateway-sdk/agents";
+import type {
+    McpAuthRequiredEvent,
+    Turn,
+    TurnCreatedEvent,
+    TurnDoneEvent,
+    TurnInputItem,
+} from "truefoundry-gateway-sdk/agents";
 
 import { extractTurnUserText } from "./extractTurnUserText.js";
 import { PeerThreadFoldState } from "./foldPeerThreads.js";
@@ -81,6 +87,26 @@ export function turnToSessionRecord(turn: Turn): SessionTurnRecord {
     };
 }
 
+/** Builds a SessionTurnRecord from session-level TurnCreatedEvent + TurnDoneEvent data. */
+export function sessionEventsToSessionRecord(
+    turnId: string,
+    createdEvent: TurnCreatedEvent,
+    doneEvent: TurnDoneEvent,
+    rootModelMessageIds: readonly string[],
+    sandboxId?: string,
+): SessionTurnRecord {
+    const userText = extractTurnUserText(createdEvent.input);
+    return {
+        id: turnId,
+        ...(userText ? { userText } : {}),
+        createdAt: createdEvent.createdAt,
+        state: doneEvent.state,
+        input: createdEvent.input,
+        rootModelMessageIds,
+        ...(sandboxId != null ? { sandboxId } : {}),
+    };
+}
+
 /** Returns a new snapshot wrapper; fold maps may be mutated in place before calling. */
 export function replaceSessionSnapshot(
     snapshot: SessionSnapshot,

package/src/sessions.ts

@@ -4,7 +4,7 @@ import type {
 } from "truefoundry-gateway-sdk/agents";
 import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
 
-import { bindDraftAgentSession } from "./bindDraftAgentSession.js";
+import { bindDraftAgentSession } from "./private/bindDraftAgentSession.js";
 
 const inflightBySessionId = new Map<string, Promise<AgentSession>>();
 

package/src/truefoundryExtras.ts

@@ -1,7 +1,7 @@
 import { createRuntimeExtras } from "@assistant-ui/core/internal";
 import type { McpAuthRequiredEvent } from "truefoundry-gateway-sdk/agents";
 
-import type { AgentSpec, AgentSpecUpdate } from "./agentSpec.js";
+import type { AgentSpec, AgentSpecUpdate } from "./private/agentSpec.js";
 import type { PendingApproval, PendingToolResponse } from "./collectPending.js";
 import type { RespondToToolApprovalOptions } from "./toolApproval.js";
 import type { RespondToToolResponseOptions } from "./toolResponse.js";
@@ -27,6 +27,7 @@ export type TrueFoundryRuntimeExtras = {
     downloadSandboxFile: (path: string) => Promise<Blob>;
     cancel: () => Promise<void>;
     resetFromTurn: (turnId: string) => Promise<void>;
+    reload: () => void;
     draft: TrueFoundryDraftRuntimeExtras | null;
 };
 

package/src/types.ts

@@ -9,7 +9,7 @@ import type {
 import type { AgentSessionClient } from "truefoundry-gateway-sdk/agents";
 import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
 
-import type { AgentSpec } from "./agentSpec.js";
+import type { AgentSpec } from "./private/agentSpec.js";
 
 export type NamedAgentConfig = {
     mode: "named";