@truefoundry/assistant-ui-runtime 0.1.4 → 0.1.6-rc.0

package/dist/index.js

@@ -88,9 +88,10 @@ function findApprovalRequiredInTurn(turn) {
   if (turn.state.status !== "done") {
     return void 0;
   }
-  return turn.state.requiredActions?.find(
+  const found = turn.state.requiredActions?.find(
     (action) => action.type === "tool.approval_required"
   );
+  return found?.type === "tool.approval_required" ? found : void 0;
 }
 function toolCallPartHasPendingApproval(part) {
   return hasPendingToolApproval(part.approval);
@@ -250,10 +251,93 @@ function toTrueFoundryApprovalInputs(message, response, defaultThreadId = ROOT_T
   return collectApprovalInputs(updated, defaultThreadId);
 }
 
-// src/foldPeerThreads.ts
-import {
-  isEventDelta as isEventDelta2
-} from "truefoundry-gateway-sdk/agents";
+// src/server/eventUtils.ts
+function isEventDelta(event) {
+  return typeof event.type === "string" && event.type.endsWith(".delta");
+}
+function mergeEventDelta(base, delta) {
+  if (base.id !== delta.id) {
+    throw new Error(
+      `Cannot merge delta into a different event: base id "${base.id}" != delta id "${delta.id}".`
+    );
+  }
+  if (delta.type === "model.message.delta" && base.type === "model.message") {
+    mergeModelMessageDelta(base, delta);
+  }
+}
+function asToolInfo(value) {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value;
+}
+function mergeModelMessageDelta(base, delta) {
+  if (delta.content) {
+    if (base.content === void 0 || base.content === null || typeof base.content === "string") {
+      base.content = (base.content ?? "") + delta.content;
+    } else {
+      const last = base.content[base.content.length - 1];
+      if (last && last.type === "text") {
+        last.text += delta.content;
+      } else {
+        base.content.push({ type: "text", text: delta.content });
+      }
+    }
+  }
+  if (delta.refusal) {
+    base.refusal = (base.refusal ?? "") + delta.refusal;
+  }
+  if (delta.toolCalls) {
+    base.toolCalls ??= [];
+    for (const d of delta.toolCalls) {
+      let tc = base.toolCalls[d.index];
+      if (tc === void 0) {
+        const toolInfo2 = asToolInfo(d.toolInfo);
+        tc = {
+          id: d.id ?? "",
+          type: d.type ?? "function",
+          function: {
+            name: d.function?.name ?? "",
+            arguments: ""
+          },
+          ...toolInfo2 != null ? { toolInfo: toolInfo2 } : {}
+        };
+        base.toolCalls[d.index] = tc;
+      }
+      if (d.id) {
+        tc.id = d.id;
+      }
+      if (d.type) {
+        tc.type = d.type;
+      }
+      if (d.function?.name) {
+        tc.function.name = d.function.name;
+      }
+      if (d.function?.arguments) {
+        tc.function.arguments += d.function.arguments;
+      }
+      const toolInfo = asToolInfo(d.toolInfo);
+      if (toolInfo != null) {
+        tc.toolInfo = toolInfo;
+      }
+      if (d.providerSpecificFields) {
+        tc.providerSpecificFields = {
+          ...tc.providerSpecificFields ?? {},
+          ...d.providerSpecificFields
+        };
+      }
+    }
+  }
+  if (delta.finishReason) {
+    base.finishReason = delta.finishReason;
+  }
+  if (delta.reasoningContent) {
+    base.reasoningContent = (base.reasoningContent ?? "") + delta.reasoningContent;
+  }
+  if (delta.usage) {
+    base.usage = delta.usage;
+  }
+}
 
 // src/askUserQuestion.ts
 function parseAskUserQuestionArgs(argsText) {
@@ -283,7 +367,6 @@ function isCreateSubAgentToolCall(toolCall) {
 }
 
 // src/modelMessageImageContent.ts
-import { isEventDelta, mergeEventDelta } from "truefoundry-gateway-sdk/agents";
 function parseDataUriMime(data) {
   if (!data.startsWith("data:")) {
     return "image/png";
@@ -545,7 +628,7 @@ function ingestEventIntoBucket(bucket, message) {
   if (isTurnScopedEvent(message)) {
     return;
   }
-  if (isEventDelta2(message)) {
+  if (isEventDelta(message)) {
     const base = bucket.events.get(message.id);
     if (base != null) {
       mergeStreamEventDelta(base, message);
@@ -899,9 +982,10 @@ function findResponseRequiredInTurn(turn) {
   if (turn.state.status !== "done") {
     return void 0;
   }
-  return turn.state.requiredActions?.find(
+  const found = turn.state.requiredActions?.find(
     (action) => action.type === "tool.response_required"
   );
+  return found?.type === "tool.response_required" ? found : void 0;
 }
 function applyToolResponseToToolCall(part, content) {
   return { ...part, result: content };
@@ -1150,6 +1234,21 @@ function deriveSandboxId(messages) {
   return void 0;
 }
 
+// src/listPages.ts
+async function drainListPages(fetchPage) {
+  const items = [];
+  let pageToken;
+  for (; ; ) {
+    const page = await fetchPage(pageToken);
+    items.push(...page.data);
+    if (page.nextPageToken == null || page.nextPageToken === "") {
+      break;
+    }
+    pageToken = page.nextPageToken;
+  }
+  return items;
+}
+
 // src/extractTurnUserText.ts
 function extractTurnUserText(input) {
   const parts = [];
@@ -1187,9 +1286,10 @@ function buildMcpAuthTextParts(servers) {
   return [{ type: "text", text }];
 }
 function findMcpAuthRequired(requiredActions) {
-  return requiredActions?.find(
+  const found = requiredActions?.find(
     (action) => action.type === "mcp.auth_required"
   );
+  return found?.type === "mcp.auth_required" ? found : void 0;
 }
 function mcpAuthAssistantStatus() {
   return { type: "requires-action", reason: "interrupt" };
@@ -1329,28 +1429,28 @@ function oldestCompleteTurnGroupState(itemsAsc) {
   }
   return extractTurnUserText(created.event.input) != null ? "user-group" : "continuation";
 }
-async function fetchSessionEventsPage(session, options) {
-  const page = await session.listEvents({
+async function fetchSessionEventsPage(server, sessionId, options) {
+  const page = await server.listEvents({
+    sessionId,
     limit: SESSION_EVENTS_PAGE_SIZE,
     ...options?.lastTurnId != null ? { lastTurnId: options.lastTurnId } : {},
     ...options?.pageToken != null ? { pageToken: options.pageToken } : {}
   });
-  const response = page.response;
-  const olderPageToken = response.pagination?.nextPageToken;
-  const hasOlder = typeof page.hasNextPage === "function" ? page.hasNextPage() : olderPageToken != null && olderPageToken !== "";
+  const olderPageToken = page.nextPageToken;
+  const hasOlder = olderPageToken != null && olderPageToken !== "";
   return {
     itemsNewestFirst: page.data,
     ...olderPageToken != null && olderPageToken !== "" ? { olderPageToken } : {},
     hasOlder
   };
 }
-async function fetchSessionEventsWindow(session, options) {
+async function fetchSessionEventsWindow(server, sessionId, options) {
   let itemsNewestFirst = [];
   let pageToken = options?.pageToken;
   let olderPageToken;
   let hasOlder = false;
   for (let pageCount = 0; pageCount < MAX_HISTORY_BOUNDARY_PAGES; pageCount++) {
-    const page = await fetchSessionEventsPage(session, {
+    const page = await fetchSessionEventsPage(server, sessionId, {
       ...options,
       ...pageToken != null ? { pageToken } : {}
     });
@@ -1378,14 +1478,15 @@ async function fetchSessionEventsWindow(session, options) {
     hasOlder
   };
 }
-async function fetchAllSessionEvents(session, options) {
-  const items = [];
-  for await (const item of await session.listEvents({
-    limit: SESSION_EVENTS_PAGE_SIZE,
-    ...options?.lastTurnId != null ? { lastTurnId: options.lastTurnId } : {}
-  })) {
-    items.push(item);
-  }
+async function fetchAllSessionEvents(server, sessionId, options) {
+  const items = await drainListPages(
+    (pageToken) => server.listEvents({
+      sessionId,
+      limit: SESSION_EVENTS_PAGE_SIZE,
+      ...options?.lastTurnId != null ? { lastTurnId: options.lastTurnId } : {},
+      ...pageToken != null ? { pageToken } : {}
+    })
+  );
   items.reverse();
   return items;
 }
@@ -1520,11 +1621,11 @@ function attachRunningTurn(snapshot, runningTurn) {
     } : {}
   });
 }
-async function buildSnapshotFromSessionEvents(session, onProgress) {
-  const turnsPage = await session.listTurns({ limit: 1 });
+async function buildSnapshotFromSessionEvents(server, sessionId, onProgress) {
+  const turnsPage = await server.listTurns({ sessionId, limit: 1 });
   const newestTurn = turnsPage.data[0];
   const runningTurn = newestTurn?.state?.status === "running" ? newestTurn : void 0;
-  const window = await fetchSessionEventsWindow(session);
+  const window = await fetchSessionEventsWindow(server, sessionId);
   const historyPagination = {
     hasOlder: window.hasOlder,
     ...window.olderPageToken != null ? { olderPageToken: window.olderPageToken } : {}
@@ -1537,12 +1638,12 @@ async function buildSnapshotFromSessionEvents(session, onProgress) {
   });
   return attachRunningTurn(withHistory, runningTurn);
 }
-async function prependOlderSessionHistory(session, snapshot) {
+async function prependOlderSessionHistory(server, sessionId, snapshot) {
   const pagination = snapshot.historyPagination;
   if (pagination?.hasOlder !== true || pagination.olderPageToken == null) {
     return snapshot;
   }
-  const window = await fetchSessionEventsWindow(session, {
+  const window = await fetchSessionEventsWindow(server, sessionId, {
     pageToken: pagination.olderPageToken
   });
   if (window.itemsAsc.length === 0) {
@@ -1694,22 +1795,36 @@ function buildAssistantMessage(turnId, content, createdAt, status, custom = {},
     }
   };
 }
-async function ingestTurnEventsIntoFold(foldState, turn) {
-  for await (const event of await turn.listEvents({
-    order: "asc",
-    limit: TURN_EVENTS_PAGE_SIZE
-  })) {
+async function ingestTurnEventsIntoFold(server, sessionId, turnId, foldState) {
+  if (server.listTurnEvents == null) {
+    return;
+  }
+  const events = await drainListPages(
+    (pageToken) => server.listTurnEvents({
+      sessionId,
+      turnId,
+      order: "asc",
+      limit: TURN_EVENTS_PAGE_SIZE,
+      ...pageToken != null ? { pageToken } : {}
+    })
+  );
+  for (const event of events) {
     ingestTurnEvent(foldState, event);
   }
 }
-async function fetchTurnEvents(turn) {
-  const events = [];
-  for await (const event of await turn.listEvents({
-    order: "asc",
-    limit: TURN_EVENTS_PAGE_SIZE
-  })) {
-    events.push(event);
+async function fetchTurnEvents(server, sessionId, turnId) {
+  if (server.listTurnEvents == null) {
+    return [];
   }
+  const events = await drainListPages(
+    (pageToken) => server.listTurnEvents({
+      sessionId,
+      turnId,
+      order: "asc",
+      limit: TURN_EVENTS_PAGE_SIZE,
+      ...pageToken != null ? { pageToken } : {}
+    })
+  );
   return events;
 }
 function ingestCollectedEventsIntoFold(foldState, events) {
@@ -1717,16 +1832,18 @@ function ingestCollectedEventsIntoFold(foldState, events) {
     ingestTurnEvent(foldState, event);
   }
 }
-async function fetchAllTurnEventsWithConcurrency(turns, concurrency) {
+async function fetchAllTurnEventsWithConcurrency(server, sessionId, turns, concurrency) {
   const results = new Array(turns.length);
   const pool = /* @__PURE__ */ new Set();
   for (let i = 0; i < turns.length; i++) {
     const idx = i;
     const turn = turns[idx];
-    const p = fetchTurnEvents(turn).then((events) => {
-      results[idx] = events;
-      pool.delete(p);
-    });
+    const p = fetchTurnEvents(server, sessionId, turn.id).then(
+      (events) => {
+        results[idx] = events;
+        pool.delete(p);
+      }
+    );
     pool.add(p);
     if (pool.size >= concurrency) await Promise.race(pool);
   }
@@ -2011,13 +2128,18 @@ function ingestTurnsIntoSnapshot(snapshot, turns, eventArrays) {
   }
   return runningTurn;
 }
-async function buildSnapshotFromSession(session, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY) {
-  const snapshot = await buildSnapshotFromSessionEvents(session);
+async function buildSnapshotFromSession(server, sessionId, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY) {
+  const snapshot = await buildSnapshotFromSessionEvents(server, sessionId);
   if (snapshot.runningTurn == null) {
     return snapshot;
   }
   const turn = snapshot.runningTurn;
-  const eventArrays = await fetchAllTurnEventsWithConcurrency([turn], concurrency);
+  const eventArrays = await fetchAllTurnEventsWithConcurrency(
+    server,
+    sessionId,
+    [turn],
+    concurrency
+  );
   ingestTurnsIntoSnapshot(snapshot, [turn], eventArrays);
   return replaceSessionSnapshot(snapshot, {
     runningTurn: turn,
@@ -2026,59 +2148,67 @@ async function buildSnapshotFromSession(session, concurrency = DEFAULT_LIST_EVEN
     pendingUser: void 0
   });
 }
-async function buildSnapshotBeforeTurn(session, beforeTurnId, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY) {
-  const turns = await listSessionTurnsOrdered(session);
+async function buildSnapshotBeforeTurn(server, sessionId, beforeTurnId, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY) {
+  const turns = await listSessionTurnsOrdered(server, sessionId);
   const beforeIndex = turns.findIndex((turn) => turn.id === beforeTurnId);
   if (beforeIndex === -1) {
     throw new Error(`Turn ${beforeTurnId} not found in session`);
   }
-  return buildSnapshotBeforeTurnIndex(session, beforeIndex, concurrency, turns);
+  return buildSnapshotBeforeTurnIndex(
+    server,
+    sessionId,
+    beforeIndex,
+    concurrency,
+    turns
+  );
 }
-async function buildSnapshotBeforeTurnIndex(session, turnIndex, _concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY, orderedTurns) {
+async function buildSnapshotBeforeTurnIndex(server, sessionId, turnIndex, _concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY, orderedTurns) {
   if (turnIndex <= 0) {
     return createEmptySessionSnapshot();
   }
-  const turns = orderedTurns ?? await listSessionTurnsOrdered(session);
+  const turns = orderedTurns ?? await listSessionTurnsOrdered(server, sessionId);
   const turnsToInclude = turns.slice(0, turnIndex);
   const lastTurnId = turnsToInclude.at(-1)?.id;
   if (lastTurnId == null) {
     return createEmptySessionSnapshot();
   }
-  const items = await fetchAllSessionEvents(session, { lastTurnId });
+  const items = await fetchAllSessionEvents(server, sessionId, { lastTurnId });
   const snapshot = createEmptySessionSnapshot();
   ingestSessionEventsIntoSnapshot(snapshot, items);
   return snapshot;
 }
-async function resolveGatewayBranchPreviousTurnId(session, turnIndex, orderedTurns) {
+async function resolveGatewayBranchPreviousTurnId(server, sessionId, turnIndex, orderedTurns) {
   if (turnIndex <= 0) {
-    return null;
+    return "none";
   }
-  const turns = orderedTurns ?? await listSessionTurnsOrdered(session);
-  return turns[turnIndex - 1]?.id ?? null;
+  const turns = orderedTurns ?? await listSessionTurnsOrdered(server, sessionId);
+  return turns[turnIndex - 1]?.id ?? "none";
 }
-async function resolveGatewayBranchPreviousTurnIdForTurn(session, turnId) {
-  const turns = await listSessionTurnsOrdered(session);
+async function resolveGatewayBranchPreviousTurnIdForTurn(server, sessionId, turnId) {
+  const turns = await listSessionTurnsOrdered(server, sessionId);
   const turnIndex = turns.findIndex((turn) => turn.id === turnId);
-  return resolveGatewayBranchPreviousTurnId(session, turnIndex, turns);
+  return resolveGatewayBranchPreviousTurnId(server, sessionId, turnIndex, turns);
 }
-async function listSessionTurnsOrdered(session) {
-  const turns = [];
-  for await (const turn of await session.listTurns()) {
-    turns.push(turn);
-  }
+async function listSessionTurnsOrdered(server, sessionId) {
+  const turns = await drainListPages(
+    (pageToken) => server.listTurns({
+      sessionId,
+      ...pageToken != null ? { pageToken } : {}
+    })
+  );
   turns.reverse();
   return turns;
 }
-async function buildTurnAssistantContent(turn, foldState) {
+async function buildTurnAssistantContent(server, sessionId, turn, foldState) {
   const state = foldState ?? new PeerThreadFoldState();
   const beforeCount = state.threads.get(ROOT_THREAD_ID)?.modelMessageIds.length ?? 0;
-  await ingestTurnEventsIntoFold(state, turn);
+  await ingestTurnEventsIntoFold(server, sessionId, turn.id, state);
   const afterIds = state.threads.get(ROOT_THREAD_ID)?.modelMessageIds ?? [];
   const rootModelMessageIds = afterIds.slice(beforeCount);
   return buildTurnUpdateFromFold(state, turn, rootModelMessageIds).content;
 }
-async function convertTurnsToThreadMessages(session) {
-  const snapshot = await buildSnapshotFromSession(session);
+async function convertTurnsToThreadMessages(server, sessionId) {
+  const snapshot = await buildSnapshotFromSession(server, sessionId);
   const messages = projectSessionMessages(snapshot);
   return {
     messages,
@@ -2218,7 +2348,7 @@ function buildMcpAuthUpdate(pendingMcpAuth, foldState, groupRootBaseline) {
     metadata: { custom: mcpAuthMessageCustom(pendingMcpAuth.mcpServers) }
   };
 }
-async function* streamTurnEvents(stream, foldState, groupRootBaseline) {
+async function* streamTurnEvents(stream, foldState, groupRootBaseline, onTurnIdAvailable) {
   let pendingMcpAuth;
   let sandboxId;
   let sandboxIdYielded = false;
@@ -2239,6 +2369,10 @@ async function* streamTurnEvents(stream, foldState, groupRootBaseline) {
   };
   for await (const data of stream) {
     const event = data.event;
+    if (event.type === "turn.created") {
+      onTurnIdAvailable?.(event.turnId);
+      continue;
+    }
     if (event.type === "sandbox.created") {
       sandboxId = event.sandboxId;
       continue;
@@ -2326,30 +2460,25 @@ function repositoryItemsFromMessages(messages) {
   return items;
 }
 
-// src/private/getGatewayFromPrivateClient.ts
-function getGatewayFromPrivateClient(privateClient) {
-  const internal = privateClient;
-  if (internal.client == null) {
-    throw new Error("PrivateAgentSessionClient is missing an internal gateway client.");
-  }
-  return internal.client;
-}
-
 // src/private/draftSessionBridge.ts
 var DRAFT_SESSION_LAST_UPDATED_AT_HEADER = "x-tfy-session-last-updated-at";
-function createDraftSessionBridge(privateClient) {
+function createDraftSessionBridge(server) {
   return {
     async getDraftAgentSpec(draftSessionId) {
-      const draft = await privateClient.getDraftSession({ draftSessionId });
-      return draft.agentSpec;
+      const session = await server.getSession({ sessionId: draftSessionId });
+      if (session.agentSpec == null) {
+        throw new Error(
+          `Session ${draftSessionId} has no agentSpec (isMutable=${session.isMutable}).`
+        );
+      }
+      return session.agentSpec;
     },
     async syncAgentSpec(draftSessionId, agentSpec) {
-      const gateway = getGatewayFromPrivateClient(privateClient);
-      const response = await gateway.agents.private.draftSessions.update(
-        draftSessionId,
-        { agentSpec }
-      );
-      return response.data.updatedAt;
+      const updated = await server.updateSession({
+        sessionId: draftSessionId,
+        agentSpec
+      });
+      return updated.updatedAt;
     }
   };
 }
@@ -2385,39 +2514,43 @@ function sessionListStartTimestamp() {
 // src/private/truefoundryDraftThreadListAdapter.ts
 var THREAD_LIST_PAGE_SIZE = 20;
 function createTrueFoundryDraftThreadListAdapter(options) {
-  const { privateClient, defaultAgentSpec, getAgentSpec } = options;
+  const { server, defaultAgentSpec, getAgentSpec } = options;
   return {
     async list({ after } = {}) {
-      const page = await privateClient.listDraftSessions({
+      const page = await server.listSessions({
         limit: THREAD_LIST_PAGE_SIZE,
         pageToken: after,
         startTimestamp: sessionListStartTimestamp()
       });
-      const threads = page.data.map((draft) => ({
+      const threads = page.data.filter((session) => session.isMutable).map((draft) => ({
         status: "regular",
         remoteId: draft.id,
-        title: draftSessionTitle(draft),
+        title: draftSessionTitle({
+          title: draft.title,
+          agentSpec: draft.agentSpec ?? defaultAgentSpec
+        }),
         lastMessageAt: new Date(draft.updatedAt)
       }));
       return {
         threads,
-        nextCursor: page.response.pagination.nextPageToken ?? void 0
+        nextCursor: page.nextPageToken ?? void 0
       };
     },
     async initialize(_threadId) {
-      const draft = await privateClient.createDraftSession({
+      const draft = await server.createSession({
         agentSpec: getAgentSpec?.() ?? defaultAgentSpec
       });
       return { remoteId: draft.id, externalId: void 0 };
     },
     async fetch(remoteId) {
-      const draft = await privateClient.getDraftSession({
-        draftSessionId: remoteId
-      });
+      const draft = await server.getSession({ sessionId: remoteId });
       return {
         status: "regular",
         remoteId: draft.id,
-        title: draftSessionTitle(draft),
+        title: draftSessionTitle({
+          title: draft.title,
+          agentSpec: draft.agentSpec ?? defaultAgentSpec
+        }),
         lastMessageAt: new Date(draft.updatedAt)
       };
     },
@@ -2450,30 +2583,12 @@ var EMPTY_DRAFT_EXTRAS = {
   }
 };
 
-// src/private/bindDraftAgentSession.ts
-var inflightByDraftId = /* @__PURE__ */ new Map();
-async function bindDraftAgentSession(privateClient, draftSessionId) {
-  let inflight = inflightByDraftId.get(draftSessionId);
-  if (inflight == null) {
-    inflight = privateClient.getDraftSession({ draftSessionId }).then((draft) => draft).finally(() => {
-      if (inflightByDraftId.get(draftSessionId) === inflight) {
-        inflightByDraftId.delete(draftSessionId);
-      }
-    });
-    inflightByDraftId.set(draftSessionId, inflight);
-  }
-  return inflight;
-}
-
 // src/sessions.ts
 var inflightBySessionId = /* @__PURE__ */ new Map();
-function getSession(client, sessionId, options) {
-  if (options?.privateClient != null) {
-    return bindDraftAgentSession(options.privateClient, sessionId);
-  }
+function getSession(server, sessionId) {
   let inflight = inflightBySessionId.get(sessionId);
   if (inflight == null) {
-    inflight = client.getSession({ sessionId }).finally(() => {
+    inflight = server.getSession({ sessionId }).finally(() => {
       if (inflightBySessionId.get(sessionId) === inflight) {
         inflightBySessionId.delete(sessionId);
       }
@@ -2486,10 +2601,10 @@ function getSession(client, sessionId, options) {
 // src/truefoundryThreadListAdapter.ts
 var THREAD_LIST_PAGE_SIZE2 = 20;
 function createTrueFoundryThreadListAdapter(options) {
-  const { client, agentName } = options;
+  const { server, agentName } = options;
   return {
     async list({ after } = {}) {
-      const page = await client.listSessions({
+      const page = await server.listSessions({
         agentName,
         limit: THREAD_LIST_PAGE_SIZE2,
         pageToken: after,
@@ -2498,24 +2613,24 @@ function createTrueFoundryThreadListAdapter(options) {
       const threads = page.data.map((session) => ({
         status: "regular",
         remoteId: session.id,
-        title: session.title,
+        title: session.title ?? void 0,
         lastMessageAt: new Date(session.updatedAt)
       }));
       return {
         threads,
-        nextCursor: page.response.pagination.nextPageToken ?? void 0
+        nextCursor: page.nextPageToken ?? void 0
       };
     },
     async initialize(_threadId) {
-      const session = await client.createSession({ agentName });
+      const session = await server.createSession({ agentName });
       return { remoteId: session.id, externalId: void 0 };
     },
     async fetch(remoteId) {
-      const session = await getSession(client, remoteId);
+      const session = await getSession(server, remoteId);
       return {
         status: "regular",
         remoteId: session.id,
-        title: session.title,
+        title: session.title ?? void 0,
         lastMessageAt: new Date(session.updatedAt)
       };
     },
@@ -2550,15 +2665,9 @@ function resolveTrueFoundryAgentConfig(options) {
 }
 function resolveTrueFoundryAgentRuntimeOptions(options) {
   const agent = resolveTrueFoundryAgentConfig(options);
-  if (agent.mode === "draft" && options.privateClient == null) {
-    throw new Error(
-      "Draft agent mode requires a `privateClient` PrivateAgentSessionClient."
-    );
-  }
   return {
     ...options,
-    agent,
-    privateClient: options.privateClient
+    agent
   };
 }
 
@@ -2769,18 +2878,15 @@ import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMem
 
 // src/loadSessionSnapshot.ts
 var inflightBySessionId2 = /* @__PURE__ */ new Map();
-function loadSessionSnapshot(client, sessionId, sessionOptions, onProgress) {
-  const cacheKey = sessionOptions?.privateClient != null ? `draft:${sessionId}` : sessionId;
-  let inflight = inflightBySessionId2.get(cacheKey);
+function loadSessionSnapshot(server, sessionId, onProgress) {
+  let inflight = inflightBySessionId2.get(sessionId);
   if (inflight == null) {
-    inflight = getSession(client, sessionId, sessionOptions).then(
-      (session) => buildSnapshotFromSessionEvents(session, onProgress)
-    ).finally(() => {
-      if (inflightBySessionId2.get(cacheKey) === inflight) {
-        inflightBySessionId2.delete(cacheKey);
+    inflight = getSession(server, sessionId).then(() => buildSnapshotFromSessionEvents(server, sessionId, onProgress)).finally(() => {
+      if (inflightBySessionId2.get(sessionId) === inflight) {
+        inflightBySessionId2.delete(sessionId);
       }
     });
-    inflightBySessionId2.set(cacheKey, inflight);
+    inflightBySessionId2.set(sessionId, inflight);
   }
   return inflight;
 }
@@ -2818,9 +2924,9 @@ function buildTurnInput(options) {
   }
   return [{ type: "user.message", content: options.userMessage ?? "" }];
 }
-function bindAbort(session, abortSignal) {
+function bindAbort(server, sessionId, abortSignal) {
   const onAbort = () => {
-    void session.cancel().catch(() => void 0);
+    void server.cancelSession({ sessionId }).catch(() => void 0);
   };
   if (abortSignal.aborted) {
     onAbort();
@@ -2829,41 +2935,35 @@ function bindAbort(session, abortSignal) {
   abortSignal.addEventListener("abort", onAbort, { once: true });
   return onAbort;
 }
-async function* streamTurnContent(session, foldState, options, abortSignal, groupRootBaseline, onTurnIdAvailable) {
-  const previousTurnId = options.previousTurnId === null ? null : options.previousTurnId ?? "auto";
-  const turn = session.prepareTurn({
-    input: buildTurnInput(options),
-    ...previousTurnId !== void 0 ? { previousTurnId } : {}
-  });
-  const onAbort = bindAbort(session, abortSignal);
+async function* streamTurnContent(server, sessionId, foldState, options, abortSignal, groupRootBaseline, onTurnIdAvailable) {
+  const onAbort = bindAbort(server, sessionId, abortSignal);
   if (abortSignal.aborted) {
     return;
   }
   let turnIdNotified = false;
-  const notifyTurnIdIfAvailable = () => {
-    if (!turnIdNotified && turn.id != null) {
-      onTurnIdAvailable?.(turn.id);
+  const notifyTurnId = (turnId) => {
+    if (!turnIdNotified) {
+      onTurnIdAvailable?.(turnId);
       turnIdNotified = true;
     }
   };
+  const stream = server.prepareAndExecuteTurn({
+    sessionId,
+    input: buildTurnInput(options),
+    previousTurnId: options.previousTurnId ?? "auto",
+    abortSignal,
+    ...options.headers != null ? { headers: options.headers } : {}
+  });
   try {
     for await (const update of streamTurnEvents(
-      turn.execute(
-        { stream: true },
-        {
-          abortSignal,
-          ...options.headers != null ? { headers: options.headers } : {}
-        }
-      ),
+      stream,
       foldState,
-      groupRootBaseline
+      groupRootBaseline,
+      notifyTurnId
     )) {
-      notifyTurnIdIfAvailable();
       yield update;
     }
-    notifyTurnIdIfAvailable();
   } catch (error) {
-    notifyTurnIdIfAvailable();
     if (error instanceof Error && error.name === "AbortError") {
       return;
     }
@@ -2872,9 +2972,14 @@ async function* streamTurnContent(session, foldState, options, abortSignal, grou
     abortSignal.removeEventListener("abort", onAbort);
   }
 }
-async function* resumeTurnStream(turn, foldState, abortSignal, afterSequenceNumber, groupRootBaseline) {
+async function* resumeTurnStream(server, sessionId, turnId, foldState, abortSignal, afterSequenceNumber, groupRootBaseline) {
+  if (server.subscribeToTurn == null) {
+    throw new Error(
+      "resumeTurnStream requires AgentChatServer.subscribeToTurn"
+    );
+  }
   const onAbort = () => {
-    void turn.session.cancel().catch(() => void 0);
+    void server.cancelSession({ sessionId }).catch(() => void 0);
   };
   if (abortSignal.aborted) {
     onAbort();
@@ -2883,10 +2988,12 @@ async function* resumeTurnStream(turn, foldState, abortSignal, afterSequenceNumb
   abortSignal.addEventListener("abort", onAbort, { once: true });
   try {
     yield* streamTurnEvents(
-      turn.stream(
-        afterSequenceNumber != null ? { afterSequenceNumber } : {},
-        { abortSignal }
-      ),
+      server.subscribeToTurn({
+        sessionId,
+        turnId,
+        ...afterSequenceNumber != null ? { afterSequenceNumber } : {},
+        abortSignal
+      }),
       foldState,
       groupRootBaseline
     );
@@ -3022,20 +3129,15 @@ function resolveTurnInput(snapshot, turnId) {
   return void 0;
 }
 function useTrueFoundryAgentMessages({
-  client,
+  server,
   sessionId,
   isMain,
   listEventsConcurrency,
   onError,
   initializeSession,
   resolveConversationSessionId,
-  privateClient,
   getTurnHeaders
 }) {
-  const sessionOptions = useMemo2(
-    () => privateClient != null ? { privateClient } : void 0,
-    [privateClient]
-  );
   const [snapshot, setSnapshot] = useState2(createEmptySessionSnapshot);
   const [isRunning, setIsRunning] = useState2(false);
   const [isLoading, setIsLoading] = useState2(false);
@@ -3195,9 +3297,8 @@ function useTrueFoundryAgentMessages({
         resolveConversationSessionIdRef.current
       );
       const loadedSnapshot = await loadSessionSnapshot(
-        client,
+        server,
         conversationSessionId,
-        sessionOptions,
         (snap) => {
           if (generation === loadGenerationRef.current) {
             setSnapshot(snap);
@@ -3216,7 +3317,9 @@ function useTrueFoundryAgentMessages({
         const isContinuation = !extractTurnUserText(turn.input);
         void runStream(
           (signal) => resumeTurnStream(
-            turn,
+            server,
+            conversationSessionId,
+            turn.id,
             loadedSnapshot.fold,
             signal,
             void 0,
@@ -3236,7 +3339,7 @@ function useTrueFoundryAgentMessages({
         setIsLoading(false);
       }
     }
-  }, [client, runStream, sessionId, sessionOptions, loadRetryTrigger, isMain]);
+  }, [server, runStream, sessionId, loadRetryTrigger, isMain]);
   useEffect2(() => {
     void load().catch(() => void 0);
   }, [load]);
@@ -3255,7 +3358,6 @@ function useTrueFoundryAgentMessages({
         activeSessionId,
         resolveConversationSessionIdRef.current
       );
-      const session = await getSession(client, conversationSessionId, sessionOptions);
       const turnHeaders = await getTurnHeadersRef.current?.();
       const streamHeaders = turnHeaders != null ? { headers: turnHeaders } : {};
       const isContinuation = "inputs" in options || "resumeMcpAuth" in options && options.resumeMcpAuth === true;
@@ -3316,7 +3418,8 @@ function useTrueFoundryAgentMessages({
         (signal) => {
           if ("inputs" in options) {
             return streamTurnContent(
-              session,
+              server,
+              conversationSessionId,
               snapshotRef.current.fold,
               { inputs: options.inputs, ...streamHeaders },
               signal,
@@ -3325,7 +3428,8 @@ function useTrueFoundryAgentMessages({
           }
           if ("resumeMcpAuth" in options) {
             return streamTurnContent(
-              session,
+              server,
+              conversationSessionId,
               snapshotRef.current.fold,
               { resumeMcpAuth: true, ...streamHeaders },
               signal,
@@ -3333,11 +3437,12 @@ function useTrueFoundryAgentMessages({
             );
           }
           return streamTurnContent(
-            session,
+            server,
+            conversationSessionId,
             snapshotRef.current.fold,
             {
               userMessage: options.userMessage,
-              ...options.previousTurnId !== void 0 ? { previousTurnId: options.previousTurnId } : isFirstTurnInSession ? { previousTurnId: null } : {},
+              ...options.previousTurnId !== void 0 ? { previousTurnId: options.previousTurnId ?? "none" } : isFirstTurnInSession ? { previousTurnId: "none" } : {},
               ...streamHeaders
             },
             signal,
@@ -3363,7 +3468,7 @@ function useTrueFoundryAgentMessages({
         isContinuation
       );
     },
-    [client, runStream, sessionId, sessionOptions]
+    [server, runStream, sessionId]
   );
   const cancel = useCallback2(async () => {
     if (sessionId == null) {
@@ -3374,10 +3479,9 @@ function useTrueFoundryAgentMessages({
       sessionId,
       resolveConversationSessionIdRef.current
     );
-    const session = await getSession(client, conversationSessionId, sessionOptions);
-    await session.cancel().catch(() => void 0);
+    await server.cancelSession({ sessionId: conversationSessionId }).catch(() => void 0);
     await activeRunRef.current?.catch(() => void 0);
-  }, [client, sessionId, sessionOptions]);
+  }, [server, sessionId]);
   const isRunningRef = useRef2(isRunning);
   isRunningRef.current = isRunning;
   const trySendCollectedRequiredActions = useCallback2(
@@ -3439,7 +3543,9 @@ function useTrueFoundryAgentMessages({
     }
     await runStream(
       (signal) => resumeTurnStream(
-        turn,
+        server,
+        turn.sessionId,
+        turn.id,
         snapshotRef.current.fold,
         signal,
         void 0,
@@ -3448,7 +3554,7 @@ function useTrueFoundryAgentMessages({
       { current: turn.id },
       true
     );
-  }, [runStream]);
+  }, [runStream, server]);
   const branchFromTurn = useCallback2(
     async (turnId, userMessage) => {
       let activeSessionId = sessionId;
@@ -3462,13 +3568,14 @@ function useTrueFoundryAgentMessages({
         activeSessionId,
         resolveConversationSessionIdRef.current
       );
-      const session = await getSession(client, conversationSessionId, sessionOptions);
       const previousTurnId = await resolveGatewayBranchPreviousTurnIdForTurn(
-        session,
+        server,
+        conversationSessionId,
         turnId
       );
       const rewound = await buildSnapshotBeforeTurn(
-        session,
+        server,
+        conversationSessionId,
         turnId,
         listEventsConcurrency
       );
@@ -3483,11 +3590,10 @@ function useTrueFoundryAgentMessages({
     },
     [
       cancel,
-      client,
+      server,
       listEventsConcurrency,
       sendTurn,
-      sessionId,
-      sessionOptions
+      sessionId
     ]
   );
   const resetFromTurn = useCallback2(
@@ -3543,13 +3649,9 @@ function useTrueFoundryAgentMessages({
           sessionId,
           resolveConversationSessionIdRef.current
         );
-        const session = await getSession(
-          client,
-          conversationSessionId,
-          sessionOptions
-        );
         const next = await prependOlderSessionHistory(
-          session,
+          server,
+          conversationSessionId,
           snapshotRef.current
         );
         if (generation !== loadGenerationRef.current) {
@@ -3570,7 +3672,7 @@ function useTrueFoundryAgentMessages({
     })();
     loadOlderInflightRef.current = run;
     return run;
-  }, [client, isMain, sessionId, sessionOptions]);
+  }, [server, isMain, sessionId]);
   return {
     messages,
     isRunning,
@@ -3593,16 +3695,15 @@ function useTrueFoundryAgentMessages({
 // src/useTrueFoundryAgentRuntime.ts
 function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
   const {
-    client,
+    server,
     agent,
-    privateClient,
     adapters,
     onError,
     listEventsConcurrency,
     ...sharedOptions
   } = options;
   const draftBridgeRef = useRef3(
-    agent.mode === "draft" && privateClient != null ? createDraftSessionBridge(privateClient) : null
+    agent.mode === "draft" ? createDraftSessionBridge(server) : null
   );
   const draftSessionId = useAuiState(
     (state) => agent.mode === "draft" ? state.threadListItem.remoteId ?? void 0 : void 0
@@ -3653,13 +3754,12 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
     resetFromTurn,
     retryLoad
   } = useTrueFoundryAgentMessages({
-    client,
+    server,
     sessionId,
     isMain,
     listEventsConcurrency,
     onError,
     initializeSession,
-    privateClient: agent.mode === "draft" ? privateClient : void 0,
     getTurnHeaders: agent.mode === "draft" ? getTurnHeaders : void 0
   });
   if (agent.mode === "draft" && draftSpec.agentSpec != null) {
@@ -3681,9 +3781,9 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
   );
   const downloadSandboxFile = useCallback3(
     async (path) => {
-      if (privateClient == null) {
+      if (server.downloadSandboxFile == null) {
         const error = new Error(
-          "Downloading a sandbox file requires a `privateClient` PrivateAgentSessionClient."
+          "Downloading a sandbox file requires AgentChatServer.downloadSandboxFile."
         );
         onError?.(error);
         throw error;
@@ -3693,10 +3793,9 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
         onError?.(error);
         throw error;
       }
-      const response = await privateClient.downloadSandboxFile(sandboxId, { path });
-      return await response.blob();
+      return await server.downloadSandboxFile(sandboxId, { path });
     },
-    [privateClient, sandboxId, onError]
+    [server, sandboxId, onError]
   );
   const draftExtras = useMemo3(() => {
     if (agent.mode !== "draft") {
@@ -3781,7 +3880,7 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
 }
 function useTrueFoundryAgentRuntime(options) {
   const resolved = resolveTrueFoundryAgentRuntimeOptions(options);
-  const { client, agent, privateClient } = resolved;
+  const { server, agent } = resolved;
   const pendingAgentSpecRef = useRef3(
     agent.mode === "draft" ? agent.defaultAgentSpec : void 0
   );
@@ -3789,23 +3888,18 @@ function useTrueFoundryAgentRuntime(options) {
   const namedAgentName = agent.mode === "named" ? agent.agentName : void 0;
   const threadListAdapter = useMemo3(() => {
     if (agentMode === "draft") {
-      if (privateClient == null) {
-        throw new Error(
-          "Draft agent mode requires a `privateClient` PrivateAgentSessionClient."
-        );
-      }
       const draftAgent = agent;
       return createTrueFoundryDraftThreadListAdapter({
-        privateClient,
+        server,
         defaultAgentSpec: draftAgent.defaultAgentSpec,
         getAgentSpec: () => pendingAgentSpecRef.current ?? draftAgent.defaultAgentSpec
       });
     }
     return createTrueFoundryThreadListAdapter({
-      client,
+      server,
       agentName: namedAgentName
     });
-  }, [agentMode, namedAgentName, client, privateClient]);
+  }, [agentMode, namedAgentName, server]);
   return useRemoteThreadListRuntime({
     allowNesting: true,
     adapter: threadListAdapter,
@@ -3819,16 +3913,19 @@ function useTrueFoundryAgentRuntime(options) {
 // src/truefoundryOwnedSessionsThreadListAdapter.ts
 var THREAD_LIST_PAGE_SIZE3 = 20;
 function ownedSessionTitle(session) {
-  if (session.type === "session/draft") {
-    return draftSessionTitle(session);
+  if (session.isMutable && session.agentSpec != null) {
+    return draftSessionTitle({
+      title: session.title,
+      agentSpec: session.agentSpec
+    });
   }
-  return session.title ?? session.agentName;
+  return session.title ?? session.agentName ?? session.id;
 }
 function createTrueFoundryOwnedSessionsThreadListAdapter(options) {
-  const { privateClient } = options;
+  const { server } = options;
   return {
     async list({ after } = {}) {
-      const page = await privateClient.listOwnedSessions({
+      const page = await server.listSessions({
         limit: THREAD_LIST_PAGE_SIZE3,
         pageToken: after,
         startTimestamp: sessionListStartTimestamp()
@@ -3841,7 +3938,7 @@ function createTrueFoundryOwnedSessionsThreadListAdapter(options) {
       }));
       return {
         threads,
-        nextCursor: page.response.pagination.nextPageToken ?? void 0
+        nextCursor: page.nextPageToken ?? void 0
       };
     },
     async initialize() {
@@ -3850,14 +3947,12 @@ function createTrueFoundryOwnedSessionsThreadListAdapter(options) {
       );
     },
     async fetch(remoteId) {
-      const draft = await privateClient.getDraftSession({
-        draftSessionId: remoteId
-      });
+      const session = await server.getSession({ sessionId: remoteId });
       return {
         status: "regular",
-        remoteId: draft.id,
-        title: draftSessionTitle(draft),
-        lastMessageAt: new Date(draft.updatedAt)
+        remoteId: session.id,
+        title: ownedSessionTitle(session),
+        lastMessageAt: new Date(session.updatedAt)
       };
     },
     async rename() {
@@ -3874,9 +3969,6 @@ function createTrueFoundryOwnedSessionsThreadListAdapter(options) {
   };
 }
 
-// src/index.ts
-import { PrivateAgentSessionClient } from "truefoundry-gateway-sdk/agents/private";
-
 // src/hooks.ts
 import { useMemo as useMemo4 } from "react";
 import { useAui as useAui2 } from "@assistant-ui/store";
@@ -4021,7 +4113,6 @@ var trueFoundryAttachmentAdapter = {
   }
 };
 export {
-  PrivateAgentSessionClient,
   ROOT_THREAD_ID,
   TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY,
   buildEditedUserMessageContent,
@@ -4039,7 +4130,9 @@ export {
   findPausedAssistantMessage,
   getSession,
   getTurnMessageContent,
+  isEventDelta,
   mergeAgentSpec,
+  mergeEventDelta,
   messageHasPendingApprovals,
   messageHasPendingRequiredActions,
   messageHasPendingResponses,