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

package/dist/index.js

@@ -0,0 +1,4440 @@
+// src/useTrueFoundryAgentRuntime.ts
+import {
+  pickExternalStoreSharedOptions
+} from "@assistant-ui/core";
+import {
+  useExternalStoreRuntime,
+  useRemoteThreadListRuntime,
+  useRuntimeAdapters
+} from "@assistant-ui/core/react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+import { useCallback as useCallback3, useMemo as useMemo3, useRef as useRef3, useState as useState3 } from "react";
+
+// src/constants.ts
+var ROOT_THREAD_ID = "main";
+
+// src/toolApproval.ts
+var TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY = "toolApprovalThreadId";
+function hasPendingToolApproval(approval) {
+  return approval != null && approval.approved === void 0 && approval.resolution === void 0;
+}
+function applyApprovalDecisionToToolCall(part, options) {
+  const { approved, optionId, reason } = options;
+  const targetApproval = part.approval;
+  const approval = {
+    ...targetApproval,
+    approved,
+    ...optionId != null ? { optionId } : {},
+    ...reason != null ? { reason } : {}
+  };
+  if (approved) {
+    return { ...part, approval };
+  }
+  return {
+    ...part,
+    approval,
+    result: { error: reason || "Tool approval denied" },
+    isError: true
+  };
+}
+function updateToolApprovalInContent(content, options) {
+  let found = false;
+  const newContent = content.map((part) => {
+    if (part.type !== "tool-call") {
+      return part;
+    }
+    if (part.approval?.id === options.approvalId) {
+      found = true;
+      return applyApprovalDecisionToToolCall(part, options);
+    }
+    if (part.messages == null) {
+      return part;
+    }
+    const messages = part.messages.map((message) => {
+      if (message.role !== "assistant") {
+        return message;
+      }
+      const nested = updateToolApprovalInContent(message.content, options);
+      if (!nested.found) {
+        return message;
+      }
+      found = true;
+      return { ...message, content: nested.content };
+    });
+    return { ...part, messages };
+  });
+  return { content: newContent, found };
+}
+function applyApprovalDecisionsToMessage(message, options) {
+  const { content } = updateToolApprovalInContent(message.content, options);
+  return { ...message, content: [...content] };
+}
+function toolApprovalStatus() {
+  return { type: "requires-action", reason: "tool-calls" };
+}
+function toolApprovalMessageCustom(threadId) {
+  return {
+    [TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY]: threadId === ROOT_THREAD_ID ? ROOT_THREAD_ID : threadId
+  };
+}
+function getToolApprovalThreadId(message) {
+  if (message?.role !== "assistant") {
+    return void 0;
+  }
+  const threadId = message.metadata.custom[TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY];
+  return typeof threadId === "string" ? threadId : void 0;
+}
+function findApprovalRequiredInTurn(turn) {
+  if (turn.state.status !== "done") {
+    return void 0;
+  }
+  return turn.state.requiredActions?.find(
+    (action) => action.type === "tool.approval_required"
+  );
+}
+function toolCallPartHasPendingApproval(part) {
+  return hasPendingToolApproval(part.approval);
+}
+function nestedMessagesHavePendingApprovals(messages) {
+  for (const message of messages) {
+    if (messageHasPendingApprovals(message)) {
+      return true;
+    }
+  }
+  return false;
+}
+function messageHasPendingApprovals(message) {
+  if (message?.role !== "assistant") {
+    return false;
+  }
+  for (const part of message.content) {
+    if (part.type !== "tool-call") {
+      continue;
+    }
+    if (toolCallPartHasPendingApproval(part)) {
+      return true;
+    }
+    if (part.messages != null && nestedMessagesHavePendingApprovals(part.messages)) {
+      return true;
+    }
+  }
+  return false;
+}
+function applyApprovalDecisionsToMessages(messages, decisions) {
+  return messages.map((message) => {
+    if (message.role !== "assistant") {
+      return message;
+    }
+    return {
+      ...message,
+      content: applyApprovalDecisionsToContent(message.content, decisions)
+    };
+  });
+}
+function applyApprovalDecisionsToContent(content, decisions) {
+  return content.map((part) => {
+    if (part.type !== "tool-call") {
+      return part;
+    }
+    const decision = part.approval?.id != null ? decisions.get(part.approval.id) : void 0;
+    let nextPart = part;
+    if (decision != null && part.approval != null && part.approval.approved === void 0) {
+      nextPart = applyApprovalDecisionToToolCall(part, {
+        approvalId: part.approval.id,
+        approved: decision.approved,
+        reason: decision.reason
+      });
+    }
+    if (nextPart.messages == null) {
+      return nextPart;
+    }
+    return {
+      ...nextPart,
+      messages: applyApprovalDecisionsToMessages(nextPart.messages, decisions)
+    };
+  });
+}
+function extractToolApprovalsFromTurnInput(input) {
+  const events = [];
+  for (const item of input ?? []) {
+    if (item.type === "user.tool_approval") {
+      events.push(item);
+    }
+  }
+  return events;
+}
+function collectSubsequentApprovalDecisions(turns, fromIndex) {
+  const decisions = /* @__PURE__ */ new Map();
+  for (let index = fromIndex + 1; index < turns.length; index++) {
+    const input = turns[index]?.input ?? [];
+    if (input.some((item) => item.type === "user.message")) {
+      break;
+    }
+    for (const event of extractToolApprovalsFromTurnInput(input)) {
+      decisions.set(event.toolCallId, {
+        approved: event.approval.status === "allow",
+        ...event.approval.status === "deny" && event.approval.reason != null ? { reason: event.approval.reason } : {}
+      });
+    }
+  }
+  return decisions;
+}
+function collectApprovalDecisionsFromTurnInput(input) {
+  const decisions = /* @__PURE__ */ new Map();
+  for (const event of extractToolApprovalsFromTurnInput(input)) {
+    decisions.set(event.toolCallId, {
+      approved: event.approval.status === "allow",
+      ...event.approval.status === "deny" && event.approval.reason != null ? { reason: event.approval.reason } : {}
+    });
+  }
+  return decisions;
+}
+function mapApprovalDecision(approved, reason) {
+  if (approved) {
+    return { status: "allow" };
+  }
+  return { status: "deny", ...reason != null ? { reason } : {} };
+}
+function isDecidedApprovalAwaitingSdk(part) {
+  const { approval, result, isError } = part;
+  if (approval?.id == null || approval.approved === void 0) {
+    return false;
+  }
+  if (approval.approved === true) {
+    return result === void 0;
+  }
+  return isError === true;
+}
+function collectApprovalInputsFromMessages(messages, defaultThreadId) {
+  const events = [];
+  for (const message of messages) {
+    events.push(...collectApprovalInputs(message, defaultThreadId));
+  }
+  return events;
+}
+function collectApprovalInputs(message, threadId) {
+  if (message.role !== "assistant" || !threadId) {
+    return [];
+  }
+  if (messageHasPendingApprovals(message)) {
+    return [];
+  }
+  const scopedThreadId = getToolApprovalThreadId(message) ?? threadId;
+  const events = [];
+  for (const part of message.content) {
+    if (part.type !== "tool-call") {
+      continue;
+    }
+    if (isDecidedApprovalAwaitingSdk(part)) {
+      const { approval } = part;
+      if (approval == null) {
+        continue;
+      }
+      events.push({
+        type: "user.tool_approval",
+        threadId: scopedThreadId,
+        toolCallId: approval.id,
+        approval: mapApprovalDecision(approval.approved, approval.reason)
+      });
+    }
+    if (part.messages != null) {
+      events.push(
+        ...collectApprovalInputsFromMessages(part.messages, scopedThreadId)
+      );
+    }
+  }
+  return events;
+}
+function toTrueFoundryApprovalInputs(message, response, defaultThreadId = ROOT_THREAD_ID) {
+  const updated = applyApprovalDecisionsToMessage(message, response);
+  return collectApprovalInputs(updated, defaultThreadId);
+}
+
+// src/foldPeerThreads.ts
+import {
+  isEventDelta as isEventDelta2
+} from "truefoundry-gateway-sdk/agents";
+
+// src/askUserQuestion.ts
+function parseAskUserQuestionArgs(argsText) {
+  if (!argsText) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(argsText);
+    if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    const record = parsed;
+    const question = typeof record.question === "string" ? record.question : void 0;
+    const options = Array.isArray(record.options) ? record.options.filter((item) => typeof item === "string") : void 0;
+    return { question, options };
+  } catch {
+    return {};
+  }
+}
+
+// src/createSubAgent.ts
+function isCreateSubAgentToolCall(toolCall) {
+  return toolCall.toolInfo.type === "truefoundry-system" && toolCall.toolInfo.name === "create_sub_agent";
+}
+
+// src/modelMessageImageContent.ts
+import { isEventDelta, mergeEventDelta } from "truefoundry-gateway-sdk/agents";
+function parseDataUriMime(data) {
+  if (!data.startsWith("data:")) {
+    return "image/png";
+  }
+  const match = /^data:([^;,]+)/.exec(data);
+  return match?.[1] ?? "image/png";
+}
+function imageFilenameFromUrl(url, index) {
+  const mimeType = parseDataUriMime(url);
+  const ext = mimeType.split("/")[1] ?? "png";
+  return `image-${index + 1}.${ext}`;
+}
+function isImageUrlContentPart(part) {
+  return part != null && typeof part === "object" && part.type === "image_url" && typeof part.image_url?.url === "string";
+}
+function normalizeModelMessageContent(message) {
+  const { content } = message;
+  if (content == null) {
+    return [];
+  }
+  if (typeof content === "string") {
+    return content.length > 0 ? [{ type: "text", text: content }] : [];
+  }
+  return content;
+}
+function ensureModelMessageContentArray(message) {
+  if (Array.isArray(message.content)) {
+    return;
+  }
+  message.content = normalizeModelMessageContent(message);
+}
+function mergeContentBlockDeltas(message, blocks) {
+  ensureModelMessageContentArray(message);
+  const content = message.content;
+  for (const block of blocks) {
+    const index = block.index;
+    while (content.length <= index) {
+      content.push({ type: "text", text: "" });
+    }
+    const delta = block.delta;
+    if (delta.type === "text") {
+      const existing2 = content[index];
+      if (existing2?.type === "text") {
+        existing2.text += delta.text ?? "";
+      } else {
+        content[index] = { type: "text", text: delta.text ?? "" };
+      }
+      continue;
+    }
+    if (delta.type !== "image_url") {
+      continue;
+    }
+    const chunk = delta.image_url?.url ?? "";
+    const existing = content[index];
+    if (isImageUrlContentPart(existing)) {
+      existing.image_url.url += chunk;
+    } else {
+      content[index] = { type: "image_url", image_url: { url: chunk } };
+    }
+  }
+}
+function mergeStreamEventDelta(base, delta) {
+  if (!isEventDelta(delta)) {
+    return;
+  }
+  mergeEventDelta(base, delta);
+  if (base.type !== "model.message" || delta.type !== "model.message.delta") {
+    return;
+  }
+  const extended = delta;
+  const blocks = extended.contentBlocks ?? extended.content_blocks;
+  if (blocks == null || blocks.length === 0) {
+    return;
+  }
+  mergeContentBlockDeltas(base, blocks);
+}
+function imageUrlToAttachment(url, attachmentId) {
+  const mimeType = parseDataUriMime(url);
+  return {
+    id: attachmentId,
+    type: "image",
+    name: imageFilenameFromUrl(url, 0),
+    contentType: mimeType,
+    status: { type: "complete" },
+    content: [{ type: "image", image: url, filename: imageFilenameFromUrl(url, 0) }]
+  };
+}
+function imagePartToAssistantImage(url, index) {
+  return {
+    type: "image",
+    image: url,
+    filename: imageFilenameFromUrl(url, index)
+  };
+}
+function extractImagePartsFromModelMessage(message) {
+  const parts = [];
+  let imageIndex = 0;
+  for (const part of normalizeModelMessageContent(message)) {
+    if (!isImageUrlContentPart(part)) {
+      continue;
+    }
+    const url = part.image_url.url.trim();
+    if (url.length === 0) {
+      continue;
+    }
+    parts.push(imagePartToAssistantImage(url, imageIndex));
+    imageIndex += 1;
+  }
+  return parts;
+}
+function extractImageUrlFromUserContentItem(part) {
+  if (isImageUrlContentPart(part)) {
+    const url = part.image_url.url.trim();
+    return url.length > 0 ? url : void 0;
+  }
+  return void 0;
+}
+
+// src/modelMessageContent.ts
+function parseToolArgs(argsText) {
+  if (!argsText) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(argsText);
+    if (parsed != null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function toolCallToPart(toolCall, context) {
+  const argsText = toolCall.function.arguments ?? "";
+  const toolResult = context?.toolResults?.get(toolCall.id);
+  const pendingResponse = context?.pendingResponses?.get(toolCall.id);
+  const pendingApproval = context?.pendingApprovals?.get(toolCall.id);
+  const approvalDecision = context?.approvalDecisions?.get(toolCall.id);
+  let interrupt;
+  if (pendingResponse != null && toolResult === void 0) {
+    interrupt = {
+      type: "human",
+      payload: {
+        ...pendingResponse.question != null ? { question: pendingResponse.question } : {},
+        ...pendingResponse.options != null ? { options: pendingResponse.options } : {}
+      }
+    };
+  }
+  let approval;
+  if (approvalDecision != null) {
+    approval = {
+      id: approvalDecision.id,
+      approved: approvalDecision.approved,
+      ...approvalDecision.reason != null ? { reason: approvalDecision.reason } : {}
+    };
+  } else if (pendingApproval != null) {
+    approval = { id: pendingApproval.id };
+  }
+  let result;
+  let isError = false;
+  if (toolResult !== void 0) {
+    result = toolResult;
+  } else if (approvalDecision?.approved === false) {
+    result = { error: approvalDecision.reason || "Tool approval denied" };
+    isError = true;
+  }
+  return {
+    type: "tool-call",
+    toolCallId: toolCall.id,
+    toolName: toolCall.function.name,
+    argsText,
+    args: parseToolArgs(argsText),
+    ...result !== void 0 ? { result } : {},
+    ...isError ? { isError: true } : {},
+    ...approval != null ? { approval } : {},
+    ...interrupt != null ? { interrupt } : {}
+  };
+}
+function extractText(message) {
+  const { content, refusal } = message;
+  if (content == null) {
+    return refusal ?? "";
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    if (part.type === "text") {
+      return part.text;
+    }
+    if (part.type === "refusal") {
+      return part.refusal;
+    }
+    return "";
+  }).join("");
+}
+function buildAssistantContent(message, context) {
+  const parts = [];
+  if (message.reasoningContent) {
+    parts.push({ type: "reasoning", text: message.reasoningContent });
+  }
+  const text = extractText(message);
+  if (text) {
+    parts.push({ type: "text", text });
+  }
+  parts.push(...extractImagePartsFromModelMessage(message));
+  for (const toolCall of message.toolCalls ?? []) {
+    parts.push(toolCallToPart(toolCall, context));
+  }
+  return parts;
+}
+
+// src/foldPeerThreads.ts
+var isDev = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.NODE_ENV !== "production";
+function warnUnexpectedRootThread(threadId, eventType) {
+  if (!isDev) {
+    return;
+  }
+  console.warn(
+    `[@truefoundry/assistant-ui-runtime] Expected root thread "${ROOT_THREAD_ID}" but received "${threadId}" on ${eventType}.`
+  );
+}
+function assertRootThreadEvent(threadId, eventType) {
+  if (threadId === ROOT_THREAD_ID) {
+    return;
+  }
+  if (isDev) {
+    throw new Error(
+      `[@truefoundry/assistant-ui-runtime] Root-looking event ${eventType} arrived on thread "${threadId}" instead of "${ROOT_THREAD_ID}".`
+    );
+  }
+  warnUnexpectedRootThread(threadId, eventType);
+}
+var PeerThreadFoldState = class {
+  threads = /* @__PURE__ */ new Map();
+  threadParents = /* @__PURE__ */ new Map();
+  getOrCreateBucket(threadId) {
+    let bucket = this.threads.get(threadId);
+    if (bucket == null) {
+      bucket = {
+        events: /* @__PURE__ */ new Map(),
+        modelMessageIds: [],
+        toolResults: /* @__PURE__ */ new Map(),
+        pendingApprovals: /* @__PURE__ */ new Map(),
+        approvalDecisions: /* @__PURE__ */ new Map(),
+        pendingResponses: /* @__PURE__ */ new Map(),
+        done: false
+      };
+      this.threads.set(threadId, bucket);
+    }
+    return bucket;
+  }
+};
+function isTurnScopedEvent(message) {
+  return message.type === "turn.created" || message.type === "turn.done";
+}
+function ingestEventIntoBucket(bucket, message) {
+  if (isTurnScopedEvent(message)) {
+    return;
+  }
+  if (isEventDelta2(message)) {
+    const base = bucket.events.get(message.id);
+    if (base != null) {
+      mergeStreamEventDelta(base, message);
+    }
+    return;
+  }
+  bucket.events.set(message.id, message);
+  if (message.type === "model.message") {
+    if (!bucket.modelMessageIds.includes(message.id)) {
+      bucket.modelMessageIds.push(message.id);
+    }
+    return;
+  }
+  if (message.type === "tool.response") {
+    bucket.toolResults.set(message.toolCallId, message.content);
+    bucket.pendingResponses.delete(message.toolCallId);
+    return;
+  }
+  if (message.type === "tool.approval_required") {
+    for (const ref of message.toolCalls) {
+      bucket.pendingApprovals.set(ref.id, { id: ref.id });
+    }
+    return;
+  }
+  if (message.type === "tool.response_required") {
+    for (const ref of message.toolCalls) {
+      const resolved = resolveAskUserQuestionFromBucket(bucket, ref);
+      bucket.pendingResponses.set(ref.id, {
+        id: ref.id,
+        sourceEventId: ref.sourceEventId,
+        ...resolved?.question != null ? { question: resolved.question } : {},
+        ...resolved?.options != null ? { options: resolved.options } : {}
+      });
+    }
+    return;
+  }
+  if (message.type === "thread.done") {
+    bucket.done = true;
+    if (message.title) {
+      bucket.title = message.title;
+    }
+  }
+}
+function isContentAffectingEvent(message) {
+  return message.type === "thread.created" || message.type === "thread.done" || message.type === "model.message" || message.type === "model.message.delta" || message.type === "tool.response" || message.type === "tool.approval_required" || message.type === "tool.response_required";
+}
+function ingestStreamEvent(state, message) {
+  if (message.type === "mcp.auth_required" || isTurnScopedEvent(message)) {
+    return false;
+  }
+  if (message.threadId == null) {
+    return false;
+  }
+  if (message.type === "thread.created") {
+    state.threadParents.set(message.threadId, {
+      parentThreadId: message.parent.threadId,
+      toolCallId: message.parent.toolCallId
+    });
+    const bucket2 = state.getOrCreateBucket(message.threadId);
+    bucket2.title = message.title;
+    bucket2.agentInfo = message.agentInfo;
+    return true;
+  }
+  if (message.type === "model.message" && message.threadId === ROOT_THREAD_ID) {
+    assertRootThreadEvent(message.threadId, message.type);
+  }
+  const bucket = state.getOrCreateBucket(message.threadId);
+  ingestEventIntoBucket(bucket, message);
+  return isContentAffectingEvent(message);
+}
+function ingestTurnEvent(state, event) {
+  if (event.threadId == null) {
+    return;
+  }
+  if (event.type === "thread.created") {
+    state.threadParents.set(event.threadId, {
+      parentThreadId: event.parent.threadId,
+      toolCallId: event.parent.toolCallId
+    });
+    const bucket = state.getOrCreateBucket(event.threadId);
+    bucket.title = event.title;
+    bucket.agentInfo = event.agentInfo;
+  } else if (event.type === "model.message" && event.threadId === ROOT_THREAD_ID) {
+    assertRootThreadEvent(event.threadId, event.type);
+  }
+  ingestEventIntoBucket(state.getOrCreateBucket(event.threadId), event);
+}
+function resolveAskUserQuestionFromBucket(bucket, ref) {
+  const modelMessage = bucket.events.get(ref.sourceEventId);
+  if (modelMessage?.type !== "model.message") {
+    return void 0;
+  }
+  const toolCall = modelMessage.toolCalls?.find((call) => call.id === ref.id);
+  if (toolCall == null) {
+    return void 0;
+  }
+  return parseAskUserQuestionArgs(toolCall.function.arguments);
+}
+function findToolCallInBucket(bucket, toolCallId) {
+  for (const id of bucket.modelMessageIds) {
+    const event = bucket.events.get(id);
+    if (event?.type !== "model.message") {
+      continue;
+    }
+    const match = event.toolCalls?.find((toolCall) => toolCall.id === toolCallId);
+    if (match != null) {
+      return match;
+    }
+  }
+  return void 0;
+}
+function isLinkedCreateSubAgentThread(state, subThreadId) {
+  const link = state.threadParents.get(subThreadId);
+  if (link == null) {
+    return false;
+  }
+  const parentBucket = state.threads.get(link.parentThreadId);
+  if (parentBucket == null) {
+    return false;
+  }
+  const toolCall = findToolCallInBucket(parentBucket, link.toolCallId);
+  return toolCall != null && isCreateSubAgentToolCall(toolCall);
+}
+function childSubThreadIds(state, parentThreadId, toolCallId) {
+  const ids = [];
+  for (const [subThreadId, link] of state.threadParents) {
+    if (link.parentThreadId === parentThreadId && link.toolCallId === toolCallId && isLinkedCreateSubAgentThread(state, subThreadId)) {
+      ids.push(subThreadId);
+    }
+  }
+  return ids;
+}
+function bucketHasUnresolvedPendingResponses(bucket) {
+  for (const id of bucket.pendingResponses.keys()) {
+    if (!bucket.toolResults.has(id)) {
+      return true;
+    }
+  }
+  return false;
+}
+function bucketAssistantStatus(bucket) {
+  if (bucket.pendingApprovals.size > 0) {
+    return toolApprovalStatus();
+  }
+  if (bucketHasUnresolvedPendingResponses(bucket)) {
+    return toolResponseStatus();
+  }
+  if (!bucket.done && bucket.modelMessageIds.length > 0) {
+    return { type: "running" };
+  }
+  return { type: "complete", reason: "stop" };
+}
+function buildSubAgentCustomMetadata(threadId, bucket) {
+  const metadata = {
+    threadId,
+    ...bucket.title != null ? { title: bucket.title } : {},
+    ...bucket.agentInfo?.name != null ? { name: bucket.agentInfo.name } : {},
+    ...bucket.agentInfo?.model != null ? { model: bucket.agentInfo.model } : {},
+    ...bucket.agentInfo?.input != null ? { input: bucket.agentInfo.input } : {}
+  };
+  return { subAgent: metadata };
+}
+function attachSubAgentMessages(state, parentThreadId, parts) {
+  const parentBucket = state.threads.get(parentThreadId);
+  return parts.map((part) => {
+    if (part.type !== "tool-call" || parentBucket == null) {
+      return part;
+    }
+    const sdkToolCall = findToolCallInBucket(parentBucket, part.toolCallId);
+    if (sdkToolCall == null || !isCreateSubAgentToolCall(sdkToolCall)) {
+      return part;
+    }
+    const childIds = childSubThreadIds(state, parentThreadId, part.toolCallId);
+    if (childIds.length === 0) {
+      return part;
+    }
+    const messages = [];
+    const subAgents = [];
+    for (const childId of childIds) {
+      const childMessages = buildSubThreadMessages(state, childId);
+      if (childMessages.length > 0) {
+        messages.push(...childMessages);
+      }
+      const childBucket = state.threads.get(childId);
+      if (childBucket != null) {
+        subAgents.push({
+          threadId: childId,
+          ...childBucket.title != null ? { title: childBucket.title } : {},
+          ...childBucket.agentInfo != null ? { agentInfo: childBucket.agentInfo } : {}
+        });
+      }
+    }
+    if (messages.length === 0) {
+      return part;
+    }
+    const artifact = { subAgents };
+    return { ...part, messages, artifact };
+  });
+}
+function buildThreadAssistantParts(state, threadId, modelMessageIds) {
+  const bucket = state.threads.get(threadId);
+  if (bucket == null) {
+    return [];
+  }
+  const ids = threadId === ROOT_THREAD_ID && modelMessageIds != null ? modelMessageIds : bucket.modelMessageIds;
+  const parts = [];
+  const toolCallIndexById = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const event = bucket.events.get(id);
+    if (event?.type !== "model.message") {
+      continue;
+    }
+    for (const part of buildAssistantContent(event, {
+      toolResults: bucket.toolResults,
+      pendingApprovals: bucket.pendingApprovals,
+      approvalDecisions: bucket.approvalDecisions,
+      pendingResponses: bucket.pendingResponses
+    })) {
+      if (part.type === "tool-call") {
+        const existingIndex = toolCallIndexById.get(part.toolCallId);
+        if (existingIndex != null) {
+          parts[existingIndex] = part;
+          continue;
+        }
+        toolCallIndexById.set(part.toolCallId, parts.length);
+      }
+      parts.push(part);
+    }
+  }
+  return attachSubAgentMessages(state, threadId, parts);
+}
+function buildSubThreadMessages(state, threadId) {
+  const bucket = state.threads.get(threadId);
+  if (bucket == null) {
+    return [];
+  }
+  const content = buildThreadAssistantParts(state, threadId);
+  if (content.length === 0) {
+    return [];
+  }
+  const custom = {
+    ...buildSubAgentCustomMetadata(threadId, bucket),
+    ...bucket.pendingApprovals.size > 0 ? toolApprovalMessageCustom(threadId) : {},
+    ...bucketHasUnresolvedPendingResponses(bucket) ? toolResponseMessageCustom(threadId) : {}
+  };
+  return [
+    {
+      id: `${threadId}-assistant`,
+      role: "assistant",
+      content,
+      status: bucketAssistantStatus(bucket),
+      createdAt: /* @__PURE__ */ new Date(),
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom
+      }
+    }
+  ];
+}
+function buildRootAssistantContent(state) {
+  return buildThreadAssistantParts(state, ROOT_THREAD_ID);
+}
+function buildRootAssistantContentForIds(state, modelMessageIds) {
+  return buildThreadAssistantParts(state, ROOT_THREAD_ID, modelMessageIds);
+}
+function findFirstPendingApprovalThreadId(state) {
+  for (const [threadId, bucket] of state.threads) {
+    if (bucket.pendingApprovals.size > 0) {
+      return threadId;
+    }
+  }
+  return void 0;
+}
+function findFirstPendingResponseThreadId(state) {
+  for (const [threadId, bucket] of state.threads) {
+    if (bucketHasUnresolvedPendingResponses(bucket)) {
+      return threadId;
+    }
+  }
+  return void 0;
+}
+function recordToolApprovalInFold(fold, decision) {
+  const record = {
+    id: decision.toolCallId,
+    approved: decision.approved,
+    ...decision.reason != null ? { reason: decision.reason } : {}
+  };
+  let applied = false;
+  for (const bucket of fold.threads.values()) {
+    if (!bucket.pendingApprovals.has(decision.toolCallId)) {
+      continue;
+    }
+    bucket.pendingApprovals.delete(decision.toolCallId);
+    bucket.approvalDecisions.set(decision.toolCallId, record);
+    applied = true;
+  }
+  if (applied) {
+    return;
+  }
+  const rootBucket = fold.getOrCreateBucket(ROOT_THREAD_ID);
+  rootBucket.approvalDecisions.set(decision.toolCallId, record);
+}
+function recordToolResponseInFold(fold, response) {
+  let applied = false;
+  for (const bucket of fold.threads.values()) {
+    if (!bucket.pendingResponses.has(response.toolCallId)) {
+      continue;
+    }
+    bucket.toolResults.set(response.toolCallId, response.content);
+    bucket.pendingResponses.delete(response.toolCallId);
+    applied = true;
+  }
+  if (applied) {
+    return;
+  }
+  const rootBucket = fold.getOrCreateBucket(ROOT_THREAD_ID);
+  rootBucket.toolResults.set(response.toolCallId, response.content);
+  rootBucket.pendingResponses.delete(response.toolCallId);
+}
+
+// src/toolResponse.ts
+var TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY = "toolResponseThreadId";
+function hasPendingToolResponse(part) {
+  return part.interrupt != null && part.result === void 0;
+}
+function isStagedResponseAwaitingSdk(part) {
+  return part.interrupt != null && part.result !== void 0;
+}
+function toolResponseStatus() {
+  return { type: "requires-action", reason: "tool-calls" };
+}
+function toolResponseMessageCustom(threadId) {
+  return {
+    [TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY]: threadId === ROOT_THREAD_ID ? ROOT_THREAD_ID : threadId
+  };
+}
+function getToolResponseThreadId(message) {
+  if (message?.role !== "assistant") {
+    return void 0;
+  }
+  const threadId = message.metadata.custom[TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY];
+  return typeof threadId === "string" ? threadId : void 0;
+}
+function findResponseRequiredInTurn(turn) {
+  if (turn.state.status !== "done") {
+    return void 0;
+  }
+  return turn.state.requiredActions?.find(
+    (action) => action.type === "tool.response_required"
+  );
+}
+function applyToolResponseToToolCall(part, content) {
+  return { ...part, result: content };
+}
+function nestedMessagesHavePendingResponses(messages) {
+  for (const message of messages) {
+    if (messageHasPendingResponses(message)) {
+      return true;
+    }
+  }
+  return false;
+}
+function messageHasPendingResponses(message) {
+  if (message?.role !== "assistant") {
+    return false;
+  }
+  for (const part of message.content) {
+    if (part.type !== "tool-call") {
+      continue;
+    }
+    if (hasPendingToolResponse(part)) {
+      return true;
+    }
+    if (part.messages != null && nestedMessagesHavePendingResponses(part.messages)) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectResponseInputsFromMessages(messages, defaultThreadId) {
+  const events = [];
+  for (const message of messages) {
+    events.push(...collectResponseInputs(message, defaultThreadId));
+  }
+  return events;
+}
+function collectResponseInputs(message, threadId) {
+  if (message.role !== "assistant" || !threadId) {
+    return [];
+  }
+  if (messageHasPendingResponses(message)) {
+    return [];
+  }
+  const scopedThreadId = getToolResponseThreadId(message) ?? threadId;
+  const events = [];
+  for (const part of message.content) {
+    if (part.type !== "tool-call") {
+      continue;
+    }
+    if (isStagedResponseAwaitingSdk(part)) {
+      events.push({
+        type: "user.tool_response",
+        threadId: scopedThreadId,
+        toolCallId: part.toolCallId,
+        content: String(part.result)
+      });
+    }
+    if (part.messages != null) {
+      events.push(
+        ...collectResponseInputsFromMessages(part.messages, scopedThreadId)
+      );
+    }
+  }
+  return events;
+}
+function applyStagedResponsesToContentMap(content, staged) {
+  return content.map((part) => {
+    if (part.type !== "tool-call") {
+      return part;
+    }
+    const contentValue = staged.get(part.toolCallId);
+    let nextPart = part;
+    if (contentValue != null && hasPendingToolResponse(part)) {
+      nextPart = applyToolResponseToToolCall(part, contentValue);
+    }
+    if (nextPart.messages == null) {
+      return nextPart;
+    }
+    return {
+      ...nextPart,
+      messages: nextPart.messages.map((message) => {
+        if (message.role !== "assistant") {
+          return message;
+        }
+        return {
+          ...message,
+          content: applyStagedResponsesToContentMap(message.content, staged)
+        };
+      })
+    };
+  });
+}
+function extractToolResponsesFromTurnInput(input) {
+  const events = [];
+  for (const item of input ?? []) {
+    if (item.type === "user.tool_response") {
+      events.push(item);
+    }
+  }
+  return events;
+}
+function applyUserToolResponsesToFold(fold, inputs) {
+  for (const item of inputs) {
+    if (item.type === "user.tool_response") {
+      recordToolResponseInFold(fold, {
+        toolCallId: item.toolCallId,
+        content: item.content
+      });
+    } else if (item.type === "user.tool_approval") {
+      recordToolApprovalInFold(fold, {
+        toolCallId: item.toolCallId,
+        approved: item.approval.status === "allow",
+        ...item.approval.status === "deny" && item.approval.reason != null ? { reason: item.approval.reason } : {}
+      });
+    }
+  }
+}
+function collectSubsequentToolResponses(turns, fromIndex) {
+  const responses = /* @__PURE__ */ new Map();
+  for (let index = fromIndex + 1; index < turns.length; index++) {
+    const input = turns[index]?.input ?? [];
+    if (input.some((item) => item.type === "user.message")) {
+      break;
+    }
+    for (const event of extractToolResponsesFromTurnInput(input)) {
+      responses.set(event.toolCallId, { content: event.content });
+    }
+  }
+  return responses;
+}
+function collectToolResponsesFromTurnInput(input) {
+  const responses = /* @__PURE__ */ new Map();
+  for (const event of extractToolResponsesFromTurnInput(input)) {
+    responses.set(event.toolCallId, { content: event.content });
+  }
+  return responses;
+}
+function applyStagedResponsesToContent(content, responses) {
+  const staged = new Map(
+    [...responses.entries()].map(([toolCallId, value]) => [
+      toolCallId,
+      value.content
+    ])
+  );
+  return applyStagedResponsesToContentMap(content, staged);
+}
+
+// src/collectPending.ts
+function walkToolCallParts(content, visit, threadId) {
+  for (const part of content) {
+    if (part.type !== "tool-call") {
+      continue;
+    }
+    visit(part, threadId);
+    if (part.messages == null) {
+      continue;
+    }
+    for (const message of part.messages) {
+      if (message.role !== "assistant") {
+        continue;
+      }
+      const nestedThreadId = getToolApprovalThreadId(message) ?? getToolResponseThreadId(message) ?? threadId;
+      walkToolCallParts(message.content, visit, nestedThreadId);
+    }
+  }
+}
+function collectPendingApprovals(messages) {
+  const pending = [];
+  for (const message of messages) {
+    if (message.role !== "assistant") {
+      continue;
+    }
+    const rootThreadId = getToolApprovalThreadId(message) ?? ROOT_THREAD_ID;
+    walkToolCallParts(message.content, (part, threadId) => {
+      if (!hasPendingToolApproval(part.approval)) {
+        return;
+      }
+      pending.push({
+        approvalId: part.approval.id,
+        threadId,
+        toolName: part.toolName,
+        args: { ...part.args },
+        argsText: part.argsText
+      });
+    }, rootThreadId);
+  }
+  return pending;
+}
+function collectPendingToolResponses(messages) {
+  const pending = [];
+  for (const message of messages) {
+    if (message.role !== "assistant") {
+      continue;
+    }
+    const rootThreadId = getToolResponseThreadId(message) ?? ROOT_THREAD_ID;
+    walkToolCallParts(message.content, (part, threadId) => {
+      if (!hasPendingToolResponse(part)) {
+        return;
+      }
+      const payload = part.interrupt?.payload;
+      pending.push({
+        toolCallId: part.toolCallId,
+        threadId,
+        toolName: part.toolName,
+        args: { ...part.args },
+        argsText: part.argsText,
+        ...payload?.question != null ? { question: payload.question } : {},
+        ...payload?.options != null ? { options: payload.options } : {}
+      });
+    }, rootThreadId);
+  }
+  return pending;
+}
+function derivePendingMcpAuth(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role !== "assistant") {
+      continue;
+    }
+    if (message.status?.type !== "requires-action") {
+      continue;
+    }
+    const custom = message.metadata.custom;
+    if (custom.pendingMcpAuth !== true) {
+      continue;
+    }
+    const servers = custom.mcpServers;
+    if (!Array.isArray(servers)) {
+      return { mcpServers: [] };
+    }
+    return { mcpServers: servers };
+  }
+  return null;
+}
+function deriveSandboxId(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role !== "assistant") {
+      continue;
+    }
+    const custom = message.metadata.custom;
+    if (typeof custom.sandboxId === "string") {
+      return custom.sandboxId;
+    }
+  }
+  return void 0;
+}
+
+// src/mcpAuth.ts
+var MCP_AUTH_RESUME_RUN_CUSTOM_KEY = "resumeMcpAuth";
+function buildMcpAuthTextParts(servers) {
+  const linkLines = servers.map(
+    (server) => `- [Authorize ${server.name}](${server.authUrl})`
+  );
+  const text = [
+    "This agent needs access to external services before it can continue.",
+    "",
+    ...linkLines,
+    "",
+    "Open each link to sign in, then press **Continue** below."
+  ].join("\n");
+  return [{ type: "text", text }];
+}
+function findMcpAuthRequired(requiredActions) {
+  return requiredActions?.find(
+    (action) => action.type === "mcp.auth_required"
+  );
+}
+function mcpAuthAssistantStatus() {
+  return { type: "requires-action", reason: "interrupt" };
+}
+function mcpAuthMessageCustom(servers) {
+  return { pendingMcpAuth: true, mcpServers: [...servers] };
+}
+
+// src/turnEventHelpers.ts
+function buildToolApprovalUpdate(content, turn) {
+  const pendingApproval = findApprovalRequiredInTurn(turn);
+  if (pendingApproval == null) {
+    return { content };
+  }
+  return {
+    content,
+    status: toolApprovalStatus(),
+    metadata: { custom: toolApprovalMessageCustom(pendingApproval.threadId) }
+  };
+}
+function buildToolResponseUpdate(update, turn) {
+  const pendingResponse = findResponseRequiredInTurn(turn);
+  if (pendingResponse == null) {
+    return update;
+  }
+  return {
+    ...update,
+    content: update.content,
+    status: toolResponseStatus(),
+    metadata: {
+      custom: {
+        ...update.metadata?.custom,
+        ...toolResponseMessageCustom(pendingResponse.threadId)
+      }
+    }
+  };
+}
+function appendToolResponseToTurnContent(update, turn) {
+  if (update.status?.type === "requires-action") {
+    return update;
+  }
+  return buildToolResponseUpdate(update, turn);
+}
+function appendToolApprovalToTurnContent(update, turn) {
+  if (update.status?.type === "requires-action") {
+    return update;
+  }
+  const approvalUpdate = buildToolApprovalUpdate(update.content, turn);
+  return appendToolResponseToTurnContent(approvalUpdate, turn);
+}
+function appendMcpAuthToTurnContent(content, turn) {
+  const pendingMcpAuth = findMcpAuthRequired(
+    turn.state.status === "done" ? turn.state.requiredActions : void 0
+  );
+  if (pendingMcpAuth == null) {
+    return appendToolApprovalToTurnContent({ content }, turn);
+  }
+  return appendToolApprovalToTurnContent(
+    {
+      content: [...content, ...buildMcpAuthTextParts(pendingMcpAuth.mcpServers)],
+      status: mcpAuthAssistantStatus(),
+      metadata: { custom: mcpAuthMessageCustom(pendingMcpAuth.mcpServers) }
+    },
+    turn
+  );
+}
+
+// src/extractTurnUserText.ts
+function extractTurnUserText(input) {
+  const parts = [];
+  for (const item of input ?? []) {
+    if (item.type !== "user.message") {
+      continue;
+    }
+    const { content } = item;
+    if (typeof content === "string") {
+      parts.push(content);
+      continue;
+    }
+    for (const part of content) {
+      if (part.type === "text") {
+        parts.push(part.text);
+      }
+    }
+  }
+  return parts.join("\n").trim();
+}
+
+// src/sessionSnapshot.ts
+function emptyRequiredActionsOverlay() {
+  return {
+    approvals: /* @__PURE__ */ new Map(),
+    toolResponses: /* @__PURE__ */ new Map()
+  };
+}
+function createEmptySessionSnapshot() {
+  return {
+    fold: new PeerThreadFoldState(),
+    turns: [],
+    requiredActions: emptyRequiredActionsOverlay()
+  };
+}
+function turnToSessionRecord(turn) {
+  const userText = extractTurnUserText(turn.input);
+  return {
+    id: turn.id,
+    ...userText ? { userText } : {},
+    createdAt: turn.createdAt,
+    state: turn.state,
+    input: turn.input
+  };
+}
+function replaceSessionSnapshot(snapshot, patch) {
+  return {
+    ...snapshot,
+    ...patch,
+    ...patch.requiredActions != null ? { requiredActions: patch.requiredActions } : {}
+  };
+}
+
+// src/convertTurnMessages.ts
+var TURN_EVENTS_PAGE_SIZE = 25;
+function assistantStatusFromTurnState(state) {
+  switch (state.status) {
+    case "done":
+      return { type: "complete", reason: "stop" };
+    case "error":
+      return { type: "incomplete", reason: "error", error: state.message };
+    case "cancelled":
+      return { type: "incomplete", reason: "cancelled" };
+    case "running":
+      return { type: "running" };
+    default:
+      return { type: "complete", reason: "unknown" };
+  }
+}
+function resolveCreatedAt(messageId, fallback, options) {
+  return options?.getCreatedAt?.(messageId, fallback) ?? fallback;
+}
+function parseDataUriMime2(data) {
+  if (!data.startsWith("data:")) {
+    return "application/octet-stream";
+  }
+  const match = /^data:([^;,]+)/.exec(data);
+  return match?.[1] ?? "application/octet-stream";
+}
+function fileContentToAttachment(file, attachmentId) {
+  const mimeType = parseDataUriMime2(file.data);
+  if (mimeType.startsWith("image/")) {
+    return {
+      id: attachmentId,
+      type: "image",
+      name: file.name,
+      contentType: mimeType,
+      status: { type: "complete" },
+      content: [{ type: "image", image: file.data, filename: file.name }]
+    };
+  }
+  return {
+    id: attachmentId,
+    type: "file",
+    name: file.name,
+    contentType: mimeType,
+    status: { type: "complete" },
+    content: [
+      {
+        type: "file",
+        mimeType,
+        filename: file.name,
+        data: file.data
+      }
+    ]
+  };
+}
+function buildUserMessageFromTurnInput(turnId, input, createdAt, options) {
+  const fallback = createdAt instanceof Date ? createdAt : new Date(createdAt);
+  const id = `${turnId}-user`;
+  const content = [];
+  const attachments = [];
+  for (const item of input ?? []) {
+    if (item.type !== "user.message") {
+      continue;
+    }
+    const messageContent = item.content;
+    if (typeof messageContent === "string") {
+      content.push({ type: "text", text: messageContent });
+      continue;
+    }
+    for (const part of messageContent) {
+      if (part.type === "text") {
+        content.push({ type: "text", text: part.text });
+      } else if (part.type === "file") {
+        attachments.push(
+          fileContentToAttachment(
+            part,
+            `${turnId}-file-${attachments.length}`
+          )
+        );
+      } else {
+        const imageUrl = extractImageUrlFromUserContentItem(part);
+        if (imageUrl != null) {
+          attachments.push(
+            imageUrlToAttachment(
+              imageUrl,
+              `${turnId}-file-${attachments.length}`
+            )
+          );
+        }
+      }
+    }
+  }
+  return {
+    id,
+    role: "user",
+    content: content.length > 0 ? content : [{ type: "text", text: "" }],
+    attachments,
+    createdAt: resolveCreatedAt(id, fallback, options),
+    metadata: { custom: {} }
+  };
+}
+function buildAssistantMessage(turnId, content, createdAt, status, custom = {}, options) {
+  const fallback = createdAt instanceof Date ? createdAt : new Date(createdAt);
+  const id = `${turnId}-assistant`;
+  return {
+    id,
+    role: "assistant",
+    content,
+    status,
+    createdAt: resolveCreatedAt(id, fallback, options),
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom
+    }
+  };
+}
+async function ingestTurnEventsIntoFold(foldState, turn) {
+  for await (const event of await turn.listEvents({
+    order: "asc",
+    limit: TURN_EVENTS_PAGE_SIZE
+  })) {
+    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);
+  }
+  return events;
+}
+function ingestCollectedEventsIntoFold(foldState, events) {
+  for (const event of events) {
+    ingestTurnEvent(foldState, event);
+  }
+}
+async function fetchAllTurnEventsWithConcurrency(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);
+    });
+    pool.add(p);
+    if (pool.size >= concurrency) await Promise.race(pool);
+  }
+  await Promise.all(pool);
+  return results;
+}
+function rootModelMessageIdsSinceBaseline(foldState, baseline) {
+  const bucket = foldState.threads.get(ROOT_THREAD_ID);
+  if (bucket == null) {
+    return [];
+  }
+  if (baseline.length === 0) {
+    return [...bucket.modelMessageIds];
+  }
+  const baselineSet = new Set(baseline);
+  return bucket.modelMessageIds.filter((id) => !baselineSet.has(id));
+}
+function computeGroupRootBaseline(turns) {
+  let groupStartIndex = turns.length - 1;
+  while (groupStartIndex >= 0 && turns[groupStartIndex]?.userText == null) {
+    groupStartIndex--;
+  }
+  const baseline = [];
+  for (let i = 0; i < groupStartIndex; i++) {
+    baseline.push(...turns[i]?.rootModelMessageIds ?? []);
+  }
+  return baseline;
+}
+function buildTurnUpdateFromFold(foldState, turn, rootModelMessageIds) {
+  const content = buildRootAssistantContentForIds(foldState, rootModelMessageIds);
+  let update = { content };
+  update = appendMcpAuthToTurnContent(update.content, turn);
+  update = appendToolApprovalToTurnContent(update, turn);
+  return update;
+}
+function contentHasPendingRequiredActions(content) {
+  const message = {
+    id: "pending-check",
+    role: "assistant",
+    content,
+    status: { type: "complete", reason: "stop" },
+    createdAt: /* @__PURE__ */ new Date(),
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {}
+    }
+  };
+  return messageHasPendingApprovals(message) || messageHasPendingResponses(message);
+}
+function resolveProjectedRequiredActionState(turnUpdate, content, record) {
+  let status = turnUpdate.status ?? assistantStatusFromTurnState(record.state);
+  let custom = { ...turnUpdate.metadata?.custom ?? {} };
+  if (status.type === "requires-action" && status.reason === "tool-calls" && !contentHasPendingRequiredActions(content)) {
+    status = assistantStatusFromTurnState(record.state);
+    const {
+      [TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY]: _approvalThreadId,
+      [TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY]: _responseThreadId,
+      ...restCustom
+    } = custom;
+    custom = restCustom;
+  }
+  return { status, custom };
+}
+function projectActiveStreamUpdate(snapshot) {
+  const activeStream = snapshot.activeStream;
+  if (activeStream == null) {
+    throw new Error("projectActiveStreamUpdate requires an active stream");
+  }
+  const hasStagedOverlay = snapshot.requiredActions.approvals.size > 0 || snapshot.requiredActions.toolResponses.size > 0;
+  if (hasStagedOverlay) {
+    return activeStream.update;
+  }
+  const baseline = snapshot.groupRootBaseline ?? computeGroupRootBaseline(snapshot.turns);
+  const rootModelMessageIds = rootModelMessageIdsSinceBaseline(
+    snapshot.fold,
+    baseline
+  );
+  const foldContent = buildRootAssistantContentForIds(
+    snapshot.fold,
+    rootModelMessageIds
+  );
+  const content = foldContent.length > 0 ? foldContent : activeStream.update.content;
+  const turnRecord = snapshot.turns.find((turn) => turn.id === activeStream.turnId);
+  const turnLike = turnRecord ?? snapshot.runningTurn;
+  const rebuilt = turnLike != null ? buildTurnUpdateFromFold(snapshot.fold, turnLike, rootModelMessageIds) : { content };
+  return {
+    ...activeStream.update,
+    content,
+    metadata: rebuilt.metadata ?? activeStream.update.metadata,
+    status: rebuilt.status ?? activeStream.update.status
+  };
+}
+function applyRequiredActionsOverlayToMessages(messages, overlay) {
+  if (overlay.approvals.size === 0 && overlay.toolResponses.size === 0) {
+    return messages;
+  }
+  return messages.map((message) => {
+    if (message.role !== "assistant") {
+      return message;
+    }
+    let { content } = message;
+    if (overlay.approvals.size > 0) {
+      content = applyApprovalDecisionsToContent(content, overlay.approvals);
+    }
+    if (overlay.toolResponses.size > 0) {
+      content = applyStagedResponsesToContent(content, overlay.toolResponses);
+    }
+    if (content === message.content) {
+      return message;
+    }
+    return { ...message, content: [...content] };
+  });
+}
+function projectHistoryTurns(snapshot, options) {
+  const messages = [];
+  let lastAssistantIndex;
+  let groupRootIds = [];
+  for (let turnIndex = 0; turnIndex < snapshot.turns.length; turnIndex++) {
+    const record = snapshot.turns[turnIndex];
+    const turnRootIds = record.rootModelMessageIds ?? [];
+    if (record.userText) {
+      groupRootIds = [...turnRootIds];
+    } else {
+      groupRootIds = [...groupRootIds, ...turnRootIds];
+    }
+    const turnUpdate = buildTurnUpdateFromFold(snapshot.fold, record, groupRootIds);
+    let content = turnUpdate.content;
+    const subsequentDecisions = collectSubsequentApprovalDecisions(
+      snapshot.turns,
+      turnIndex
+    );
+    if (subsequentDecisions.size > 0) {
+      content = applyApprovalDecisionsToContent(content, subsequentDecisions);
+    }
+    const subsequentResponses = collectSubsequentToolResponses(
+      snapshot.turns,
+      turnIndex
+    );
+    if (subsequentResponses.size > 0) {
+      content = applyStagedResponsesToContent(content, subsequentResponses);
+    }
+    const currentResponses = collectToolResponsesFromTurnInput(record.input);
+    if (currentResponses.size > 0) {
+      content = applyStagedResponsesToContent(content, currentResponses);
+    }
+    const currentDecisions = collectApprovalDecisionsFromTurnInput(record.input);
+    if (currentDecisions.size > 0) {
+      content = applyApprovalDecisionsToContent(content, currentDecisions);
+    }
+    const { status, custom: baseCustom } = resolveProjectedRequiredActionState(
+      turnUpdate,
+      content,
+      record
+    );
+    const custom = record.sandboxId != null ? { ...baseCustom, sandboxId: record.sandboxId } : baseCustom;
+    if (record.userText) {
+      messages.push(
+        buildUserMessageFromTurnInput(
+          record.id,
+          record.input,
+          record.createdAt,
+          options
+        )
+      );
+      if (record.state.status === "running") {
+        if (content.length > 0) {
+          messages.push(
+            buildAssistantMessage(
+              record.id,
+              content,
+              record.createdAt,
+              status,
+              custom,
+              options
+            )
+          );
+          lastAssistantIndex = messages.length - 1;
+        }
+        break;
+      }
+      if (content.length > 0) {
+        messages.push(
+          buildAssistantMessage(
+            record.id,
+            content,
+            record.createdAt,
+            status,
+            custom,
+            options
+          )
+        );
+        lastAssistantIndex = messages.length - 1;
+      }
+    } else if (content.length > 0 && lastAssistantIndex != null) {
+      if (record.state.status === "running") {
+        break;
+      }
+      const existing = messages[lastAssistantIndex];
+      messages[lastAssistantIndex] = {
+        ...existing,
+        content,
+        status,
+        metadata: {
+          ...existing.metadata,
+          custom
+        }
+      };
+    } else if (record.state.status === "running") {
+      break;
+    }
+  }
+  return messages;
+}
+function projectSessionMessages(snapshot, options) {
+  let messages = projectHistoryTurns(snapshot, options);
+  if (snapshot.pendingUser != null) {
+    messages.push(
+      buildUserMessageFromTurnInput(
+        snapshot.pendingUser.turnId,
+        [{ type: "user.message", content: snapshot.pendingUser.content }],
+        snapshot.pendingUser.createdAt,
+        options
+      )
+    );
+  }
+  if (snapshot.activeStream != null) {
+    const { turnId, update, isContinuation, streamComplete } = snapshot.activeStream;
+    const resolvedUpdate = streamComplete === true ? projectActiveStreamUpdate(snapshot) : update;
+    const last = messages.at(-1);
+    const existingAssistant = isContinuation && last?.role === "assistant" ? last : void 0;
+    let assistantMessage = turnStreamUpdateToAssistantMessage(
+      turnId,
+      resolvedUpdate,
+      existingAssistant,
+      options
+    );
+    if (streamComplete === true && resolvedUpdate.status == null) {
+      assistantMessage = {
+        ...assistantMessage,
+        status: { type: "complete", reason: "stop" }
+      };
+    }
+    if (isContinuation && last?.role === "assistant") {
+      messages = [...messages.slice(0, -1), assistantMessage];
+    } else {
+      messages = [...messages, assistantMessage];
+    }
+  }
+  return applyRequiredActionsOverlayToMessages(
+    messages,
+    snapshot.requiredActions
+  );
+}
+var DEFAULT_LIST_EVENTS_CONCURRENCY = 5;
+function ingestTurnsIntoSnapshot(snapshot, turns, eventArrays) {
+  let runningTurn;
+  for (let i = 0; i < turns.length; i++) {
+    const turn = turns[i];
+    const rootBucket = snapshot.fold.threads.get(ROOT_THREAD_ID);
+    const beforeCount = rootBucket?.modelMessageIds.length ?? 0;
+    ingestCollectedEventsIntoFold(snapshot.fold, eventArrays[i] ?? []);
+    applyUserToolResponsesToFold(snapshot.fold, turn.input ?? []);
+    const afterBucket = snapshot.fold.threads.get(ROOT_THREAD_ID);
+    const rootModelMessageIds = (afterBucket?.modelMessageIds ?? []).slice(
+      beforeCount
+    );
+    const sandboxEvent = (eventArrays[i] ?? []).find(
+      (event) => event.type === "sandbox.created"
+    );
+    snapshot.turns.push({
+      ...turnToSessionRecord(turn),
+      rootModelMessageIds,
+      ...sandboxEvent != null ? { sandboxId: sandboxEvent.sandboxId } : {}
+    });
+    if (turn.state.status === "running") {
+      runningTurn = turn;
+      break;
+    }
+  }
+  return runningTurn;
+}
+async function buildSnapshotFromSession(session, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY) {
+  const turns = [];
+  for await (const turn of await session.listTurns()) {
+    turns.push(turn);
+  }
+  turns.reverse();
+  const eventArrays = await fetchAllTurnEventsWithConcurrency(turns, concurrency);
+  const snapshot = createEmptySessionSnapshot();
+  const runningTurn = ingestTurnsIntoSnapshot(snapshot, turns, eventArrays);
+  return replaceSessionSnapshot(snapshot, {
+    ...runningTurn != null ? {
+      runningTurn,
+      unstable_resume: true,
+      groupRootBaseline: computeGroupRootBaseline(snapshot.turns)
+    } : {}
+  });
+}
+async function buildSnapshotBeforeTurnIndex(session, turnIndex, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY, orderedTurns) {
+  if (turnIndex <= 0) {
+    return createEmptySessionSnapshot();
+  }
+  const turns = orderedTurns ?? await listSessionTurnsOrdered(session);
+  const turnsToInclude = turns.slice(0, turnIndex);
+  if (turnsToInclude.length === 0) {
+    return createEmptySessionSnapshot();
+  }
+  const eventArrays = await fetchAllTurnEventsWithConcurrency(
+    turnsToInclude,
+    concurrency
+  );
+  const snapshot = createEmptySessionSnapshot();
+  ingestTurnsIntoSnapshot(snapshot, turnsToInclude, eventArrays);
+  return snapshot;
+}
+async function resolveGatewayBranchPreviousTurnId(session, turnIndex, orderedTurns) {
+  if (turnIndex <= 0) {
+    return null;
+  }
+  const turns = orderedTurns ?? await listSessionTurnsOrdered(session);
+  return turns[turnIndex - 1]?.id ?? null;
+}
+async function listSessionTurnsOrdered(session) {
+  const turns = [];
+  for await (const turn of await session.listTurns()) {
+    turns.push(turn);
+  }
+  turns.reverse();
+  return turns;
+}
+async function buildTurnAssistantContent(turn, foldState) {
+  const state = foldState ?? new PeerThreadFoldState();
+  const beforeCount = state.threads.get(ROOT_THREAD_ID)?.modelMessageIds.length ?? 0;
+  await ingestTurnEventsIntoFold(state, turn);
+  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);
+  const messages = projectSessionMessages(snapshot);
+  return {
+    messages,
+    foldState: snapshot.fold,
+    ...snapshot.runningTurn != null ? {
+      runningTurn: snapshot.runningTurn,
+      unstable_resume: true
+    } : {}
+  };
+}
+function getTurnMessageContent(message) {
+  const parts = [];
+  for (const part of message.content) {
+    if (part.type === "text") {
+      parts.push(part.text);
+    }
+  }
+  const text = parts.join("\n").trim();
+  if (!text) {
+    throw new Error("User message must contain text content.");
+  }
+  return text;
+}
+function toFileDataUri(data, mimeType) {
+  if (data.startsWith("data:")) {
+    return data;
+  }
+  return `data:${mimeType};base64,${data}`;
+}
+function toFileContent(name, data, mimeType) {
+  return {
+    type: "file",
+    name,
+    data: toFileDataUri(data, mimeType)
+  };
+}
+function buildUserMessageContent(message) {
+  const contentParts = message.content;
+  const inputParts = [
+    ...contentParts,
+    ...message.attachments?.flatMap(
+      (attachment) => attachment.content.map((part) => ({
+        ...part,
+        filename: attachment.name
+      }))
+    ) ?? []
+  ];
+  const items = [];
+  for (const part of inputParts) {
+    switch (part.type) {
+      case "text":
+        if (part.text.trim().length > 0) {
+          const textPart = { type: "text", text: part.text };
+          items.push(textPart);
+        }
+        break;
+      case "image":
+        items.push(
+          toFileContent(part.filename ?? "image", part.image, "image/png")
+        );
+        break;
+      case "file":
+        items.push(
+          toFileContent(
+            part.filename ?? "file",
+            part.data,
+            part.mimeType
+          )
+        );
+        break;
+      default:
+        break;
+    }
+  }
+  const hasFile = items.some((item) => item.type === "file");
+  if (!hasFile) {
+    return getTurnMessageContent(message);
+  }
+  return items;
+}
+function userMessageContentToText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.filter(
+    (item) => item.type === "text"
+  ).map((item) => item.text).join("\n").trim();
+}
+function parseTurnIdFromMessageId(messageId) {
+  return messageId.replace(/-user$/, "");
+}
+function extractEditedText(message) {
+  return getTurnMessageContent(message);
+}
+function extractTurnUserMessageContent(input) {
+  for (const item of input ?? []) {
+    if (item.type === "user.message") {
+      return item.content;
+    }
+  }
+  return "";
+}
+function buildEditedUserMessageContent(editedText, originalInput) {
+  const fileParts = [];
+  for (const item of originalInput ?? []) {
+    if (item.type !== "user.message") {
+      continue;
+    }
+    const content = item.content;
+    if (typeof content === "string") {
+      continue;
+    }
+    for (const part of content) {
+      if (part.type === "file") {
+        fileParts.push(part);
+      }
+    }
+  }
+  if (fileParts.length === 0) {
+    return editedText;
+  }
+  const items = [];
+  if (editedText.trim().length > 0) {
+    items.push({ type: "text", text: editedText });
+  }
+  items.push(...fileParts);
+  return items;
+}
+function buildMcpAuthUpdate(pendingMcpAuth, foldState, groupRootBaseline) {
+  const base = groupRootBaseline != null ? buildRootAssistantContentForIds(
+    foldState,
+    rootModelMessageIdsSinceBaseline(foldState, groupRootBaseline)
+  ) : buildRootAssistantContent(foldState);
+  return {
+    content: [...base, ...buildMcpAuthTextParts(pendingMcpAuth.mcpServers)],
+    status: mcpAuthAssistantStatus(),
+    metadata: { custom: mcpAuthMessageCustom(pendingMcpAuth.mcpServers) }
+  };
+}
+async function* streamTurnEvents(stream, foldState, groupRootBaseline) {
+  let pendingMcpAuth;
+  let sandboxId;
+  let sandboxIdYielded = false;
+  const withSandbox = (update) => {
+    if (sandboxId == null) {
+      return update;
+    }
+    sandboxIdYielded = true;
+    return {
+      ...update,
+      metadata: { ...update.metadata, custom: { ...update.metadata?.custom, sandboxId } }
+    };
+  };
+  const yieldContent = () => {
+    const ids = groupRootBaseline != null ? rootModelMessageIdsSinceBaseline(foldState, groupRootBaseline) : foldState.threads.get(ROOT_THREAD_ID)?.modelMessageIds ?? [];
+    const content = buildRootAssistantContentForIds(foldState, ids);
+    return content.length > 0 ? content : void 0;
+  };
+  for await (const data of stream) {
+    const event = data.event;
+    if (event.type === "sandbox.created") {
+      sandboxId = event.sandboxId;
+      continue;
+    }
+    if (event.type === "mcp.auth_required") {
+      pendingMcpAuth = event;
+      continue;
+    }
+    if (event.type === "turn.done") {
+      if (event.state.status === "error") {
+        throw new Error(event.state.message);
+      }
+      break;
+    }
+    if (!ingestStreamEvent(foldState, event)) {
+      continue;
+    }
+    const content = yieldContent();
+    if (content != null) {
+      yield withSandbox({ content });
+    }
+  }
+  if (pendingMcpAuth != null) {
+    yield withSandbox(buildMcpAuthUpdate(pendingMcpAuth, foldState, groupRootBaseline));
+    return;
+  }
+  const approvalThreadId = findFirstPendingApprovalThreadId(foldState);
+  const responseThreadId = findFirstPendingResponseThreadId(foldState);
+  if (approvalThreadId != null || responseThreadId != null) {
+    const custom = {};
+    if (approvalThreadId != null) {
+      Object.assign(
+        custom,
+        toolApprovalMessageCustom(
+          approvalThreadId === ROOT_THREAD_ID ? ROOT_THREAD_ID : approvalThreadId
+        )
+      );
+    }
+    if (responseThreadId != null) {
+      Object.assign(
+        custom,
+        toolResponseMessageCustom(
+          responseThreadId === ROOT_THREAD_ID ? ROOT_THREAD_ID : responseThreadId
+        )
+      );
+    }
+    const ids = groupRootBaseline != null ? rootModelMessageIdsSinceBaseline(foldState, groupRootBaseline) : foldState.threads.get(ROOT_THREAD_ID)?.modelMessageIds ?? [];
+    yield withSandbox({
+      content: buildRootAssistantContentForIds(foldState, ids),
+      status: approvalThreadId != null ? toolApprovalStatus() : toolResponseStatus(),
+      metadata: { custom }
+    });
+    return;
+  }
+  if (sandboxId != null && !sandboxIdYielded) {
+    const ids = groupRootBaseline != null ? rootModelMessageIdsSinceBaseline(foldState, groupRootBaseline) : foldState.threads.get(ROOT_THREAD_ID)?.modelMessageIds ?? [];
+    yield withSandbox({ content: buildRootAssistantContentForIds(foldState, ids) });
+  }
+}
+function turnStreamUpdateToAssistantMessage(turnId, update, existing, options) {
+  const id = existing?.role === "assistant" ? existing.id : `${turnId}-assistant`;
+  const fallbackCreatedAt = existing?.createdAt ?? /* @__PURE__ */ new Date();
+  return {
+    id,
+    role: "assistant",
+    content: update.content,
+    status: update.status ?? { type: "running" },
+    createdAt: resolveCreatedAt(id, fallbackCreatedAt, options),
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: update.metadata?.custom ?? {}
+    }
+  };
+}
+function repositoryItemsFromMessages(messages) {
+  const items = [];
+  let parentId = null;
+  for (const message of messages) {
+    items.push({ parentId, message });
+    parentId = message.id;
+  }
+  return items;
+}
+
+// src/draftSessionBridge.ts
+function createDraftSessionBridge(gateway) {
+  async function getDraft(draftSessionId) {
+    const response = await gateway.agents.private.draftSessions.get(draftSessionId);
+    return response.data;
+  }
+  return {
+    async getDraftAgentSpec(draftSessionId) {
+      const draft = await getDraft(draftSessionId);
+      return draft.agentSpec;
+    },
+    async syncAgentSpec(draftSessionId, agentSpec) {
+      await gateway.agents.private.draftSessions.update(draftSessionId, { agentSpec });
+    }
+  };
+}
+
+// src/agentSpec.ts
+function mergeAgentSpec(base, update) {
+  const { model: modelUpdate, ...rest } = update;
+  const next = {
+    ...base,
+    ...rest
+  };
+  if (modelUpdate != null) {
+    next.model = {
+      ...base.model,
+      ...modelUpdate,
+      name: modelUpdate.name ?? base.model.name,
+      params: modelUpdate.params != null ? { ...base.model.params, ...modelUpdate.params } : base.model.params
+    };
+  }
+  return next;
+}
+function draftSessionTitle(draft) {
+  return draft.title ?? draft.agentSpec.model.name;
+}
+
+// src/sessionListStartTimestamp.ts
+function sessionListStartTimestamp() {
+  const start = /* @__PURE__ */ new Date();
+  start.setFullYear(start.getFullYear() - 1);
+  return start.toISOString();
+}
+
+// src/truefoundryDraftThreadListAdapter.ts
+var THREAD_LIST_PAGE_SIZE = 20;
+function createTrueFoundryDraftThreadListAdapter(options) {
+  const { gateway, defaultAgentSpec, getAgentSpec } = options;
+  return {
+    async list({ after } = {}) {
+      const page = await gateway.agents.private.draftSessions.list({
+        limit: THREAD_LIST_PAGE_SIZE,
+        pageToken: after,
+        startTimestamp: sessionListStartTimestamp()
+      });
+      const threads = page.data.map((draft) => ({
+        status: "regular",
+        remoteId: draft.id,
+        title: draftSessionTitle(draft),
+        lastMessageAt: new Date(draft.updatedAt)
+      }));
+      return {
+        threads,
+        nextCursor: page.response.pagination.nextPageToken ?? void 0
+      };
+    },
+    async initialize(_threadId) {
+      const response = await gateway.agents.private.draftSessions.create({
+        agentSpec: getAgentSpec?.() ?? defaultAgentSpec
+      });
+      const draft = response.data;
+      return { remoteId: draft.id, externalId: void 0 };
+    },
+    async fetch(remoteId) {
+      const response = await gateway.agents.private.draftSessions.get(remoteId);
+      const draft = response.data;
+      return {
+        status: "regular",
+        remoteId: draft.id,
+        title: draftSessionTitle(draft),
+        lastMessageAt: new Date(draft.updatedAt)
+      };
+    },
+    async rename() {
+    },
+    async archive() {
+    },
+    async unarchive() {
+    },
+    async delete() {
+    },
+    async generateTitle() {
+      return new ReadableStream();
+    }
+  };
+}
+
+// src/truefoundryExtras.ts
+import { createRuntimeExtras } from "@assistant-ui/core/internal";
+var trueFoundryExtras = createRuntimeExtras(
+  "useTrueFoundryAgentRuntime"
+);
+var EMPTY_DRAFT_EXTRAS = {
+  agentSpec: null,
+  draftSessionId: void 0,
+  isSpecSyncing: false,
+  specError: null,
+  updateAgentSpec: () => {
+    throw new Error("Draft agent extras are only available in draft mode.");
+  }
+};
+
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/core/fetcher/HttpResponsePromise.mjs
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var HttpResponsePromise = class _HttpResponsePromise extends Promise {
+  constructor(promise) {
+    super((resolve) => {
+      resolve(void 0);
+    });
+    this.innerPromise = promise;
+  }
+  /**
+   * Creates an `HttpResponsePromise` from a function that returns a promise.
+   *
+   * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
+   * @param args - Arguments to pass to the function.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromFunction(fn, ...args) {
+    return new _HttpResponsePromise(fn(...args));
+  }
+  /**
+   * Creates a function that returns an `HttpResponsePromise` from a function that returns a promise.
+   *
+   * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
+   * @returns A function that returns an `HttpResponsePromise` instance.
+   */
+  static interceptFunction(fn) {
+    return (...args) => {
+      return _HttpResponsePromise.fromPromise(fn(...args));
+    };
+  }
+  /**
+   * Creates an `HttpResponsePromise` from an existing promise.
+   *
+   * @param promise - A promise resolving to a `WithRawResponse` object.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromPromise(promise) {
+    return new _HttpResponsePromise(promise);
+  }
+  /**
+   * Creates an `HttpResponsePromise` from an executor function.
+   *
+   * @param executor - A function that takes resolve and reject callbacks to create a promise.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromExecutor(executor) {
+    const promise = new Promise(executor);
+    return new _HttpResponsePromise(promise);
+  }
+  /**
+   * Creates an `HttpResponsePromise` from a resolved result.
+   *
+   * @param result - A `WithRawResponse` object to resolve immediately.
+   * @returns An `HttpResponsePromise` instance.
+   */
+  static fromResult(result) {
+    const promise = Promise.resolve(result);
+    return new _HttpResponsePromise(promise);
+  }
+  unwrap() {
+    if (!this.unwrappedPromise) {
+      this.unwrappedPromise = this.innerPromise.then(({ data }) => data);
+    }
+    return this.unwrappedPromise;
+  }
+  /** @inheritdoc */
+  then(onfulfilled, onrejected) {
+    return this.unwrap().then(onfulfilled, onrejected);
+  }
+  /** @inheritdoc */
+  catch(onrejected) {
+    return this.unwrap().catch(onrejected);
+  }
+  /** @inheritdoc */
+  finally(onfinally) {
+    return this.unwrap().finally(onfinally);
+  }
+  /**
+   * Retrieves the data and raw response.
+   *
+   * @returns A promise resolving to a `WithRawResponse` object.
+   */
+  withRawResponse() {
+    return __awaiter(this, void 0, void 0, function* () {
+      return yield this.innerPromise;
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/core/pagination/Page.mjs
+var __awaiter2 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __await = function(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+};
+var __asyncGenerator = function(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+};
+var __asyncValues = function(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+};
+var Page = class {
+  constructor({ response, rawResponse, hasNextPage, getItems, loadPage }) {
+    this.response = response;
+    this.rawResponse = rawResponse;
+    this.data = getItems(response);
+    this._hasNextPage = hasNextPage;
+    this.getItems = getItems;
+    this.loadNextPage = loadPage;
+  }
+  /**
+   * Retrieves the next page
+   * @returns this
+   */
+  getNextPage() {
+    return __awaiter2(this, void 0, void 0, function* () {
+      const { data, rawResponse } = yield this.loadNextPage(this.response).withRawResponse();
+      this.response = data;
+      this.rawResponse = rawResponse;
+      this.data = this.getItems(this.response);
+      return this;
+    });
+  }
+  /**
+   * @returns whether there is a next page to load
+   */
+  hasNextPage() {
+    return this._hasNextPage(this.response);
+  }
+  iterMessages() {
+    return __asyncGenerator(this, arguments, function* iterMessages_1() {
+      for (const item of this.data) {
+        yield yield __await(item);
+      }
+      while (this.hasNextPage()) {
+        yield __await(this.getNextPage());
+        for (const item of this.data) {
+          yield yield __await(item);
+        }
+      }
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, arguments, function* _a() {
+      var _b, e_1, _c, _d;
+      try {
+        for (var _e = true, _f = __asyncValues(this.iterMessages()), _g; _g = yield __await(_f.next()), _b = _g.done, !_b; _e = true) {
+          _d = _g.value;
+          _e = false;
+          const message = _d;
+          yield yield __await(message);
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (!_e && !_b && (_c = _f.return)) yield __await(_c.call(_f));
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/agents/TurnStreamData.mjs
+function parseSequenceNumber(id) {
+  if (!id) {
+    throw new Error("Missing SSE sequence number id.");
+  }
+  const parsed = Number(id);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Invalid SSE sequence number id: "${id}".`);
+  }
+  return parsed;
+}
+
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/agents/Turn.mjs
+var __awaiter3 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __await2 = function(v) {
+  return this instanceof __await2 ? (this.v = v, this) : new __await2(v);
+};
+var __asyncValues2 = function(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+};
+var __asyncGenerator2 = function(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await2 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+};
+var _Turn_instances;
+var _Turn_client;
+var _Turn_state;
+var _Turn_applyEvent;
+var DEFAULT_POLL_INTERVAL_MS = 3e3;
+var MIN_POLL_INTERVAL_MS = 3e3;
+var Turn = class {
+  constructor(turn, session, client) {
+    _Turn_instances.add(this);
+    _Turn_client.set(this, void 0);
+    _Turn_state.set(this, void 0);
+    this.id = turn.id;
+    this.sessionId = turn.sessionId;
+    this.previousTurnId = turn.previousTurnId;
+    this.input = turn.input;
+    this.createdBySubject = turn.createdBySubject;
+    this.createdAt = turn.createdAt;
+    __classPrivateFieldSet(this, _Turn_state, turn.state, "f");
+    this.session = session;
+    __classPrivateFieldSet(this, _Turn_client, client, "f");
+  }
+  /**
+   * @returns {TrueFoundryGatewayApi.TurnState} Updated by `refresh()`, `stream()`, and `waitForCompletion()`.
+   */
+  get state() {
+    return __classPrivateFieldGet(this, _Turn_state, "f");
+  }
+  // Terminal states are listed explicitly (not `status !== "running"`) so a newly added
+  // non-terminal status keeps polling by default; new terminal states must be added here.
+  isTerminal(state) {
+    switch (state.status) {
+      case "done":
+      case "cancelled":
+      case "error":
+        return true;
+      default:
+        return false;
+    }
+  }
+  // Refetch from the server, update #state in place, and return self.
+  /**
+   * Refetch from the server, update state in-place and return self.
+   *
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {this} This turn with updated state.
+   */
+  refresh(requestOptions) {
+    return __awaiter3(this, void 0, void 0, function* () {
+      const response = yield __classPrivateFieldGet(this, _Turn_client, "f").agents.sessions.getTurn(this.sessionId, this.id, requestOptions);
+      __classPrivateFieldSet(this, _Turn_state, response.data.state, "f");
+      return this;
+    });
+  }
+  /**
+   * Poll getTurn until terminal.
+   *
+   * @param opts.pollIntervalMs - Poll interval ms while waiting. Minimum 3000.
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {TrueFoundryGatewayApi.TurnState} Terminal turn state.
+   */
+  waitForCompletion(opts, requestOptions) {
+    return __awaiter3(this, void 0, void 0, function* () {
+      var _a;
+      const pollIntervalMs = (_a = opts === null || opts === void 0 ? void 0 : opts.pollIntervalMs) !== null && _a !== void 0 ? _a : DEFAULT_POLL_INTERVAL_MS;
+      if (pollIntervalMs < MIN_POLL_INTERVAL_MS) {
+        throw new Error(`pollIntervalMs must be at least ${MIN_POLL_INTERVAL_MS}ms`);
+      }
+      while (!this.isTerminal(__classPrivateFieldGet(this, _Turn_state, "f"))) {
+        yield new Promise((r) => setTimeout(r, pollIntervalMs));
+        yield this.refresh(requestOptions);
+      }
+      return __classPrivateFieldGet(this, _Turn_state, "f");
+    });
+  }
+  // Reconnect to the turn's SSE; let the server decide what to stream (no client-side guard).
+  // Updates #state in place from any event that carries a state snapshot.
+  /**
+   * Reconnect to the turn's SSE. Updates state in-place from lifecycle events.
+   *
+   * @param opts.afterSequenceNumber - Sequence number to resume SSE subscription after.
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @yields {TurnStreamData} SSE stream items.
+   */
+  stream(opts, requestOptions) {
+    return __asyncGenerator2(this, arguments, function* stream_1() {
+      var _a, e_1, _b, _c;
+      const sse = yield __await2(__classPrivateFieldGet(this, _Turn_client, "f").agents.sessions.subscribeToTurn(this.sessionId, this.id, { afterSequenceNumber: opts === null || opts === void 0 ? void 0 : opts.afterSequenceNumber }, requestOptions));
+      try {
+        for (var _d = true, _e = __asyncValues2(sse.withMetadata()), _f; _f = yield __await2(_e.next()), _a = _f.done, !_a; _d = true) {
+          _c = _f.value;
+          _d = false;
+          const { data: event, id } = _c;
+          __classPrivateFieldGet(this, _Turn_instances, "m", _Turn_applyEvent).call(this, event);
+          yield yield __await2({ sequenceNumber: parseSequenceNumber(id), event });
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (!_d && !_a && (_b = _e.return)) yield __await2(_b.call(_e));
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+    });
+  }
+  /**
+   * Cancel the running last turn for the session.
+   *
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {void}
+   */
+  cancel(requestOptions) {
+    return __awaiter3(this, void 0, void 0, function* () {
+      yield __classPrivateFieldGet(this, _Turn_client, "f").agents.sessions.cancel(this.sessionId, {}, requestOptions);
+    });
+  }
+  // Expose the autogen Fern Page as-is (it is already async-iterable); no re-wrapping.
+  /**
+   * Paginated turn events; use `stream()` for live SSE.
+   *
+   * @param opts.pageToken - Token from the previous response nextPageToken.
+   * @param opts.limit - Page size. Default 25.
+   * @param opts.order - Sort by creation time. Default `asc`.
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {Promise<core.Page<TrueFoundryGatewayApi.TurnEvent, TrueFoundryGatewayApi.ListEventsResponse>>} Paginated turn events.
+   */
+  listEvents(opts, requestOptions) {
+    return __classPrivateFieldGet(this, _Turn_client, "f").agents.sessions.listTurnEvents(this.sessionId, this.id, opts, requestOptions);
+  }
+};
+_Turn_client = /* @__PURE__ */ new WeakMap(), _Turn_state = /* @__PURE__ */ new WeakMap(), _Turn_instances = /* @__PURE__ */ new WeakSet(), _Turn_applyEvent = function _Turn_applyEvent2(event) {
+  if (event.type === "turn.created" || event.type === "turn.done")
+    __classPrivateFieldSet(this, _Turn_state, event.state, "f");
+};
+
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/agents/PreparedTurn.mjs
+var __awaiter4 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __classPrivateFieldSet2 = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet2 = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __asyncValues3 = function(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+};
+var __await3 = function(v) {
+  return this instanceof __await3 ? (this.v = v, this) : new __await3(v);
+};
+var __asyncDelegator = function(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await3(o[n](v)), done: false } : f ? f(v) : v;
+    } : f;
+  }
+};
+var __asyncGenerator3 = function(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await3 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+};
+var _PreparedTurn_client;
+var _PreparedTurn_input;
+var _PreparedTurn_previousTurnIdInput;
+var _PreparedTurn_start;
+var _PreparedTurn_turn;
+var PreparedTurn = class {
+  constructor(init, session, client) {
+    _PreparedTurn_client.set(this, void 0);
+    _PreparedTurn_input.set(this, void 0);
+    _PreparedTurn_previousTurnIdInput.set(this, void 0);
+    _PreparedTurn_start.set(this, void 0);
+    _PreparedTurn_turn.set(this, void 0);
+    this.session = session;
+    this.sessionId = session.id;
+    __classPrivateFieldSet2(this, _PreparedTurn_client, client, "f");
+    __classPrivateFieldSet2(this, _PreparedTurn_input, init.input, "f");
+    __classPrivateFieldSet2(this, _PreparedTurn_previousTurnIdInput, init.previousTurnId, "f");
+  }
+  // Remaining data getters delegate to the inner Turn (undefined until started).
+  /**
+   * @returns {string | undefined} Undefined until `execute()` starts the turn.
+   */
+  get id() {
+    var _a;
+    return (_a = __classPrivateFieldGet2(this, _PreparedTurn_turn, "f")) === null || _a === void 0 ? void 0 : _a.id;
+  }
+  /**
+   * @returns {string | undefined} Undefined until `execute()` starts the turn.
+   */
+  get previousTurnId() {
+    var _a;
+    return (_a = __classPrivateFieldGet2(this, _PreparedTurn_turn, "f")) === null || _a === void 0 ? void 0 : _a.previousTurnId;
+  }
+  /**
+   * @returns {TrueFoundryGatewayApi.TurnState | undefined} Undefined until `execute()` starts the turn.
+   */
+  get state() {
+    var _a;
+    return (_a = __classPrivateFieldGet2(this, _PreparedTurn_turn, "f")) === null || _a === void 0 ? void 0 : _a.state;
+  }
+  /**
+   * @returns {TrueFoundryGatewayApi.Subject | undefined} Undefined until `execute()` starts the turn.
+   */
+  get createdBySubject() {
+    var _a;
+    return (_a = __classPrivateFieldGet2(this, _PreparedTurn_turn, "f")) === null || _a === void 0 ? void 0 : _a.createdBySubject;
+  }
+  /**
+   * @returns {string | undefined} Undefined until `execute()` starts the turn.
+   */
+  get createdAt() {
+    var _a;
+    return (_a = __classPrivateFieldGet2(this, _PreparedTurn_turn, "f")) === null || _a === void 0 ? void 0 : _a.createdAt;
+  }
+  /**
+   * @returns {TrueFoundryGatewayApi.TurnInputItem[] | undefined} Staged input before execute; inner turn input after.
+   */
+  get input() {
+    var _a, _b;
+    return (_b = (_a = __classPrivateFieldGet2(this, _PreparedTurn_turn, "f")) === null || _a === void 0 ? void 0 : _a.input) !== null && _b !== void 0 ? _b : __classPrivateFieldGet2(this, _PreparedTurn_input, "f");
+  }
+  execute(opts, requestOptions) {
+    if (__classPrivateFieldGet2(this, _PreparedTurn_start, "f") != null)
+      throw new Error("Turn already started; use stream() / waitForCompletion().");
+    __classPrivateFieldSet2(this, _PreparedTurn_start, this.openCreateTurn(requestOptions), "f");
+    const { stream = true, pollIntervalMs } = opts !== null && opts !== void 0 ? opts : {};
+    return stream === false ? this.startAndWait(pollIntervalMs, requestOptions) : this.runStreaming();
+  }
+  // Post-execution behaviors. Each throws via mustGetTurn() until execute() has started the turn,
+  // then delegates to the inner Turn. stream() here is the re-subscribe path (subscribeToTurn).
+  /**
+   * Resubscribe via subscribeToTurn after `execute()`.
+   *
+   * @param opts.afterSequenceNumber - Sequence number to resume SSE subscription after.
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @yields {TurnStreamData} SSE stream items.
+   */
+  stream(opts, requestOptions) {
+    return __asyncGenerator3(this, arguments, function* stream_1() {
+      yield __await3(yield* __asyncDelegator(__asyncValues3(this.mustGetTurn().stream(opts, requestOptions))));
+    });
+  }
+  /**
+   * Refetch from the server, update state in-place and return self.
+   *
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {this} This prepared turn with updated state.
+   */
+  refresh(requestOptions) {
+    return __awaiter4(this, void 0, void 0, function* () {
+      yield this.mustGetTurn().refresh(requestOptions);
+      return this;
+    });
+  }
+  /**
+   * Poll getTurn until terminal.
+   *
+   * @param opts.pollIntervalMs - Poll interval ms while waiting. Minimum 3000.
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {TrueFoundryGatewayApi.TurnState} Terminal turn state.
+   */
+  waitForCompletion(opts, requestOptions) {
+    return __awaiter4(this, void 0, void 0, function* () {
+      return this.mustGetTurn().waitForCompletion(opts, requestOptions);
+    });
+  }
+  /**
+   * Cancel the running last turn for the session.
+   *
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {void}
+   */
+  cancel(requestOptions) {
+    return __awaiter4(this, void 0, void 0, function* () {
+      return this.mustGetTurn().cancel(requestOptions);
+    });
+  }
+  /**
+   * Paginated turn events; use `stream()` for live SSE.
+   *
+   * @param opts.pageToken - Token from the previous response nextPageToken.
+   * @param opts.limit - Page size. Default 25.
+   * @param opts.order - Sort by creation time. Default `asc`.
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {Promise<core.Page<TrueFoundryGatewayApi.TurnEvent, TrueFoundryGatewayApi.ListEventsResponse>>} Paginated turn events.
+   */
+  listEvents(opts, requestOptions) {
+    return this.mustGetTurn().listEvents(opts, requestOptions);
+  }
+  // execute(stream:true) path: consume the already-open createTurn SSE (#start), adopting the inner Turn on turn.created.
+  runStreaming() {
+    return __asyncGenerator3(this, arguments, function* runStreaming_1() {
+      yield __await3(yield* __asyncDelegator(__asyncValues3(this.consumeStream(yield __await3(__classPrivateFieldGet2(this, _PreparedTurn_start, "f"))))));
+    });
+  }
+  // execute(stream:false) path: drive the open createTurn SSE until turn.created mints the inner Turn, then poll to terminal.
+  startAndWait(pollIntervalMs, requestOptions) {
+    return __awaiter4(this, void 0, void 0, function* () {
+      const turn = yield this.createTurnIfNotExist();
+      return turn.waitForCompletion({ pollIntervalMs }, requestOptions);
+    });
+  }
+  // Consume an SSE stream, adopting the inner Turn from the first turn.created and yielding all events.
+  // Isolated so a future reconnect wrapper can re-open the stream (subscribeToTurn) on disconnect.
+  // NOTE: reconnect/resume is out of current scope.
+  consumeStream(sse) {
+    return __asyncGenerator3(this, arguments, function* consumeStream_1() {
+      var _a, e_1, _b, _c;
+      try {
+        for (var _d = true, _e = __asyncValues3(sse.withMetadata()), _f; _f = yield __await3(_e.next()), _a = _f.done, !_a; _d = true) {
+          _c = _f.value;
+          _d = false;
+          const { data: event, id } = _c;
+          if (event.type === "turn.created" && __classPrivateFieldGet2(this, _PreparedTurn_turn, "f") == null)
+            this.adoptTurn(event);
+          else if (__classPrivateFieldGet2(this, _PreparedTurn_turn, "f") != null && event.type === "turn.done")
+            this.replaceTurnState(event.state);
+          yield yield __await3({ sequenceNumber: parseSequenceNumber(id), event });
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (!_d && !_a && (_b = _e.return)) yield __await3(_b.call(_e));
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+    });
+  }
+  // Returns the inner Turn or throws if execute() has not started it yet.
+  mustGetTurn() {
+    if (__classPrivateFieldGet2(this, _PreparedTurn_turn, "f") == null) {
+      throw new Error("Turn not started yet; call execute() first.");
+    }
+    return __classPrivateFieldGet2(this, _PreparedTurn_turn, "f");
+  }
+  // Drive the in-flight createTurn SSE (#start) only until the first turn.created has built the inner
+  // Turn, then break (which closes the underlying SSE via the generator's return()). Returns the Turn.
+  createTurnIfNotExist() {
+    return __awaiter4(this, void 0, void 0, function* () {
+      var _a, e_2, _b, _c;
+      if (__classPrivateFieldGet2(this, _PreparedTurn_turn, "f") == null) {
+        try {
+          for (var _d = true, _e = __asyncValues3(this.consumeStream(yield __classPrivateFieldGet2(this, _PreparedTurn_start, "f"))), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+            _c = _f.value;
+            _d = false;
+            const _event = _c;
+            if (__classPrivateFieldGet2(this, _PreparedTurn_turn, "f") != null)
+              break;
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+      return this.mustGetTurn();
+    });
+  }
+  // Open the createTurn SSE with the pending input/previousTurnId. Called synchronously by execute()
+  // so the POST is in flight (and #start latched) before execute returns.
+  openCreateTurn(requestOptions) {
+    return __classPrivateFieldGet2(this, _PreparedTurn_client, "f").agents.sessions.createTurn(this.sessionId, { input: __classPrivateFieldGet2(this, _PreparedTurn_input, "f"), previousTurnId: __classPrivateFieldGet2(this, _PreparedTurn_previousTurnIdInput, "f") }, requestOptions);
+  }
+  // Build the inner Turn directly from the turn.created event (no extra getTurn round trip).
+  // The TurnCreatedEvent member of the TurnStreamingEvent union carries everything Turn needs.
+  // input comes from the request we sent (this.#input), not the event.
+  adoptTurn(event) {
+    __classPrivateFieldSet2(this, _PreparedTurn_turn, new Turn({
+      id: event.turnId,
+      sessionId: this.sessionId,
+      previousTurnId: event.previousTurnId,
+      input: __classPrivateFieldGet2(this, _PreparedTurn_input, "f"),
+      state: event.state,
+      createdBySubject: event.createdBy,
+      createdAt: event.createdAt
+    }, this.session, __classPrivateFieldGet2(this, _PreparedTurn_client, "f")), "f");
+  }
+  // Replace the inner Turn with a fresh one carrying the new state. State changes are rare, so
+  // rebuilding via Turn's own constructor (rather than mutating it) keeps Turn the source of truth.
+  replaceTurnState(state) {
+    const turn = this.mustGetTurn();
+    __classPrivateFieldSet2(this, _PreparedTurn_turn, new Turn({
+      id: turn.id,
+      sessionId: turn.sessionId,
+      previousTurnId: turn.previousTurnId,
+      input: turn.input,
+      state,
+      createdBySubject: turn.createdBySubject,
+      createdAt: turn.createdAt
+    }, this.session, __classPrivateFieldGet2(this, _PreparedTurn_client, "f")), "f");
+  }
+};
+_PreparedTurn_client = /* @__PURE__ */ new WeakMap(), _PreparedTurn_input = /* @__PURE__ */ new WeakMap(), _PreparedTurn_previousTurnIdInput = /* @__PURE__ */ new WeakMap(), _PreparedTurn_start = /* @__PURE__ */ new WeakMap(), _PreparedTurn_turn = /* @__PURE__ */ new WeakMap();
+
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/agents/AgentSession.mjs
+var __awaiter5 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __classPrivateFieldSet3 = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet3 = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AgentSession_client;
+var AgentSession = class {
+  constructor(session, client) {
+    _AgentSession_client.set(this, void 0);
+    this.id = session.id;
+    this.agentName = session.agentName;
+    this.title = session.title;
+    this.createdBySubject = session.createdBySubject;
+    this.createdAt = session.createdAt;
+    this.updatedAt = session.updatedAt;
+    __classPrivateFieldSet3(this, _AgentSession_client, client, "f");
+  }
+  /**
+   * Stage a turn locally; call `execute()` to start `createTurn`.
+   *
+   * @param opts.input - Turn input items passed to createTurn.
+   * @param opts.previousTurnId - Previous turn to chain from. Default `auto`.
+   * @returns {PreparedTurn} Staged turn.
+   */
+  prepareTurn(opts) {
+    return new PreparedTurn({ input: opts === null || opts === void 0 ? void 0 : opts.input, previousTurnId: opts === null || opts === void 0 ? void 0 : opts.previousTurnId }, this, __classPrivateFieldGet3(this, _AgentSession_client, "f"));
+  }
+  /**
+   * List turns in this session.
+   *
+   * @param opts.pageToken - Token from the previous response nextPageToken.
+   * @param opts.limit - Page size. Default 10.
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {core.Page<Turn, TrueFoundryGatewayApi.ListTurnsResponse>} Paginated turns.
+   */
+  listTurns(opts, requestOptions) {
+    return __awaiter5(this, void 0, void 0, function* () {
+      const client = __classPrivateFieldGet3(this, _AgentSession_client, "f");
+      const sessionId = this.id;
+      const page = yield client.agents.sessions.listTurns(sessionId, opts, requestOptions);
+      return new Page({
+        response: page.response,
+        rawResponse: page.rawResponse,
+        hasNextPage: (response) => !!(response === null || response === void 0 ? void 0 : response.pagination.nextPageToken),
+        getItems: (response) => {
+          var _a;
+          return ((_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : []).map((turn) => new Turn(turn, this, client));
+        },
+        loadPage: (response) => HttpResponsePromise.fromPromise(client.agents.sessions.listTurns(sessionId, Object.assign(Object.assign({}, opts), { pageToken: response === null || response === void 0 ? void 0 : response.pagination.nextPageToken }), requestOptions).then((nextPage) => ({ data: nextPage.response, rawResponse: nextPage.rawResponse })))
+      });
+    });
+  }
+  /**
+   * Fetch a turn by ID.
+   *
+   * @param opts.turnId - Unique identifier of the turn to fetch.
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {Turn} Turn data.
+   */
+  getTurn(opts, requestOptions) {
+    return __awaiter5(this, void 0, void 0, function* () {
+      const response = yield __classPrivateFieldGet3(this, _AgentSession_client, "f").agents.sessions.getTurn(this.id, opts.turnId, requestOptions);
+      return new Turn(response.data, this, __classPrivateFieldGet3(this, _AgentSession_client, "f"));
+    });
+  }
+  /**
+   * Cancel the running last turn for the session.
+   *
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {void}
+   */
+  cancel(requestOptions) {
+    return __awaiter5(this, void 0, void 0, function* () {
+      yield __classPrivateFieldGet3(this, _AgentSession_client, "f").agents.sessions.cancel(this.id, {}, requestOptions);
+    });
+  }
+};
+_AgentSession_client = /* @__PURE__ */ new WeakMap();
+
+// src/bindDraftAgentSession.ts
+var inflightByDraftId = /* @__PURE__ */ new Map();
+function getGatewayFromSessionClient(client) {
+  const internal = client;
+  if (internal.client == null) {
+    throw new Error("AgentSessionClient is missing an internal gateway client.");
+  }
+  return internal.client;
+}
+function draftToSessionRecord(draft) {
+  return {
+    id: draft.id,
+    agentName: draft.agentName ?? "",
+    title: draft.title,
+    createdBySubject: draft.createdBySubject,
+    createdAt: draft.createdAt,
+    updatedAt: draft.updatedAt
+  };
+}
+async function bindDraftAgentSession(client, gateway, draftSessionId) {
+  let inflight = inflightByDraftId.get(draftSessionId);
+  if (inflight == null) {
+    inflight = (async () => {
+      const response = await gateway.agents.private.draftSessions.get(draftSessionId);
+      return new AgentSession(
+        draftToSessionRecord(response.data),
+        getGatewayFromSessionClient(client)
+      );
+    })().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?.draftGateway != null) {
+    return bindDraftAgentSession(client, options.draftGateway, sessionId);
+  }
+  let inflight = inflightBySessionId.get(sessionId);
+  if (inflight == null) {
+    inflight = client.getSession({ sessionId }).finally(() => {
+      if (inflightBySessionId.get(sessionId) === inflight) {
+        inflightBySessionId.delete(sessionId);
+      }
+    });
+    inflightBySessionId.set(sessionId, inflight);
+  }
+  return inflight;
+}
+
+// src/truefoundryThreadListAdapter.ts
+var THREAD_LIST_PAGE_SIZE2 = 20;
+function createTrueFoundryThreadListAdapter(options) {
+  const { client, agentName } = options;
+  return {
+    async list({ after } = {}) {
+      const page = await client.listSessions({
+        agentName,
+        limit: THREAD_LIST_PAGE_SIZE2,
+        pageToken: after,
+        startTimestamp: sessionListStartTimestamp()
+      });
+      const threads = page.data.map((session) => ({
+        status: "regular",
+        remoteId: session.id,
+        title: session.title,
+        lastMessageAt: new Date(session.updatedAt)
+      }));
+      return {
+        threads,
+        nextCursor: page.response.pagination.nextPageToken ?? void 0
+      };
+    },
+    async initialize(_threadId) {
+      const session = await client.createSession({ agentName });
+      return { remoteId: session.id, externalId: void 0 };
+    },
+    async fetch(remoteId) {
+      const session = await getSession(client, remoteId);
+      return {
+        status: "regular",
+        remoteId: session.id,
+        title: session.title,
+        lastMessageAt: new Date(session.updatedAt)
+      };
+    },
+    async rename() {
+    },
+    async archive() {
+    },
+    async unarchive() {
+    },
+    async delete() {
+    },
+    async generateTitle() {
+      return new ReadableStream();
+    }
+  };
+}
+
+// src/types.ts
+function resolveTrueFoundryAgentConfig(options) {
+  if (options.agent != null) {
+    if (options.agent.mode === "named" && options.agentName != null) {
+      return { mode: "named", agentName: options.agentName };
+    }
+    return options.agent;
+  }
+  if (options.agentName != null) {
+    return { mode: "named", agentName: options.agentName };
+  }
+  throw new Error(
+    "useTrueFoundryAgentRuntime requires `agent` or legacy `agentName`."
+  );
+}
+function resolveTrueFoundryAgentRuntimeOptions(options) {
+  const agent = resolveTrueFoundryAgentConfig(options);
+  if (agent.mode === "draft" && options.gateway == null) {
+    throw new Error(
+      "Draft agent mode requires a `gateway` TrueFoundryGateway client."
+    );
+  }
+  return {
+    ...options,
+    agent,
+    gateway: options.gateway
+  };
+}
+
+// src/useDraftAgentSpec.ts
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+var SPEC_SYNC_DEBOUNCE_MS = 400;
+function useDraftAgentSpec({
+  draftSessionId,
+  draftBridge,
+  defaultAgentSpec,
+  onAgentSpecChange,
+  onError
+}) {
+  const enabled = draftBridge != null;
+  const [agentSpec, setAgentSpec] = useState(defaultAgentSpec);
+  const [isSpecSyncing, setIsSpecSyncing] = useState(false);
+  const [specError, setSpecError] = useState(null);
+  const agentSpecRef = useRef(agentSpec);
+  agentSpecRef.current = agentSpec;
+  const syncTimeoutRef = useRef(void 0);
+  const syncGenerationRef = useRef(0);
+  const loadedDraftIdRef = useRef(void 0);
+  const localDirtyRef = useRef(false);
+  useEffect(() => {
+    if (!enabled || draftBridge == null) {
+      return;
+    }
+    if (draftSessionId == null) {
+      loadedDraftIdRef.current = void 0;
+      setAgentSpec(defaultAgentSpec);
+      localDirtyRef.current = false;
+      setSpecError(null);
+      return;
+    }
+    if (loadedDraftIdRef.current === draftSessionId) {
+      return;
+    }
+    let cancelled = false;
+    void (async () => {
+      try {
+        const loaded = await draftBridge.getDraftAgentSpec(draftSessionId);
+        if (cancelled) {
+          return;
+        }
+        loadedDraftIdRef.current = draftSessionId;
+        if (localDirtyRef.current) {
+          scheduleSpecSyncRef.current?.(draftSessionId, agentSpecRef.current);
+          localDirtyRef.current = false;
+          setSpecError(null);
+          return;
+        }
+        setAgentSpec(loaded);
+        setSpecError(null);
+      } catch (error) {
+        if (!cancelled) {
+          onError?.(error);
+          setSpecError(error);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [defaultAgentSpec, draftBridge, draftSessionId, enabled, onError]);
+  const flushSpecSync = useCallback(
+    async (draftId, spec, generation) => {
+      if (draftBridge == null) {
+        return;
+      }
+      setIsSpecSyncing(true);
+      try {
+        await draftBridge.syncAgentSpec(draftId, spec);
+        if (generation !== syncGenerationRef.current) {
+          return;
+        }
+        setSpecError(null);
+        onAgentSpecChange?.(spec);
+      } catch (error) {
+        if (generation === syncGenerationRef.current) {
+          setSpecError(error);
+          onError?.(error);
+        }
+      } finally {
+        if (generation === syncGenerationRef.current) {
+          setIsSpecSyncing(false);
+        }
+      }
+    },
+    [draftBridge, onAgentSpecChange, onError]
+  );
+  const scheduleSpecSync = useCallback(
+    (draftId, spec) => {
+      if (syncTimeoutRef.current != null) {
+        clearTimeout(syncTimeoutRef.current);
+      }
+      const generation = ++syncGenerationRef.current;
+      syncTimeoutRef.current = setTimeout(() => {
+        void flushSpecSync(draftId, spec, generation);
+      }, SPEC_SYNC_DEBOUNCE_MS);
+    },
+    [flushSpecSync]
+  );
+  const scheduleSpecSyncRef = useRef(scheduleSpecSync);
+  scheduleSpecSyncRef.current = scheduleSpecSync;
+  useEffect(
+    () => () => {
+      if (syncTimeoutRef.current != null) {
+        clearTimeout(syncTimeoutRef.current);
+      }
+    },
+    []
+  );
+  const updateAgentSpec = useCallback(
+    (update) => {
+      if (!enabled || draftBridge == null) {
+        return;
+      }
+      const next = mergeAgentSpec(agentSpecRef.current, update);
+      setAgentSpec(next);
+      localDirtyRef.current = true;
+      if (draftSessionId != null) {
+        scheduleSpecSync(draftSessionId, next);
+      }
+    },
+    [draftBridge, draftSessionId, enabled, scheduleSpecSync]
+  );
+  return useMemo(
+    () => ({
+      agentSpec: enabled ? agentSpec : null,
+      draftSessionId: enabled ? draftSessionId : void 0,
+      isSpecSyncing: enabled ? isSpecSyncing : false,
+      specError: enabled ? specError : null,
+      updateAgentSpec
+    }),
+    [
+      agentSpec,
+      draftSessionId,
+      enabled,
+      isSpecSyncing,
+      specError,
+      updateAgentSpec
+    ]
+  );
+}
+
+// src/useTrueFoundryAgentMessages.ts
+import { generateId } from "@assistant-ui/core";
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/loadSessionSnapshot.ts
+var inflightBySessionId2 = /* @__PURE__ */ new Map();
+function loadSessionSnapshot(client, sessionId, concurrency, sessionOptions) {
+  const cacheKey = sessionOptions?.draftGateway != null ? `draft:${sessionId}` : sessionId;
+  let inflight = inflightBySessionId2.get(cacheKey);
+  if (inflight == null) {
+    inflight = getSession(client, sessionId, sessionOptions).then((session) => buildSnapshotFromSession(session, concurrency)).finally(() => {
+      if (inflightBySessionId2.get(cacheKey) === inflight) {
+        inflightBySessionId2.delete(cacheKey);
+      }
+    });
+    inflightBySessionId2.set(cacheKey, inflight);
+  }
+  return inflight;
+}
+
+// src/requiredActionInputs.ts
+function messageHasPendingRequiredActions(message) {
+  return messageHasPendingApprovals(message) || messageHasPendingResponses(message);
+}
+function collectRequiredActionInputs(message, defaultThreadId = ROOT_THREAD_ID) {
+  if (messageHasPendingRequiredActions(message)) {
+    return [];
+  }
+  return [
+    ...collectApprovalInputs(message, defaultThreadId),
+    ...collectResponseInputs(message, defaultThreadId)
+  ];
+}
+function findPausedAssistantMessage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const candidate = messages[i];
+    if (candidate?.role === "assistant" && candidate.status?.type === "requires-action") {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+
+// src/streamTurn.ts
+import "truefoundry-gateway-sdk/agents";
+function buildTurnInput(options) {
+  if (options.inputs != null) {
+    return options.inputs;
+  }
+  if (options.resumeMcpAuth === true) {
+    return [];
+  }
+  return [{ type: "user.message", content: options.userMessage ?? "" }];
+}
+function bindAbort(session, abortSignal) {
+  const onAbort = () => {
+    void session.cancel().catch(() => void 0);
+  };
+  if (abortSignal.aborted) {
+    onAbort();
+    return onAbort;
+  }
+  abortSignal.addEventListener("abort", onAbort, { once: true });
+  return onAbort;
+}
+async function* streamTurnContent(session, foldState, options, abortSignal, groupRootBaseline) {
+  const previousTurnId = options.previousTurnId === null ? void 0 : options.previousTurnId ?? "auto";
+  const turn = session.prepareTurn({
+    input: buildTurnInput(options),
+    ...previousTurnId != null ? { previousTurnId } : {}
+  });
+  const onAbort = bindAbort(session, abortSignal);
+  if (abortSignal.aborted) {
+    return;
+  }
+  try {
+    yield* streamTurnEvents(
+      turn.execute({ stream: true }, { abortSignal }),
+      foldState,
+      groupRootBaseline
+    );
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    throw error;
+  } finally {
+    abortSignal.removeEventListener("abort", onAbort);
+  }
+}
+async function* resumeTurnStream(turn, foldState, abortSignal, afterSequenceNumber, groupRootBaseline) {
+  const onAbort = () => {
+    void turn.session.cancel().catch(() => void 0);
+  };
+  if (abortSignal.aborted) {
+    onAbort();
+    return;
+  }
+  abortSignal.addEventListener("abort", onAbort, { once: true });
+  try {
+    yield* streamTurnEvents(
+      turn.stream(
+        afterSequenceNumber != null ? { afterSequenceNumber } : {},
+        { abortSignal }
+      ),
+      foldState,
+      groupRootBaseline
+    );
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    throw error;
+  } finally {
+    abortSignal.removeEventListener("abort", onAbort);
+  }
+}
+
+// src/useTrueFoundryAgentMessages.ts
+function buildCompletedTurnState(completedAt, requiredActions = []) {
+  return {
+    status: "done",
+    requiredActions,
+    completedAt
+  };
+}
+function requiredActionsFromActiveUpdate(update) {
+  const custom = update.metadata?.custom;
+  const requiredActions = [];
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (custom?.pendingMcpAuth === true && Array.isArray(custom.mcpServers)) {
+    const mcpAuthRequired = {
+      type: "mcp.auth_required",
+      id: generateId(),
+      createdAt,
+      mcpServers: custom.mcpServers
+    };
+    requiredActions.push(mcpAuthRequired);
+  }
+  if (update.status?.type === "requires-action") {
+    const approvalThreadId = custom?.[TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY];
+    if (typeof approvalThreadId === "string") {
+      const approvalRequired = {
+        type: "tool.approval_required",
+        id: generateId(),
+        createdAt,
+        threadId: approvalThreadId,
+        toolCalls: []
+      };
+      requiredActions.push(approvalRequired);
+    }
+    const responseThreadId = custom?.[TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY];
+    if (typeof responseThreadId === "string") {
+      const responseRequired = {
+        type: "tool.response_required",
+        id: generateId(),
+        createdAt,
+        threadId: responseThreadId,
+        toolCalls: []
+      };
+      requiredActions.push(responseRequired);
+    }
+  }
+  return requiredActions;
+}
+function buildUserTurnInput(content) {
+  return { type: "user.message", content };
+}
+function appendTurnInputs(base, continuationInputs) {
+  if (continuationInputs == null || continuationInputs.length === 0) {
+    return base;
+  }
+  return [...base, ...continuationInputs];
+}
+function commitActiveStream(snapshot, continuationInputs) {
+  const active = snapshot.activeStream;
+  if (active == null || active.streamComplete !== true) {
+    return snapshot;
+  }
+  const activeSandboxId = active.update.metadata?.custom?.sandboxId;
+  const completedState = buildCompletedTurnState(
+    (/* @__PURE__ */ new Date()).toISOString(),
+    requiredActionsFromActiveUpdate(active.update)
+  );
+  const baseline = snapshot.groupRootBaseline ?? computeGroupRootBaseline(snapshot.turns);
+  const rootModelMessageIds = rootModelMessageIdsSinceBaseline(
+    snapshot.fold,
+    baseline
+  );
+  const lastTurn = snapshot.turns.at(-1);
+  if (lastTurn?.id === active.turnId) {
+    return replaceSessionSnapshot(snapshot, {
+      turns: snapshot.turns.map(
+        (turn) => turn.id === active.turnId ? {
+          ...turn,
+          state: completedState,
+          input: appendTurnInputs(turn.input ?? [], continuationInputs),
+          ...rootModelMessageIds != null ? { rootModelMessageIds } : {},
+          ...activeSandboxId != null ? { sandboxId: activeSandboxId } : {}
+        } : turn
+      ),
+      pendingUser: void 0,
+      activeStream: void 0
+    });
+  }
+  const record = {
+    id: active.turnId,
+    createdAt: snapshot.pendingUser?.createdAt.toISOString() ?? (/* @__PURE__ */ new Date()).toISOString(),
+    state: completedState,
+    input: appendTurnInputs(
+      snapshot.pendingUser ? [buildUserTurnInput(snapshot.pendingUser.content)] : [],
+      continuationInputs
+    ),
+    ...snapshot.pendingUser != null ? { userText: userMessageContentToText(snapshot.pendingUser.content) } : {},
+    ...rootModelMessageIds != null ? { rootModelMessageIds } : {},
+    ...activeSandboxId != null ? { sandboxId: activeSandboxId } : {}
+  };
+  return replaceSessionSnapshot(snapshot, {
+    turns: [...snapshot.turns, record],
+    pendingUser: void 0,
+    activeStream: void 0
+  });
+}
+async function resolveActiveSessionId(remoteId, resolveConversationSessionId) {
+  if (resolveConversationSessionId != null) {
+    return resolveConversationSessionId(remoteId);
+  }
+  return remoteId;
+}
+function findTurnIndex(snapshot, turnId) {
+  const committedIndex = snapshot.turns.findIndex((turn) => turn.id === turnId);
+  if (committedIndex !== -1) {
+    return committedIndex;
+  }
+  if (snapshot.pendingUser?.turnId === turnId) {
+    return snapshot.turns.length;
+  }
+  throw new Error(`Turn ${turnId} not found in session snapshot`);
+}
+function resolveTurnInput(snapshot, turnId) {
+  const turnRecord = snapshot.turns.find((turn) => turn.id === turnId);
+  if (turnRecord?.input != null) {
+    return turnRecord.input;
+  }
+  if (snapshot.pendingUser?.turnId === turnId) {
+    return [{ type: "user.message", content: snapshot.pendingUser.content }];
+  }
+  return void 0;
+}
+function useTrueFoundryAgentMessages({
+  client,
+  sessionId,
+  listEventsConcurrency,
+  onError,
+  initializeSession,
+  resolveConversationSessionId,
+  draftGateway
+}) {
+  const sessionOptions = useMemo2(
+    () => draftGateway != null ? { draftGateway } : void 0,
+    [draftGateway]
+  );
+  const [snapshot, setSnapshot] = useState2(createEmptySessionSnapshot);
+  const [isRunning, setIsRunning] = useState2(false);
+  const [isLoading, setIsLoading] = useState2(false);
+  const snapshotRef = useRef2(snapshot);
+  snapshotRef.current = snapshot;
+  const createdAtByMessageIdRef = useRef2(/* @__PURE__ */ new Map());
+  const abortControllerRef = useRef2(null);
+  const activeRunRef = useRef2(null);
+  const runningTurnRef = useRef2(void 0);
+  const loadGenerationRef = useRef2(0);
+  const lazilyCreatedSessionIdRef = useRef2(void 0);
+  const projectOptions = useMemo2(
+    () => ({
+      getCreatedAt: (messageId, fallback) => {
+        const cache = createdAtByMessageIdRef.current;
+        const existing = cache.get(messageId);
+        if (existing != null) {
+          return existing;
+        }
+        cache.set(messageId, fallback);
+        return fallback;
+      }
+    }),
+    []
+  );
+  const messages = useMemo2(
+    () => projectSessionMessages(snapshot, projectOptions),
+    [snapshot, projectOptions]
+  );
+  const applyStreamUpdate = useCallback2(
+    (update, turnId, isContinuation) => {
+      setSnapshot(
+        (prev) => replaceSessionSnapshot(prev, {
+          activeStream: {
+            turnId,
+            update,
+            isContinuation
+          }
+        })
+      );
+    },
+    []
+  );
+  const runStream = useCallback2(
+    (createStream, turnId, isContinuation) => {
+      abortControllerRef.current?.abort();
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+      setIsRunning(true);
+      const run = (async () => {
+        try {
+          for await (const update of createStream(abortController.signal)) {
+            if (abortController.signal.aborted) {
+              return;
+            }
+            applyStreamUpdate(update, turnId, isContinuation);
+          }
+        } catch (error) {
+          if (error instanceof Error && error.name === "AbortError") {
+            return;
+          }
+          onError?.(error);
+          throw error;
+        } finally {
+          if (abortControllerRef.current === abortController) {
+            abortControllerRef.current = null;
+          }
+          setIsRunning(false);
+          setSnapshot((prev) => {
+            if (prev.activeStream == null) {
+              return prev;
+            }
+            const marked = replaceSessionSnapshot(prev, {
+              activeStream: {
+                ...prev.activeStream,
+                streamComplete: true
+              },
+              requiredActions: {
+                approvals: /* @__PURE__ */ new Map(),
+                toolResponses: /* @__PURE__ */ new Map()
+              }
+            });
+            return commitActiveStream(marked);
+          });
+        }
+      })();
+      activeRunRef.current = run;
+      void run.catch(() => void 0).finally(() => {
+        if (activeRunRef.current === run) {
+          activeRunRef.current = null;
+        }
+      });
+      return run;
+    },
+    [applyStreamUpdate, onError]
+  );
+  const load = useCallback2(async () => {
+    if (sessionId == null) {
+      createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
+      setSnapshot(createEmptySessionSnapshot());
+      return;
+    }
+    if (sessionId === lazilyCreatedSessionIdRef.current) {
+      return;
+    }
+    const generation = ++loadGenerationRef.current;
+    abortControllerRef.current?.abort();
+    setIsLoading(true);
+    try {
+      const conversationSessionId = await resolveActiveSessionId(
+        sessionId,
+        resolveConversationSessionId
+      );
+      const loadedSnapshot = await loadSessionSnapshot(
+        client,
+        conversationSessionId,
+        listEventsConcurrency,
+        sessionOptions
+      );
+      if (generation !== loadGenerationRef.current) {
+        return;
+      }
+      createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
+      setSnapshot(loadedSnapshot);
+      runningTurnRef.current = loadedSnapshot.runningTurn;
+      if (loadedSnapshot.runningTurn != null) {
+        const turn = loadedSnapshot.runningTurn;
+        const isContinuation = !extractTurnUserText(turn.input);
+        await runStream(
+          (signal) => resumeTurnStream(
+            turn,
+            snapshotRef.current.fold,
+            signal,
+            void 0,
+            snapshotRef.current.groupRootBaseline
+          ),
+          turn.id,
+          isContinuation
+        );
+      }
+    } catch (error) {
+      onError?.(error);
+      throw error;
+    } finally {
+      if (generation === loadGenerationRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [client, listEventsConcurrency, onError, resolveConversationSessionId, runStream, sessionId, sessionOptions]);
+  useEffect2(() => {
+    void load().catch(() => void 0);
+  }, [load]);
+  const sendTurn = useCallback2(
+    async (options) => {
+      let activeSessionId = sessionId;
+      if (activeSessionId == null) {
+        if (initializeSession == null) {
+          throw new Error("Cannot send a turn without an active session.");
+        }
+        const { remoteId } = await initializeSession();
+        activeSessionId = remoteId;
+        lazilyCreatedSessionIdRef.current = remoteId;
+      }
+      const conversationSessionId = await resolveActiveSessionId(
+        activeSessionId,
+        resolveConversationSessionId
+      );
+      const session = await getSession(client, conversationSessionId, sessionOptions);
+      const isContinuation = "inputs" in options || "resumeMcpAuth" in options && options.resumeMcpAuth === true;
+      const continuationTurnId = snapshotRef.current.activeStream?.turnId;
+      const turnId = isContinuation && continuationTurnId != null ? continuationTurnId : generateId();
+      if ("inputs" in options) {
+        applyUserToolResponsesToFold(
+          snapshotRef.current.fold,
+          options.inputs
+        );
+      }
+      setSnapshot(
+        (prev) => commitActiveStream(
+          prev,
+          "inputs" in options ? options.inputs : void 0
+        )
+      );
+      let groupRootBaseline;
+      if ("userMessage" in options) {
+        const rootBucket = snapshotRef.current.fold.threads.get(ROOT_THREAD_ID);
+        groupRootBaseline = [...rootBucket?.modelMessageIds ?? []];
+        setSnapshot(
+          (prev) => replaceSessionSnapshot(prev, {
+            pendingUser: {
+              turnId,
+              content: options.userMessage,
+              createdAt: /* @__PURE__ */ new Date()
+            },
+            activeStream: void 0,
+            groupRootBaseline
+          })
+        );
+      } else {
+        groupRootBaseline = snapshotRef.current.groupRootBaseline ?? computeGroupRootBaseline(snapshotRef.current.turns);
+      }
+      await runStream(
+        (signal) => {
+          if ("inputs" in options) {
+            return streamTurnContent(
+              session,
+              snapshotRef.current.fold,
+              { inputs: options.inputs },
+              signal,
+              groupRootBaseline
+            );
+          }
+          if ("resumeMcpAuth" in options) {
+            return streamTurnContent(
+              session,
+              snapshotRef.current.fold,
+              { resumeMcpAuth: true },
+              signal,
+              groupRootBaseline
+            );
+          }
+          return streamTurnContent(
+            session,
+            snapshotRef.current.fold,
+            {
+              userMessage: options.userMessage,
+              ...options.previousTurnId !== void 0 ? { previousTurnId: options.previousTurnId } : {}
+            },
+            signal,
+            groupRootBaseline
+          );
+        },
+        turnId,
+        isContinuation
+      );
+    },
+    [client, initializeSession, resolveConversationSessionId, runStream, sessionId, sessionOptions]
+  );
+  const cancel = useCallback2(async () => {
+    if (sessionId == null) {
+      abortControllerRef.current?.abort();
+      return;
+    }
+    const conversationSessionId = await resolveActiveSessionId(
+      sessionId,
+      resolveConversationSessionId
+    );
+    const session = await getSession(client, conversationSessionId, sessionOptions);
+    await session.cancel().catch(() => void 0);
+    await activeRunRef.current?.catch(() => void 0);
+  }, [client, resolveConversationSessionId, sessionId, sessionOptions]);
+  const isRunningRef = useRef2(isRunning);
+  isRunningRef.current = isRunning;
+  const trySendCollectedRequiredActions = useCallback2(
+    (nextSnapshot) => {
+      if (isRunningRef.current) {
+        return;
+      }
+      const projected = projectSessionMessages(nextSnapshot, projectOptions);
+      const paused = findPausedAssistantMessage(projected);
+      if (paused == null || messageHasPendingRequiredActions(paused)) {
+        return;
+      }
+      const inputs = collectRequiredActionInputs(paused);
+      if (inputs.length > 0) {
+        void sendTurn({ inputs }).catch((error) => onError?.(error));
+      }
+    },
+    [onError, projectOptions, sendTurn]
+  );
+  const respondToToolApproval = useCallback2(
+    (response) => {
+      const prev = snapshotRef.current;
+      const approvals = new Map(prev.requiredActions.approvals);
+      approvals.set(response.approvalId, {
+        approved: response.approved,
+        ...response.reason != null ? { reason: response.reason } : {}
+      });
+      const nextSnapshot = replaceSessionSnapshot(prev, {
+        requiredActions: {
+          ...prev.requiredActions,
+          approvals
+        }
+      });
+      setSnapshot(nextSnapshot);
+      trySendCollectedRequiredActions(nextSnapshot);
+    },
+    [trySendCollectedRequiredActions]
+  );
+  const respondToToolResponse = useCallback2(
+    (response) => {
+      const prev = snapshotRef.current;
+      const toolResponses = new Map(prev.requiredActions.toolResponses);
+      toolResponses.set(response.toolCallId, { content: response.content });
+      const nextSnapshot = replaceSessionSnapshot(prev, {
+        requiredActions: {
+          ...prev.requiredActions,
+          toolResponses
+        }
+      });
+      setSnapshot(nextSnapshot);
+      trySendCollectedRequiredActions(nextSnapshot);
+    },
+    [trySendCollectedRequiredActions]
+  );
+  const resumeRun = useCallback2(async () => {
+    const turn = runningTurnRef.current;
+    if (turn == null) {
+      return;
+    }
+    await runStream(
+      (signal) => resumeTurnStream(
+        turn,
+        snapshotRef.current.fold,
+        signal,
+        void 0,
+        snapshotRef.current.groupRootBaseline
+      ),
+      turn.id,
+      true
+    );
+  }, [runStream]);
+  const branchFromTurn = useCallback2(
+    async (turnId, userMessage) => {
+      let activeSessionId = sessionId;
+      if (activeSessionId == null) {
+        throw new Error("Cannot branch from a turn without an active session.");
+      }
+      const committed = commitActiveStream(snapshotRef.current);
+      setSnapshot(committed);
+      const turnIndex = findTurnIndex(committed, turnId);
+      await cancel();
+      const conversationSessionId = await resolveActiveSessionId(
+        activeSessionId,
+        resolveConversationSessionId
+      );
+      const session = await getSession(client, conversationSessionId, sessionOptions);
+      const previousTurnId = await resolveGatewayBranchPreviousTurnId(
+        session,
+        turnIndex
+      );
+      const rewound = await buildSnapshotBeforeTurnIndex(
+        session,
+        turnIndex,
+        listEventsConcurrency
+      );
+      createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
+      setSnapshot(rewound);
+      await sendTurn({
+        userMessage,
+        previousTurnId
+      });
+    },
+    [
+      cancel,
+      client,
+      listEventsConcurrency,
+      resolveConversationSessionId,
+      sendTurn,
+      sessionId,
+      sessionOptions
+    ]
+  );
+  const resetFromTurn = useCallback2(
+    async (turnId) => {
+      const committed = commitActiveStream(snapshotRef.current);
+      const originalInput = resolveTurnInput(committed, turnId);
+      if (originalInput == null) {
+        throw new Error(`Turn ${turnId} not found in session snapshot`);
+      }
+      const userMessage = extractTurnUserMessageContent(originalInput);
+      await branchFromTurn(turnId, userMessage);
+    },
+    [branchFromTurn]
+  );
+  const editFromTurn = useCallback2(
+    async (turnId, editedText) => {
+      const committed = commitActiveStream(snapshotRef.current);
+      const originalInput = resolveTurnInput(committed, turnId);
+      if (originalInput == null) {
+        throw new Error(`Turn ${turnId} not found in session snapshot`);
+      }
+      const userMessage = buildEditedUserMessageContent(
+        editedText,
+        originalInput
+      );
+      await branchFromTurn(turnId, userMessage);
+    },
+    [branchFromTurn]
+  );
+  return {
+    messages,
+    isRunning,
+    isLoading,
+    load,
+    sendTurn,
+    cancel,
+    respondToToolApproval,
+    respondToToolResponse,
+    resumeRun,
+    branchFromTurn,
+    resetFromTurn,
+    editFromTurn
+  };
+}
+
+// src/useTrueFoundryAgentRuntime.ts
+function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
+  const {
+    client,
+    agent,
+    gateway,
+    adapters,
+    onError,
+    listEventsConcurrency,
+    ...sharedOptions
+  } = options;
+  const draftBridgeRef = useRef3(
+    agent.mode === "draft" && gateway != null ? createDraftSessionBridge(gateway) : null
+  );
+  const draftSessionId = useAuiState(
+    (state) => agent.mode === "draft" ? state.threadListItem.remoteId ?? void 0 : void 0
+  );
+  const sessionId = useAuiState((state) => state.threadListItem.remoteId ?? void 0);
+  const draftSpec = useDraftAgentSpec({
+    draftSessionId,
+    draftBridge: draftBridgeRef.current,
+    defaultAgentSpec: agent.mode === "draft" ? agent.defaultAgentSpec : { model: { name: "" } },
+    onAgentSpecChange: agent.mode === "draft" ? agent.onAgentSpecChange : void 0,
+    onError
+  });
+  const aui = useAui();
+  const initializeSession = useCallback3(
+    () => aui.threadListItem().initialize(),
+    [aui]
+  );
+  const runtimeAdapters = useRuntimeAdapters();
+  const [toolStatuses, setToolStatuses] = useState3({});
+  const {
+    messages,
+    isRunning,
+    isLoading,
+    sendTurn,
+    cancel,
+    respondToToolApproval,
+    respondToToolResponse,
+    resumeRun,
+    editFromTurn,
+    resetFromTurn
+  } = useTrueFoundryAgentMessages({
+    client,
+    sessionId,
+    listEventsConcurrency,
+    onError,
+    initializeSession,
+    draftGateway: agent.mode === "draft" ? gateway : void 0
+  });
+  if (agent.mode === "draft" && draftSpec.agentSpec != null) {
+    pendingAgentSpecRef.current = draftSpec.agentSpec;
+  }
+  const pendingApprovals = useMemo3(
+    () => collectPendingApprovals(messages),
+    [messages]
+  );
+  const pendingToolResponses = useMemo3(
+    () => collectPendingToolResponses(messages),
+    [messages]
+  );
+  const pendingMcpAuth = useMemo3(() => derivePendingMcpAuth(messages), [messages]);
+  const sandboxId = useMemo3(() => deriveSandboxId(messages), [messages]);
+  const resumeMcpAuth = useMemo3(
+    () => () => sendTurn({ resumeMcpAuth: true }),
+    [sendTurn]
+  );
+  const downloadSandboxFile = useCallback3(
+    async (path) => {
+      if (gateway == null) {
+        const error = new Error(
+          "Downloading a sandbox file requires a `gateway` TrueFoundryGateway client."
+        );
+        onError?.(error);
+        throw error;
+      }
+      if (sandboxId == null) {
+        const error = new Error("No sandbox is available yet for this session.");
+        onError?.(error);
+        throw error;
+      }
+      const response = await gateway.agents.downloadSandboxFile(sandboxId, { path });
+      return await response.blob();
+    },
+    [gateway, sandboxId, onError]
+  );
+  const draftExtras = useMemo3(() => {
+    if (agent.mode !== "draft") {
+      return null;
+    }
+    return {
+      agentSpec: draftSpec.agentSpec,
+      draftSessionId: draftSpec.draftSessionId,
+      isSpecSyncing: draftSpec.isSpecSyncing,
+      specError: draftSpec.specError,
+      updateAgentSpec: draftSpec.updateAgentSpec
+    };
+  }, [agent.mode, draftSpec]);
+  return useExternalStoreRuntime({
+    ...pickExternalStoreSharedOptions(sharedOptions),
+    messages,
+    isRunning,
+    isLoading,
+    extras: trueFoundryExtras.provide({
+      pendingApprovals,
+      pendingToolResponses,
+      pendingMcpAuth,
+      sandboxId,
+      respondToToolApproval,
+      respondToToolResponse,
+      resumeMcpAuth,
+      downloadSandboxFile,
+      cancel,
+      resetFromTurn: (turnId) => resetFromTurn(turnId).catch((error) => {
+        onError?.(error);
+      }),
+      draft: draftExtras
+    }),
+    unstable_enableToolInvocations: true,
+    setToolStatuses,
+    adapters: {
+      attachments: adapters?.attachments ?? runtimeAdapters?.attachments,
+      speech: adapters?.speech,
+      dictation: adapters?.dictation,
+      voice: adapters?.voice,
+      feedback: adapters?.feedback
+    },
+    onNew: async (message) => {
+      if (!(message.startRun ?? message.role === "user")) {
+        return;
+      }
+      const resumeMcpAuthFlag = message.runConfig?.custom?.[MCP_AUTH_RESUME_RUN_CUSTOM_KEY] === true;
+      if (resumeMcpAuthFlag) {
+        await sendTurn({ resumeMcpAuth: true });
+        return;
+      }
+      await sendTurn({ userMessage: buildUserMessageContent(message) });
+    },
+    onCancel: async () => {
+      await cancel();
+    },
+    onRespondToToolApproval: async (response) => {
+      respondToToolApproval(response);
+    },
+    onResume: async () => {
+      await resumeRun();
+    },
+    onEdit: async (message) => {
+      const sourceId = message.sourceId;
+      if (sourceId == null) {
+        throw new Error("Could not resolve edited user message.");
+      }
+      const turnId = parseTurnIdFromMessageId(sourceId);
+      const editedText = extractEditedText(message);
+      try {
+        await editFromTurn(turnId, editedText);
+      } catch (error) {
+        onError?.(error);
+        throw error;
+      }
+    }
+  });
+}
+function useTrueFoundryAgentRuntime(options) {
+  const resolved = useMemo3(
+    () => resolveTrueFoundryAgentRuntimeOptions(options),
+    [options]
+  );
+  const { client, agent, gateway } = resolved;
+  const pendingAgentSpecRef = useRef3(
+    agent.mode === "draft" ? agent.defaultAgentSpec : void 0
+  );
+  const threadListAdapter = useMemo3(() => {
+    if (agent.mode === "draft") {
+      if (gateway == null) {
+        throw new Error(
+          "Draft agent mode requires a `gateway` TrueFoundryGateway client."
+        );
+      }
+      return createTrueFoundryDraftThreadListAdapter({
+        gateway,
+        defaultAgentSpec: agent.defaultAgentSpec,
+        getAgentSpec: () => pendingAgentSpecRef.current ?? agent.defaultAgentSpec
+      });
+    }
+    return createTrueFoundryThreadListAdapter({
+      client,
+      agentName: agent.agentName
+    });
+  }, [agent, client, gateway]);
+  return useRemoteThreadListRuntime({
+    allowNesting: true,
+    adapter: threadListAdapter,
+    initialThreadId: resolved.initialSessionId,
+    threadId: resolved.threadId,
+    onThreadIdChange: resolved.onThreadIdChange,
+    runtimeHook: () => useTrueFoundryAgentRuntimeImpl(resolved, pendingAgentSpecRef)
+  });
+}
+
+// src/hooks.ts
+import { useMemo as useMemo4 } from "react";
+import { useAui as useAui2 } from "@assistant-ui/store";
+var useTrueFoundryApprovals = () => {
+  const extras = trueFoundryExtras.use((e) => e, void 0);
+  return useMemo4(
+    () => ({
+      pending: extras?.pendingApprovals ?? [],
+      respond: extras?.respondToToolApproval ?? (() => {
+        throw new Error("TrueFoundry runtime is not ready yet");
+      })
+    }),
+    [extras]
+  );
+};
+var useTrueFoundryToolResponses = () => {
+  const extras = trueFoundryExtras.use((e) => e, void 0);
+  return useMemo4(
+    () => ({
+      pending: extras?.pendingToolResponses ?? [],
+      respond: extras?.respondToToolResponse ?? ((_response) => {
+        throw new Error("TrueFoundry runtime is not ready yet");
+      })
+    }),
+    [extras]
+  );
+};
+var useTrueFoundryMcpAuth = () => {
+  const extras = trueFoundryExtras.use((e) => e, void 0);
+  return useMemo4(
+    () => ({
+      pending: extras?.pendingMcpAuth ?? null,
+      resume: extras?.resumeMcpAuth ?? (async () => {
+        throw new Error("TrueFoundry runtime is not ready yet");
+      })
+    }),
+    [extras]
+  );
+};
+var useTrueFoundryRespondToToolApproval = () => {
+  const aui = useAui2();
+  return (response) => trueFoundryExtras.get(aui).respondToToolApproval(response);
+};
+var useTrueFoundryRespondToToolResponse = () => {
+  const aui = useAui2();
+  return (response) => trueFoundryExtras.get(aui).respondToToolResponse(response);
+};
+var useTrueFoundryResumeMcpAuth = () => {
+  const aui = useAui2();
+  return () => trueFoundryExtras.get(aui).resumeMcpAuth();
+};
+var useTrueFoundrySandboxId = () => trueFoundryExtras.use((e) => e.sandboxId, void 0);
+var useTrueFoundryDownloadSandboxFile = () => {
+  const aui = useAui2();
+  return (path) => trueFoundryExtras.get(aui).downloadSandboxFile(path);
+};
+var useTrueFoundryCancel = () => {
+  const aui = useAui2();
+  return () => trueFoundryExtras.get(aui).cancel();
+};
+var useTrueFoundryResetFromTurn = () => {
+  const aui = useAui2();
+  return (turnId) => trueFoundryExtras.get(aui).resetFromTurn(turnId);
+};
+var useTrueFoundryAgentSpec = () => {
+  const extras = trueFoundryExtras.use((e) => e.draft, null);
+  return useMemo4(
+    () => ({ ...EMPTY_DRAFT_EXTRAS, ...extras }),
+    [extras]
+  );
+};
+var useTrueFoundryUpdateAgentSpec = () => {
+  const aui = useAui2();
+  return (update) => trueFoundryExtras.get(aui).draft?.updateAgentSpec(update);
+};
+
+// src/attachmentAdapter.ts
+import {
+  generateId as generateId2
+} from "@assistant-ui/core";
+var bytesToBase64 = (bytes) => globalThis.Buffer.from(bytes).toString("base64");
+var getFileDataURL = async (file) => {
+  if (typeof FileReader === "undefined") {
+    const buffer = await file.arrayBuffer();
+    return `data:${file.type};base64,${bytesToBase64(new Uint8Array(buffer))}`;
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = (error) => reject(error);
+    reader.readAsDataURL(file);
+  });
+};
+var trueFoundryAttachmentAdapter = {
+  accept: "*",
+  async add({ file }) {
+    return {
+      id: generateId2(),
+      type: "file",
+      name: file.name,
+      file,
+      contentType: file.type,
+      content: [],
+      status: {
+        type: "requires-action",
+        reason: "composer-send"
+      }
+    };
+  },
+  async send(attachment) {
+    return {
+      ...attachment,
+      status: { type: "complete" },
+      content: [
+        {
+          type: "file",
+          mimeType: attachment.contentType ?? "",
+          filename: attachment.name,
+          data: await getFileDataURL(attachment.file)
+        }
+      ]
+    };
+  },
+  async remove() {
+  }
+};
+export {
+  ROOT_THREAD_ID,
+  TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY,
+  buildEditedUserMessageContent,
+  buildTurnAssistantContent,
+  buildUserMessageContent,
+  collectApprovalInputs,
+  collectRequiredActionInputs,
+  collectResponseInputs,
+  convertTurnsToThreadMessages,
+  createDraftSessionBridge,
+  createTrueFoundryDraftThreadListAdapter,
+  createTrueFoundryThreadListAdapter,
+  draftSessionTitle,
+  findPausedAssistantMessage,
+  getSession,
+  getTurnMessageContent,
+  mergeAgentSpec,
+  messageHasPendingApprovals,
+  messageHasPendingRequiredActions,
+  messageHasPendingResponses,
+  parseTurnIdFromMessageId,
+  repositoryItemsFromMessages,
+  toTrueFoundryApprovalInputs,
+  trueFoundryAttachmentAdapter,
+  trueFoundryExtras,
+  useTrueFoundryAgentRuntime,
+  useTrueFoundryAgentSpec,
+  useTrueFoundryApprovals,
+  useTrueFoundryCancel,
+  useTrueFoundryDownloadSandboxFile,
+  useTrueFoundryMcpAuth,
+  useTrueFoundryResetFromTurn,
+  useTrueFoundryRespondToToolApproval,
+  useTrueFoundryRespondToToolResponse,
+  useTrueFoundryResumeMcpAuth,
+  useTrueFoundrySandboxId,
+  useTrueFoundryToolResponses,
+  useTrueFoundryUpdateAgentSpec
+};
+//# sourceMappingURL=index.js.map