@truefoundry/assistant-ui-runtime 0.1.13 → 0.1.15

package/src/draft/useDraftAgentSpec.test.tsx

@@ -150,4 +150,111 @@ describe("useDraftAgentSpec", () => {
         expect(syncAgentSpec).toHaveBeenCalledOnce();
         expect(result.current.isSpecSyncing).toBe(false);
     });
+
+    it("flushes pending work before a coordinated save", async () => {
+        const syncAgentSpec = vi
+            .fn()
+            .mockResolvedValue("2026-06-30T15:00:00.000Z");
+        const draftBridge: DraftSessionBridge = {
+            getDraftAgentSpec: vi.fn().mockResolvedValue(defaultAgentSpec),
+            syncAgentSpec,
+        };
+        const { result } = renderHook(() =>
+            useDraftAgentSpec({
+                draftSessionId: "draft-1",
+                draftBridge,
+                defaultAgentSpec,
+            }),
+        );
+        await flushMicrotasks();
+
+        act(() => {
+            result.current.updateAgentSpec({ instructions: "latest draft" });
+        });
+        await act(async () => {
+            await result.current.flushAgentSpec();
+        });
+
+        expect(syncAgentSpec).toHaveBeenCalledWith("draft-1", {
+            model: defaultAgentSpec.model,
+            instructions: "latest draft",
+        });
+    });
+
+    it("adopts an atomically persisted spec without scheduling another sync", async () => {
+        const syncAgentSpec = vi.fn().mockResolvedValue("unused");
+        const draftBridge: DraftSessionBridge = {
+            getDraftAgentSpec: vi.fn().mockResolvedValue(defaultAgentSpec),
+            syncAgentSpec,
+        };
+        const { result } = renderHook(() =>
+            useDraftAgentSpec({
+                draftSessionId: "draft-1",
+                draftBridge,
+                defaultAgentSpec,
+            }),
+        );
+        await flushMicrotasks();
+
+        act(() => {
+            result.current.adoptAgentSpec({
+                agentSpec: {
+                    model: { name: "openai/gpt-5" },
+                    config: { generativeUi: { enabled: false } },
+                },
+                updatedAt: "2026-06-30T16:00:00.000Z",
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(400);
+        });
+
+        expect(result.current.agentSpec).toEqual({
+            model: { name: "openai/gpt-5" },
+            config: { generativeUi: { enabled: false } },
+        });
+        expect(syncAgentSpec).not.toHaveBeenCalled();
+        await expect(result.current.takeTurnHeaderTimestamp()).resolves.toBe(
+            "2026-06-30T16:00:00.000Z",
+        );
+    });
+
+    it("preserves the last sync timestamp when adopt omits updatedAt", async () => {
+        const syncAgentSpec = vi
+            .fn()
+            .mockResolvedValue("2026-06-30T17:00:00.000Z");
+        const draftBridge: DraftSessionBridge = {
+            getDraftAgentSpec: vi.fn().mockResolvedValue(defaultAgentSpec),
+            syncAgentSpec,
+        };
+        const { result } = renderHook(() =>
+            useDraftAgentSpec({
+                draftSessionId: "draft-1",
+                draftBridge,
+                defaultAgentSpec,
+            }),
+        );
+        await flushMicrotasks();
+
+        act(() => {
+            result.current.updateAgentSpec({ instructions: "synced" });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(400);
+        });
+        await flushMicrotasks();
+        expect(syncAgentSpec).toHaveBeenCalledOnce();
+
+        act(() => {
+            result.current.adoptAgentSpec({
+                agentSpec: {
+                    model: { name: "openai/gpt-5" },
+                },
+            });
+        });
+
+        await expect(result.current.takeTurnHeaderTimestamp()).resolves.toBe(
+            "2026-06-30T17:00:00.000Z",
+        );
+    });
 });

package/src/draft/useDraftAgentSpec.ts

@@ -23,6 +23,11 @@ export type UseDraftAgentSpecResult = {
     isSpecSyncing: boolean;
     specError: unknown | null;
     updateAgentSpec: (update: AgentSpecUpdate) => void;
+    flushAgentSpec: () => Promise<void>;
+    adoptAgentSpec: (request: {
+        agentSpec: AgentSpec;
+        updatedAt?: string;
+    }) => void;
     takeTurnHeaderTimestamp: () => Promise<string | undefined>;
 };
 
@@ -206,6 +211,35 @@ export function useDraftAgentSpec({
         }
     }, []);
 
+    const adoptAgentSpec = useCallback(
+        ({
+            agentSpec: persistedSpec,
+            updatedAt,
+        }: {
+            agentSpec: AgentSpec;
+            updatedAt?: string;
+        }) => {
+            if (syncTimeoutRef.current != null) {
+                clearTimeout(syncTimeoutRef.current);
+                syncTimeoutRef.current = undefined;
+            }
+            syncGenerationRef.current++;
+            pendingFlushRef.current = undefined;
+            inFlightFlushRef.current = undefined;
+            localDirtyRef.current = false;
+            // Keep the last successful sync timestamp when the caller omits
+            // updatedAt (e.g. a save that did not return sessionUpdatedAt).
+            if (updatedAt !== undefined) {
+                lastUpdatedAtRef.current = updatedAt;
+            }
+            agentSpecRef.current = persistedSpec;
+            setAgentSpec(persistedSpec);
+            setSpecError(null);
+            setIsSpecSyncing(false);
+        },
+        [],
+    );
+
     const takeTurnHeaderTimestamp = useCallback(async () => {
         await flushPendingSpecSyncNow();
         const updatedAt = lastUpdatedAtRef.current;
@@ -245,6 +279,8 @@ export function useDraftAgentSpec({
             isSpecSyncing: enabled ? isSpecSyncing : false,
             specError: enabled ? specError : null,
             updateAgentSpec,
+            flushAgentSpec: flushPendingSpecSyncNow,
+            adoptAgentSpec,
             takeTurnHeaderTimestamp,
         }),
         [
@@ -254,6 +290,8 @@ export function useDraftAgentSpec({
             isSpecLoading,
             isSpecSyncing,
             specError,
+            flushPendingSpecSyncNow,
+            adoptAgentSpec,
             takeTurnHeaderTimestamp,
             updateAgentSpec,
         ],

package/src/hooks.ts

@@ -142,6 +142,13 @@ export const useTrueFoundryHistoryPagination = () => {
     );
 };
 
+/**
+ * True while a turn runs that this server cannot stream, so its result will not
+ * arrive in this client. Falls back to `false` on runtimes that predate the flag.
+ */
+export const useTrueFoundryResumeUnavailable = () =>
+    trueFoundryExtras.use((e) => e.resumeUnavailable, false) ?? false;
+
 /** Returns a function to reset (re-submit) a user turn from any render context. */
 export const useTrueFoundryResetFromTurn = () => {
     const aui = useAui();
@@ -165,3 +172,18 @@ export const useTrueFoundryUpdateAgentSpec = () => {
         trueFoundryExtras.get(aui).draft?.updateAgentSpec(update);
 };
 
+/** Flushes any pending draft-spec synchronization before a coordinated write. */
+export const useTrueFoundryFlushAgentSpec = () => {
+    const aui = useAui();
+    return () =>
+        trueFoundryExtras.get(aui).draft?.flushAgentSpec() ?? Promise.resolve();
+};
+
+/** Adopts a spec already persisted by another server operation without syncing again. */
+export const useTrueFoundryAdoptAgentSpec = () => {
+    const aui = useAui();
+    return (
+        request: Parameters<TrueFoundryDraftRuntimeExtras["adoptAgentSpec"]>[0],
+    ) => trueFoundryExtras.get(aui).draft?.adoptAgentSpec(request);
+};
+

package/src/index.ts

@@ -25,7 +25,9 @@ export { createTrueFoundryOwnedSessionsThreadListAdapter } from "./truefoundryOw
 export { createDraftSessionBridge } from "./draft/draftSessionBridge.js";
 export type { DraftSessionBridge } from "./draft/draftSessionBridge.js";
 export {
+    useTrueFoundryAdoptAgentSpec,
     useTrueFoundryAgentSpec,
+    useTrueFoundryFlushAgentSpec,
     useTrueFoundryUpdateAgentSpec,
 } from "./hooks.js";
 export type { TrueFoundryDraftRuntimeExtras } from "./truefoundryExtras.js";
@@ -55,6 +57,7 @@ export {
     useTrueFoundryResetFromTurn,
     useTrueFoundryReload,
     useTrueFoundryHistoryPagination,
+    useTrueFoundryResumeUnavailable,
 } from "./hooks.js";
 export {
     collectApprovalInputs,
@@ -79,7 +82,10 @@ export type {
     AgentChatServer,
     AgentBuilderCapabilitiesResponse,
     AgentBuilderServer,
+    AgentCapabilityConfig,
+    AgentRuntimeConfig,
     SaveAgentRequest,
+    SaveAgentResult,
     Session,
     Turn,
     TurnState,

package/src/plugins/truefoundry-agent-server-adapter/cp.ts

@@ -9,6 +9,7 @@ import type {
     AgentSelectorEntry,
     ConnectorSelectorEntry,
     ModelSelectorEntry,
+    SaveAgentRequest,
     SearchAgentSelectorParams,
     SkillSelectorEntry,
 } from "../../server/types.js";
@@ -595,7 +596,7 @@ export function buildSaveAgentManifest(
  */
 export async function saveAgent(
     opts: CpCredentials,
-    req: { agentName: string; agentSpec: TfyAgentSpec },
+    req: SaveAgentRequest<TfyAgentSpec>,
 ): Promise<unknown> {
     const manifest = buildSaveAgentManifest(req.agentName, req.agentSpec);
     return cpFetch(opts, "/api/svc/v1/agents", {

package/src/plugins/truefoundry-agent-server-adapter/types.ts

@@ -67,9 +67,9 @@ export interface TfyAgentSpec
     extends AgentSpec<
         TruefoundryGatewayApi.Model,
         TfySkillMount,
-        TfyMcpServerMount
+        TfyMcpServerMount,
+        TruefoundryGatewayApi.RuntimeConfig
     > {
-    config?: TruefoundryGatewayApi.RuntimeConfig;
     responseFormat?: TruefoundryGatewayApi.ResponseFormat;
     messages?: TruefoundryGatewayApi.AgentSpecUserMessage[];
 }

package/src/server/index.ts

@@ -15,8 +15,11 @@ export type {
     McpServerMount,
     ModelParams,
     Model,
+    AgentCapabilityConfig,
+    AgentRuntimeConfig,
     AgentSpec,
     SaveAgentRequest,
+    SaveAgentResult,
     Session,
     CreateSessionRequest,
     UpdateSessionRequest,

package/src/server/types.ts

@@ -105,19 +105,31 @@ export interface Model {
   params?: ModelParams;
 }
 
+export interface AgentCapabilityConfig {
+  enabled?: boolean;
+}
+
+export 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<...>`.
 */
 export 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>;
 }
@@ -329,6 +341,16 @@ export interface AgentChatServer<
 export 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;
+}
+
+export interface SaveAgentResult {
+  /** Immutable id allocated by the host registry. */
+  agentId?: string;
+  /** Timestamp returned when the active mutable session was updated. */
+  sessionUpdatedAt?: string;
 }
 
 /**
@@ -352,7 +374,7 @@ export interface AgentBuilderServer<
   TSkill extends SkillSelectorEntry = SkillSelectorEntry,
   TMcp extends ConnectorSelectorEntry = ConnectorSelectorEntry,
   TAgent extends AgentSelectorEntry = AgentSelectorEntry,
-  TSave = unknown,
+  TSave = SaveAgentResult,
   TCapabilities extends AgentBuilderCapabilitiesResponse = AgentBuilderCapabilitiesResponse,
 > {
   getCapabilities(): Promise<TCapabilities>;

package/src/streamTurn.test.ts

@@ -357,6 +357,24 @@ describe("streamTurn", () => {
             expect(updates).toEqual([{ content: [{ type: "text", text: "resumed" }] }]);
         });
 
+        it("yields nothing when the server omits subscribeToTurn", async () => {
+            const cancelSession = vi.fn().mockResolvedValue(undefined);
+            const server = mockServer({ cancelSession });
+
+            const updates = await collectUpdates(
+                resumeTurnStream(
+                    server,
+                    SESSION_ID,
+                    "turn-1",
+                    new PeerThreadFoldState(),
+                    new AbortController().signal,
+                ),
+            );
+
+            expect(updates).toEqual([]);
+            expect(cancelSession).not.toHaveBeenCalled();
+        });
+
         it("returns early when aborted before streaming starts", async () => {
             const subscribeToTurn = vi.fn(async function* () {});
             const cancelSession = vi.fn().mockResolvedValue(undefined);

package/src/streamTurn.ts

@@ -116,10 +116,10 @@ export async function* resumeTurnStream(
     afterSequenceNumber?: number,
     groupRootBaseline?: readonly string[],
 ): AsyncGenerator<TurnStreamUpdate> {
+    // Optional on custom backends. Callers detect the gap and report it, so an
+    // empty stream here is safer than throwing mid-render.
     if (server.subscribeToTurn == null) {
-        throw new Error(
-            "resumeTurnStream requires AgentChatServer.subscribeToTurn",
-        );
+        return;
     }
 
     const onAbort = () => {

package/src/truefoundryExtras.ts

@@ -16,12 +16,18 @@ export type TrueFoundryDraftRuntimeExtras = {
     isSpecSyncing: boolean;
     specError: unknown | null;
     updateAgentSpec: (update: AgentSpecUpdate) => void;
+    flushAgentSpec: () => Promise<void>;
+    adoptAgentSpec: (request: {
+        agentSpec: AgentSpec;
+        updatedAt?: string;
+    }) => void;
 };
 
 export type TrueFoundryRuntimeExtras = {
     pendingApprovals: PendingApproval[];
     pendingToolResponses: PendingToolResponse[];
     pendingMcpAuth: { mcpServers: McpAuthRequiredEvent["mcpServers"] } | null;
+    resumeUnavailable: boolean;
     sandboxId: string | undefined;
     respondToToolApproval: (response: RespondToToolApprovalOptions) => void;
     respondToToolResponse: (response: RespondToToolResponseOptions) => void;
@@ -49,4 +55,10 @@ export const EMPTY_DRAFT_EXTRAS: TrueFoundryDraftRuntimeExtras = {
     updateAgentSpec: () => {
         throw new Error("Draft agent extras are only available in draft mode.");
     },
+    flushAgentSpec: async () => {
+        throw new Error("Draft agent extras are only available in draft mode.");
+    },
+    adoptAgentSpec: () => {
+        throw new Error("Draft agent extras are only available in draft mode.");
+    },
 };

package/src/useTrueFoundryAgentMessages.test.tsx

@@ -47,6 +47,8 @@ vi.mock("./convertTurnMessages.js", async (importOriginal) => {
 const mockServer = {
     cancelSession: vi.fn().mockResolvedValue(undefined),
     listTurns: vi.fn(),
+    // Present so resume-capable paths are exercised; resumeTurnStream is mocked.
+    subscribeToTurn: vi.fn(),
 } as unknown as AgentChatServer;
 
 function snapshotWithAssistantMessage(
@@ -503,6 +505,119 @@ describe("useTrueFoundryAgentMessages", () => {
         );
     });
 
+    it("shows loaded history as running when the server cannot resume the turn", async () => {
+        const onError = vi.fn();
+        const runningTurn = {
+            id: "turn-running",
+            input: [{ type: "user.message", content: "keep going" }],
+            createdAt: new Date().toISOString(),
+        } as Turn;
+        vi.mocked(loadSessionSnapshot).mockResolvedValue(
+            replaceSessionSnapshot(createEmptySessionSnapshot(), {
+                runningTurn,
+                unstable_resume: true,
+                pendingUser: {
+                    turnId: runningTurn.id,
+                    content: "keep going",
+                    createdAt: new Date(runningTurn.createdAt),
+                },
+            }),
+        );
+        const serverWithoutSubscribe = {
+            cancelSession: vi.fn().mockResolvedValue(undefined),
+            listTurns: vi.fn().mockResolvedValue({ data: [] }),
+        } as unknown as AgentChatServer;
+
+        const { result } = renderHook(() =>
+            useTrueFoundryAgentMessages({
+                server: serverWithoutSubscribe,
+                sessionId: "session-1",
+                onError,
+            }),
+        );
+
+        await waitFor(() => expect(result.current.isLoading).toBe(false));
+        expect(resumeTurnStream).not.toHaveBeenCalled();
+        // The turn keeps running server-side, so history renders with a
+        // pending indicator rather than an endless skeleton.
+        await waitFor(() => expect(result.current.isRunning).toBe(true));
+        expect(result.current.messages[0]).toMatchObject({
+            role: "user",
+            content: [{ type: "text", text: "keep going" }],
+        });
+        // Waiting, not failing: hosts render this as state, not an error.
+        expect(result.current.resumeUnavailable).toBe(true);
+        expect(onError).not.toHaveBeenCalled();
+    });
+
+    it("clears the running state when cancelling a turn it could not resume", async () => {
+        const runningTurn = { id: "turn-running" } as Turn;
+        vi.mocked(loadSessionSnapshot).mockResolvedValue(
+            replaceSessionSnapshot(createEmptySessionSnapshot(), {
+                runningTurn,
+                unstable_resume: true,
+            }),
+        );
+        const serverWithoutSubscribe = {
+            cancelSession: vi.fn().mockResolvedValue(undefined),
+            listTurns: vi.fn().mockResolvedValue({ data: [] }),
+        } as unknown as AgentChatServer;
+
+        const { result } = renderHook(() =>
+            useTrueFoundryAgentMessages({
+                server: serverWithoutSubscribe,
+                sessionId: "session-1",
+                onError: vi.fn(),
+            }),
+        );
+
+        await waitFor(() => expect(result.current.isRunning).toBe(true));
+
+        await act(async () => {
+            await result.current.cancel();
+        });
+
+        expect(serverWithoutSubscribe.cancelSession).toHaveBeenCalledWith({
+            sessionId: "session-1",
+        });
+        // No stream was attached, so nothing else would release the composer.
+        expect(result.current.isRunning).toBe(false);
+        expect(result.current.resumeUnavailable).toBe(false);
+    });
+
+    it("stays in the waiting state instead of resuming when resumeRun has no subscribeToTurn", async () => {
+        const onError = vi.fn();
+        const runningTurn = { id: "turn-running" } as Turn;
+        vi.mocked(loadSessionSnapshot).mockResolvedValue(
+            replaceSessionSnapshot(createEmptySessionSnapshot(), {
+                runningTurn,
+                unstable_resume: true,
+            }),
+        );
+        const serverWithoutSubscribe = {
+            cancelSession: vi.fn().mockResolvedValue(undefined),
+            listTurns: vi.fn().mockResolvedValue({ data: [] }),
+        } as unknown as AgentChatServer;
+
+        const { result } = renderHook(() =>
+            useTrueFoundryAgentMessages({
+                server: serverWithoutSubscribe,
+                sessionId: "session-1",
+                onError,
+            }),
+        );
+        await waitFor(() => expect(result.current.isLoading).toBe(false));
+        onError.mockClear();
+
+        await act(async () => {
+            await result.current.resumeRun();
+        });
+
+        expect(resumeTurnStream).not.toHaveBeenCalled();
+        expect(result.current.resumeUnavailable).toBe(true);
+        expect(onError).not.toHaveBeenCalled();
+    });
+
     it("clears isLoading while a resumed turn is still streaming", async () => {
         let releaseStream: (() => void) | undefined;
         vi.mocked(resumeTurnStream).mockReturnValue(

package/src/useTrueFoundryAgentMessages.ts

@@ -309,6 +309,7 @@ export function useTrueFoundryAgentMessages({
     );
     const [isLoadingOlderHistory, setIsLoadingOlderHistory] = useState(false);
     const [loadRetryTrigger, setLoadRetryTrigger] = useState(0);
+    const [resumeUnavailable, setResumeUnavailable] = useState(false);
 
     const snapshotRef = useRef(snapshot);
     snapshotRef.current = snapshot;
@@ -326,6 +327,8 @@ export function useTrueFoundryAgentMessages({
     const createdAtByMessageIdRef = useRef(new Map<string, Date>());
     const abortControllerRef = useRef<AbortController | null>(null);
     const activeRunRef = useRef<Promise<void> | null>(null);
+    // Mirrors `resumeUnavailable` for `cancel`, which reads it outside render.
+    const resumeUnavailableRef = useRef(false);
     const runningTurnRef = useRef<Turn | undefined>(undefined);
     const loadGenerationRef = useRef(0);
     const streamGenerationRef = useRef(0);
@@ -333,6 +336,16 @@ export function useTrueFoundryAgentMessages({
     const initialLoadStartedForRef = useRef<string | undefined>(undefined);
     const skipInitialPromotionLoadForRef = useRef<string | undefined>(undefined);
 
+    /**
+     * A turn is running that this server cannot stream. Nothing will deliver its
+     * result to this client, so the UI shows a waiting state until the run is
+     * cancelled or the session is reloaded.
+     */
+    const markResumeUnavailable = useCallback((value: boolean) => {
+        resumeUnavailableRef.current = value;
+        setResumeUnavailable(value);
+    }, []);
+
     const projectOptions = useMemo(
         () => ({
             getCreatedAt: (messageId: string, fallback: Date) => {
@@ -371,6 +384,8 @@ export function useTrueFoundryAgentMessages({
             const abortController = new AbortController();
             abortControllerRef.current = abortController;
             setIsRunning(true);
+            // This stream's `finally` owns the running flag from here on.
+            markResumeUnavailable(false);
 
             const run = (async () => {
                 // Sub-agent turns can emit 100+ stream events per frame. Coalesce to one
@@ -516,6 +531,7 @@ export function useTrueFoundryAgentMessages({
         const generation = ++loadGenerationRef.current;
         ++streamGenerationRef.current;
         setIsRunning(false);
+        markResumeUnavailable(false);
         abortControllerRef.current?.abort();
         loadOlderInflightRef.current = null;
         createdAtByMessageIdRef.current = new Map();
@@ -554,6 +570,16 @@ export function useTrueFoundryAgentMessages({
 
             if (loadedSnapshot.runningTurn != null) {
                 const turn = loadedSnapshot.runningTurn;
+
+                // subscribeToTurn is optional, so a server can leave us without
+                // a reconnect path. The turn still runs on the backend: show the
+                // loaded history as running and let the host explain the gap.
+                if (server.subscribeToTurn == null) {
+                    setIsRunning(true);
+                    markResumeUnavailable(true);
+                    return;
+                }
+
                 const isContinuation = !extractTurnUserText(turn.input);
                 // TODO: pass afterSequenceNumber once stream ingestion tracks sequence numbers.
                 // Use loadedSnapshot directly — snapshotRef.current still points at
@@ -831,7 +857,13 @@ export function useTrueFoundryAgentMessages({
         // reconcile is needed here — the cancelled turn is terminal and local
         // state reconciles against the event log on the next session load.
         await activeRunRef.current?.catch(() => undefined);
-    }, [server, sessionId]);
+        // Nothing drained when the load could not attach a stream, so clear the
+        // running flag here or the composer stays blocked until a reload.
+        if (resumeUnavailableRef.current) {
+            markResumeUnavailable(false);
+            setIsRunning(false);
+        }
+    }, [server, sessionId, markResumeUnavailable]);
 
     const isRunningRef = useRef(isRunning);
     isRunningRef.current = isRunning;
@@ -897,6 +929,10 @@ export function useTrueFoundryAgentMessages({
         if (turn == null) {
             return;
         }
+        if (server.subscribeToTurn == null) {
+            markResumeUnavailable(true);
+            return;
+        }
         // TODO: pass afterSequenceNumber once stream ingestion tracks sequence numbers.
         await runStream(
             (signal) =>
@@ -1066,6 +1102,7 @@ export function useTrueFoundryAgentMessages({
     return {
         messages,
         isRunning,
+        resumeUnavailable,
         isLoading,
         isLoadingOlderHistory,
         hasOlderHistory,

package/src/useTrueFoundryAgentRuntime.ts

@@ -108,6 +108,7 @@ function useTrueFoundryAgentRuntimeImpl(
     const {
         messages,
         isRunning,
+        resumeUnavailable,
         isLoading,
         isLoadingOlderHistory,
         hasOlderHistory,
@@ -187,6 +188,8 @@ function useTrueFoundryAgentRuntimeImpl(
             isSpecSyncing: draftSpec.isSpecSyncing,
             specError: draftSpec.specError,
             updateAgentSpec: draftSpec.updateAgentSpec,
+            flushAgentSpec: draftSpec.flushAgentSpec,
+            adoptAgentSpec: draftSpec.adoptAgentSpec,
         };
     }, [agent.mode, draftSpec]);
 
@@ -199,6 +202,7 @@ function useTrueFoundryAgentRuntimeImpl(
             pendingApprovals,
             pendingToolResponses,
             pendingMcpAuth,
+            resumeUnavailable,
             sandboxId,
             respondToToolApproval,
             respondToToolResponse,