@truefoundry/assistant-ui-runtime 0.1.2 → 0.1.3-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truefoundry/assistant-ui-runtime",
-  "version": "0.1.2",
+  "version": "0.1.3-rc.2",
   "description": "TrueFoundry Gateway agent runtime adapter for assistant-ui",
   "license": "Apache-2.0",
   "repository": {
@@ -50,7 +50,7 @@
   "peerDependencies": {
     "@types/react": "*",
     "react": "^18 || ^19",
-    "truefoundry-gateway-sdk": "^0.3.1"
+    "truefoundry-gateway-sdk": "^0.3.2-rc.1"
   },
   "peerDependenciesMeta": {
     "@types/react": {
@@ -63,8 +63,9 @@
     "@types/react": "^19.2.17",
     "jsdom": "^29.1.1",
     "react": "^19.2.4",
+    "truefoundry-gateway-sdk": "0.3.2-rc.1",
     "tsup": "^8.5.0",
     "typescript": "^5.9.3",
     "vitest": "^4.1.9"
   }
-}
+}

package/src/draftAgentConfig.test.ts

@@ -1,7 +1,12 @@
 import { describe, expect, it } from "vitest";
 
 import { mergeAgentSpec } from "./private/agentSpec.js";
-import { resolveTrueFoundryAgentConfig } from "./types.js";
+import {
+    resolveTrueFoundryAgentConfig,
+    resolveTrueFoundryAgentRuntimeOptions,
+} from "./types.js";
+import type { AgentSessionClient } from "truefoundry-gateway-sdk/agents";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 describe("resolveTrueFoundryAgentConfig", () => {
     it("supports legacy agentName", () => {
@@ -36,6 +41,30 @@ describe("resolveTrueFoundryAgentConfig", () => {
     });
 });
 
+describe("resolveTrueFoundryAgentRuntimeOptions", () => {
+    const client = {} as AgentSessionClient;
+
+    it("requires privateClient for draft mode", () => {
+        expect(() =>
+            resolveTrueFoundryAgentRuntimeOptions({
+                client,
+                agent: { mode: "draft", defaultAgentSpec: { model: { name: "x" } } },
+            }),
+        ).toThrow(/privateClient/);
+    });
+
+    it("accepts privateClient for draft mode", () => {
+        const privateClient = {} as PrivateAgentSessionClient;
+        const resolved = resolveTrueFoundryAgentRuntimeOptions({
+            client,
+            privateClient,
+            agent: { mode: "draft", defaultAgentSpec: { model: { name: "x" } } },
+        });
+        expect(resolved.privateClient).toBe(privateClient);
+        expect(resolved.agent.mode).toBe("draft");
+    });
+});
+
 describe("mergeAgentSpec", () => {
     it("deep-merges model params", () => {
         const base = {

package/src/index.ts

@@ -16,8 +16,11 @@ export type { UseTrueFoundryAgentRuntimeOptions, NamedAgentConfig, DraftAgentCon
 export type { AgentSpec, AgentSpecUpdate, DraftSession } from "./private/agentSpec.js";
 export { mergeAgentSpec, draftSessionTitle } from "./private/agentSpec.js";
 export { createTrueFoundryDraftThreadListAdapter } from "./private/truefoundryDraftThreadListAdapter.js";
+export { createTrueFoundryOwnedSessionsThreadListAdapter } from "./truefoundryOwnedSessionsThreadListAdapter.js";
 export { createDraftSessionBridge } from "./private/draftSessionBridge.js";
 export type { DraftSessionBridge } from "./private/draftSessionBridge.js";
+export { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
+export type { AgentDraftSession } from "truefoundry-gateway-sdk/agents/private";
 export {
     useTrueFoundryAgentSpec,
     useTrueFoundryUpdateAgentSpec,

package/src/loadSessionSnapshot.ts

@@ -21,7 +21,7 @@ export function loadSessionSnapshot(
     onProgress?: (snap: SessionSnapshot) => void,
 ): Promise<SessionSnapshot> {
     const cacheKey =
-        sessionOptions?.draftGateway != null ? `draft:${sessionId}` : sessionId;
+        sessionOptions?.privateClient != null ? `draft:${sessionId}` : sessionId;
     let inflight = inflightBySessionId.get(cacheKey);
     if (inflight == null) {
         inflight = getSession(client, sessionId, sessionOptions)

package/src/private/bindDraftAgentSession.test.ts

@@ -1,11 +1,11 @@
 import { describe, expect, it, vi } from "vitest";
 
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
-import type { AgentSessionClient } from "truefoundry-gateway-sdk/agents";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 import { bindDraftAgentSession } from "./bindDraftAgentSession.js";
 
 const draft = {
+    type: "session/draft" as const,
     id: "draft-1",
     agentSpec: { model: { name: "anthropic/claude-sonnet-4-6" } },
     createdBySubject: { type: "user" as const, id: "u1" },
@@ -15,17 +15,14 @@ const draft = {
 
 describe("bindDraftAgentSession", () => {
     it("validates the draft and binds turns to the draft session id", async () => {
-        const get = vi.fn().mockResolvedValue({ data: draft });
-        const gateway = {
-            agents: { private: { draftSessions: { get } } },
-        } as unknown as TrueFoundryGateway;
-        const client = {
-            client: gateway,
-        } as unknown as AgentSessionClient;
+        const getDraftSession = vi.fn().mockResolvedValue(draft);
+        const privateClient = {
+            getDraftSession,
+        } as unknown as PrivateAgentSessionClient;
 
-        const session = await bindDraftAgentSession(client, gateway, "draft-1");
+        const session = await bindDraftAgentSession(privateClient, "draft-1");
 
-        expect(get).toHaveBeenCalledWith("draft-1");
+        expect(getDraftSession).toHaveBeenCalledWith({ draftSessionId: "draft-1" });
         expect(session.id).toBe("draft-1");
     });
 });
@@ -34,18 +31,19 @@ describe("createDraftSessionBridge", () => {
     it("syncs agent spec via draftSessions.update and returns updatedAt", async () => {
         const { createDraftSessionBridge } = await import("./draftSessionBridge.js");
         const update = vi.fn().mockResolvedValue({ data: draft });
-        const gateway = {
-            agents: {
-                private: {
-                    draftSessions: {
-                        get: vi.fn().mockResolvedValue({ data: draft }),
-                        update,
+        const getDraftSession = vi.fn().mockResolvedValue(draft);
+        const privateClient = {
+            getDraftSession,
+            client: {
+                agents: {
+                    private: {
+                        draftSessions: { update },
                     },
                 },
             },
-        } as unknown as TrueFoundryGateway;
+        } as unknown as PrivateAgentSessionClient;
 
-        const bridge = createDraftSessionBridge(gateway);
+        const bridge = createDraftSessionBridge(privateClient);
         const updatedAt = await bridge.syncAgentSpec("draft-1", draft.agentSpec);
 
         expect(update).toHaveBeenCalledWith("draft-1", {

package/src/private/bindDraftAgentSession.ts

@@ -1,65 +1,27 @@
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
-import type { AgentSession, AgentSessionClient } from "truefoundry-gateway-sdk/agents";
-// SDK does not publicly export the AgentSession class; bind draft ids for turn routes.
-import { AgentSession as AgentSessionClass } from "truefoundry-gateway-sdk/dist/esm/agents/AgentSession.mjs";
-
-import type { DraftSession } from "./agentSpec.js";
-
-type SessionRecord = {
-    id: string;
-    agentName: string;
-    title?: string;
-    createdBySubject: DraftSession["createdBySubject"];
-    createdAt: string;
-    updatedAt: string;
-};
+import type { AgentSession } from "truefoundry-gateway-sdk/agents";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 const inflightByDraftId = new Map<string, Promise<AgentSession>>();
 
-export function getGatewayFromSessionClient(
-    client: AgentSessionClient,
-): TrueFoundryGateway {
-    const internal = client as unknown as { client: TrueFoundryGateway };
-    if (internal.client == null) {
-        throw new Error("AgentSessionClient is missing an internal gateway client.");
-    }
-    return internal.client;
-}
-
-function draftToSessionRecord(draft: DraftSession): SessionRecord {
-    return {
-        id: draft.id,
-        agentName: draft.agentName ?? "",
-        title: draft.title,
-        createdBySubject: draft.createdBySubject,
-        createdAt: draft.createdAt,
-        updatedAt: draft.updatedAt,
-    };
-}
-
 /**
- * Binds an `AgentSession` for turn APIs at `/agents/sessions/{draftSessionId}/turns`
- * after validating the draft via `GET draft-sessions/{draftSessionId}`.
- * Does not call `GET` or `POST` on `/agents/sessions` root.
+ * Binds turn APIs for a draft session via `PrivateAgentSessionClient.getDraftSession`.
+ * Returns an `AgentDraftSession` (identical turn surface to `AgentSession`).
  */
 export async function bindDraftAgentSession(
-    client: AgentSessionClient,
-    gateway: TrueFoundryGateway,
+    privateClient: PrivateAgentSessionClient,
     draftSessionId: string,
 ): Promise<AgentSession> {
     let inflight = inflightByDraftId.get(draftSessionId);
     if (inflight == null) {
-        inflight = (async () => {
-            const response = await gateway.agents.private.draftSessions.get(draftSessionId);
-            return new AgentSessionClass(
-                draftToSessionRecord(response.data),
-                getGatewayFromSessionClient(client),
-            ) as AgentSession;
-        })().finally(() => {
-            if (inflightByDraftId.get(draftSessionId) === inflight) {
-                inflightByDraftId.delete(draftSessionId);
-            }
-        });
+        inflight = privateClient
+            .getDraftSession({ draftSessionId })
+            // AgentDraftSession shares the turn API with AgentSession.
+            .then((draft) => draft as unknown as AgentSession)
+            .finally(() => {
+                if (inflightByDraftId.get(draftSessionId) === inflight) {
+                    inflightByDraftId.delete(draftSessionId);
+                }
+            });
         inflightByDraftId.set(draftSessionId, inflight);
     }
     return inflight;

package/src/private/draftSessionBridge.ts

@@ -1,6 +1,7 @@
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 import type { AgentSpec } from "./agentSpec.js";
+import { getGatewayFromPrivateClient } from "./getGatewayFromPrivateClient.js";
 
 export const DRAFT_SESSION_LAST_UPDATED_AT_HEADER = "x-tfy-session-last-updated-at";
 
@@ -10,20 +11,17 @@ export type DraftSessionBridge = {
 };
 
 export function createDraftSessionBridge(
-    gateway: TrueFoundryGateway,
+    privateClient: PrivateAgentSessionClient,
 ): DraftSessionBridge {
-    async function getDraft(draftSessionId: string) {
-        const response = await gateway.agents.private.draftSessions.get(draftSessionId);
-        return response.data;
-    }
-
     return {
         async getDraftAgentSpec(draftSessionId) {
-            const draft = await getDraft(draftSessionId);
+            const draft = await privateClient.getDraftSession({ draftSessionId });
             return draft.agentSpec;
         },
 
         async syncAgentSpec(draftSessionId, agentSpec) {
+            // PrivateAgentSessionClient does not wrap update yet — use the low-level client.
+            const gateway = getGatewayFromPrivateClient(privateClient);
             const response = await gateway.agents.private.draftSessions.update(
                 draftSessionId,
                 { agentSpec },

package/src/private/getGatewayFromPrivateClient.ts

@@ -0,0 +1,13 @@
+import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
+
+/** Reach the underlying gateway for APIs not yet wrapped on PrivateAgentSessionClient (update, sandbox download). */
+export function getGatewayFromPrivateClient(
+    privateClient: PrivateAgentSessionClient,
+): TrueFoundryGateway {
+    const internal = privateClient as unknown as { client: TrueFoundryGateway };
+    if (internal.client == null) {
+        throw new Error("PrivateAgentSessionClient is missing an internal gateway client.");
+    }
+    return internal.client;
+}

package/src/private/truefoundryDraftThreadListAdapter.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 import { createTrueFoundryDraftThreadListAdapter } from "./truefoundryDraftThreadListAdapter.js";
 import type { AgentSpec } from "./agentSpec.js";
@@ -12,6 +12,7 @@ const defaultAgentSpec: AgentSpec = {
 
 function mockDraft(id: string, title: string | undefined, updatedAt: string) {
     return {
+        type: "session/draft" as const,
         id,
         agentSpec: defaultAgentSpec,
         title,
@@ -38,31 +39,33 @@ function mockDraftListPage(
 
 describe("createTrueFoundryDraftThreadListAdapter", () => {
     it("lists draft sessions with pagination cursor", async () => {
-        const list = vi.fn().mockResolvedValue(
+        const listDraftSessions = vi.fn().mockResolvedValue(
             mockDraftListPage(
                 [mockDraft("d1", "My draft", "2026-06-30T10:00:00.000Z")],
                 "page-2",
             ),
         );
-        const gateway = {
-            agents: { private: { draftSessions: { list, create: vi.fn(), get: vi.fn() } } },
-        } as unknown as TrueFoundryGateway;
+        const privateClient = {
+            listDraftSessions,
+            createDraftSession: vi.fn(),
+            getDraftSession: vi.fn(),
+        } as unknown as PrivateAgentSessionClient;
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            gateway,
+            privateClient,
             defaultAgentSpec,
         });
 
         const result = await adapter.list();
 
-        expect(list).toHaveBeenCalledWith(
+        expect(listDraftSessions).toHaveBeenCalledWith(
             expect.objectContaining({
                 limit: 20,
                 pageToken: undefined,
                 startTimestamp: expect.any(String),
             }),
         );
-        expect(list).toHaveBeenCalledWith(
+        expect(listDraftSessions).toHaveBeenCalledWith(
             expect.not.objectContaining({ agentName: expect.anything() }),
         );
         expect(result.threads).toEqual([
@@ -77,21 +80,23 @@ describe("createTrueFoundryDraftThreadListAdapter", () => {
     });
 
     it("creates a draft session on initialize", async () => {
-        const create = vi.fn().mockResolvedValue({
-            data: mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
-        });
-        const gateway = {
-            agents: { private: { draftSessions: { list: vi.fn(), create, get: vi.fn() } } },
-        } as unknown as TrueFoundryGateway;
+        const createDraftSession = vi.fn().mockResolvedValue(
+            mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
+        );
+        const privateClient = {
+            listDraftSessions: vi.fn(),
+            createDraftSession,
+            getDraftSession: vi.fn(),
+        } as unknown as PrivateAgentSessionClient;
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            gateway,
+            privateClient,
             defaultAgentSpec,
         });
 
         const result = await adapter.initialize("local-thread-id");
 
-        expect(create).toHaveBeenCalledWith({ agentSpec: defaultAgentSpec });
+        expect(createDraftSession).toHaveBeenCalledWith({ agentSpec: defaultAgentSpec });
         expect(result).toEqual({ remoteId: "d-new", externalId: undefined });
     });
 
@@ -102,39 +107,44 @@ describe("createTrueFoundryDraftThreadListAdapter", () => {
             mcpServers: [{ name: "github", enableTools: ["@all"] }],
             skills: [{ fqn: "acme/skill-a:1", preload: false }],
         };
-        const create = vi.fn().mockResolvedValue({
-            data: mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
-        });
-        const gateway = {
-            agents: { private: { draftSessions: { list: vi.fn(), create, get: vi.fn() } } },
-        } as unknown as TrueFoundryGateway;
+        const createDraftSession = vi.fn().mockResolvedValue(
+            mockDraft("d-new", undefined, "2026-06-30T12:00:00.000Z"),
+        );
+        const privateClient = {
+            listDraftSessions: vi.fn(),
+            createDraftSession,
+            getDraftSession: vi.fn(),
+        } as unknown as PrivateAgentSessionClient;
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            gateway,
+            privateClient,
             defaultAgentSpec,
             getAgentSpec: () => liveAgentSpec,
         });
 
         await adapter.initialize("local-thread-id");
 
-        expect(create).toHaveBeenCalledWith({ agentSpec: liveAgentSpec });
+        expect(createDraftSession).toHaveBeenCalledWith({ agentSpec: liveAgentSpec });
     });
 
     it("falls back to model name for title when draft has no title", async () => {
-        const get = vi.fn().mockResolvedValue({
-            data: mockDraft("d1", undefined, "2026-06-30T10:00:00.000Z"),
-        });
-        const gateway = {
-            agents: { private: { draftSessions: { list: vi.fn(), create: vi.fn(), get } } },
-        } as unknown as TrueFoundryGateway;
+        const getDraftSession = vi.fn().mockResolvedValue(
+            mockDraft("d1", undefined, "2026-06-30T10:00:00.000Z"),
+        );
+        const privateClient = {
+            listDraftSessions: vi.fn(),
+            createDraftSession: vi.fn(),
+            getDraftSession,
+        } as unknown as PrivateAgentSessionClient;
 
         const adapter = createTrueFoundryDraftThreadListAdapter({
-            gateway,
+            privateClient,
             defaultAgentSpec,
         });
 
         const result = await adapter.fetch("d1");
 
+        expect(getDraftSession).toHaveBeenCalledWith({ draftSessionId: "d1" });
         expect(result.title).toBe("anthropic/claude-sonnet-4-6");
     });
 });

package/src/private/truefoundryDraftThreadListAdapter.ts

@@ -1,5 +1,5 @@
 import type { RemoteThreadListAdapter } from "@assistant-ui/core";
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 import { draftSessionTitle, type AgentSpec } from "./agentSpec.js";
 import { sessionListStartTimestamp } from "../sessionListStartTimestamp.js";
@@ -7,15 +7,15 @@ import { sessionListStartTimestamp } from "../sessionListStartTimestamp.js";
 const THREAD_LIST_PAGE_SIZE = 20;
 
 export function createTrueFoundryDraftThreadListAdapter(options: {
-    gateway: TrueFoundryGateway;
+    privateClient: PrivateAgentSessionClient;
     defaultAgentSpec: AgentSpec;
     getAgentSpec?: () => AgentSpec;
 }): RemoteThreadListAdapter {
-    const { gateway, defaultAgentSpec, getAgentSpec } = options;
+    const { privateClient, defaultAgentSpec, getAgentSpec } = options;
 
     return {
         async list({ after } = {}) {
-            const page = await gateway.agents.private.draftSessions.list({
+            const page = await privateClient.listDraftSessions({
                 limit: THREAD_LIST_PAGE_SIZE,
                 pageToken: after,
                 startTimestamp: sessionListStartTimestamp(),
@@ -33,16 +33,16 @@ export function createTrueFoundryDraftThreadListAdapter(options: {
         },
 
         async initialize(_threadId: string) {
-            const response = await gateway.agents.private.draftSessions.create({
+            const draft = await privateClient.createDraftSession({
                 agentSpec: getAgentSpec?.() ?? defaultAgentSpec,
             });
-            const draft = response.data;
             return { remoteId: draft.id, externalId: undefined };
         },
 
         async fetch(remoteId) {
-            const response = await gateway.agents.private.draftSessions.get(remoteId);
-            const draft = response.data;
+            const draft = await privateClient.getDraftSession({
+                draftSessionId: remoteId,
+            });
             return {
                 status: "regular" as const,
                 remoteId: draft.id,

package/src/sessions.ts

@@ -2,15 +2,15 @@ import type {
     AgentSession,
     AgentSessionClient,
 } from "truefoundry-gateway-sdk/agents";
-import type { TrueFoundryGateway } from "truefoundry-gateway-sdk";
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
 
 import { bindDraftAgentSession } from "./private/bindDraftAgentSession.js";
 
 const inflightBySessionId = new Map<string, Promise<AgentSession>>();
 
 export type GetSessionOptions = {
-    /** When set, validates the draft and binds turns to `/agents/sessions/{id}/turns`. */
-    draftGateway?: TrueFoundryGateway;
+    /** When set, validates the draft and binds turns via PrivateAgentSessionClient. */
+    privateClient?: PrivateAgentSessionClient;
 };
 
 /** `sessionId` is the assistant-ui thread `remoteId` from `RemoteThreadListAdapter.initialize`. */
@@ -19,8 +19,8 @@ export function getSession(
     sessionId: string,
     options?: GetSessionOptions,
 ): Promise<AgentSession> {
-    if (options?.draftGateway != null) {
-        return bindDraftAgentSession(client, options.draftGateway, sessionId);
+    if (options?.privateClient != null) {
+        return bindDraftAgentSession(options.privateClient, sessionId);
     }
 
     let inflight = inflightBySessionId.get(sessionId);

package/src/streamTurn.ts

@@ -53,6 +53,13 @@ export async function* streamTurnContent(
     options: StreamTurnOptions,
     abortSignal: AbortSignal,
     groupRootBaseline?: readonly string[],
+    /**
+     * Called once with the gateway-assigned turn ID as soon as it becomes
+     * available (after the first `turn.created` SSE event). Use this to
+     * reconcile the locally-generated optimistic ID with the real gateway ID
+     * so that edit/retry can find the turn in `buildSnapshotBeforeTurn`.
+     */
+    onTurnIdAvailable?: (turnId: string) => void,
 ): AsyncGenerator<TurnStreamUpdate> {
     const previousTurnId =
         options.previousTurnId === null
@@ -69,7 +76,8 @@ export async function* streamTurnContent(
     }
 
     try {
-        yield* streamTurnEvents(
+        let turnIdNotified = false;
+        for await (const update of streamTurnEvents(
             turn.execute(
                 { stream: true },
                 {
@@ -79,7 +87,20 @@ export async function* streamTurnContent(
             ),
             foldState,
             groupRootBaseline,
-        );
+        )) {
+            // After the first `turn.created` event, `turn.id` is set.
+            // Notify BEFORE yielding so the caller can update its tracking
+            // before the snapshot is written with the stream update.
+            if (!turnIdNotified && turn.id != null) {
+                onTurnIdAvailable?.(turn.id);
+                turnIdNotified = true;
+            }
+            yield update;
+        }
+        // Handle streams that complete without yielding any content.
+        if (!turnIdNotified && turn.id != null) {
+            onTurnIdAvailable?.(turn.id);
+        }
     } catch (error) {
         if (error instanceof Error && error.name === "AbortError") {
             return;

package/src/truefoundryOwnedSessionsThreadListAdapter.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it, vi } from "vitest";
+
+import type { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
+
+import { createTrueFoundryOwnedSessionsThreadListAdapter } from "./truefoundryOwnedSessionsThreadListAdapter.js";
+
+function mockNamedSession(id: string, title: string, updatedAt: string) {
+    return {
+        type: "session" as const,
+        id,
+        agentName: "my-agent",
+        title,
+        createdBySubject: { type: "user" as const, id: "u1" },
+        createdAt: updatedAt,
+        updatedAt,
+    };
+}
+
+function mockDraftSession(id: string, title: string | undefined, updatedAt: string) {
+    return {
+        type: "session/draft" as const,
+        id,
+        agentSpec: { model: { name: "anthropic/claude-sonnet-4-6" } },
+        title,
+        createdBySubject: { type: "user" as const, id: "u1" },
+        createdAt: updatedAt,
+        updatedAt,
+    };
+}
+
+describe("createTrueFoundryOwnedSessionsThreadListAdapter", () => {
+    it("lists owned sessions (named + draft) with pagination cursor", async () => {
+        const listOwnedSessions = vi.fn().mockResolvedValue({
+            data: [
+                mockNamedSession("s1", "Named chat", "2026-06-30T12:00:00.000Z"),
+                mockDraftSession("d1", "Draft chat", "2026-06-30T11:00:00.000Z"),
+            ],
+            response: {
+                pagination: { nextPageToken: "page-2", limit: 20 },
+            },
+        });
+        const privateClient = {
+            listOwnedSessions,
+            getDraftSession: vi.fn(),
+        } as unknown as PrivateAgentSessionClient;
+
+        const adapter = createTrueFoundryOwnedSessionsThreadListAdapter({ privateClient });
+        const result = await adapter.list();
+
+        expect(listOwnedSessions).toHaveBeenCalledWith(
+            expect.objectContaining({
+                limit: 20,
+                pageToken: undefined,
+                startTimestamp: expect.any(String),
+            }),
+        );
+        expect(result.threads).toEqual([
+            {
+                status: "regular",
+                remoteId: "s1",
+                title: "Named chat",
+                lastMessageAt: new Date("2026-06-30T12:00:00.000Z"),
+            },
+            {
+                status: "regular",
+                remoteId: "d1",
+                title: "Draft chat",
+                lastMessageAt: new Date("2026-06-30T11:00:00.000Z"),
+            },
+        ]);
+        expect(result.nextCursor).toBe("page-2");
+    });
+
+    it("falls back to model name for untitled drafts", async () => {
+        const listOwnedSessions = vi.fn().mockResolvedValue({
+            data: [mockDraftSession("d1", undefined, "2026-06-30T11:00:00.000Z")],
+            response: { pagination: { limit: 20 } },
+        });
+        const privateClient = {
+            listOwnedSessions,
+            getDraftSession: vi.fn(),
+        } as unknown as PrivateAgentSessionClient;
+
+        const adapter = createTrueFoundryOwnedSessionsThreadListAdapter({ privateClient });
+        const result = await adapter.list();
+
+        expect(result.threads[0]?.title).toBe("anthropic/claude-sonnet-4-6");
+    });
+
+    it("throws on initialize because the adapter is read-only", async () => {
+        const privateClient = {
+            listOwnedSessions: vi.fn(),
+            getDraftSession: vi.fn(),
+        } as unknown as PrivateAgentSessionClient;
+
+        const adapter = createTrueFoundryOwnedSessionsThreadListAdapter({ privateClient });
+
+        await expect(adapter.initialize("local")).rejects.toThrow(/read-only/);
+    });
+});