omp-fabric 0.85.0

package/dist/ui/conversation-native-reader.js

@@ -0,0 +1,784 @@
+// src/ui/conversation-native-reader.ts
+import fs from "node:fs";
+var isCustomMessageContent = (content) => typeof content === "string" || Array.isArray(content);
+var customMessageFromEntry = (entry) => ({
+  role: "custom",
+  customType: entry.customType,
+  content: entry.content,
+  display: entry.display,
+  ...entry.details !== void 0 ? { details: entry.details } : {},
+  ...entry.attribution !== void 0 ? { attribution: entry.attribution } : {},
+  timestamp: new Date(entry.timestamp).getTime()
+});
+var compactionSummaryMessage = (entry) => ({
+  role: "compactionSummary",
+  summary: entry.summary,
+  ...entry.shortSummary !== void 0 ? { shortSummary: entry.shortSummary } : {},
+  tokensBefore: entry.tokensBefore,
+  ...entry.tokensAfter !== void 0 ? { tokensAfter: entry.tokensAfter } : {},
+  ...entry.method !== void 0 ? { method: entry.method } : {},
+  ...entry.warning !== void 0 ? { warning: entry.warning } : {},
+  timestamp: new Date(entry.timestamp).getTime()
+});
+var branchSummaryMessage = (entry) => ({
+  role: "branchSummary",
+  summary: entry.summary,
+  fromId: entry.fromId,
+  timestamp: new Date(entry.timestamp).getTime()
+});
+var buildContextEntries = (entries, leafId, byId) => {
+  const path = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = byId.get(leafId);
+  while (current && !seen.has(current.id)) {
+    seen.add(current.id);
+    path.push(current);
+    current = current.parentId ? byId.get(current.parentId) : void 0;
+  }
+  path.reverse();
+  let compactionIdx = -1;
+  for (let index = 0; index < path.length; index++) {
+    if (path[index]?.type === "compaction") compactionIdx = index;
+  }
+  if (compactionIdx < 0) return path;
+  const compaction = path[compactionIdx];
+  const keptStart = path.findIndex((candidate) => candidate.id === compaction.firstKeptEntryId);
+  const kept = keptStart >= 0 ? path.slice(keptStart, compactionIdx) : [];
+  return [compaction, ...kept, ...path.slice(compactionIdx + 1)];
+};
+var buildSessionContext = (entries, leafId, byId) => {
+  const messages = [];
+  let activeSummaryEmitted = false;
+  for (const entry of buildContextEntries(entries, leafId, byId)) {
+    if (entry.type === "message") {
+      messages.push(entry.message);
+    } else if (entry.type === "compaction") {
+      if (activeSummaryEmitted) continue;
+      activeSummaryEmitted = true;
+      messages.push(compactionSummaryMessage(entry));
+    } else if (entry.type === "custom_message") {
+      if (isCustomMessageContent(entry.content)) messages.push(customMessageFromEntry(entry));
+    } else if (entry.type === "branch_summary" && entry.summary) {
+      messages.push(branchSummaryMessage(entry));
+    }
+  }
+  return { messages };
+};
+var INITIAL_PAGE_BYTES = 256 * 1024;
+var OLDER_PAGE_BYTES = 256 * 1024;
+var GROWTH_PAGE_BYTES = 1024 * 1024;
+var MAX_PAGE_BYTES = 64 * 1024 * 1024;
+var CLASSIFY_PROBE_BYTES = 4096;
+var SESSION_CLASSIFY_SCAN_LINES = 8;
+var MAX_ERROR_CHARS = 200;
+var emptyUsage = () => ({
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+});
+var parseRecord = (raw) => {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+};
+var isSessionEntry = (value) => typeof value === "object" && value !== null && typeof value.type === "string" && typeof value.id === "string" && (value.parentId === null || typeof value.parentId === "string");
+var messageFingerprint = (message) => {
+  if ("content" in message) return JSON.stringify(message.content);
+  if ("summary" in message) return JSON.stringify(message.summary);
+  return "";
+};
+var messageKey = (message) => {
+  if (message.role === "toolResult") return `toolResult:${message.toolCallId}`;
+  if (message.role === "assistant") {
+    const calls = message.content.filter((block) => block.type === "toolCall").map((block) => block.id);
+    if (calls.length > 0) return `assistant:${message.timestamp}:calls:${calls.join(",")}`;
+  }
+  return `${message.role}:${message.timestamp}:${messageFingerprint(message)}`;
+};
+var clipError = (error) => {
+  const text = error instanceof Error ? error.message : String(error);
+  return text.length > MAX_ERROR_CHARS ? `${text.slice(0, MAX_ERROR_CHARS)}\u2026` : text;
+};
+var readBackwardPage = (descriptor, end, budget, includeFinalPartialLine) => {
+  let windowBudget = Math.min(Math.max(budget, 1), MAX_PAGE_BYTES);
+  for (; ; ) {
+    const candidate = Math.max(0, end - windowBudget);
+    const buffer = Buffer.allocUnsafe(end - candidate);
+    const bytesRead = fs.readSync(descriptor, buffer, 0, buffer.length, candidate);
+    const data = buffer.subarray(0, Math.max(0, bytesRead));
+    if (data.length === 0) return { start: candidate, end: candidate, records: [] };
+    const firstNewline = data.indexOf(10);
+    if (firstNewline === -1) {
+      if (candidate === 0) {
+        const raw = data.toString("utf8").replace(/\r$/, "");
+        return { start: 0, end, records: raw ? [raw] : [] };
+      }
+      if (windowBudget >= MAX_PAGE_BYTES) return { start: end, end, records: [] };
+      windowBudget = Math.min(windowBudget * 2, MAX_PAGE_BYTES);
+      continue;
+    }
+    const alignStart = candidate > 0 ? firstNewline + 1 : 0;
+    const records = [];
+    let lineStart = alignStart;
+    let lastComplete = alignStart;
+    for (let index = alignStart; index < data.length; index++) {
+      if (data[index] !== 10) continue;
+      const raw = data.subarray(lineStart, index).toString("utf8").replace(/\r$/, "");
+      if (raw) records.push(raw);
+      lineStart = index + 1;
+      lastComplete = lineStart;
+    }
+    if (records.length === 0 && candidate > 0) {
+      if (windowBudget >= MAX_PAGE_BYTES) return { start: end, end, records: [] };
+      windowBudget = Math.min(windowBudget * 2, MAX_PAGE_BYTES);
+      continue;
+    }
+    let endOffset = end;
+    if (lastComplete < data.length) {
+      const tail = data.subarray(lastComplete).toString("utf8").replace(/\r$/, "");
+      if (includeFinalPartialLine && tail && parseRecord(tail)) {
+        records.push(tail);
+      } else {
+        endOffset = candidate + lastComplete;
+      }
+    }
+    return { start: candidate + alignStart, end: endOffset, records };
+  }
+};
+var readForwardPage = (descriptor, start, size, budget) => {
+  let windowBudget = Math.min(Math.max(budget, 1), MAX_PAGE_BYTES);
+  for (; ; ) {
+    const limit = Math.min(size, start + windowBudget);
+    if (limit <= start) return { start, end: start, records: [] };
+    const buffer = Buffer.allocUnsafe(limit - start);
+    const bytesRead = fs.readSync(descriptor, buffer, 0, buffer.length, start);
+    const data = buffer.subarray(0, Math.max(0, bytesRead));
+    if (data.length === 0) return { start, end: start, records: [] };
+    const records = [];
+    let lineStart = 0;
+    let lastComplete = 0;
+    for (let index = 0; index < data.length; index++) {
+      if (data[index] !== 10) continue;
+      const raw = data.subarray(lineStart, index).toString("utf8").replace(/\r$/, "");
+      if (raw) records.push(raw);
+      lineStart = index + 1;
+      lastComplete = lineStart;
+    }
+    if (lastComplete < data.length) {
+      const tail = data.subarray(lastComplete).toString("utf8").replace(/\r$/, "");
+      if (limit >= size && tail && parseRecord(tail)) {
+        records.push(tail);
+        lastComplete = data.length;
+      }
+    }
+    if (lastComplete === 0 && limit < size) {
+      if (windowBudget >= MAX_PAGE_BYTES) return { start, end: start, records: [] };
+      windowBudget = Math.min(windowBudget * 2, MAX_PAGE_BYTES);
+      continue;
+    }
+    return { start, end: start + lastComplete, records };
+  }
+};
+var classifyFile = (filePath) => {
+  let descriptor;
+  try {
+    const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+    descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | noFollow);
+    const stat = fs.fstatSync(descriptor);
+    if (!stat.isFile()) return "unreadable";
+    const buffer = Buffer.allocUnsafe(Math.max(1, Math.min(CLASSIFY_PROBE_BYTES, stat.size)));
+    const bytesRead = fs.readSync(descriptor, buffer, 0, buffer.length, 0);
+    const head = buffer.subarray(0, Math.max(0, bytesRead)).toString("utf8");
+    for (const line of head.split("\n").slice(0, SESSION_CLASSIFY_SCAN_LINES)) {
+      const parsed = parseRecord(line);
+      if (!parsed) continue;
+      if (parsed.type === "session") return "session";
+      if (parsed.type !== "title") break;
+    }
+    return "events";
+  } catch {
+    return "unreadable";
+  } finally {
+    if (descriptor !== void 0) closeQuietly(descriptor);
+  }
+};
+var openDescriptor = (filePath) => {
+  try {
+    const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+    const descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | noFollow);
+    const stat = fs.fstatSync(descriptor);
+    if (!stat.isFile()) {
+      closeQuietly(descriptor);
+      return { error: "not a regular file" };
+    }
+    return { descriptor, size: stat.size };
+  } catch (error) {
+    return { error: clipError(error) };
+  }
+};
+var closeQuietly = (descriptor) => {
+  try {
+    fs.closeSync(descriptor);
+  } catch {
+  }
+};
+var NativeConversationReader = class {
+  #sourceId = "";
+  #status = "";
+  #sessionFile;
+  #eventsFile;
+  #entries = [];
+  #entryIds = /* @__PURE__ */ new Set();
+  #byId = /* @__PURE__ */ new Map();
+  #sessionEntryIds = /* @__PURE__ */ new Set();
+  #eventEntryIds = /* @__PURE__ */ new Set();
+  #sessionLeafId;
+  #eventLeafId;
+  #sessionId;
+  #streamed = /* @__PURE__ */ new Map();
+  #streamedOrder = [];
+  #partial;
+  #eventRecords = [];
+  #pendingMessages;
+  #partialArgsRaw = /* @__PURE__ */ new Map();
+  #tools = /* @__PURE__ */ new Map();
+  #windows = /* @__PURE__ */ new Map();
+  #followed = true;
+  #revision = 0;
+  #error;
+  #snapshot;
+  /** Last transcript produced; undefined before the first successful read. */
+  get last() {
+    return this.#snapshot;
+  }
+  read(source, followLatest = true) {
+    const sourceId = typeof source?.id === "string" ? source.id : "";
+    const status = typeof source?.status === "string" ? source.status : "";
+    const explicitSession = typeof source?.sessionFile === "string" && source.sessionFile ? source.sessionFile : void 0;
+    const explicitEvents = typeof source?.eventsFile === "string" && source.eventsFile ? source.eventsFile : void 0;
+    const logFile = typeof source?.logFile === "string" ? source.logFile : void 0;
+    let sessionFile = explicitSession;
+    let eventsFile = explicitEvents;
+    let logUnresolved = false;
+    if (logFile && logFile !== explicitSession && logFile !== explicitEvents) {
+      const kind = classifyFile(logFile);
+      if (kind === "session") sessionFile ??= logFile;
+      else if (kind === "events") eventsFile ??= logFile;
+      else logUnresolved = true;
+    }
+    if (sourceId !== this.#sourceId || sessionFile !== this.#sessionFile) {
+      this.#resetPaths(sourceId, status, sessionFile, eventsFile);
+    } else {
+      this.#status = status;
+      if (eventsFile !== this.#eventsFile) {
+        this.#eventsFile = eventsFile;
+        this.#resetEventsState();
+        this.#revision += 1;
+      }
+    }
+    if (logUnresolved) {
+      this.#windows.set("events", { head: 0, tail: 0, size: 0, hasOlder: false, unavailable: true });
+      this.#setError(logFile ?? "source log unreadable");
+    }
+    this.#followed = followLatest !== false;
+    this.#ingest(this.#followed);
+    return this.#snapshot ?? this.#buildSnapshot();
+  }
+  /** Load older whole-record pages of history. Repeated calls load all of it. */
+  loadOlder(pages = 1) {
+    if (!this.#snapshot) return void 0;
+    for (let page = 0; page < Math.max(1, pages); page++) {
+      let progressed = false;
+      for (const [kind, filePath] of this.#windowFiles()) {
+        if (this.#loadOlderFile(kind, filePath)) progressed = true;
+      }
+      if (!progressed) break;
+    }
+    this.#revision += 1;
+    this.#snapshot = this.#buildSnapshot();
+    return this.#snapshot;
+  }
+  /** Consume any records newer than the current window (used when pinned). */
+  loadNewer() {
+    if (!this.#snapshot) return void 0;
+    this.#followed = true;
+    this.#ingest(true);
+    return this.#snapshot ?? void 0;
+  }
+  /** Drop the current windows and re-read from the tail of both files. */
+  loadLatest() {
+    if (!this.#snapshot) return void 0;
+    for (const [kind, filePath] of this.#windowFiles()) this.#initWindow(kind, filePath);
+    this.#followed = true;
+    this.#ingest(true);
+    return this.#snapshot ?? void 0;
+  }
+  /** Drop all cached state for a clean re-read. */
+  clear() {
+    this.#resetPaths("", "", void 0, void 0);
+  }
+  #windowFiles() {
+    const files = [];
+    if (this.#sessionFile) files.push(["session", this.#sessionFile]);
+    if (this.#eventsFile) files.push(["events", this.#eventsFile]);
+    return files;
+  }
+  #setError(detail) {
+    this.#error = clipError(detail);
+  }
+  #resetPaths(sourceId, status, sessionFile, eventsFile) {
+    this.#sourceId = sourceId;
+    this.#status = status;
+    this.#sessionFile = sessionFile;
+    this.#eventsFile = eventsFile;
+    this.#entries = [];
+    this.#entryIds.clear();
+    this.#byId.clear();
+    this.#sessionEntryIds.clear();
+    this.#eventEntryIds.clear();
+    this.#sessionLeafId = void 0;
+    this.#eventLeafId = void 0;
+    this.#sessionId = void 0;
+    this.#eventRecords = [];
+    this.#resetStreamingState();
+    this.#windows.clear();
+    this.#revision = 0;
+    this.#error = void 0;
+    this.#snapshot = void 0;
+    for (const [kind, filePath] of this.#windowFiles()) this.#initWindow(kind, filePath);
+  }
+  #resetStreamingState() {
+    this.#pendingMessages = void 0;
+    this.#streamed.clear();
+    this.#streamedOrder = [];
+    this.#partial = void 0;
+    this.#partialArgsRaw.clear();
+    this.#tools.clear();
+  }
+  #resetEventsState() {
+    this.#eventRecords = [];
+    this.#resetStreamingState();
+    this.#eventLeafId = void 0;
+    for (const id of this.#eventEntryIds) {
+      if (this.#sessionEntryIds.has(id)) continue;
+      this.#entryIds.delete(id);
+      const entry = this.#byId.get(id);
+      if (entry) {
+        this.#byId.delete(id);
+        const index = this.#entries.indexOf(entry);
+        if (index >= 0) this.#entries.splice(index, 1);
+      }
+    }
+    this.#eventEntryIds.clear();
+    this.#windows.delete("events");
+    this.#error = void 0;
+    if (this.#eventsFile) this.#initWindow("events", this.#eventsFile);
+  }
+  #initWindow(kind, filePath) {
+    const opened = openDescriptor(filePath);
+    if (!opened || "error" in opened) {
+      this.#windows.set(kind, {
+        head: 0,
+        tail: 0,
+        size: 0,
+        hasOlder: false,
+        unavailable: true
+      });
+      if (opened && "error" in opened) this.#setError(`${filePath}: ${opened.error}`);
+      return;
+    }
+    try {
+      const page = readBackwardPage(opened.descriptor, opened.size, INITIAL_PAGE_BYTES, kind === "events");
+      this.#applyRecords(kind, page.records, true);
+      this.#windows.set(kind, {
+        head: page.start,
+        tail: page.end,
+        size: opened.size,
+        hasOlder: page.start > 0,
+        unavailable: false
+      });
+    } catch (error) {
+      this.#windows.set(kind, {
+        head: 0,
+        tail: 0,
+        size: 0,
+        hasOlder: false,
+        unavailable: true
+      });
+      this.#setError(`${filePath}: ${clipError(error)}`);
+    } finally {
+      closeQuietly(opened.descriptor);
+    }
+  }
+  #loadOlderFile(kind, filePath) {
+    const window = this.#windows.get(kind);
+    if (!window || !window.hasOlder || window.head <= 0) return false;
+    const opened = openDescriptor(filePath);
+    if (!opened) return false;
+    if ("error" in opened) {
+      window.unavailable = true;
+      this.#setError(`${filePath}: ${opened.error}`);
+      return false;
+    }
+    try {
+      const page = readBackwardPage(opened.descriptor, window.head, OLDER_PAGE_BYTES, false);
+      if (page.start >= window.head) return false;
+      this.#applyRecords(kind, page.records, false);
+      window.head = page.start;
+      window.hasOlder = page.start > 0;
+      window.unavailable = false;
+      return true;
+    } finally {
+      closeQuietly(opened.descriptor);
+    }
+  }
+  #growFile(kind, filePath, followLatest) {
+    const window = this.#windows.get(kind);
+    if (!window) return false;
+    const opened = openDescriptor(filePath);
+    if (!opened) return false;
+    if ("error" in opened) {
+      window.unavailable = true;
+      this.#setError(`${filePath}: ${opened.error}`);
+      return false;
+    }
+    try {
+      window.size = opened.size;
+      window.unavailable = false;
+      if (!followLatest || opened.size <= window.tail) return false;
+      const page = readForwardPage(opened.descriptor, window.tail, opened.size, GROWTH_PAGE_BYTES);
+      if (page.end <= window.tail) return false;
+      this.#applyRecords(kind, page.records, true);
+      window.tail = Math.max(window.tail, page.end);
+      return true;
+    } finally {
+      closeQuietly(opened.descriptor);
+    }
+  }
+  #ingest(followLatest) {
+    let changed = false;
+    for (const [kind, filePath] of this.#windowFiles()) {
+      if (this.#growFile(kind, filePath, followLatest)) changed = true;
+    }
+    if (changed) this.#revision += 1;
+    this.#snapshot = this.#buildSnapshot();
+  }
+  #applyRecords(kind, records, updateLeaf) {
+    const parsed = records.map(parseRecord).filter((record) => record !== void 0);
+    if (kind === "session") {
+      for (const record of parsed) this.#applySessionRecord(record, updateLeaf);
+      return;
+    }
+    if (updateLeaf) {
+      this.#eventRecords.push(...parsed);
+      for (const record of parsed) this.#applyEventRecord(record);
+    } else {
+      this.#eventRecords = [...parsed, ...this.#eventRecords];
+      this.#resetStreamingState();
+      this.#eventLeafId = void 0;
+      for (const record of this.#eventRecords) this.#applyEventRecord(record);
+    }
+  }
+  #applySessionRecord(record, updateLeaf) {
+    if (record.type === "session") {
+      if (typeof record.id === "string") this.#sessionId = record.id;
+      return;
+    }
+    if (!isSessionEntry(record)) return;
+    this.#appendEntry(record, "session", updateLeaf);
+  }
+  // Entry list order is irrelevant: path construction walks byId from the leaf,
+  // so older pages and live folds can append in any order.
+  #appendEntry(entry, origin, updateLeaf = true) {
+    if (this.#entryIds.has(entry.id)) {
+      const existing = this.#byId.get(entry.id);
+      if (existing) Object.assign(existing, entry);
+      (origin === "session" ? this.#sessionEntryIds : this.#eventEntryIds).add(entry.id);
+      if (updateLeaf) {
+        if (origin === "session") this.#sessionLeafId = entry.id;
+        else this.#eventLeafId = entry.id;
+      }
+      return;
+    }
+    this.#entryIds.add(entry.id);
+    this.#byId.set(entry.id, entry);
+    (origin === "session" ? this.#sessionEntryIds : this.#eventEntryIds).add(entry.id);
+    this.#entries.push(entry);
+    if (!updateLeaf) return;
+    if (origin === "session") this.#sessionLeafId = entry.id;
+    else this.#eventLeafId = entry.id;
+  }
+  #applyEventRecord(event) {
+    switch (event.type) {
+      case "queue_update": {
+        const strings = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+        this.#pendingMessages = { steering: strings(event.steering), followUp: strings(event.followUp) };
+        return;
+      }
+      case "message_start": {
+        const message = event.message;
+        if (!message || typeof message !== "object") return;
+        if (message.role === "assistant") {
+          this.#partial = {
+            ...message,
+            content: message.content.map((part) => ({ ...part })),
+            usage: message.usage ?? emptyUsage(),
+            stopReason: message.stopReason ?? "stop"
+          };
+        } else {
+          this.#foldMessage(message);
+        }
+        return;
+      }
+      case "message_update":
+        this.#applyPartialDelta(event);
+        return;
+      case "message_end": {
+        const message = event.message;
+        if (!message || typeof message !== "object") return;
+        if (message.role === "assistant") {
+          this.#partial = void 0;
+          this.#partialArgsRaw.clear();
+        }
+        this.#foldMessage(message);
+        return;
+      }
+      case "tool_execution_start": {
+        if (typeof event.toolCallId !== "string") return;
+        const args = event.args;
+        this.#tools.set(event.toolCallId, {
+          toolCallId: event.toolCallId,
+          toolName: typeof event.toolName === "string" ? event.toolName : "",
+          ...args !== void 0 ? { args } : {},
+          status: "running",
+          executionStarted: true,
+          argsComplete: true
+        });
+        return;
+      }
+      case "tool_execution_update": {
+        const tool = this.#toolFor(event);
+        if (!tool) return;
+        const partial = event.partialResult;
+        if (partial && typeof partial === "object") {
+          tool.partial = {
+            ...Array.isArray(partial.content) ? { content: partial.content } : {},
+            ...partial.details !== void 0 ? { details: partial.details } : {}
+          };
+        }
+        return;
+      }
+      case "tool_execution_end": {
+        const tool = this.#toolFor(event);
+        if (!tool) return;
+        const result = event.result;
+        if (result && typeof result === "object") {
+          tool.result = {
+            ...Array.isArray(result.content) ? { content: result.content } : {},
+            ...result.details !== void 0 ? { details: result.details } : {}
+          };
+        }
+        tool.isError = event.isError === true;
+        tool.status = event.isError === true ? "failed" : "completed";
+        tool.executionStarted = true;
+        tool.argsComplete = true;
+        return;
+      }
+      case "turn_end": {
+        const message = event.message;
+        if (message && typeof message === "object") this.#foldMessage(message);
+        if (Array.isArray(event.toolResults)) {
+          for (const result of event.toolResults) {
+            if (result && typeof result === "object") this.#foldMessage(result);
+          }
+        }
+        return;
+      }
+      case "agent_end": {
+        if (!Array.isArray(event.messages)) return;
+        for (const message of event.messages) {
+          if (message && typeof message === "object") this.#foldMessage(message);
+        }
+        return;
+      }
+      case "entry_appended": {
+        if (isSessionEntry(event.entry)) this.#appendEntry(event.entry, "events");
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  #toolFor(event) {
+    if (typeof event.toolCallId !== "string") return void 0;
+    return this.#tools.get(event.toolCallId);
+  }
+  #applyPartialDelta(event) {
+    const delta = event.assistantMessageEvent;
+    if (!delta || typeof delta !== "object") return;
+    if (!this.#partial) {
+      this.#partial = {
+        role: "assistant",
+        content: [],
+        api: "",
+        provider: "",
+        model: "",
+        usage: emptyUsage(),
+        stopReason: "stop",
+        timestamp: Date.now()
+      };
+    }
+    const partial = this.#partial;
+    if (event.usage && typeof event.usage === "object") {
+      partial.usage = event.usage;
+    }
+    const contentIndex = typeof delta.contentIndex === "number" ? delta.contentIndex : 0;
+    switch (delta.type) {
+      case "text_start":
+        partial.content[contentIndex] = { type: "text", text: "" };
+        return;
+      case "text_delta": {
+        const block = partial.content[contentIndex];
+        const text = typeof delta.delta === "string" ? delta.delta : "";
+        partial.content[contentIndex] = {
+          type: "text",
+          text: (block?.type === "text" ? block.text : "") + text
+        };
+        return;
+      }
+      case "text_end": {
+        if (typeof delta.content === "string") {
+          partial.content[contentIndex] = { type: "text", text: delta.content };
+        }
+        return;
+      }
+      case "thinking_start":
+        partial.content[contentIndex] = { type: "thinking", thinking: "" };
+        return;
+      case "thinking_delta": {
+        const block = partial.content[contentIndex];
+        const text = typeof delta.delta === "string" ? delta.delta : "";
+        partial.content[contentIndex] = {
+          type: "thinking",
+          thinking: (block?.type === "thinking" ? block.thinking : "") + text
+        };
+        return;
+      }
+      case "thinking_end": {
+        if (typeof delta.content === "string") {
+          partial.content[contentIndex] = { type: "thinking", thinking: delta.content };
+        }
+        return;
+      }
+      case "toolcall_start": {
+        this.#partialArgsRaw.delete(contentIndex);
+        partial.content[contentIndex] = {
+          type: "toolCall",
+          id: typeof delta.id === "string" ? delta.id : "",
+          name: typeof delta.toolName === "string" ? delta.toolName : "",
+          arguments: {}
+        };
+        return;
+      }
+      case "toolcall_delta": {
+        const raw = typeof delta.delta === "string" ? delta.delta : "";
+        if (!raw) return;
+        const accumulated = (this.#partialArgsRaw.get(contentIndex) ?? "") + raw;
+        this.#partialArgsRaw.set(contentIndex, accumulated);
+        const parsed = parseRecord(accumulated);
+        const block = partial.content[contentIndex];
+        if (block?.type === "toolCall" && parsed) block.arguments = parsed;
+        return;
+      }
+      case "toolcall_end": {
+        const toolCall = delta.toolCall;
+        if (toolCall && typeof toolCall === "object") partial.content[contentIndex] = toolCall;
+        this.#partialArgsRaw.delete(contentIndex);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  #foldMessage(message) {
+    if (!message || typeof message !== "object" || typeof message.role !== "string") return;
+    const key = messageKey(message);
+    if (this.#streamed.has(key)) return;
+    this.#streamed.set(key, message);
+    this.#streamedOrder.push(key);
+  }
+  #buildSnapshot() {
+    const sessionWindow = this.#windows.get("session");
+    const eventsWindow = this.#windows.get("events");
+    const hasMore = (sessionWindow?.hasOlder ?? false) || (eventsWindow?.hasOlder ?? false);
+    const hasNewer = !this.#followed && (sessionWindow !== void 0 && sessionWindow.tail < sessionWindow.size || eventsWindow !== void 0 && eventsWindow.tail < eventsWindow.size);
+    const leafId = this.#sessionLeafId ?? this.#eventLeafId ?? null;
+    const pathComplete = leafId !== null && this.#pathReachesRoot(leafId);
+    const historyComplete = !hasMore && pathComplete && (sessionWindow?.head ?? 0) === 0 && (eventsWindow?.head ?? 0) === 0;
+    const activeEntries = leafId !== null ? buildContextEntries(this.#entries, leafId, this.#byId) : [];
+    const sessionMessages = leafId !== null ? buildSessionContext(this.#entries, leafId, this.#byId).messages : [];
+    const persisted = new Set(this.#entries.flatMap((entry) => entry.type === "message" ? [messageKey(entry.message)] : []));
+    const streamed = this.#streamedOrder.filter((key) => !persisted.has(key)).map((key) => this.#streamed.get(key)).filter((message) => message !== void 0);
+    const messages = [...sessionMessages, ...streamed];
+    const entries = leafId !== null ? activeEntries.map((entry) => ({
+      entryId: entry.id,
+      parentId: entry.parentId,
+      entryType: entry.type,
+      timestamp: entry.timestamp,
+      ...entry.type === "message" ? { message: entry.message } : {},
+      entry
+    })) : [];
+    const tools = [...this.#tools.values()].map((tool) => ({ ...tool }));
+    const partialAssistant = this.#partial ? { ...this.#partial, content: [...this.#partial.content] } : void 0;
+    const unavailable = {};
+    if (sessionWindow?.unavailable) unavailable.sessionFile = true;
+    if (eventsWindow?.unavailable) unavailable.eventsFile = true;
+    return {
+      messages,
+      revision: this.#revision,
+      entries,
+      streaming: {
+        active: partialAssistant !== void 0 || tools.some((tool) => tool.status === "running"),
+        ...partialAssistant ? { partialAssistant } : {},
+        tools
+      },
+      ...this.#pendingMessages ? { pendingMessages: { steering: [...this.#pendingMessages.steering], followUp: [...this.#pendingMessages.followUp] } } : {},
+      leafId,
+      sourceId: this.#sourceId,
+      status: this.#status,
+      ...this.#sessionFile ? { sessionFile: this.#sessionFile } : {},
+      ...this.#eventsFile ? { eventsFile: this.#eventsFile } : {},
+      ...this.#sessionId ? { sessionId: this.#sessionId } : {},
+      historyComplete,
+      hasMore,
+      hasNewer,
+      ...Object.keys(unavailable).length > 0 ? { unavailable } : {},
+      ...Object.keys(unavailable).length > 0 && this.#error ? { error: this.#error } : {},
+      updatedAt: Date.now()
+    };
+  }
+  #pathReachesRoot(leafId) {
+    let current = this.#byId.get(leafId);
+    if (!current) return false;
+    const guard = /* @__PURE__ */ new Set();
+    while (current.parentId !== null) {
+      if (guard.has(current.id)) return true;
+      guard.add(current.id);
+      const parent = this.#byId.get(current.parentId);
+      if (!parent) return false;
+      current = parent;
+    }
+    return true;
+  }
+};
+export {
+  NativeConversationReader
+};
+//# sourceMappingURL=conversation-native-reader.js.map