@truefoundry/trueforge-assistant-ui-runtime 0.0.0 → 0.2.0-rc.0

package/dist/index.js

@@ -0,0 +1,4391 @@
+import {
+  isEventDelta,
+  mergeEventDelta
+} from "./chunk-2SQK6TIO.js";
+
+// src/attachmentAdapter.ts
+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 = () => {
+      if (typeof reader.result === "string") {
+        resolve(reader.result);
+      } else {
+        reject(new Error("Attachment reader returned non-text data."));
+      }
+    };
+    reader.onerror = () => {
+      reject(reader.error ?? new Error("Failed to read attachment."));
+    };
+    reader.readAsDataURL(file);
+  });
+};
+var trueForgeAttachmentAdapter = {
+  accept: "*",
+  add({ file }) {
+    return Promise.resolve({
+      id: globalThis.crypto.randomUUID(),
+      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)
+        }
+      ]
+    };
+  },
+  remove() {
+    return Promise.resolve();
+  }
+};
+
+// src/constants.ts
+var ROOT_THREAD_ID = "main";
+
+// src/extractTurnUserText.ts
+function extractTurnUserText(input) {
+  const parts = [];
+  let hasUserMessage = false;
+  for (const item of input ?? []) {
+    if (item.type !== "user.message") {
+      continue;
+    }
+    hasUserMessage = true;
+    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 hasUserMessage ? parts.join("\n").trim() : void 0;
+}
+
+// src/askUserQuestion.ts
+function parseAskUserQuestionArgs(argsText) {
+  if (!argsText) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(argsText);
+    if (!isUnknownRecord(parsed)) {
+      return {};
+    }
+    const rawQuestion = parsed["question"];
+    const rawOptions = parsed["options"];
+    const question = typeof rawQuestion === "string" ? rawQuestion : void 0;
+    const options = Array.isArray(rawOptions) ? rawOptions.filter((item) => typeof item === "string") : void 0;
+    return {
+      ...question == null ? {} : { question },
+      ...options == null ? {} : { options }
+    };
+  } catch {
+    return {};
+  }
+}
+function isUnknownRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/createSubAgent.ts
+function isCreateSubAgentToolCall(toolCall) {
+  if (toolCall.toolInfo?.type === "trueforge-system" && toolCall.toolInfo.name === "create_sub_agent") {
+    return true;
+  }
+  return toolCall.function.name === "create_sub_agent";
+}
+
+// src/modelMessageImageContent.ts
+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-${String(index + 1)}.${ext}`;
+}
+function isImageUrlContentPart(part) {
+  if (!isUnknownRecord2(part) || part["type"] !== "image_url" || !isUnknownRecord2(part["image_url"])) {
+    return false;
+  }
+  return typeof part["image_url"]["url"] === "string";
+}
+function isUnknownRecord2(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+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 mergeContentBlockDeltas(message, blocks) {
+  const content = normalizeModelMessageContent(message);
+  message.content = 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;
+    }
+    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") {
+    return;
+  }
+  const blocks = delta.contentBlocks ?? delta.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 isToolCallArgValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return true;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value);
+  }
+  if (Array.isArray(value)) {
+    return value.every(isToolCallArgValue);
+  }
+  if (value != null && typeof value === "object") {
+    return Object.keys(value).every((key) => isToolCallArgValue(Reflect.get(value, key)));
+  }
+  return false;
+}
+function parseToolArgs(argsText) {
+  if (!argsText) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(argsText);
+    if (parsed != null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const entries = [];
+      for (const key of Object.keys(parsed)) {
+        const value = Reflect.get(parsed, key);
+        if (isToolCallArgValue(value)) {
+          entries.push([key, value]);
+        }
+      }
+      return Object.fromEntries(entries);
+    }
+    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 == null || approvalDecision.reason.length === 0 ? "Tool approval denied" : approvalDecision.reason
+    };
+    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/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;
+  if (targetApproval == null) {
+    return part;
+  }
+  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;
+  }
+  const found = turn.state.requiredActions?.find((action) => action.type === "tool.approval_required");
+  return found?.type === "tool.approval_required" ? found : void 0;
+}
+function toolCallPartHasPendingApproval(part) {
+  return hasPendingToolApproval(part.approval);
+}
+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,
+        ...decision.reason == null ? {} : { 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) {
+    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?.approved === void 0) {
+        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 toTrueForgeApprovalInputs(message, response, defaultThreadId = ROOT_THREAD_ID) {
+  const updated = applyApprovalDecisionsToMessage(message, response);
+  return collectApprovalInputs(updated, defaultThreadId);
+}
+
+// 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;
+  }
+  const found = turn.state.requiredActions?.find((action) => action.type === "tool.response_required");
+  return found?.type === "tool.response_required" ? found : void 0;
+}
+function applyToolResponseToToolCall(part, content) {
+  return { ...part, result: content };
+}
+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/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/trueforge-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/trueforge-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 (isEventDelta(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 && subAgents.length === 0) {
+      return part;
+    }
+    const artifact = { subAgents };
+    if (messages.length === 0) {
+      return { ...part, artifact };
+    }
+    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/listPages.ts
+async function drainListPages(fetchPage) {
+  const items = [];
+  let pageToken;
+  for (; ; ) {
+    const page = await fetchPage(pageToken);
+    items.push(...page.data);
+    if (page.nextPageToken == null || page.nextPageToken === "") {
+      break;
+    }
+    pageToken = page.nextPageToken;
+  }
+  return items;
+}
+
+// src/mcpAuth.ts
+var MCP_AUTH_RESUME_RUN_CUSTOM_KEY = "resumeMcpAuth";
+function buildMcpAuthTextParts(servers) {
+  void servers;
+  const text = [
+    "This agent needs access to external services before it can continue.",
+    "",
+    "Click the **Connect** button(s) to authorize the Connectors, then press **Continue**."
+  ].join("\n");
+  return [{ type: "text", text }];
+}
+function findMcpAuthRequired(requiredActions) {
+  const found = requiredActions?.find((action) => action.type === "mcp.auth_required");
+  return found?.type === "mcp.auth_required" ? found : void 0;
+}
+function mcpAuthAssistantStatus() {
+  return { type: "requires-action", reason: "interrupt" };
+}
+function mcpAuthMessageCustom(servers) {
+  return { pendingMcpAuth: true, mcpServers: [...servers] };
+}
+
+// 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 !== void 0 ? { userText } : {},
+    createdAt: turn.createdAt,
+    state: turn.state,
+    input: turn.input ?? []
+  };
+}
+function sessionEventsToSessionRecord(turnId, createdEvent, doneEvent, rootModelMessageIds, sandboxId) {
+  const userText = extractTurnUserText(createdEvent.input);
+  return {
+    id: turnId,
+    ...userText !== void 0 ? { userText } : {},
+    createdAt: createdEvent.createdAt,
+    state: doneEvent.state,
+    input: createdEvent.input ?? [],
+    rootModelMessageIds,
+    ...sandboxId != null ? { sandboxId } : {}
+  };
+}
+function replaceSessionSnapshot(snapshot, patch) {
+  return {
+    ...snapshot,
+    ...patch,
+    ...patch.requiredActions != null ? { requiredActions: patch.requiredActions } : {}
+  };
+}
+
+// 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/convertTurnMessages.ts
+var TURN_EVENTS_PAGE_SIZE = 25;
+var SESSION_EVENTS_PAGE_SIZE = 100;
+var MAX_HISTORY_BOUNDARY_PAGES = 10;
+function trimIncompleteLeadingEvents(itemsAsc) {
+  const start = itemsAsc.findIndex((item) => item.event.type === "turn.created");
+  if (start === -1) {
+    return [];
+  }
+  return itemsAsc.slice(start);
+}
+function oldestCompleteTurnGroupState(itemsAsc) {
+  const trimmed = trimIncompleteLeadingEvents(itemsAsc);
+  if (trimmed.length === 0) {
+    return "incomplete";
+  }
+  const created = trimmed[0];
+  if (created?.event.type !== "turn.created") {
+    return "incomplete";
+  }
+  const hasDone = trimmed.some((item) => item.turnId === created.turnId && item.event.type === "turn.done");
+  if (!hasDone) {
+    return "incomplete";
+  }
+  return extractTurnUserText(created.event.input) != null ? "user-group" : "continuation";
+}
+async function fetchSessionEventsPage(server, sessionId, options) {
+  const page = await server.listEvents({
+    sessionId,
+    limit: SESSION_EVENTS_PAGE_SIZE,
+    ...options?.lastTurnId != null ? { lastTurnId: options.lastTurnId } : {},
+    ...options?.pageToken != null ? { pageToken: options.pageToken } : {}
+  });
+  const olderPageToken = page.nextPageToken;
+  const hasOlder = olderPageToken != null && olderPageToken !== "";
+  return {
+    itemsNewestFirst: page.data,
+    ...olderPageToken != null && olderPageToken !== "" ? { olderPageToken } : {},
+    hasOlder
+  };
+}
+async function fetchSessionEventsWindow(server, sessionId, options) {
+  let itemsNewestFirst = [];
+  let pageToken = options?.pageToken;
+  let olderPageToken;
+  let hasOlder = false;
+  for (let pageCount = 0; pageCount < MAX_HISTORY_BOUNDARY_PAGES; pageCount++) {
+    const page = await fetchSessionEventsPage(server, sessionId, {
+      ...options,
+      ...pageToken != null ? { pageToken } : {}
+    });
+    itemsNewestFirst = [...itemsNewestFirst, ...page.itemsNewestFirst];
+    olderPageToken = page.olderPageToken;
+    hasOlder = page.hasOlder;
+    const itemsAsc2 = trimIncompleteLeadingEvents([...itemsNewestFirst].reverse());
+    const groupState = oldestCompleteTurnGroupState(itemsAsc2);
+    if (groupState === "user-group" || !hasOlder) {
+      return {
+        itemsAsc: itemsAsc2,
+        ...olderPageToken != null ? { olderPageToken } : {},
+        hasOlder
+      };
+    }
+    if (olderPageToken == null) {
+      return { itemsAsc: itemsAsc2, hasOlder: false };
+    }
+    pageToken = olderPageToken;
+  }
+  const itemsAsc = trimIncompleteLeadingEvents([...itemsNewestFirst].reverse());
+  return {
+    itemsAsc,
+    ...olderPageToken != null ? { olderPageToken } : {},
+    hasOlder
+  };
+}
+async function fetchAllSessionEvents(server, sessionId, options) {
+  const items = await drainListPages(
+    (pageToken) => server.listEvents({
+      sessionId,
+      limit: SESSION_EVENTS_PAGE_SIZE,
+      ...options?.lastTurnId != null ? { lastTurnId: options.lastTurnId } : {},
+      ...pageToken != null ? { pageToken } : {}
+    })
+  );
+  items.reverse();
+  return items;
+}
+function cloneThreadBucket(bucket) {
+  return {
+    events: new Map(bucket.events),
+    modelMessageIds: [...bucket.modelMessageIds],
+    toolResults: new Map(bucket.toolResults),
+    pendingApprovals: new Map(bucket.pendingApprovals),
+    approvalDecisions: new Map(bucket.approvalDecisions),
+    pendingResponses: new Map(bucket.pendingResponses),
+    done: bucket.done,
+    ...bucket.title != null ? { title: bucket.title } : {},
+    ...bucket.agentInfo != null ? { agentInfo: bucket.agentInfo } : {}
+  };
+}
+function prependFoldState(older, newer) {
+  const result = new PeerThreadFoldState();
+  const threadIds = /* @__PURE__ */ new Set([...older.threads.keys(), ...newer.threads.keys()]);
+  for (const threadId of threadIds) {
+    const olderBucket = older.threads.get(threadId);
+    const newerBucket = newer.threads.get(threadId);
+    if (olderBucket == null && newerBucket != null) {
+      result.threads.set(threadId, cloneThreadBucket(newerBucket));
+      continue;
+    }
+    if (newerBucket == null && olderBucket != null) {
+      result.threads.set(threadId, cloneThreadBucket(olderBucket));
+      continue;
+    }
+    if (olderBucket == null || newerBucket == null) {
+      continue;
+    }
+    result.threads.set(threadId, {
+      events: new Map([...olderBucket.events, ...newerBucket.events]),
+      modelMessageIds: [...olderBucket.modelMessageIds, ...newerBucket.modelMessageIds],
+      toolResults: new Map([...olderBucket.toolResults, ...newerBucket.toolResults]),
+      pendingApprovals: new Map([...olderBucket.pendingApprovals, ...newerBucket.pendingApprovals]),
+      approvalDecisions: new Map([...olderBucket.approvalDecisions, ...newerBucket.approvalDecisions]),
+      pendingResponses: new Map([...olderBucket.pendingResponses, ...newerBucket.pendingResponses]),
+      done: newerBucket.done || olderBucket.done,
+      ...newerBucket.title != null || olderBucket.title != null ? { title: newerBucket.title ?? olderBucket.title } : {},
+      ...newerBucket.agentInfo != null || olderBucket.agentInfo != null ? { agentInfo: newerBucket.agentInfo ?? olderBucket.agentInfo } : {}
+    });
+  }
+  for (const [threadId, link] of older.threadParents) {
+    result.threadParents.set(threadId, link);
+  }
+  for (const [threadId, link] of newer.threadParents) {
+    result.threadParents.set(threadId, link);
+  }
+  return result;
+}
+function ingestSessionEventsIntoSnapshot(snapshot, items, onTurnComplete) {
+  let currentTurnId = null;
+  let currentCreatedEvent = null;
+  let currentContentEvents = [];
+  let beforeCount = 0;
+  let sessionSandboxId;
+  for (const item of items) {
+    const { turnId, event } = item;
+    if (event.type === "turn.created") {
+      currentTurnId = turnId;
+      currentCreatedEvent = event;
+      currentContentEvents = [];
+      beforeCount = snapshot.fold.threads.get(ROOT_THREAD_ID)?.modelMessageIds.length ?? 0;
+    } else if (event.type === "turn.done") {
+      if (currentTurnId == null || currentCreatedEvent == null) {
+        continue;
+      }
+      const afterBucket = snapshot.fold.threads.get(ROOT_THREAD_ID);
+      const rootModelMessageIds = (afterBucket?.modelMessageIds ?? []).slice(beforeCount);
+      const sandboxEvent = currentContentEvents.find(
+        (ev) => ev.type === "sandbox.created"
+      );
+      sessionSandboxId = sandboxEvent?.sandboxId ?? sessionSandboxId;
+      applyUserToolResponsesToFold(snapshot.fold, currentCreatedEvent.input ?? []);
+      snapshot.turns.push(
+        sessionEventsToSessionRecord(currentTurnId, currentCreatedEvent, event, rootModelMessageIds, sessionSandboxId)
+      );
+      onTurnComplete?.(replaceSessionSnapshot(snapshot, {}));
+      currentTurnId = null;
+      currentCreatedEvent = null;
+      currentContentEvents = [];
+    } else {
+      if (currentTurnId != null) {
+        ingestTurnEvent(snapshot.fold, event);
+        currentContentEvents.push(event);
+      }
+    }
+  }
+}
+function attachRunningTurn(snapshot, runningTurn) {
+  if (runningTurn == null) {
+    return snapshot;
+  }
+  const pendingUserText = extractTurnUserText(runningTurn.input);
+  return replaceSessionSnapshot(snapshot, {
+    runningTurn,
+    unstable_resume: true,
+    groupRootBaseline: computeGroupRootBaseline(snapshot.turns),
+    ...pendingUserText !== void 0 ? {
+      pendingUser: {
+        turnId: runningTurn.id,
+        content: extractTurnUserMessageContent(runningTurn.input),
+        createdAt: new Date(runningTurn.createdAt)
+      }
+    } : {}
+  });
+}
+function findOpenTurnCreated(itemsAsc) {
+  let open;
+  for (const item of itemsAsc) {
+    if (item.event.type === "turn.created") {
+      open = { turnId: item.turnId, event: item.event };
+    } else if (item.event.type === "turn.done") {
+      open = void 0;
+    }
+  }
+  return open;
+}
+function turnFromCreatedEvent(options) {
+  const { sessionId, turnId, event } = options;
+  return {
+    id: turnId,
+    sessionId,
+    state: { status: "running" },
+    createdAt: event.createdAt,
+    ...event.input != null ? { input: event.input } : {},
+    ...event.previousTurnId === void 0 ? {} : { previousTurnId: event.previousTurnId }
+  };
+}
+async function resolveSessionTip(options) {
+  const { server, sessionId, itemsAsc } = options;
+  const open = findOpenTurnCreated(itemsAsc);
+  if (open != null) {
+    const continuationInput = open.event.input ?? [];
+    if (typeof server.getTurn === "function") {
+      try {
+        const turn = await server.getTurn({
+          sessionId,
+          turnId: open.turnId
+        });
+        if (turn.state.status === "running") {
+          return {
+            runningTurn: turn,
+            continuationInput: turn.input ?? continuationInput
+          };
+        }
+        return { continuationInput: turn.input ?? continuationInput };
+      } catch {
+      }
+    }
+    return {
+      runningTurn: turnFromCreatedEvent({
+        sessionId,
+        turnId: open.turnId,
+        event: open.event
+      }),
+      continuationInput
+    };
+  }
+  const turnsPage = await server.listTurns({ sessionId, limit: 1 });
+  const tip = turnsPage.data[0];
+  return tip?.state.status === "running" ? { runningTurn: tip, continuationInput: tip.input ?? [] } : { continuationInput: [] };
+}
+async function buildSnapshotFromSessionEvents(server, sessionId, onProgress) {
+  const window = await fetchSessionEventsWindow(server, sessionId);
+  const historyPagination = {
+    hasOlder: window.hasOlder,
+    ...window.olderPageToken != null ? { olderPageToken: window.olderPageToken } : {}
+  };
+  const snapshot = createEmptySessionSnapshot();
+  ingestSessionEventsIntoSnapshot(snapshot, window.itemsAsc, onProgress);
+  const withHistory = replaceSessionSnapshot(snapshot, {
+    historyEvents: window.itemsAsc,
+    historyPagination
+  });
+  const tip = await resolveSessionTip({
+    server,
+    sessionId,
+    itemsAsc: window.itemsAsc
+  });
+  applyUserToolResponsesToFold(withHistory.fold, tip.continuationInput);
+  return attachRunningTurn(withHistory, tip.runningTurn);
+}
+async function prependOlderSessionHistory(server, sessionId, snapshot) {
+  const pagination = snapshot.historyPagination;
+  if (pagination?.hasOlder !== true || pagination.olderPageToken == null) {
+    return snapshot;
+  }
+  const window = await fetchSessionEventsWindow(server, sessionId, {
+    pageToken: pagination.olderPageToken
+  });
+  if (window.itemsAsc.length === 0) {
+    return replaceSessionSnapshot(snapshot, {
+      historyPagination: { hasOlder: false }
+    });
+  }
+  const olderSnap = createEmptySessionSnapshot();
+  ingestSessionEventsIntoSnapshot(olderSnap, window.itemsAsc);
+  const existingIds = new Set(snapshot.turns.map((turn) => turn.id));
+  const olderTurns = olderSnap.turns.filter((turn) => !existingIds.has(turn.id));
+  const mergedFold = prependFoldState(olderSnap.fold, snapshot.fold);
+  const historyEvents = [...window.itemsAsc, ...snapshot.historyEvents ?? []];
+  const olderRootIds = olderTurns.flatMap((turn) => turn.rootModelMessageIds ?? []);
+  let knownSandboxId;
+  const mergedTurns = [...olderTurns, ...snapshot.turns].map((turn) => {
+    if (turn.sandboxId != null) {
+      knownSandboxId = turn.sandboxId;
+      return turn;
+    }
+    if (knownSandboxId != null) {
+      return { ...turn, sandboxId: knownSandboxId };
+    }
+    return turn;
+  });
+  return replaceSessionSnapshot(snapshot, {
+    fold: mergedFold,
+    turns: mergedTurns,
+    historyEvents,
+    historyPagination: {
+      hasOlder: window.hasOlder,
+      ...window.olderPageToken != null ? { olderPageToken: window.olderPageToken } : {}
+    },
+    ...snapshot.groupRootBaseline != null ? {
+      groupRootBaseline: [...olderRootIds, ...snapshot.groupRootBaseline]
+    } : {}
+  });
+}
+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, replace = false) {
+  return options?.getCreatedAt?.(messageId, fallback, replace) ?? 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) {
+      const imageUrl = extractImageUrlFromUserContentItem(part);
+      if (imageUrl != null) {
+        attachments.push(imageUrlToAttachment(imageUrl, `${turnId}-file-${String(attachments.length)}`));
+        continue;
+      }
+      if (part.type === "text") {
+        content.push({ type: "text", text: part.text });
+      } else {
+        attachments.push(fileContentToAttachment(part, `${turnId}-file-${String(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, replaceCreatedAt = false) {
+  const fallback = createdAt instanceof Date ? createdAt : new Date(createdAt);
+  const id = `${turnId}-assistant`;
+  return {
+    id,
+    role: "assistant",
+    content,
+    status,
+    createdAt: resolveCreatedAt(id, fallback, options, replaceCreatedAt),
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom
+    }
+  };
+}
+async function ingestTurnEventsIntoFold(server, sessionId, turnId, foldState) {
+  if (server.listTurnEvents == null) {
+    return;
+  }
+  const listTurnEvents = server.listTurnEvents.bind(server);
+  const events = await drainListPages(
+    (pageToken) => listTurnEvents({
+      sessionId,
+      turnId,
+      order: "asc",
+      limit: TURN_EVENTS_PAGE_SIZE,
+      ...pageToken != null ? { pageToken } : {}
+    })
+  );
+  for (const event of events) {
+    ingestTurnEvent(foldState, event);
+  }
+}
+async function fetchTurnEvents(server, sessionId, turnId) {
+  if (server.listTurnEvents == null) {
+    return [];
+  }
+  const listTurnEvents = server.listTurnEvents.bind(server);
+  const events = await drainListPages(
+    (pageToken) => listTurnEvents({
+      sessionId,
+      turnId,
+      order: "asc",
+      limit: TURN_EVENTS_PAGE_SIZE,
+      ...pageToken != null ? { pageToken } : {}
+    })
+  );
+  return events;
+}
+function ingestCollectedEventsIntoFold(foldState, events) {
+  for (const event of events) {
+    ingestTurnEvent(foldState, event);
+  }
+}
+async function fetchAllTurnEventsWithConcurrency(server, sessionId, turns, concurrency) {
+  const results = Array.from({ length: turns.length }, () => []);
+  const pool = /* @__PURE__ */ new Set();
+  for (let i = 0; i < turns.length; i++) {
+    const idx = i;
+    const turn = turns[idx];
+    if (turn == null) {
+      continue;
+    }
+    const p = fetchTurnEvents(server, sessionId, turn.id).then((events) => {
+      results[idx] = events;
+      pool.delete(p);
+    });
+    pool.add(p);
+    if (pool.size >= concurrency) {
+      await Promise.race(pool);
+    }
+  }
+  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);
+    custom = Object.fromEntries(
+      Object.entries(custom).filter(
+        ([key]) => key !== TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY && key !== TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY
+      )
+    );
+  }
+  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 };
+  const metadata = rebuilt.metadata ?? activeStream.update.metadata;
+  const status = rebuilt.status ?? activeStream.update.status;
+  return {
+    ...activeStream.update,
+    content,
+    ...metadata == null ? {} : { metadata },
+    ...status == null ? {} : { 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 = [];
+  let sandboxId;
+  for (let turnIndex = 0; turnIndex < snapshot.turns.length; turnIndex++) {
+    const record = snapshot.turns[turnIndex];
+    if (record == null) {
+      continue;
+    }
+    const turnRootIds = record.rootModelMessageIds ?? [];
+    sandboxId = record.sandboxId ?? sandboxId;
+    if (record.userText !== void 0) {
+      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 = {
+      ...baseCustom,
+      turnId: record.id,
+      ...sandboxId != null ? { sandboxId } : {}
+    };
+    const assistantCreatedAt = record.state.status === "running" ? record.createdAt : record.state.completedAt;
+    const replaceAssistantCreatedAt = record.state.status !== "running";
+    if (record.userText !== void 0) {
+      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,
+              assistantCreatedAt,
+              status,
+              custom,
+              options,
+              replaceAssistantCreatedAt
+            )
+          );
+        }
+        break;
+      }
+      if (content.length > 0) {
+        messages.push(
+          buildAssistantMessage(
+            record.id,
+            content,
+            assistantCreatedAt,
+            status,
+            custom,
+            options,
+            replaceAssistantCreatedAt
+          )
+        );
+        lastAssistantIndex = messages.length - 1;
+      }
+    } else if (content.length > 0 && lastAssistantIndex != null) {
+      if (record.state.status === "running") {
+        break;
+      }
+      const existing = messages[lastAssistantIndex];
+      if (existing?.role !== "assistant") {
+        continue;
+      }
+      messages[lastAssistantIndex] = {
+        ...existing,
+        content,
+        status,
+        createdAt: resolveCreatedAt(existing.id, new Date(assistantCreatedAt), options, true),
+        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;
+  let sessionSandboxId;
+  for (let i = 0; i < turns.length; i++) {
+    const turn = turns[i];
+    if (turn == null) {
+      continue;
+    }
+    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"
+    );
+    sessionSandboxId = sandboxEvent?.sandboxId ?? sessionSandboxId;
+    snapshot.turns.push({
+      ...turnToSessionRecord(turn),
+      rootModelMessageIds,
+      ...sessionSandboxId != null ? { sandboxId: sessionSandboxId } : {}
+    });
+    if (turn.state.status === "running") {
+      runningTurn = turn;
+      break;
+    }
+  }
+  return runningTurn;
+}
+async function buildSnapshotFromSession(server, sessionId, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY) {
+  const snapshot = await buildSnapshotFromSessionEvents(server, sessionId);
+  if (snapshot.runningTurn == null) {
+    return snapshot;
+  }
+  const turn = snapshot.runningTurn;
+  const eventArrays = await fetchAllTurnEventsWithConcurrency(server, sessionId, [turn], concurrency);
+  ingestTurnsIntoSnapshot(snapshot, [turn], eventArrays);
+  const snapshotWithoutPendingUser = { ...snapshot };
+  delete snapshotWithoutPendingUser.pendingUser;
+  return replaceSessionSnapshot(snapshotWithoutPendingUser, {
+    runningTurn: turn,
+    unstable_resume: true,
+    groupRootBaseline: computeGroupRootBaseline(snapshot.turns)
+  });
+}
+async function buildSnapshotThroughTurn(server, sessionId, anchorTurnId) {
+  if (anchorTurnId == null) {
+    return createEmptySessionSnapshot();
+  }
+  const items = await fetchAllSessionEvents(server, sessionId, {
+    lastTurnId: anchorTurnId
+  });
+  const snapshot = createEmptySessionSnapshot();
+  ingestSessionEventsIntoSnapshot(snapshot, items);
+  return snapshot;
+}
+async function resolveGatewayBranchPreviousTurnIdForTurn(server, sessionId, turnId) {
+  const turn = await server.getTurn({ sessionId, turnId });
+  return turn.previousTurnId ?? "none";
+}
+async function buildTurnAssistantContent(server, sessionId, turn, foldState) {
+  const state = foldState ?? new PeerThreadFoldState();
+  const beforeCount = state.threads.get(ROOT_THREAD_ID)?.modelMessageIds.length ?? 0;
+  await ingestTurnEventsIntoFold(server, sessionId, turn.id, state);
+  const afterIds = state.threads.get(ROOT_THREAD_ID)?.modelMessageIds ?? [];
+  const rootModelMessageIds = afterIds.slice(beforeCount);
+  return buildTurnUpdateFromFold(state, turn, rootModelMessageIds).content;
+}
+async function convertTurnsToThreadMessages(server, sessionId) {
+  const snapshot = await buildSnapshotFromSession(server, sessionId);
+  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 inputParts = [
+    ...message.content,
+    ...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()],
+    status: mcpAuthAssistantStatus(),
+    metadata: { custom: mcpAuthMessageCustom(pendingMcpAuth.mcpServers) }
+  };
+}
+async function* streamTurnEvents(stream, foldState, groupRootBaseline, onTurnIdAvailable) {
+  let pendingMcpAuth;
+  let sandboxId;
+  let sandboxIdYielded = false;
+  const withSandbox = (update) => {
+    if (sandboxId == null) {
+      return update;
+    }
+    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 === "turn.created") {
+      onTurnIdAvailable?.(event.turnId);
+      continue;
+    }
+    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) {
+      if (sandboxId != null) {
+        sandboxIdYielded = true;
+      }
+      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: {
+        ...existing?.role === "assistant" ? existing.metadata.custom : {},
+        ...update.metadata?.custom,
+        turnId
+      }
+    }
+  };
+}
+function repositoryItemsFromMessages(messages) {
+  const items = [];
+  let parentId = null;
+  for (const message of messages) {
+    items.push({ parentId, message });
+    parentId = message.id;
+  }
+  return items;
+}
+
+// src/draft/agentSpec.ts
+function mergeAgentSpec(base, update) {
+  const { model: modelUpdate, ...rest } = update;
+  const next = Object.assign({}, base, rest);
+  if (modelUpdate != null) {
+    next.model = Object.assign({}, 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/draft/draftSessionBridge.ts
+var DRAFT_SESSION_LAST_UPDATED_AT_HEADER = "x-tfy-session-last-updated-at";
+function createDraftSessionBridge(server) {
+  return {
+    async getDraftAgentSpec(draftSessionId) {
+      const session = await server.getSession({ sessionId: draftSessionId });
+      if (session.agentSpec == null) {
+        throw new Error(`Session ${draftSessionId} has no agentSpec (isMutable=${String(session.isMutable)}).`);
+      }
+      return session.agentSpec;
+    },
+    async syncAgentSpec(draftSessionId, agentSpec) {
+      const updated = await server.updateSession({
+        sessionId: draftSessionId,
+        agentSpec
+      });
+      return updated.updatedAt;
+    }
+  };
+}
+
+// src/sessionListStartTimestamp.ts
+function sessionListStartTimestamp() {
+  const start = /* @__PURE__ */ new Date();
+  start.setFullYear(start.getFullYear() - 1);
+  return start.toISOString();
+}
+
+// src/sessionThreadMetadata.ts
+function sessionDisplayTitle(session, defaultAgentSpec) {
+  if (session.isMutable) {
+    const agentSpec = session.agentSpec ?? defaultAgentSpec;
+    if (agentSpec != null) {
+      return draftSessionTitle({
+        agentSpec,
+        ...session.title === void 0 ? {} : { title: session.title }
+      });
+    }
+  }
+  return session.title ?? session.agentName ?? session.id;
+}
+function sessionToThreadMetadata(session, title) {
+  return {
+    status: "regular",
+    remoteId: session.id,
+    title,
+    lastMessageAt: new Date(session.updatedAt),
+    custom: {
+      isMutable: session.isMutable,
+      ...session.agentName != null ? { agentName: session.agentName } : {}
+    }
+  };
+}
+
+// src/draft/trueforgeDraftThreadListAdapter.ts
+var THREAD_LIST_PAGE_SIZE = 20;
+function createTrueForgeDraftThreadListAdapter(options) {
+  const { server, defaultAgentSpec, getAgentSpec, listSessionsAgentId, listSessionsCreatedByMe = false } = options;
+  return {
+    async list({ after } = {}) {
+      const page = await server.listSessions({
+        ...listSessionsAgentId != null ? { agentId: listSessionsAgentId } : {},
+        createdByMe: listSessionsCreatedByMe,
+        limit: THREAD_LIST_PAGE_SIZE,
+        ...after == null ? {} : { pageToken: after },
+        startTimestamp: sessionListStartTimestamp()
+      });
+      const threads = page.data.map(
+        (session) => sessionToThreadMetadata(session, sessionDisplayTitle(session, defaultAgentSpec))
+      );
+      return {
+        threads,
+        nextCursor: page.nextPageToken ?? void 0
+      };
+    },
+    async initialize() {
+      const draft = await server.createSession({
+        agentSpec: getAgentSpec?.() ?? defaultAgentSpec
+      });
+      return { remoteId: draft.id, externalId: void 0 };
+    },
+    async fetch(remoteId) {
+      const draft = await server.getSession({ sessionId: remoteId });
+      return sessionToThreadMetadata(draft, sessionDisplayTitle(draft, defaultAgentSpec));
+    },
+    async rename(remoteId, newTitle) {
+      if (typeof server.renameSession !== "function") {
+        return;
+      }
+      await server.renameSession({ sessionId: remoteId, title: newTitle });
+    },
+    archive() {
+      return Promise.resolve();
+    },
+    unarchive() {
+      return Promise.resolve();
+    },
+    async delete(remoteId) {
+      if (typeof server.deleteSession !== "function") {
+        return;
+      }
+      await server.deleteSession({ sessionId: remoteId });
+    },
+    generateTitle() {
+      return Promise.resolve(new ReadableStream());
+    }
+  };
+}
+
+// src/hooks.ts
+import { useAui as useAui2, useAuiState } from "@assistant-ui/store";
+import { useMemo } from "react";
+
+// src/trueforgeExtras.ts
+import { useAui } from "@assistant-ui/store";
+import { useCallback, useSyncExternalStore } from "react";
+var extrasBrandSymbol = /* @__PURE__ */ Symbol("useTrueForgeAgentRuntime extras");
+var isTrueForgeExtras = (extras) => typeof extras === "object" && extras !== null && extrasBrandSymbol in extras;
+var extrasBrand = {
+  provide: (value) => {
+    Object.defineProperty(value, extrasBrandSymbol, {
+      value: true,
+      enumerable: false,
+      configurable: true
+    });
+    return value;
+  },
+  is: isTrueForgeExtras,
+  tryGet: (extras) => isTrueForgeExtras(extras) ? extras : void 0
+};
+var EMPTY_DRAFT_EXTRAS = {
+  agentSpec: null,
+  draftSessionId: void 0,
+  isSpecLoading: false,
+  isSpecSyncing: false,
+  specError: null,
+  updateAgentSpec: () => {
+    throw new Error("Draft agent extras are only available in draft mode.");
+  },
+  flushAgentSpec: () => Promise.reject(new Error("Draft agent extras are only available in draft mode.")),
+  adoptAgentSpec: () => {
+    throw new Error("Draft agent extras are only available in draft mode.");
+  }
+};
+function isThreadAccessor(value) {
+  return typeof value === "function";
+}
+function isGetState(value) {
+  return typeof value === "function";
+}
+function isSubscribe(value) {
+  return typeof value === "function";
+}
+function walkAssistantClientAncestors(client, visit) {
+  let current = client;
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(current)) {
+    seen.add(current);
+    if (visit(current) === "stop") {
+      return;
+    }
+    const parent = Reflect.getPrototypeOf(current);
+    if (parent == null || parent === Object.prototype) {
+      return;
+    }
+    current = parent;
+  }
+}
+function tryGetTrueForgeExtras(client) {
+  let found;
+  walkAssistantClientAncestors(client, (current) => {
+    try {
+      const thread = Reflect.get(current, "thread");
+      if (isThreadAccessor(thread)) {
+        const threadClient = Reflect.apply(thread, current, []);
+        if (threadClient == null || typeof threadClient !== "object") {
+          return "continue";
+        }
+        const getState = Reflect.get(threadClient, "getState");
+        if (!isGetState(getState)) {
+          return "continue";
+        }
+        const state = Reflect.apply(getState, threadClient, []);
+        const extras = extrasBrand.tryGet(
+          state != null && typeof state === "object" ? Reflect.get(state, "extras") : void 0
+        );
+        if (extras != null) {
+          found = extras;
+          return "stop";
+        }
+      }
+    } catch {
+    }
+    return "continue";
+  });
+  return found;
+}
+function getTrueForgeExtras(client) {
+  const extras = tryGetTrueForgeExtras(client);
+  if (extras == null) {
+    throw new Error("The current thread is not backed by the useTrueForgeAgentRuntime runtime.");
+  }
+  return extras;
+}
+function subscribeClientChain(client) {
+  return (onStoreChange) => {
+    const unsubs = [];
+    walkAssistantClientAncestors(client, (current) => {
+      try {
+        const subscribe = Reflect.get(current, "subscribe");
+        if (isSubscribe(subscribe)) {
+          const unsubscribe = Reflect.apply(subscribe, current, [onStoreChange]);
+          if (typeof unsubscribe === "function") {
+            unsubs.push(() => {
+              Reflect.apply(unsubscribe, void 0, []);
+            });
+          }
+        }
+        return "continue";
+      } catch {
+        return "stop";
+      }
+    });
+    return () => {
+      for (const unsub of unsubs) {
+        unsub();
+      }
+    };
+  };
+}
+function useTrueForgeRuntimeExtras() {
+  const aui = useAui();
+  const subscribe = useCallback(subscribeClientChain(aui), [aui]);
+  const getSnapshot = useCallback(() => tryGetTrueForgeExtras(aui), [aui]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+function useTrueForgeExtrasApi(select, fallback) {
+  const extras = useTrueForgeRuntimeExtras();
+  const hasFallback = arguments.length >= 2;
+  if (extras == null) {
+    if (hasFallback) {
+      return fallback;
+    }
+    throw new Error("The current thread is not backed by the useTrueForgeAgentRuntime runtime.");
+  }
+  return select != null ? select(extras) : extras;
+}
+var trueForgeExtras = {
+  provide: extrasBrand.provide,
+  is: extrasBrand.is,
+  tryGet: extrasBrand.tryGet,
+  get: getTrueForgeExtras,
+  use: useTrueForgeExtrasApi
+};
+
+// src/hooks.ts
+var useTrueForgeApprovals = () => {
+  const extras = useTrueForgeRuntimeExtras();
+  return useMemo(
+    () => ({
+      pending: extras?.pendingApprovals ?? [],
+      respond: extras?.respondToToolApproval ?? (() => {
+        throw new Error("TrueForge runtime is not ready yet");
+      })
+    }),
+    [extras]
+  );
+};
+var useTrueForgeToolResponses = () => {
+  const extras = useTrueForgeRuntimeExtras();
+  return useMemo(
+    () => ({
+      pending: extras?.pendingToolResponses ?? [],
+      respond: extras?.respondToToolResponse ?? (() => {
+        throw new Error("TrueForge runtime is not ready yet");
+      })
+    }),
+    [extras]
+  );
+};
+var useTrueForgeMcpAuth = () => {
+  const extras = useTrueForgeRuntimeExtras();
+  return useMemo(
+    () => ({
+      pending: extras?.pendingMcpAuth ?? null,
+      resume: extras?.resumeMcpAuth ?? (() => Promise.reject(new Error("TrueForge runtime is not ready yet")))
+    }),
+    [extras]
+  );
+};
+var useTrueForgeRespondToToolApproval = () => {
+  const aui = useAui2();
+  return (response) => {
+    getTrueForgeExtras(aui).respondToToolApproval(response);
+  };
+};
+var useTrueForgeRespondToToolResponse = () => {
+  const aui = useAui2();
+  return (response) => {
+    getTrueForgeExtras(aui).respondToToolResponse(response);
+  };
+};
+var useTrueForgeResumeMcpAuth = () => {
+  const aui = useAui2();
+  return () => getTrueForgeExtras(aui).resumeMcpAuth();
+};
+var useTrueForgeSandboxId = () => useTrueForgeRuntimeExtras()?.sandboxId;
+var useTrueForgeTurnId = () => useAuiState((state) => {
+  const turnId = state.message.metadata.custom["turnId"];
+  return typeof turnId === "string" ? turnId : void 0;
+});
+var useTrueForgeDownloadSandboxFile = () => {
+  const aui = useAui2();
+  const turnId = useTrueForgeTurnId();
+  return (path) => {
+    if (turnId == null) {
+      throw new Error("Downloading a sandbox file requires a message scope to resolve its turn.");
+    }
+    return getTrueForgeExtras(aui).downloadSandboxFile({ turnId, path });
+  };
+};
+var useTrueForgeCancel = () => {
+  const aui = useAui2();
+  return () => getTrueForgeExtras(aui).cancel();
+};
+var useTrueForgeReload = () => {
+  const aui = useAui2();
+  return () => {
+    getTrueForgeExtras(aui).reload();
+  };
+};
+var useTrueForgeHistoryPagination = () => {
+  const extras = useTrueForgeRuntimeExtras();
+  return useMemo(
+    () => ({
+      hasOlderHistory: extras?.hasOlderHistory ?? false,
+      isLoadingOlderHistory: extras?.isLoadingOlderHistory ?? false,
+      loadOlderHistory: extras?.loadOlderHistory ?? (() => Promise.reject(new Error("TrueForge runtime is not ready yet")))
+    }),
+    [extras]
+  );
+};
+var useTrueForgeResumeUnavailable = () => useTrueForgeRuntimeExtras()?.resumeUnavailable ?? false;
+var useTrueForgeResetFromTurn = () => {
+  const aui = useAui2();
+  return (turnId) => getTrueForgeExtras(aui).resetFromTurn(turnId);
+};
+var useTrueForgeAgentSpec = () => {
+  const extras = useTrueForgeRuntimeExtras()?.draft ?? null;
+  return useMemo(() => ({ ...EMPTY_DRAFT_EXTRAS, ...extras }), [extras]);
+};
+var useTrueForgeUpdateAgentSpec = () => {
+  const aui = useAui2();
+  return (update) => getTrueForgeExtras(aui).draft?.updateAgentSpec(update);
+};
+var useTrueForgeFlushAgentSpec = () => {
+  const aui = useAui2();
+  return () => getTrueForgeExtras(aui).draft?.flushAgentSpec() ?? Promise.resolve();
+};
+var useTrueForgeAdoptAgentSpec = () => {
+  const aui = useAui2();
+  return (request) => getTrueForgeExtras(aui).draft?.adoptAgentSpec(request);
+};
+
+// 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/sessions.ts
+var inflightBySessionId = /* @__PURE__ */ new Map();
+function getSession(server, sessionId) {
+  let inflight = inflightBySessionId.get(sessionId);
+  if (inflight == null) {
+    inflight = server.getSession({ sessionId }).finally(() => {
+      if (inflightBySessionId.get(sessionId) === inflight) {
+        inflightBySessionId.delete(sessionId);
+      }
+    });
+    inflightBySessionId.set(sessionId, inflight);
+  }
+  return inflight;
+}
+
+// src/trueforgeOwnedSessionsThreadListAdapter.ts
+var THREAD_LIST_PAGE_SIZE2 = 20;
+function createTrueForgeOwnedSessionsThreadListAdapter(options) {
+  const { server, listSessionsAgentId, listSessionsCreatedByMe = false } = options;
+  return {
+    async list({ after } = {}) {
+      const page = await server.listSessions({
+        ...listSessionsAgentId != null ? { agentId: listSessionsAgentId } : {},
+        createdByMe: listSessionsCreatedByMe,
+        limit: THREAD_LIST_PAGE_SIZE2,
+        ...after == null ? {} : { pageToken: after },
+        startTimestamp: sessionListStartTimestamp()
+      });
+      const threads = page.data.map((session) => sessionToThreadMetadata(session, sessionDisplayTitle(session)));
+      return {
+        threads,
+        nextCursor: page.nextPageToken ?? void 0
+      };
+    },
+    initialize() {
+      return Promise.reject(
+        new Error("Owned sessions history adapter is read-only; create sessions via a named or draft runtime.")
+      );
+    },
+    async fetch(remoteId) {
+      const session = await server.getSession({ sessionId: remoteId });
+      return sessionToThreadMetadata(session, sessionDisplayTitle(session));
+    },
+    async rename(remoteId, newTitle) {
+      if (typeof server.renameSession !== "function") {
+        return;
+      }
+      await server.renameSession({ sessionId: remoteId, title: newTitle });
+    },
+    archive() {
+      return Promise.resolve();
+    },
+    unarchive() {
+      return Promise.resolve();
+    },
+    async delete(remoteId) {
+      if (typeof server.deleteSession !== "function") {
+        return;
+      }
+      await server.deleteSession({ sessionId: remoteId });
+    },
+    generateTitle() {
+      return Promise.resolve(new ReadableStream());
+    }
+  };
+}
+
+// src/trueforgeThreadListAdapter.ts
+var THREAD_LIST_PAGE_SIZE3 = 20;
+function createTrueForgeThreadListAdapter(options) {
+  const { server, agentName, listSessionsAgentId, listSessionsCreatedByMe = false } = options;
+  return {
+    async list({ after } = {}) {
+      const page = await server.listSessions({
+        ...listSessionsAgentId != null ? { agentId: listSessionsAgentId } : {},
+        createdByMe: listSessionsCreatedByMe,
+        limit: THREAD_LIST_PAGE_SIZE3,
+        ...after == null ? {} : { pageToken: after },
+        startTimestamp: sessionListStartTimestamp()
+      });
+      const threads = page.data.map((session) => sessionToThreadMetadata(session, session.title ?? void 0));
+      return {
+        threads,
+        nextCursor: page.nextPageToken ?? void 0
+      };
+    },
+    async initialize() {
+      const session = await server.createSession({ agentName });
+      return { remoteId: session.id, externalId: void 0 };
+    },
+    async fetch(remoteId) {
+      const session = await getSession(server, remoteId);
+      return sessionToThreadMetadata(session, session.title ?? void 0);
+    },
+    async rename(remoteId, newTitle) {
+      if (typeof server.renameSession !== "function") {
+        return;
+      }
+      await server.renameSession({ sessionId: remoteId, title: newTitle });
+    },
+    archive() {
+      return Promise.resolve();
+    },
+    unarchive() {
+      return Promise.resolve();
+    },
+    async delete(remoteId) {
+      if (typeof server.deleteSession !== "function") {
+        return;
+      }
+      await server.deleteSession({ sessionId: remoteId });
+    },
+    generateTitle() {
+      return Promise.resolve(new ReadableStream());
+    }
+  };
+}
+
+// src/useTrueForgeAgentRuntime.ts
+import {
+  pickExternalStoreSharedOptions
+} from "@assistant-ui/core";
+import { useExternalStoreRuntime, useRemoteThreadListRuntime, useRuntimeAdapters } from "@assistant-ui/core/react";
+import { useAui as useAui3, useAuiState as useAuiState2 } from "@assistant-ui/store";
+import { useCallback as useCallback4, useEffect as useEffect3, useMemo as useMemo4, useRef as useRef3, useState as useState3 } from "react";
+
+// src/messageCustomMetadata.ts
+function isUnknownRecord3(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isMcpServerAuthInfoList(value) {
+  return Array.isArray(value) && value.every(
+    (server) => isUnknownRecord3(server) && typeof server["id"] === "string" && typeof server["name"] === "string" && typeof server["authUrl"] === "string"
+  );
+}
+
+// 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) => {
+        const approval = part.approval;
+        if (approval == null || !hasPendingToolApproval(approval)) {
+          return;
+        }
+        pending.push({
+          approvalId: 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 = isUnknownRecord3(part.interrupt?.payload) ? {
+          ...typeof part.interrupt.payload["question"] === "string" ? { question: part.interrupt.payload["question"] } : {},
+          ...Array.isArray(part.interrupt.payload["options"]) && part.interrupt.payload["options"].every((option) => typeof option === "string") ? { options: part.interrupt.payload["options"] } : {}
+        } : void 0;
+        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 (const message of messages.toReversed()) {
+    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 (!isMcpServerAuthInfoList(servers)) {
+      return { mcpServers: [] };
+    }
+    return { mcpServers: servers };
+  }
+  return null;
+}
+function deriveSandboxId(messages) {
+  for (const message of messages.toReversed()) {
+    if (message.role !== "assistant") {
+      continue;
+    }
+    const sandboxId = message.metadata.custom["sandboxId"];
+    if (typeof sandboxId === "string") {
+      return sandboxId;
+    }
+  }
+  return void 0;
+}
+
+// src/draft/useDraftAgentSpec.ts
+import { useCallback as useCallback2, useEffect, useMemo as useMemo2, 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 [isSpecLoading, setIsSpecLoading] = useState(false);
+  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);
+  const lastUpdatedAtRef = useRef(void 0);
+  const pendingFlushRef = useRef(void 0);
+  const inFlightFlushRef = useRef(void 0);
+  const activeDraftIdRef = useRef(draftSessionId);
+  useEffect(() => {
+    const previousDraftId = activeDraftIdRef.current;
+    if (previousDraftId === draftSessionId) {
+      return;
+    }
+    activeDraftIdRef.current = draftSessionId;
+    syncGenerationRef.current++;
+    if (syncTimeoutRef.current != null) {
+      clearTimeout(syncTimeoutRef.current);
+      syncTimeoutRef.current = void 0;
+    }
+    pendingFlushRef.current = void 0;
+    inFlightFlushRef.current = void 0;
+    lastUpdatedAtRef.current = void 0;
+    setIsSpecSyncing(false);
+    if (previousDraftId != null) {
+      localDirtyRef.current = false;
+    }
+  }, [draftSessionId]);
+  useEffect(() => {
+    if (draftBridge == null) {
+      return;
+    }
+    if (draftSessionId == null) {
+      loadedDraftIdRef.current = void 0;
+      setAgentSpec(defaultAgentSpec);
+      localDirtyRef.current = false;
+      setSpecError(null);
+      setIsSpecLoading(false);
+      return;
+    }
+    if (loadedDraftIdRef.current === draftSessionId) {
+      return;
+    }
+    const abortController = new AbortController();
+    setIsSpecLoading(true);
+    void (async () => {
+      try {
+        const loaded = await draftBridge.getDraftAgentSpec(draftSessionId);
+        if (abortController.signal.aborted) {
+          return;
+        }
+        loadedDraftIdRef.current = draftSessionId;
+        if (localDirtyRef.current) {
+          scheduleSpecSyncRef.current(draftSessionId, agentSpecRef.current);
+          localDirtyRef.current = false;
+          setSpecError(null);
+          setIsSpecLoading(false);
+          return;
+        }
+        setAgentSpec(loaded);
+        setSpecError(null);
+        setIsSpecLoading(false);
+      } catch (error) {
+        if (!abortController.signal.aborted) {
+          onError?.(error);
+          setSpecError(error);
+          setIsSpecLoading(false);
+        }
+      }
+    })();
+    return () => {
+      abortController.abort();
+      setIsSpecLoading(false);
+    };
+  }, [defaultAgentSpec, draftBridge, draftSessionId, enabled, onError]);
+  const flushSpecSync = useCallback2(
+    async (draftId, spec, generation) => {
+      if (draftBridge == null) {
+        return;
+      }
+      setIsSpecSyncing(true);
+      try {
+        const updatedAt = await draftBridge.syncAgentSpec(draftId, spec);
+        if (generation !== syncGenerationRef.current) {
+          return;
+        }
+        lastUpdatedAtRef.current = updatedAt || (/* @__PURE__ */ new Date()).toISOString();
+        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 = useCallback2(
+    (draftId, spec) => {
+      if (syncTimeoutRef.current != null) {
+        clearTimeout(syncTimeoutRef.current);
+      }
+      const generation = ++syncGenerationRef.current;
+      const flush = () => {
+        pendingFlushRef.current = void 0;
+        syncTimeoutRef.current = void 0;
+        const promise = flushSpecSync(draftId, spec, generation).finally(() => {
+          if (inFlightFlushRef.current === promise) {
+            inFlightFlushRef.current = void 0;
+          }
+        });
+        inFlightFlushRef.current = promise;
+        return promise;
+      };
+      pendingFlushRef.current = flush;
+      syncTimeoutRef.current = setTimeout(() => {
+        void flush();
+      }, SPEC_SYNC_DEBOUNCE_MS);
+    },
+    [flushSpecSync]
+  );
+  const scheduleSpecSyncRef = useRef(scheduleSpecSync);
+  scheduleSpecSyncRef.current = scheduleSpecSync;
+  const flushPendingSpecSyncNow = useCallback2(async () => {
+    if (syncTimeoutRef.current != null) {
+      clearTimeout(syncTimeoutRef.current);
+      syncTimeoutRef.current = void 0;
+    }
+    const pending = pendingFlushRef.current;
+    if (pending != null) {
+      pendingFlushRef.current = void 0;
+      await pending();
+      return;
+    }
+    if (inFlightFlushRef.current != null) {
+      await inFlightFlushRef.current;
+    }
+  }, []);
+  const adoptAgentSpec = useCallback2(
+    ({ agentSpec: persistedSpec, updatedAt }) => {
+      if (syncTimeoutRef.current != null) {
+        clearTimeout(syncTimeoutRef.current);
+        syncTimeoutRef.current = void 0;
+      }
+      syncGenerationRef.current++;
+      pendingFlushRef.current = void 0;
+      inFlightFlushRef.current = void 0;
+      localDirtyRef.current = false;
+      if (updatedAt !== void 0) {
+        lastUpdatedAtRef.current = updatedAt;
+      }
+      agentSpecRef.current = persistedSpec;
+      setAgentSpec(persistedSpec);
+      setSpecError(null);
+      setIsSpecSyncing(false);
+    },
+    []
+  );
+  const takeTurnHeaderTimestamp = useCallback2(async () => {
+    await flushPendingSpecSyncNow();
+    const updatedAt = lastUpdatedAtRef.current;
+    lastUpdatedAtRef.current = void 0;
+    return updatedAt;
+  }, [flushPendingSpecSyncNow]);
+  useEffect(
+    () => () => {
+      if (syncTimeoutRef.current != null) {
+        clearTimeout(syncTimeoutRef.current);
+      }
+    },
+    []
+  );
+  const updateAgentSpec = useCallback2(
+    (update) => {
+      if (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 useMemo2(
+    () => ({
+      agentSpec: enabled ? agentSpec : null,
+      draftSessionId: enabled ? draftSessionId : void 0,
+      isSpecLoading: enabled ? isSpecLoading : false,
+      isSpecSyncing: enabled ? isSpecSyncing : false,
+      specError: enabled ? specError : null,
+      updateAgentSpec,
+      flushAgentSpec: flushPendingSpecSyncNow,
+      adoptAgentSpec,
+      takeTurnHeaderTimestamp
+    }),
+    [
+      agentSpec,
+      draftSessionId,
+      enabled,
+      isSpecLoading,
+      isSpecSyncing,
+      specError,
+      flushPendingSpecSyncNow,
+      adoptAgentSpec,
+      takeTurnHeaderTimestamp,
+      updateAgentSpec
+    ]
+  );
+}
+
+// src/sandboxDownload.ts
+function buildSandboxDownloadRequest(args) {
+  if (args.sessionId == null) {
+    throw new Error("This session has not been saved yet, so its files cannot be downloaded.");
+  }
+  return {
+    sessionId: args.sessionId,
+    turnId: args.turnId,
+    path: args.path,
+    ...args.sandboxId != null ? { sandboxId: args.sandboxId } : {}
+  };
+}
+
+// src/types.ts
+function resolveTrueForgeAgentConfig(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("useTrueForgeAgentRuntime requires `agent` or legacy `agentName`.");
+}
+function resolveTrueForgeAgentRuntimeOptions(options) {
+  const agent = resolveTrueForgeAgentConfig(options);
+  return {
+    ...options,
+    agent
+  };
+}
+
+// src/useTrueForgeAgentMessages.ts
+import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo3, useRef as useRef2, useState as useState2 } from "react";
+
+// src/loadSessionSnapshot.ts
+var inflightBySessionId2 = /* @__PURE__ */ new Map();
+function loadSessionSnapshot(server, sessionId, onProgress) {
+  let inflight = inflightBySessionId2.get(sessionId);
+  if (inflight == null) {
+    inflight = getSession(server, sessionId).then(() => buildSnapshotFromSessionEvents(server, sessionId, onProgress)).finally(() => {
+      if (inflightBySessionId2.get(sessionId) === inflight) {
+        inflightBySessionId2.delete(sessionId);
+      }
+    });
+    inflightBySessionId2.set(sessionId, inflight);
+  }
+  return inflight;
+}
+
+// src/streamTurn.ts
+function buildTurnInput(options) {
+  if (options.inputs != null) {
+    return options.inputs;
+  }
+  if (options.resumeMcpAuth === true) {
+    return [];
+  }
+  return [{ type: "user.message", content: options.userMessage ?? "" }];
+}
+async function* streamTurnContent(server, sessionId, foldState, options, abortSignal, groupRootBaseline, onTurnIdAvailable) {
+  if (abortSignal.aborted) {
+    return;
+  }
+  let turnIdNotified = false;
+  const notifyTurnId = (turnId) => {
+    if (!turnIdNotified) {
+      onTurnIdAvailable?.(turnId);
+      turnIdNotified = true;
+    }
+  };
+  const stream = server.createTurn({
+    sessionId,
+    input: buildTurnInput(options),
+    previousTurnId: options.previousTurnId ?? "auto",
+    abortSignal,
+    ...options.headers != null ? { headers: options.headers } : {}
+  });
+  try {
+    for await (const update of streamTurnEvents(stream, foldState, groupRootBaseline, notifyTurnId)) {
+      yield update;
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    throw error;
+  }
+}
+async function* resumeTurnStream(server, sessionId, turnId, foldState, abortSignal, afterSequenceNumber, groupRootBaseline) {
+  if (server.subscribeToTurn == null) {
+    return;
+  }
+  if (abortSignal.aborted) {
+    return;
+  }
+  try {
+    yield* streamTurnEvents(
+      server.subscribeToTurn({
+        sessionId,
+        turnId,
+        ...afterSequenceNumber != null ? { afterSequenceNumber } : {},
+        abortSignal
+      }),
+      foldState,
+      groupRootBaseline
+    );
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/useTrueForgeAgentMessages.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 && isMcpServerAuthInfoList(custom["mcpServers"])) {
+    const mcpAuthRequired = {
+      type: "mcp.auth_required",
+      id: crypto.randomUUID(),
+      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: crypto.randomUUID(),
+        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: crypto.randomUUID(),
+        createdAt,
+        threadId: responseThreadId,
+        toolCalls: []
+      };
+      requiredActions.push(responseRequired);
+    }
+  }
+  return requiredActions;
+}
+function buildUserTurnInput(content) {
+  return { type: "user.message", content };
+}
+function appendTurnInputs(base, continuationInputs) {
+  const existingInputs = base ?? [];
+  if (continuationInputs == null || continuationInputs.length === 0) {
+    return existingInputs;
+  }
+  return [...existingInputs, ...continuationInputs];
+}
+function cancelScheduledAnimationFrame(frame) {
+  if (frame != null) {
+    cancelAnimationFrame(frame);
+  }
+}
+function commitActiveStream(snapshot, continuationInputs) {
+  const active = snapshot.activeStream;
+  if (active?.streamComplete !== true) {
+    return snapshot;
+  }
+  const activeSandboxIdValue = active.update.metadata?.custom?.["sandboxId"];
+  const activeSandboxId = typeof activeSandboxIdValue === "string" ? activeSandboxIdValue : void 0;
+  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,
+          ...activeSandboxId != null ? { sandboxId: activeSandboxId } : {}
+        } : turn
+      ),
+      pendingUser: void 0,
+      // Custom stream adapters may yield projected content without fold events.
+      // Keep that completed projection until the next stream replaces it.
+      ...rootModelMessageIds.length > 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 ? { userText: userMessageContentToText(snapshot.pendingUser.content) } : {},
+    rootModelMessageIds,
+    ...activeSandboxId != null ? { sandboxId: activeSandboxId } : {}
+  };
+  return replaceSessionSnapshot(snapshot, {
+    turns: [...snapshot.turns, record],
+    pendingUser: void 0,
+    ...rootModelMessageIds.length > 0 ? { activeStream: void 0 } : {}
+  });
+}
+var MAX_SANDBOX_HISTORY_PAGE_INS = 20;
+function findSandboxIdInSnapshot(snapshot, turnId) {
+  const active = snapshot.activeStream;
+  if (active?.turnId === turnId) {
+    const sandboxId = active.update.metadata?.custom?.["sandboxId"];
+    if (typeof sandboxId === "string") {
+      return sandboxId;
+    }
+  }
+  const turns = snapshot.turns;
+  const turnIndex = turns.findIndex((turn) => turn.id === turnId);
+  for (let i = turnIndex === -1 ? turns.length - 1 : turnIndex; i >= 0; i--) {
+    const sandboxId = turns[i]?.sandboxId;
+    if (sandboxId != null) {
+      return sandboxId;
+    }
+  }
+  return void 0;
+}
+async function resolveActiveSessionId(remoteId, resolveConversationSessionId) {
+  if (resolveConversationSessionId != null) {
+    return resolveConversationSessionId(remoteId);
+  }
+  return remoteId;
+}
+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 useTrueForgeAgentMessages({
+  server,
+  sessionId,
+  isMain,
+  isInitialSession,
+  onError,
+  initializeSession,
+  resolveConversationSessionId,
+  getTurnHeaders
+}) {
+  const [snapshot, setSnapshot] = useState2(createEmptySessionSnapshot);
+  const [isRunning, setIsRunning] = useState2(false);
+  const [isLoading, setIsLoading] = useState2(sessionId != null && (isMain !== false || isInitialSession === true));
+  const [isLoadingOlderHistory, setIsLoadingOlderHistory] = useState2(false);
+  const [loadRetryTrigger, setLoadRetryTrigger] = useState2(0);
+  const [resumeUnavailable, setResumeUnavailable] = useState2(false);
+  const snapshotRef = useRef2(snapshot);
+  snapshotRef.current = snapshot;
+  const sessionIdRef = useRef2(sessionId);
+  sessionIdRef.current = sessionId;
+  const loadOlderInflightRef = useRef2(null);
+  const onErrorRef = useRef2(onError);
+  onErrorRef.current = onError;
+  const resolveConversationSessionIdRef = useRef2(resolveConversationSessionId);
+  resolveConversationSessionIdRef.current = resolveConversationSessionId;
+  const initializeSessionRef = useRef2(initializeSession);
+  initializeSessionRef.current = initializeSession;
+  const getTurnHeadersRef = useRef2(getTurnHeaders);
+  getTurnHeadersRef.current = getTurnHeaders;
+  const createdAtByMessageIdRef = useRef2(/* @__PURE__ */ new Map());
+  const abortControllerRef = useRef2(null);
+  const activeRunRef = useRef2(null);
+  const resumeUnavailableRef = useRef2(false);
+  const runningTurnRef = useRef2(void 0);
+  const loadGenerationRef = useRef2(0);
+  const streamGenerationRef = useRef2(0);
+  const lazilyCreatedSessionIdRef = useRef2(void 0);
+  const initialLoadStartedForRef = useRef2(void 0);
+  const skipInitialPromotionLoadForRef = useRef2(void 0);
+  const markResumeUnavailable = useCallback3((value) => {
+    resumeUnavailableRef.current = value;
+    setResumeUnavailable(value);
+  }, []);
+  const projectOptions = useMemo3(
+    () => ({
+      getCreatedAt: (messageId, fallback, replace = false) => {
+        const cache = createdAtByMessageIdRef.current;
+        const existing = cache.get(messageId);
+        if (existing != null && (!replace || existing.getTime() === fallback.getTime())) {
+          return existing;
+        }
+        cache.set(messageId, fallback);
+        return fallback;
+      }
+    }),
+    []
+  );
+  const messages = useMemo3(() => projectSessionMessages(snapshot, projectOptions), [snapshot, projectOptions]);
+  const runStream = useCallback3(
+    (createStream, turnIdRef, isContinuation) => {
+      const streamGeneration = ++streamGenerationRef.current;
+      abortControllerRef.current?.abort();
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+      setIsRunning(true);
+      markResumeUnavailable(false);
+      const run = (async () => {
+        let pendingStreamUpdate = null;
+        let streamUpdateRaf = null;
+        const flushPendingStreamUpdate = () => {
+          streamUpdateRaf = null;
+          const pending = pendingStreamUpdate;
+          pendingStreamUpdate = null;
+          if (pending == null || streamGeneration !== streamGenerationRef.current) {
+            return;
+          }
+          const { update, isContinuation: pendingIsContinuation } = pending;
+          setSnapshot(
+            (prev) => replaceSessionSnapshot(prev, {
+              activeStream: {
+                // Read from the ref so we always use the latest ID,
+                // including any gateway ID that arrived after the RAf
+                // was scheduled.
+                turnId: turnIdRef.current,
+                update,
+                isContinuation: pendingIsContinuation
+              }
+            })
+          );
+        };
+        const applyStreamUpdate = (update) => {
+          pendingStreamUpdate = { update, isContinuation };
+          streamUpdateRaf ??= requestAnimationFrame(flushPendingStreamUpdate);
+        };
+        try {
+          for await (const update of createStream(abortController.signal)) {
+            if (abortController.signal.aborted) {
+              return;
+            }
+            applyStreamUpdate(update);
+          }
+        } catch (error) {
+          if (error instanceof Error && error.name === "AbortError") {
+            return;
+          }
+          onErrorRef.current?.(error);
+          throw error;
+        } finally {
+          cancelScheduledAnimationFrame(streamUpdateRaf);
+          if (streamGeneration === streamGenerationRef.current) {
+            flushPendingStreamUpdate();
+            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;
+    },
+    [onError]
+  );
+  const load = useCallback3(async () => {
+    void loadRetryTrigger;
+    if (sessionId == null) {
+      createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
+      setSnapshot(createEmptySessionSnapshot());
+      return;
+    }
+    const isEarlyInitialLoad = isMain === false && isInitialSession === true && initialLoadStartedForRef.current !== sessionId;
+    if (isMain === false) {
+      if (!isEarlyInitialLoad) {
+        return;
+      }
+      initialLoadStartedForRef.current = sessionId;
+      skipInitialPromotionLoadForRef.current = sessionId;
+    } else if (isMain === true && skipInitialPromotionLoadForRef.current === sessionId) {
+      skipInitialPromotionLoadForRef.current = void 0;
+      return;
+    }
+    if (isInitialSession === true) {
+      initialLoadStartedForRef.current = sessionId;
+    }
+    if (lazilyCreatedSessionIdRef.current != null && sessionId !== lazilyCreatedSessionIdRef.current) {
+      lazilyCreatedSessionIdRef.current = void 0;
+    }
+    if (sessionId === lazilyCreatedSessionIdRef.current) {
+      return;
+    }
+    const generation = ++loadGenerationRef.current;
+    ++streamGenerationRef.current;
+    setIsRunning(false);
+    markResumeUnavailable(false);
+    abortControllerRef.current?.abort();
+    loadOlderInflightRef.current = null;
+    createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
+    setSnapshot(createEmptySessionSnapshot());
+    setIsLoading(true);
+    setIsLoadingOlderHistory(false);
+    try {
+      const conversationSessionId = await resolveActiveSessionId(sessionId, resolveConversationSessionIdRef.current);
+      const loadedSnapshot = await loadSessionSnapshot(server, conversationSessionId, (snap) => {
+        if (generation === loadGenerationRef.current) {
+          setSnapshot(snap);
+        }
+      });
+      if (generation !== loadGenerationRef.current) {
+        return;
+      }
+      createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
+      setSnapshot(loadedSnapshot);
+      runningTurnRef.current = loadedSnapshot.runningTurn;
+      setIsLoading(false);
+      if (loadedSnapshot.runningTurn != null) {
+        const turn = loadedSnapshot.runningTurn;
+        if (server.subscribeToTurn == null) {
+          setIsRunning(true);
+          markResumeUnavailable(true);
+          return;
+        }
+        const isContinuation = extractTurnUserText(turn.input) === void 0;
+        void runStream(
+          (signal) => resumeTurnStream(
+            server,
+            conversationSessionId,
+            turn.id,
+            loadedSnapshot.fold,
+            signal,
+            void 0,
+            loadedSnapshot.groupRootBaseline
+          ),
+          { current: turn.id },
+          isContinuation
+        ).catch(() => void 0);
+      }
+    } catch (error) {
+      if (generation === loadGenerationRef.current) {
+        if (isEarlyInitialLoad) {
+          initialLoadStartedForRef.current = void 0;
+          skipInitialPromotionLoadForRef.current = void 0;
+        }
+        onErrorRef.current?.(error);
+      }
+      throw error;
+    } finally {
+      if (generation === loadGenerationRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [server, runStream, sessionId, loadRetryTrigger, isMain, isInitialSession]);
+  useEffect2(() => {
+    void load().catch(() => void 0);
+  }, [load]);
+  const sendTurn = useCallback3(
+    async (options) => {
+      const gatewayTurnAccepted = { current: false };
+      let pendingUserWasSet = false;
+      let runStreamStarted = false;
+      let pendingUserTurnId;
+      try {
+        let activeSessionId = sessionId;
+        if (activeSessionId == null) {
+          if (initializeSessionRef.current == null) {
+            throw new Error("Cannot send a turn without an active session.");
+          }
+          const { remoteId } = await initializeSessionRef.current();
+          activeSessionId = remoteId;
+          lazilyCreatedSessionIdRef.current = remoteId;
+        }
+        const conversationSessionId = await resolveActiveSessionId(
+          activeSessionId,
+          resolveConversationSessionIdRef.current
+        );
+        const turnHeaders = await getTurnHeadersRef.current?.();
+        const streamHeaders = turnHeaders != null ? { headers: turnHeaders } : {};
+        const isContinuation = "inputs" in options || "resumeMcpAuth" in options && options.resumeMcpAuth;
+        const continuationTurnId = snapshotRef.current.activeStream?.turnId;
+        const turnId = isContinuation ? (
+          // A paused stream is usually already committed (commitActiveStream
+          // cleared activeStream), so continue under the committed turn's
+          // real id. Never mint a local id for a continuation — it leaks to
+          // the backend via `custom.turnId` (sandbox downloads, edit/retry)
+          // as a turn the gateway has never heard of.
+          continuationTurnId ?? snapshotRef.current.turns.at(-1)?.id ?? crypto.randomUUID()
+        ) : crypto.randomUUID();
+        const isFirstTurnInSession = "userMessage" in options && options.previousTurnId === void 0 && snapshotRef.current.turns.length === 0 && snapshotRef.current.pendingUser == null && snapshotRef.current.activeStream == null;
+        const turnIdRef = { current: turnId };
+        const handleGatewayTurnId = (gatewayTurnId) => {
+          const oldId = turnIdRef.current;
+          gatewayTurnAccepted.current = true;
+          if (gatewayTurnId === oldId) {
+            return;
+          }
+          turnIdRef.current = gatewayTurnId;
+          const renamePendingUser = (prev) => {
+            if (prev.pendingUser?.turnId !== oldId) {
+              return prev;
+            }
+            return replaceSessionSnapshot(prev, {
+              pendingUser: {
+                ...prev.pendingUser,
+                turnId: gatewayTurnId
+              }
+            });
+          };
+          snapshotRef.current = renamePendingUser(snapshotRef.current);
+          setSnapshot(renamePendingUser);
+        };
+        if ("inputs" in options) {
+          applyUserToolResponsesToFold(snapshotRef.current.fold, options.inputs);
+        }
+        const branchBase = "userMessage" in options ? options.branchFromSnapshot : void 0;
+        let groupRootBaseline;
+        if (branchBase != null && "userMessage" in options) {
+          const rootBucket = branchBase.fold.threads.get(ROOT_THREAD_ID);
+          groupRootBaseline = [...rootBucket?.modelMessageIds ?? []];
+          const nextSnapshot = replaceSessionSnapshot(branchBase, {
+            pendingUser: {
+              turnId,
+              content: options.userMessage,
+              createdAt: /* @__PURE__ */ new Date()
+            },
+            activeStream: void 0,
+            groupRootBaseline
+          });
+          snapshotRef.current = nextSnapshot;
+          setSnapshot(nextSnapshot);
+          pendingUserWasSet = true;
+          pendingUserTurnId = turnId;
+        } else {
+          setSnapshot((prev) => commitActiveStream(prev, "inputs" in options ? options.inputs : void 0));
+          if ("userMessage" in options) {
+            const rootBucket = snapshotRef.current.fold.threads.get(ROOT_THREAD_ID);
+            groupRootBaseline = [...rootBucket?.modelMessageIds ?? []];
+            setSnapshot((prev) => {
+              const next = replaceSessionSnapshot(prev, {
+                pendingUser: {
+                  turnId,
+                  content: options.userMessage,
+                  createdAt: /* @__PURE__ */ new Date()
+                },
+                activeStream: void 0,
+                groupRootBaseline
+              });
+              snapshotRef.current = next;
+              return next;
+            });
+            pendingUserWasSet = true;
+            pendingUserTurnId = turnId;
+          } else {
+            groupRootBaseline = snapshotRef.current.groupRootBaseline ?? computeGroupRootBaseline(snapshotRef.current.turns);
+          }
+        }
+        runStreamStarted = true;
+        await runStream(
+          (signal) => {
+            if ("inputs" in options) {
+              return streamTurnContent(
+                server,
+                conversationSessionId,
+                snapshotRef.current.fold,
+                { inputs: options.inputs, ...streamHeaders },
+                signal,
+                groupRootBaseline,
+                handleGatewayTurnId
+              );
+            }
+            if ("resumeMcpAuth" in options) {
+              return streamTurnContent(
+                server,
+                conversationSessionId,
+                snapshotRef.current.fold,
+                { resumeMcpAuth: true, ...streamHeaders },
+                signal,
+                groupRootBaseline,
+                handleGatewayTurnId
+              );
+            }
+            return streamTurnContent(
+              server,
+              conversationSessionId,
+              snapshotRef.current.fold,
+              {
+                userMessage: options.userMessage,
+                ...options.previousTurnId !== void 0 ? { previousTurnId: options.previousTurnId ?? "none" } : isFirstTurnInSession ? { previousTurnId: "none" } : {},
+                ...streamHeaders
+              },
+              signal,
+              groupRootBaseline,
+              handleGatewayTurnId
+            );
+          },
+          turnIdRef,
+          isContinuation
+        );
+      } catch (error) {
+        if ("userMessage" in options && !gatewayTurnAccepted.current) {
+          const branchRollbackSnapshot = options.branchRollbackSnapshot;
+          const canRestoreBranch = branchRollbackSnapshot != null && (snapshotRef.current === options.branchFromSnapshot || snapshotRef.current.pendingUser?.turnId === pendingUserTurnId);
+          if (canRestoreBranch) {
+            snapshotRef.current = branchRollbackSnapshot;
+            setSnapshot(branchRollbackSnapshot);
+          } else if (pendingUserWasSet) {
+            const clearPendingUser = (previous) => {
+              if (previous.pendingUser?.turnId !== pendingUserTurnId) {
+                return previous;
+              }
+              return replaceSessionSnapshot(previous, {
+                pendingUser: void 0
+              });
+            };
+            snapshotRef.current = clearPendingUser(snapshotRef.current);
+            setSnapshot(clearPendingUser);
+          }
+          options.onPreTurnFailure?.();
+        }
+        if (!runStreamStarted) {
+          onErrorRef.current?.(error);
+        }
+        throw error;
+      }
+    },
+    [server, runStream, sessionId]
+  );
+  const cancel = useCallback3(async () => {
+    const activeSessionId = sessionId ?? lazilyCreatedSessionIdRef.current;
+    if (activeSessionId == null) {
+      abortControllerRef.current?.abort();
+      return;
+    }
+    const conversationSessionId = await resolveActiveSessionId(
+      activeSessionId,
+      resolveConversationSessionIdRef.current
+    );
+    await server.cancelSession({ sessionId: conversationSessionId }).catch(() => void 0);
+    await activeRunRef.current?.catch(() => void 0);
+    if (resumeUnavailableRef.current) {
+      markResumeUnavailable(false);
+      setIsRunning(false);
+    }
+  }, [server, sessionId, markResumeUnavailable]);
+  const isRunningRef = useRef2(isRunning);
+  isRunningRef.current = isRunning;
+  const trySendCollectedRequiredActions = useCallback3(
+    (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(() => void 0);
+      }
+    },
+    [projectOptions, sendTurn]
+  );
+  const respondToToolApproval = useCallback3(
+    (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 = useCallback3(
+    (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 = useCallback3(async () => {
+    const turn = runningTurnRef.current;
+    if (turn == null) {
+      return;
+    }
+    if (server.subscribeToTurn == null) {
+      markResumeUnavailable(true);
+      return;
+    }
+    await runStream(
+      (signal) => resumeTurnStream(
+        server,
+        turn.sessionId,
+        turn.id,
+        snapshotRef.current.fold,
+        signal,
+        void 0,
+        snapshotRef.current.groupRootBaseline
+      ),
+      { current: turn.id },
+      true
+    );
+  }, [runStream, server]);
+  const branchFromTurn = useCallback3(
+    async (turnId, userMessage) => {
+      let committed;
+      let previousTurnId;
+      let rewound;
+      try {
+        const activeSessionId = sessionId;
+        if (activeSessionId == null) {
+          throw new Error("Cannot branch from a turn without an active session.");
+        }
+        committed = commitActiveStream(snapshotRef.current);
+        setSnapshot(committed);
+        await cancel();
+        const conversationSessionId = await resolveActiveSessionId(
+          activeSessionId,
+          resolveConversationSessionIdRef.current
+        );
+        previousTurnId = await resolveGatewayBranchPreviousTurnIdForTurn(server, conversationSessionId, turnId);
+        rewound = await buildSnapshotThroughTurn(
+          server,
+          conversationSessionId,
+          previousTurnId === "none" ? null : previousTurnId
+        );
+        createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
+        snapshotRef.current = rewound;
+        setSnapshot(rewound);
+      } catch (error) {
+        onErrorRef.current?.(error);
+        throw error;
+      }
+      await sendTurn({
+        userMessage,
+        previousTurnId,
+        branchFromSnapshot: rewound,
+        branchRollbackSnapshot: committed
+      });
+    },
+    [cancel, server, sendTurn, sessionId]
+  );
+  const resetFromTurn = useCallback3(
+    async (turnId) => {
+      const committed = commitActiveStream(snapshotRef.current);
+      const originalInput = resolveTurnInput(committed, turnId);
+      if (originalInput == null) {
+        const error = new Error(`Turn ${turnId} not found in session snapshot`);
+        onErrorRef.current?.(error);
+        throw error;
+      }
+      const userMessage = extractTurnUserMessageContent(originalInput);
+      await branchFromTurn(turnId, userMessage);
+    },
+    [branchFromTurn]
+  );
+  const editFromTurn = useCallback3(
+    async (turnId, editedText) => {
+      const committed = commitActiveStream(snapshotRef.current);
+      const originalInput = resolveTurnInput(committed, turnId);
+      if (originalInput == null) {
+        const error = new Error(`Turn ${turnId} not found in session snapshot`);
+        onErrorRef.current?.(error);
+        throw error;
+      }
+      const userMessage = buildEditedUserMessageContent(editedText, originalInput);
+      await branchFromTurn(turnId, userMessage);
+    },
+    [branchFromTurn]
+  );
+  const retryLoad = useCallback3(() => {
+    setLoadRetryTrigger((n) => n + 1);
+  }, []);
+  const hasOlderHistory = snapshot.historyPagination?.hasOlder === true;
+  const loadOlderHistory = useCallback3(async () => {
+    if (sessionId == null || isMain === false) {
+      return;
+    }
+    const requestedSessionId = sessionId;
+    if (sessionIdRef.current !== requestedSessionId) {
+      return;
+    }
+    if (loadOlderInflightRef.current != null) {
+      return loadOlderInflightRef.current;
+    }
+    const current = snapshotRef.current;
+    if (current.historyPagination?.hasOlder !== true) {
+      return;
+    }
+    if (current.historyPagination.olderPageToken == null) {
+      return;
+    }
+    const generation = loadGenerationRef.current;
+    setIsLoadingOlderHistory(true);
+    const run = (async () => {
+      const stillCurrent = () => generation === loadGenerationRef.current && sessionIdRef.current === requestedSessionId;
+      try {
+        const conversationSessionId = await resolveActiveSessionId(
+          requestedSessionId,
+          resolveConversationSessionIdRef.current
+        );
+        if (!stillCurrent()) {
+          return;
+        }
+        const next = await prependOlderSessionHistory(server, conversationSessionId, snapshotRef.current);
+        if (!stillCurrent()) {
+          return;
+        }
+        snapshotRef.current = next;
+        setSnapshot(next);
+      } catch (error) {
+        if (stillCurrent()) {
+          onErrorRef.current?.(error);
+        }
+        throw error;
+      } finally {
+        if (stillCurrent()) {
+          setIsLoadingOlderHistory(false);
+        }
+        loadOlderInflightRef.current = null;
+      }
+    })();
+    loadOlderInflightRef.current = run;
+    return run;
+  }, [server, isMain, sessionId]);
+  const resolveSandboxIdForTurn = useCallback3(
+    async (turnId) => {
+      const generation = loadGenerationRef.current;
+      const requestedSessionId = sessionId;
+      const stillCurrent = () => generation === loadGenerationRef.current && sessionIdRef.current === requestedSessionId;
+      if (!stillCurrent()) {
+        return void 0;
+      }
+      let sandboxId = findSandboxIdInSnapshot(snapshotRef.current, turnId);
+      for (let i = 0; sandboxId == null && stillCurrent() && snapshotRef.current.historyPagination?.hasOlder === true && i < MAX_SANDBOX_HISTORY_PAGE_INS; i++) {
+        await loadOlderHistory();
+        if (!stillCurrent()) {
+          return void 0;
+        }
+        sandboxId = findSandboxIdInSnapshot(snapshotRef.current, turnId);
+      }
+      return stillCurrent() ? sandboxId : void 0;
+    },
+    [loadOlderHistory, sessionId]
+  );
+  return {
+    messages,
+    isRunning,
+    resumeUnavailable,
+    isLoading,
+    isLoadingOlderHistory,
+    hasOlderHistory,
+    loadOlderHistory,
+    resolveSandboxIdForTurn,
+    retryLoad,
+    sendTurn,
+    cancel,
+    respondToToolApproval,
+    respondToToolResponse,
+    resumeRun,
+    branchFromTurn,
+    resetFromTurn,
+    editFromTurn
+  };
+}
+
+// src/useTrueForgeAgentRuntime.ts
+function createDelegatingThreadListAdapter(adapterRef) {
+  return {
+    list: (params) => adapterRef.current.list(params),
+    initialize: (threadId) => adapterRef.current.initialize(threadId),
+    fetch: (threadId) => adapterRef.current.fetch(threadId),
+    rename: (remoteId, newTitle) => adapterRef.current.rename(remoteId, newTitle),
+    archive: (remoteId) => adapterRef.current.archive(remoteId),
+    unarchive: (remoteId) => adapterRef.current.unarchive(remoteId),
+    delete: (remoteId) => adapterRef.current.delete(remoteId),
+    generateTitle: (remoteId, messages) => adapterRef.current.generateTitle(remoteId, messages)
+  };
+}
+function useTrueForgeAgentRuntimeImpl(options, pendingAgentSpecRef) {
+  const { server, agent, adapters, onError, ...sharedOptions } = options;
+  const draftBridgeRef = useRef3(agent.mode === "draft" ? createDraftSessionBridge(server) : null);
+  const draftSessionId = useAuiState2(
+    (state) => agent.mode === "draft" ? state.threadListItem.remoteId ?? void 0 : void 0
+  );
+  const sessionId = useAuiState2((state) => state.threadListItem.remoteId ?? void 0);
+  const isMain = useAuiState2((state) => state.threads.mainThreadId === state.threadListItem.id);
+  const isInitialSession = sessionId != null && sessionId === options.initialSessionId;
+  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 takeTurnHeaderTimestampRef = useRef3(draftSpec.takeTurnHeaderTimestamp);
+  takeTurnHeaderTimestampRef.current = draftSpec.takeTurnHeaderTimestamp;
+  const getTurnHeaders = useCallback4(async () => {
+    if (agent.mode !== "draft") {
+      return void 0;
+    }
+    const updatedAt = await takeTurnHeaderTimestampRef.current();
+    if (updatedAt == null) {
+      return void 0;
+    }
+    return { [DRAFT_SESSION_LAST_UPDATED_AT_HEADER]: updatedAt };
+  }, [agent.mode]);
+  const aui = useAui3();
+  const initializeSession = useCallback4(() => aui.threadListItem().initialize(), [aui]);
+  const runtimeAdapters = useRuntimeAdapters();
+  const [, setToolStatuses] = useState3({});
+  const {
+    messages,
+    isRunning,
+    resumeUnavailable,
+    isLoading,
+    isLoadingOlderHistory,
+    hasOlderHistory,
+    loadOlderHistory,
+    sendTurn,
+    cancel,
+    respondToToolApproval,
+    respondToToolResponse,
+    resumeRun,
+    editFromTurn,
+    resetFromTurn,
+    resolveSandboxIdForTurn,
+    retryLoad
+  } = useTrueForgeAgentMessages({
+    server,
+    sessionId,
+    isMain,
+    isInitialSession,
+    onError,
+    initializeSession,
+    ...agent.mode === "draft" ? { getTurnHeaders } : {}
+  });
+  if (agent.mode === "draft" && draftSpec.agentSpec != null) {
+    pendingAgentSpecRef.current = draftSpec.agentSpec;
+  }
+  const pendingApprovals = useMemo4(() => collectPendingApprovals(messages), [messages]);
+  const pendingToolResponses = useMemo4(() => collectPendingToolResponses(messages), [messages]);
+  const pendingMcpAuth = useMemo4(() => derivePendingMcpAuth(messages), [messages]);
+  const sandboxId = useMemo4(() => deriveSandboxId(messages), [messages]);
+  const resumeMcpAuth = useMemo4(() => () => sendTurn({ resumeMcpAuth: true }), [sendTurn]);
+  const downloadSandboxFile = useCallback4(
+    async ({ turnId, path }) => {
+      if (server.downloadSandboxFile == null) {
+        throw new Error("Downloading a sandbox file requires AgentChatServer.downloadSandboxFile.");
+      }
+      const turnSandboxId = await resolveSandboxIdForTurn(turnId) ?? sandboxId;
+      return await server.downloadSandboxFile(
+        buildSandboxDownloadRequest({
+          sessionId,
+          turnId,
+          path,
+          ...turnSandboxId != null ? { sandboxId: turnSandboxId } : {}
+        })
+      );
+    },
+    [server, sessionId, sandboxId, resolveSandboxIdForTurn]
+  );
+  const draftExtras = useMemo4(() => {
+    if (agent.mode !== "draft") {
+      return null;
+    }
+    return {
+      agentSpec: draftSpec.agentSpec,
+      draftSessionId: draftSpec.draftSessionId,
+      isSpecLoading: draftSpec.isSpecLoading,
+      isSpecSyncing: draftSpec.isSpecSyncing,
+      specError: draftSpec.specError,
+      updateAgentSpec: draftSpec.updateAgentSpec,
+      flushAgentSpec: draftSpec.flushAgentSpec,
+      adoptAgentSpec: draftSpec.adoptAgentSpec
+    };
+  }, [agent.mode, draftSpec]);
+  return useExternalStoreRuntime({
+    ...pickExternalStoreSharedOptions(sharedOptions),
+    messages,
+    isRunning,
+    isLoading,
+    extras: trueForgeExtras.provide({
+      pendingApprovals,
+      pendingToolResponses,
+      pendingMcpAuth,
+      resumeUnavailable,
+      sandboxId,
+      respondToToolApproval,
+      respondToToolResponse,
+      resumeMcpAuth,
+      downloadSandboxFile,
+      cancel,
+      // resetFromTurn/branchFromTurn/sendTurn already report via onError.
+      resetFromTurn: (turnId) => resetFromTurn(turnId).catch(() => void 0),
+      reload: retryLoad,
+      hasOlderHistory,
+      isLoadingOlderHistory,
+      loadOlderHistory,
+      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;
+      }
+      const userMessage = buildUserMessageContent(message);
+      await sendTurn({
+        userMessage,
+        // The composer clears before onNew runs. Restore its text only when
+        // the turn failed before turn.created registered it in the backend.
+        onPreTurnFailure: () => {
+          const text = userMessageContentToText(userMessage);
+          const composer = aui.thread().composer();
+          if (text && !composer.getState().text.trim()) {
+            composer.setText(text);
+          }
+        }
+      });
+    },
+    onCancel: async () => {
+      await cancel();
+    },
+    onRespondToToolApproval: (response) => {
+      respondToToolApproval(response);
+      return Promise.resolve();
+    },
+    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);
+      await editFromTurn(turnId, editedText);
+    }
+  });
+}
+function useTrueForgeAgentRuntime(options) {
+  const resolved = resolveTrueForgeAgentRuntimeOptions(options);
+  const { server, agent } = resolved;
+  const pendingAgentSpecRef = useRef3(
+    agent.mode === "draft" ? agent.defaultAgentSpec : void 0
+  );
+  const listSessionsAgentId = resolved.listSessionsAgentId;
+  const listSessionsCreatedByMe = resolved.listSessionsCreatedByMe;
+  const modeThreadListAdapter = useMemo4(() => {
+    if (agent.mode === "draft") {
+      return createTrueForgeDraftThreadListAdapter({
+        server,
+        defaultAgentSpec: agent.defaultAgentSpec,
+        getAgentSpec: () => pendingAgentSpecRef.current ?? agent.defaultAgentSpec,
+        ...listSessionsAgentId == null ? {} : { listSessionsAgentId },
+        ...listSessionsCreatedByMe == null ? {} : { listSessionsCreatedByMe }
+      });
+    }
+    return createTrueForgeThreadListAdapter({
+      server,
+      agentName: agent.agentName,
+      ...listSessionsAgentId == null ? {} : { listSessionsAgentId },
+      ...listSessionsCreatedByMe == null ? {} : { listSessionsCreatedByMe }
+    });
+  }, [agent, listSessionsAgentId, listSessionsCreatedByMe, server]);
+  const modeThreadListAdapterRef = useRef3(modeThreadListAdapter);
+  useEffect3(() => {
+    modeThreadListAdapterRef.current = modeThreadListAdapter;
+  }, [modeThreadListAdapter]);
+  const threadListAdapter = useMemo4(
+    () => createDelegatingThreadListAdapter(modeThreadListAdapterRef),
+    [listSessionsAgentId, listSessionsCreatedByMe, server]
+  );
+  return useRemoteThreadListRuntime({
+    allowNesting: true,
+    adapter: threadListAdapter,
+    initialThreadId: resolved.initialSessionId,
+    threadId: resolved.threadId,
+    onThreadIdChange: resolved.onThreadIdChange,
+    runtimeHook: () => useTrueForgeAgentRuntimeImpl(resolved, pendingAgentSpecRef)
+  });
+}
+export {
+  ROOT_THREAD_ID,
+  TOOL_RESPONSE_THREAD_ID_CUSTOM_KEY,
+  buildEditedUserMessageContent,
+  buildTurnAssistantContent,
+  buildUserMessageContent,
+  collectApprovalInputs,
+  collectRequiredActionInputs,
+  collectResponseInputs,
+  convertTurnsToThreadMessages,
+  createDraftSessionBridge,
+  createTrueForgeDraftThreadListAdapter,
+  createTrueForgeOwnedSessionsThreadListAdapter,
+  createTrueForgeThreadListAdapter,
+  draftSessionTitle,
+  findPausedAssistantMessage,
+  getSession,
+  getTrueForgeExtras,
+  getTurnMessageContent,
+  isEventDelta,
+  mergeAgentSpec,
+  mergeEventDelta,
+  messageHasPendingApprovals,
+  messageHasPendingRequiredActions,
+  messageHasPendingResponses,
+  parseTurnIdFromMessageId,
+  repositoryItemsFromMessages,
+  toTrueForgeApprovalInputs,
+  trueForgeAttachmentAdapter,
+  trueForgeExtras,
+  tryGetTrueForgeExtras,
+  useTrueForgeAdoptAgentSpec,
+  useTrueForgeAgentRuntime,
+  useTrueForgeAgentSpec,
+  useTrueForgeApprovals,
+  useTrueForgeCancel,
+  useTrueForgeDownloadSandboxFile,
+  useTrueForgeFlushAgentSpec,
+  useTrueForgeHistoryPagination,
+  useTrueForgeMcpAuth,
+  useTrueForgeReload,
+  useTrueForgeResetFromTurn,
+  useTrueForgeRespondToToolApproval,
+  useTrueForgeRespondToToolResponse,
+  useTrueForgeResumeMcpAuth,
+  useTrueForgeResumeUnavailable,
+  useTrueForgeSandboxId,
+  useTrueForgeToolResponses,
+  useTrueForgeTurnId,
+  useTrueForgeUpdateAgentSpec
+};
+//# sourceMappingURL=index.js.map