@truefoundry/assistant-ui-runtime 0.1.6 → 0.1.7

package/src/server/index.ts

@@ -31,6 +31,29 @@ export type {
     Turn,
     AgentChatServer,
     AgentBuilderServer,
+    ProviderType,
+    ModelEntry,
+    ModelProviderConfigBase,
+    ModelProviderBase,
+    ModelProviderCatalogEntry,
+    CreateModelProviderRequest,
+    UpdateModelProviderRequest,
+    ModelCatalogServer,
+    ToolBase,
+    ConnectorAuthType,
+    ConnectorAuth,
+    ConnectorAuthPublic,
+    ConnectorConfigBase,
+    ConnectorBase,
+    ConnectorCatalogEntry,
+    CreateConnectorRequest,
+    UpdateConnectorRequest,
+    ConnectorCatalogServer,
+    SkillBase,
+    CreateSkillRequest,
+    SkillCatalogServer,
+    CatalogServer,
+    AgentUIServerPort,
 } from "./types.js";
 
 export type {

package/src/server/types.ts

@@ -10,8 +10,7 @@ import type {
     ActionRequiredEvent,
     SessionEventItem,
     TurnEvent,
-    TurnStreamData,
-    TurnStreamingEvent,
+    TurnStreamData
 } from "./events.js";
 
 // ---------------------------------------------------------------------------
@@ -72,7 +71,7 @@ export type SkillMount = object;
 export type McpServerMount = object;
 
 // ---------------------------------------------------------------------------
-// AgentSpec — model + skills + mcpServers on base; host widens the rest
+// AgentSpec — model / skills / mcpServers are type params; host widens the rest
 // ---------------------------------------------------------------------------
 
 export interface ModelParams {
@@ -87,17 +86,19 @@ export interface Model {
 
 /**
  * SDK-owned agent definition — fields the FE reads/writes.
- * Host adds additional fields via `TSpec extends AgentSpec`.
+ * Host widens `model` / `skills` / `mcpServers` via type params, and adds
+ * extra fields via `TSpec extends AgentSpec<...>`.
  */
-export interface AgentSpec {
-    model: Model;
-    skills?: SkillMount[];
-    mcpServers?: McpServerMount[];
+export interface AgentSpec<
+    TModel extends Model = Model,
+    TSkill extends SkillMount = SkillMount,
+    TMcp extends McpServerMount = McpServerMount,
+> {
+    model: TModel;
+    skills?: TSkill[];
+    mcpServers?: TMcp[];
     instructions?: string;
-    messages?: unknown[];
     variables?: Record<string, string>;
-    responseFormat?: unknown;
-    config?: unknown;
 }
 
 // ---------------------------------------------------------------------------
@@ -317,3 +318,247 @@ export interface AgentBuilderServer<
     }): Promise<TSave>;
     deleteAgent?(req: { agentName: string }): Promise<void>;
 }
+
+// ---------------------------------------------------------------------------
+// Catalog management — FE-minimal settings DTOs (host extends via generics)
+// ---------------------------------------------------------------------------
+
+/**
+ * Provider type id. Reserved literal: `"custom"` for user-defined providers;
+ * any other string is a builtin (e.g. `"openai"`, `"anthropic"`).
+ *
+ * Note: `string | "custom"` is useless in TypeScript (`"custom"` ⊆ `string`),
+ * so this stays `string` and `"custom"` is a documented convention.
+ */
+export type ProviderType = string;
+
+/**
+ * Model row — form "Model ID" + "Display name".
+ * Host extends for properties, etc.
+ */
+export interface ModelEntry {
+    id: string;
+    name: string;
+}
+
+/**
+ * Write config for create/update (custom form + catalog "Save key").
+ * Host extends. `baseUrl` present iff `type === "custom"`.
+ */
+export interface ModelProviderConfigBase<TModel extends ModelEntry = ModelEntry> {
+    type: ProviderType;
+    name: string;
+    /** Present iff `type === "custom"`. */
+    baseUrl?: string;
+    apiKey: string;
+    models: TModel[];
+}
+
+/**
+ * Configured provider card (list/read). No raw `apiKey`.
+ * Host extends for apiKeySet, timestamps, etc.
+ */
+export interface ModelProviderBase<TModel extends ModelEntry = ModelEntry> {
+    id: string;
+    type: ProviderType;
+    name: string;
+    /** Present iff `type === "custom"`. */
+    baseUrl?: string;
+    models: TModel[];
+}
+
+/**
+ * Discovery-only catalog provider (AVAILABLE list).
+ * `type` must not be `"custom"` — custom providers use the custom form.
+ * Host extends for richer model rows.
+ */
+export interface ModelProviderCatalogEntry<TModel extends ModelEntry = ModelEntry> {
+    type: ProviderType;
+    name: string;
+    models: TModel[];
+}
+
+/** Create — no `id`; server assigns it. Catalog path = entry + apiKey. */
+export type CreateModelProviderRequest<TModel extends ModelEntry = ModelEntry> =
+    ModelProviderConfigBase<TModel>;
+
+/** Update — `id` required. */
+export type UpdateModelProviderRequest<TModel extends ModelEntry = ModelEntry> =
+    ModelProviderConfigBase<TModel> & { id: string };
+
+export interface ModelCatalogServer<
+    TModel extends ModelEntry = ModelEntry,
+    TProvider extends ModelProviderBase<TModel> = ModelProviderBase<TModel>,
+    TCatalogProvider extends ModelProviderCatalogEntry<TModel> = ModelProviderCatalogEntry<TModel>,
+    TCreate extends CreateModelProviderRequest<TModel> = CreateModelProviderRequest<TModel>,
+    TUpdate extends UpdateModelProviderRequest<TModel> = UpdateModelProviderRequest<TModel>,
+> {
+    getModelProviderCatalog(): Promise<TCatalogProvider[]>;
+    listModelProviders(): Promise<TProvider[]>;
+    createModelProvider(req: TCreate): Promise<TProvider>;
+    /** Full replace update keyed by provider `id`. */
+    updateModelProvider(req: TUpdate): Promise<TProvider>;
+    deleteModelProvider?(req: { id: string }): Promise<void>;
+}
+
+/** Tool row on a connector detail. Host extends for schemas, etc. */
+export interface ToolBase {
+    id: string;
+    name: string;
+}
+
+/**
+ * Auth type id. Reserved literals: `"None"`, `"OAuth"`, `"API Key"`.
+ * Stays `string` so hosts can widen (same pattern as `ProviderType`).
+ */
+export type ConnectorAuthType = string;
+
+/**
+ * Write-time connector auth. Host extends / narrows via `TType`.
+ * For `"API Key"`, pass `apiKey` (and optional `headerName`).
+ */
+export interface ConnectorAuth<TType extends ConnectorAuthType = ConnectorAuthType> {
+    type: TType;
+    apiKey?: string;
+    headerName?: string;
+}
+
+/**
+ * Catalog / list auth — no secrets. Host extends / narrows via `TType`.
+ */
+export interface ConnectorAuthPublic<
+    TType extends ConnectorAuthType = ConnectorAuthType,
+> {
+    type: TType;
+    headerName?: string;
+}
+
+/**
+ * MCP / connector create-edit config. Host extends for extra fields, etc.
+ */
+export interface ConnectorConfigBase<
+    TAuth extends ConnectorAuth = ConnectorAuth,
+> {
+    name: string;
+    url: string;
+    auth: TAuth;
+}
+
+/**
+ * Connected connector row (settings/connectors). No raw `apiKey`.
+ * Host extends.
+ */
+export interface ConnectorBase<
+    TTool extends ToolBase = ToolBase,
+    TAuth extends ConnectorAuthPublic = ConnectorAuthPublic,
+> {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    auth: TAuth;
+    authenticated: boolean;
+    tools: TTool[];
+}
+
+/** Discovery catalog entry for "+ Add MCP server". Host extends. */
+export interface ConnectorCatalogEntry<
+    TAuth extends ConnectorAuthPublic = ConnectorAuthPublic,
+> {
+    id: string;
+    name: string;
+    description?: string;
+    url: string;
+    auth: TAuth;
+}
+
+/** Create connector — no `id`; server assigns it. Host extends. */
+export type CreateConnectorRequest<TAuth extends ConnectorAuth = ConnectorAuth> =
+    ConnectorConfigBase<TAuth>;
+
+/** Update connector — `id` required. Host extends. */
+export type UpdateConnectorRequest<TAuth extends ConnectorAuth = ConnectorAuth> =
+    ConnectorConfigBase<TAuth> & { id: string };
+
+export interface ConnectorCatalogServer<
+    TTool extends ToolBase = ToolBase,
+    TAuthWrite extends ConnectorAuth = ConnectorAuth,
+    TAuthPublic extends ConnectorAuthPublic = ConnectorAuthPublic,
+    TConnector extends ConnectorBase<TTool, TAuthPublic> = ConnectorBase<
+        TTool,
+        TAuthPublic
+    >,
+    TCatalogEntry extends ConnectorCatalogEntry<TAuthPublic> =
+        ConnectorCatalogEntry<TAuthPublic>,
+    TCreate extends CreateConnectorRequest<TAuthWrite> =
+        CreateConnectorRequest<TAuthWrite>,
+    TUpdate extends UpdateConnectorRequest<TAuthWrite> =
+        UpdateConnectorRequest<TAuthWrite>,
+> {
+    getConnectorCatalog(): Promise<TCatalogEntry[]>;
+    listConnectors(req?: { query?: string }): Promise<TConnector[]>;
+    createConnector(req: TCreate): Promise<TConnector>;
+    /** Full replace update keyed by connector `id`. */
+    updateConnector(req: TUpdate): Promise<TConnector>;
+    /** Start connector auth (e.g. OAuth). Host may widen return with `authUrl`. */
+    authenticateConnector(req: { id: string }): Promise<TConnector>;
+    /** Clear connector auth. */
+    disconnectConnector(req: { id: string }): Promise<TConnector>;
+    deleteConnector?(req: { id: string }): Promise<void>;
+}
+
+// ---------------------------------------------------------------------------
+// Skills catalog — FE-minimal settings DTOs (host extends via generics)
+// ---------------------------------------------------------------------------
+
+/** Skill row shown in settings/skills (list + delete). Host extends for fqn, etc. */
+export interface SkillBase {
+    id: string;
+    name: string;
+    description: string;
+}
+
+/** Create-skill request. Host extends for branch, auth, etc. */
+export interface CreateSkillRequest {
+    repo: string;
+    directory: string;
+}
+
+export interface SkillCatalogServer<
+    TSkill extends SkillBase = SkillBase,
+    TCreate extends CreateSkillRequest = CreateSkillRequest,
+> {
+    listSkills(req?: { query?: string }): Promise<TSkill[]>;
+    createSkill(req: TCreate): Promise<TSkill>;
+    deleteSkill?(req: { id: string }): Promise<void>;
+}
+
+/**
+ * Settings management aggregate — modelCatalog + connectorCatalog + optional skillCatalog.
+ * Hosts may pass the whole object to an app shell, or a focused sub-port to a page.
+ */
+export interface CatalogServer<
+    TModelCatalog extends ModelCatalogServer = ModelCatalogServer,
+    TConnectorCatalog extends ConnectorCatalogServer = ConnectorCatalogServer,
+    TSkillCatalog extends SkillCatalogServer = SkillCatalogServer,
+> {
+    modelCatalog: TModelCatalog;
+    connectorCatalog: TConnectorCatalog;
+    /** Optional — omit when the host has no skills settings surface. */
+    skillCatalog?: TSkillCatalog;
+}
+
+/**
+ * Composed host port: chat + builder + optional settings catalog.
+ * Agent-ui's `AgentUIServer` mirrors this shape; named differently here to
+ * avoid colliding with that package's local type name.
+ *
+ * `catalog` is optional — if the host passes it, settings UI can call
+ * `useCatalogServer()` / show modelCatalog, connectorCatalog, and skillCatalog;
+ * if omitted, those surfaces stay hidden.
+ */
+export type AgentUIServerPort<
+    TChat extends AgentChatServer = AgentChatServer,
+    TBuilder extends AgentBuilderServer = AgentBuilderServer,
+    TCatalog extends CatalogServer = CatalogServer,
+> = TChat & TBuilder & { catalog?: TCatalog };

package/src/truefoundryExtras.ts

@@ -1,7 +1,8 @@
 import { createRuntimeExtras } from "@assistant-ui/core/internal";
 import type { McpAuthRequiredEvent } from "./server/index.js";
 
-import type { AgentSpec, AgentSpecUpdate } from "./private/agentSpec.js";
+import type { AgentSpec } from "./server/types.js";
+import type { AgentSpecUpdate } from "./draft/agentSpec.js";
 import type { PendingApproval, PendingToolResponse } from "./collectPending.js";
 import type { RespondToToolApprovalOptions } from "./toolApproval.js";
 import type { RespondToToolResponseOptions } from "./toolResponse.js";
@@ -11,6 +12,7 @@ export type { PendingApproval, PendingToolResponse };
 export type TrueFoundryDraftRuntimeExtras = {
     agentSpec: AgentSpec | null;
     draftSessionId: string | undefined;
+    isSpecLoading: boolean;
     isSpecSyncing: boolean;
     specError: unknown | null;
     updateAgentSpec: (update: AgentSpecUpdate) => void;
@@ -41,6 +43,7 @@ export const trueFoundryExtras = createRuntimeExtras<TrueFoundryRuntimeExtras>(
 export const EMPTY_DRAFT_EXTRAS: TrueFoundryDraftRuntimeExtras = {
     agentSpec: null,
     draftSessionId: undefined,
+    isSpecLoading: false,
     isSpecSyncing: false,
     specError: null,
     updateAgentSpec: () => {

package/src/truefoundryOwnedSessionsThreadListAdapter.ts

@@ -1,7 +1,7 @@
 import type { RemoteThreadListAdapter } from "@assistant-ui/core";
 
 import type { AgentChatServer, Session } from "./server/types.js";
-import { draftSessionTitle } from "./private/agentSpec.js";
+import { draftSessionTitle } from "./draft/agentSpec.js";
 import { sessionListStartTimestamp } from "./sessionListStartTimestamp.js";
 
 const THREAD_LIST_PAGE_SIZE = 20;

package/src/types.ts

@@ -7,8 +7,7 @@ import type {
     SpeechSynthesisAdapter,
 } from "@assistant-ui/core";
 
-import type { AgentSpec } from "./private/agentSpec.js";
-import type { AgentChatServer } from "./server/types.js";
+import type { AgentChatServer, AgentSpec } from "./server/types.js";
 
 export type NamedAgentConfig = {
     mode: "named";

package/src/useTrueFoundryAgentMessages.test.tsx

@@ -46,6 +46,7 @@ vi.mock("./convertTurnMessages.js", async (importOriginal) => {
 
 const mockServer = {
     cancelSession: vi.fn().mockResolvedValue(undefined),
+    listTurns: vi.fn(),
 } as unknown as AgentChatServer;
 
 function snapshotWithAssistantMessage(
@@ -279,6 +280,7 @@ describe("useTrueFoundryAgentMessages", () => {
     beforeEach(() => {
         vi.clearAllMocks();
         vi.mocked(mockServer.cancelSession).mockResolvedValue(undefined);
+        vi.mocked(mockServer.listTurns).mockResolvedValue({ data: [] });
         vi.mocked(loadSessionSnapshot).mockResolvedValue(createEmptySessionSnapshot());
         vi.mocked(streamTurnContent).mockReturnValue(singleUpdateStream());
         vi.mocked(resumeTurnStream).mockReturnValue(singleUpdateStream());
@@ -298,6 +300,79 @@ describe("useTrueFoundryAgentMessages", () => {
         expect(loadSessionSnapshot).not.toHaveBeenCalled();
     });
 
+    it("loads the initial URL session before it is marked as the main thread", async () => {
+        const { rerender } = renderHook(
+            ({ isMain }: { isMain: boolean }) =>
+                useTrueFoundryAgentMessages({
+                    server: mockServer,
+                    sessionId: "session-from-url",
+                    isMain,
+                    isInitialSession: true,
+                }),
+            { initialProps: { isMain: false } },
+        );
+
+        await waitFor(() =>
+            expect(loadSessionSnapshot).toHaveBeenCalledWith(
+                mockServer,
+                "session-from-url",
+                expect.any(Function),
+            ),
+        );
+
+        rerender({ isMain: true });
+        await act(async () => Promise.resolve());
+        expect(loadSessionSnapshot).toHaveBeenCalledTimes(1);
+
+        rerender({ isMain: false });
+        rerender({ isMain: true });
+        await waitFor(() => expect(loadSessionSnapshot).toHaveBeenCalledTimes(2));
+    });
+
+    it("does not load an inactive background thread", async () => {
+        const { result } = renderHook(() =>
+            useTrueFoundryAgentMessages({
+                server: mockServer,
+                sessionId: "background-session",
+                isMain: false,
+                isInitialSession: false,
+            }),
+        );
+
+        await waitFor(() => expect(result.current.isLoading).toBe(false));
+        expect(loadSessionSnapshot).not.toHaveBeenCalled();
+    });
+
+    it("retries a failed URL early load before the thread is promoted to main", async () => {
+        vi.mocked(loadSessionSnapshot)
+            .mockRejectedValueOnce(new Error("load failed"))
+            .mockResolvedValueOnce(snapshotWithUserTurn("Hello"));
+
+        const { result } = renderHook(() =>
+            useTrueFoundryAgentMessages({
+                server: mockServer,
+                sessionId: "session-from-url",
+                isMain: false,
+                isInitialSession: true,
+            }),
+        );
+
+        await waitFor(() => expect(loadSessionSnapshot).toHaveBeenCalledTimes(1));
+        await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+        await act(async () => {
+            result.current.retryLoad();
+        });
+
+        await waitFor(() => expect(loadSessionSnapshot).toHaveBeenCalledTimes(2));
+        await waitFor(() =>
+            expect(result.current.messages[0]).toMatchObject({
+                role: "user",
+                content: [{ type: "text", text: "Hello" }],
+            }),
+        );
+    });
+
     it("sendTurn lazily initializes a session when sessionId is undefined", async () => {
         const initializeSession = vi.fn().mockResolvedValue({
             remoteId: "session-new",
@@ -358,6 +433,7 @@ describe("useTrueFoundryAgentMessages", () => {
             },
             expect.any(AbortSignal),
             expect.any(Array),
+            expect.any(Function),
         );
 
         await act(async () => {
@@ -372,6 +448,7 @@ describe("useTrueFoundryAgentMessages", () => {
             { userMessage: "second" },
             expect.any(AbortSignal),
             expect.any(Array),
+            expect.any(Function),
         );
     });
 
@@ -385,7 +462,11 @@ describe("useTrueFoundryAgentMessages", () => {
         );
 
         await waitFor(() => expect(result.current.isLoading).toBe(false));
-        expect(loadSessionSnapshot).toHaveBeenCalledWith(mockServer, "session-1");
+        expect(loadSessionSnapshot).toHaveBeenCalledWith(
+            mockServer,
+            "session-1",
+            expect.any(Function),
+        );
         expect(result.current.messages).toHaveLength(1);
         expect(result.current.messages[0]?.role).toBe("user");
     });
@@ -493,6 +574,21 @@ describe("useTrueFoundryAgentMessages", () => {
 
     it("editFromTurn drops prior turns before showing the edited user message", async () => {
         const createdAt = new Date().toISOString();
+        vi.mocked(mockServer.listTurns).mockResolvedValue({
+            data: [
+                {
+                    id: "turn-1",
+                    sessionId: "session-1",
+                    createdAt,
+                    state: {
+                        status: "done",
+                        requiredActions: [],
+                        completedAt: createdAt,
+                    },
+                    input: [{ type: "user.message", content: "Hello" }],
+                } as Turn,
+            ],
+        });
         const fold = new PeerThreadFoldState();
         ingestTurnEvent(fold, {
             type: "model.message",
@@ -589,6 +685,54 @@ describe("useTrueFoundryAgentMessages", () => {
         });
     });
 
+    it("restores history when edit fails before turn.created", async () => {
+        const createdAt = new Date().toISOString();
+        const onError = vi.fn();
+        const original = snapshotWithUserTurn("Hello");
+        vi.mocked(loadSessionSnapshot).mockResolvedValue(original);
+        vi.mocked(mockServer.listTurns).mockResolvedValue({
+            data: [
+                {
+                    id: "turn-1",
+                    sessionId: "session-1",
+                    createdAt,
+                    state: {
+                        status: "done",
+                        requiredActions: [],
+                        completedAt: createdAt,
+                    },
+                    input: [{ type: "user.message", content: "Hello" }],
+                } as Turn,
+            ],
+        });
+        vi.mocked(streamTurnContent).mockImplementation(async function* () {
+            throw new Error("Turn preparation failed");
+        });
+
+        const { result } = renderHook(() =>
+            useTrueFoundryAgentMessages({
+                server: mockServer,
+                sessionId: "session-1",
+                onError,
+            }),
+        );
+        await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+        await act(async () => {
+            await expect(
+                result.current.editFromTurn("turn-1", "Edited"),
+            ).rejects.toThrow("Turn preparation failed");
+        });
+
+        expect(result.current.messages).toHaveLength(1);
+        expect(result.current.messages[0]).toMatchObject({
+            role: "user",
+            content: [{ type: "text", text: "Hello" }],
+        });
+        // runStream reports once; callers must not double-toast.
+        expect(onError).toHaveBeenCalledOnce();
+    });
+
     it("does not let a superseded stream complete the current stream", async () => {
         let releaseFirstStream: (() => void) | undefined;
         let releaseSecondStream: (() => void) | undefined;
@@ -962,4 +1106,120 @@ describe("useTrueFoundryAgentMessages", () => {
         // on mount and reconciles against the event log on the next page load.
         expect(loadSessionSnapshot).toHaveBeenCalledTimes(1);
     });
+
+    describe("pre-turn failure rollback", () => {
+        it("reports and restores a user message when initializeSession fails", async () => {
+            const onError = vi.fn();
+            const onPreTurnFailure = vi.fn();
+            const initializeSession = vi
+                .fn()
+                .mockRejectedValue(new Error("Draft session creation failed"));
+
+            const { result } = renderHook(() =>
+                useTrueFoundryAgentMessages({
+                    server: mockServer,
+                    sessionId: undefined,
+                    initializeSession,
+                    onError,
+                }),
+            );
+
+            await waitFor(() => expect(result.current.isLoading).toBe(false));
+            expect(result.current.messages).toEqual([]);
+
+            await act(async () => {
+                await expect(
+                    result.current.sendTurn({
+                        userMessage: "test message",
+                        onPreTurnFailure,
+                    }),
+                ).rejects.toThrow("Draft session creation failed");
+            });
+
+            expect(result.current.messages).toEqual([]);
+            expect(onPreTurnFailure).toHaveBeenCalledOnce();
+            expect(onError).toHaveBeenCalledWith(expect.any(Error));
+            expect(initializeSession).toHaveBeenCalledOnce();
+            expect(streamTurnContent).not.toHaveBeenCalled();
+        });
+
+        it("rolls back when the turns stream fails before turn.created", async () => {
+            const onError = vi.fn();
+            const onPreTurnFailure = vi.fn();
+            vi.mocked(streamTurnContent).mockImplementation(async function* () {
+                throw new Error("Turn preparation failed");
+            });
+
+            const { result } = renderHook(() =>
+                useTrueFoundryAgentMessages({
+                    server: mockServer,
+                    sessionId: "session-1",
+                    onError,
+                }),
+            );
+
+            await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+            await act(async () => {
+                await expect(
+                    result.current.sendTurn({
+                        userMessage: "test message",
+                        onPreTurnFailure,
+                    }),
+                ).rejects.toThrow("Turn preparation failed");
+            });
+
+            expect(result.current.messages).toEqual([]);
+            expect(onPreTurnFailure).toHaveBeenCalledOnce();
+            expect(onError).toHaveBeenCalledWith(expect.any(Error));
+        });
+
+        it("does not roll back after turn.created registers the user message", async () => {
+            const onError = vi.fn();
+            const onPreTurnFailure = vi.fn();
+            vi.mocked(streamTurnContent).mockImplementation(
+                async function* (
+                    _server,
+                    _sessionId,
+                    _fold,
+                    _options,
+                    _signal,
+                    _baseline,
+                    onTurnIdAvailable,
+                ) {
+                    onTurnIdAvailable?.("gateway-turn-123");
+                    yield { content: [{ type: "text" as const, text: "partial" }] };
+                    throw new Error("Mid-stream error");
+                },
+            );
+
+            const { result } = renderHook(() =>
+                useTrueFoundryAgentMessages({
+                    server: mockServer,
+                    sessionId: "session-1",
+                    onError,
+                }),
+            );
+
+            await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+            await act(async () => {
+                await expect(
+                    result.current.sendTurn({
+                        userMessage: "test message",
+                        onPreTurnFailure,
+                    }),
+                ).rejects.toThrow("Mid-stream error");
+            });
+
+            const userMessages = result.current.messages.filter((m) => m.role === "user");
+            expect(userMessages).toHaveLength(1);
+            expect(userMessages[0]?.content[0]).toMatchObject({
+                type: "text",
+                text: "test message",
+            });
+            expect(onPreTurnFailure).not.toHaveBeenCalled();
+            expect(onError).toHaveBeenCalledWith(expect.any(Error));
+        });
+    });
 });