@jrkropp/codex-js 0.1.4 → 0.2.0

package/dist/testing/index.js

@@ -1,15 +1,1698 @@
-export { ThreadEventStore } from '../chunk-6ZMJ34KE.js';
-export { InMemoryThreadStore, LocalThreadStore } from '../chunk-4DPLJPB5.js';
-import '../chunk-V4BMZWBM.js';
-import '../chunk-LWQNX4LI.js';
-import '../chunk-PST3ZWX2.js';
-import '../chunk-Z63UPBS3.js';
-import '../chunk-YHVCFD2D.js';
-import '../chunk-DCMKA2A6.js';
-import '../chunk-CGBS37IU.js';
-import '../chunk-2DZRMCI2.js';
-export { createRenderedThreadState, renderThreadFromHistory } from '../chunk-DYLHN3HG.js';
-import '../chunk-SYPHCDRD.js';
-import '../chunk-O44XP7LH.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+// src/internal/codex/core/src/event-mapping.ts
+function isContextualUserMessageContent(message) {
+  return message.some(isContextualUserFragment);
+}
+function parseUserMessage(id, message) {
+  if (isContextualUserMessageContent(message)) {
+    return null;
+  }
+  const content = [];
+  for (const [index, contentItem] of message.entries()) {
+    if (contentItem.type === "input_text") {
+      if ((isLocalImageOpenTagText(contentItem.text) || isImageOpenTagText(contentItem.text)) && message[index + 1]?.type === "input_image" || index > 0 && (isLocalImageCloseTagText(contentItem.text) || isImageCloseTagText(contentItem.text)) && message[index - 1]?.type === "input_image") {
+        continue;
+      }
+      content.push({
+        type: "text",
+        text: contentItem.text,
+        text_elements: []
+      });
+      continue;
+    }
+    if (contentItem.type === "input_image") {
+      content.push({
+        type: "image",
+        image_url: contentItem.image_url
+      });
+    }
+  }
+  return {
+    type: "UserMessage",
+    id: id ?? "",
+    content
+  };
+}
+function parseAgentMessage(id, message, phase) {
+  const content = [];
+  for (const contentItem of message) {
+    if (contentItem.type === "input_text" || contentItem.type === "output_text") {
+      content.push({ type: "Text", text: contentItem.text });
+    }
+  }
+  return {
+    type: "AgentMessage",
+    id: id ?? "",
+    content,
+    phase: phase ?? null,
+    memory_citation: null
+  };
+}
+function parseVisibleHookPromptMessage(id, message) {
+  const fragments = [];
+  for (const contentItem of message) {
+    if (contentItem.type !== "input_text") {
+      return null;
+    }
+    const fragment = parseHookPromptFragment(contentItem.text);
+    if (fragment) {
+      fragments.push(fragment);
+      continue;
+    }
+    if (isStandardContextualUserText(contentItem.text)) {
+      continue;
+    }
+    return null;
+  }
+  if (fragments.length === 0) {
+    return null;
+  }
+  return {
+    type: "HookPrompt",
+    id: id ?? "",
+    fragments
+  };
+}
+function parseTurnItem(item) {
+  switch (item.type) {
+    case "message":
+      if (item.role === "user") {
+        return parseVisibleHookPromptMessage(item.id, item.content) ?? parseUserMessage(item.id, item.content);
+      }
+      if (item.role === "assistant" || !item.role) {
+        return parseAgentMessage(item.id, item.content, item.phase);
+      }
+      return null;
+    case "reasoning":
+      return parseReasoningItem(item);
+    case "web_search_call":
+      return parseWebSearchCall(item);
+    case "image_generation_call":
+      return parseImageGenerationCall(item);
+    default:
+      return null;
+  }
+}
+function parseReasoningItem(item) {
+  return {
+    type: "Reasoning",
+    id: item.id ?? "",
+    summary_text: item.summary.flatMap((entry) => {
+      if (typeof entry.text === "string") {
+        return [entry.text];
+      }
+      return [];
+    }),
+    raw_content: (item.content ?? []).flatMap((entry) => {
+      if ((entry.type === "reasoning_text" || entry.type === "text") && typeof entry.text === "string") {
+        return [entry.text];
+      }
+      return [];
+    })
+  };
+}
+function parseWebSearchCall(item) {
+  const action = webSearchActionFromRecord(item.action);
+  return {
+    type: "WebSearch",
+    id: item.id ?? "",
+    query: webSearchActionDetail(action),
+    action
+  };
+}
+function parseImageGenerationCall(item) {
+  return {
+    type: "ImageGeneration",
+    id: item.id,
+    status: item.status,
+    revised_prompt: item.revised_prompt ?? void 0,
+    result: item.result,
+    saved_path: item.saved_path
+  };
+}
+function webSearchActionFromRecord(action) {
+  if (!action) {
+    return { type: "other" };
+  }
+  if (action.type === "search") {
+    return {
+      type: "search",
+      ...typeof action.query === "string" ? { query: action.query } : {},
+      ...Array.isArray(action.queries) ? { queries: action.queries.filter(isString) } : {}
+    };
+  }
+  if (action.type === "open_page") {
+    return {
+      type: "open_page",
+      ...typeof action.url === "string" ? { url: action.url } : {}
+    };
+  }
+  if (action.type === "find_in_page") {
+    return {
+      type: "find_in_page",
+      ...typeof action.url === "string" ? { url: action.url } : {},
+      ...typeof action.pattern === "string" ? { pattern: action.pattern } : {}
+    };
+  }
+  return { type: "other" };
+}
+function webSearchActionDetail(action) {
+  switch (action.type) {
+    case "search":
+      return action.query ?? action.queries?.join(", ") ?? "";
+    case "open_page":
+      return action.url ?? "";
+    case "find_in_page": {
+      const pattern = action.pattern ?? "";
+      const url = action.url ?? "";
+      return pattern && url ? `'${pattern}' in ${url}` : pattern || url;
+    }
+    case "other":
+      return "";
+  }
+}
+function isContextualUserFragment(contentItem) {
+  return contentItem.type === "input_text" && (parseHookPromptFragment(contentItem.text) !== null || isStandardContextualUserText(contentItem.text));
+}
+function isStandardContextualUserText(text) {
+  const trimmed = text.trimStart();
+  return trimmed.startsWith("# AGENTS.md instructions for ") || trimmed.startsWith("<environment_context>") || trimmed.startsWith("<skill>") || trimmed.startsWith("<user_shell_command>") || trimmed.startsWith("<turn_aborted>") || trimmed.startsWith("<thread_goal_budget_limit>") || trimmed.startsWith("<subagent_notification>");
+}
+function parseHookPromptFragment(text) {
+  const trimmed = text.trim();
+  const match = trimmed.match(
+    /^<hook_prompt\s+hook_run_id=(["'])(.*?)\1>([\s\S]*)<\/hook_prompt>$/u
+  );
+  if (!match) {
+    return null;
+  }
+  const hookRunId = decodeXmlEntities(match[2] ?? "").trim();
+  if (!hookRunId) {
+    return null;
+  }
+  return {
+    hookRunId,
+    text: decodeXmlEntities(match[3] ?? "")
+  };
+}
+function isImageOpenTagText(text) {
+  return text === "<image>";
+}
+function isImageCloseTagText(text) {
+  return text === "</image>";
+}
+function isLocalImageOpenTagText(text) {
+  return text.startsWith("<image name=") && text.endsWith(">");
+}
+function isLocalImageCloseTagText(text) {
+  return isImageCloseTagText(text);
+}
+function decodeXmlEntities(value) {
+  return value.replaceAll("&amp;", "&").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&quot;", '"').replaceAll("&apos;", "'");
+}
+function isString(value) {
+  return typeof value === "string";
+}
+
+// src/internal/codex/core/src/thread-history-builder.ts
+var ThreadHistoryBuilder = class _ThreadHistoryBuilder {
+  turns = [];
+  next_item_index = 1;
+  static fromTurns(turns) {
+    const builder = new _ThreadHistoryBuilder();
+    builder.turns = turns.map((turn) => ({
+      ...cloneTurn(turn),
+      opened_explicitly: true
+    }));
+    builder.next_item_index = nextItemIndexFromTurns(turns);
+    return builder;
+  }
+  handle_rollout_item(item, index = this.next_item_index) {
+    if (item.type === "event_msg") {
+      this.handle_event(item.payload, `rollout-${index}`);
+      return;
+    }
+    if (item.type === "response_item") {
+      this.handle_response_item(item.payload, `response-${index}`);
+      return;
+    }
+    if (item.type === "compacted") {
+      this.append_to_current_turn({
+        type: "ContextCompaction",
+        id: `compacted-${index}`
+      });
+    }
+  }
+  handle_event(event, eventId = `event-${this.next_item_index}`) {
+    switch (event.type) {
+      case "turn_started":
+        this.open_explicit_turn(event.turn_id);
+        if (event.started_at !== void 0 && event.started_at !== null) {
+          const turn = this.turn_by_id(event.turn_id);
+          if (turn) {
+            turn.started_at = event.started_at;
+          }
+        }
+        return;
+      case "turn_complete":
+        this.complete_turn(event.turn_id, {
+          status: "completed",
+          completed_at: event.completed_at ?? null,
+          duration_ms: event.duration_ms ?? null
+        });
+        return;
+      case "turn_aborted":
+        this.complete_turn(event.turn_id, {
+          status: "interrupted",
+          completed_at: event.completed_at ?? event.aborted_at ?? null,
+          duration_ms: event.duration_ms ?? null
+        });
+        return;
+      case "user_message":
+        this.append_user_message(userMessageTurnItem(event, userMessageId(eventId)), {
+          replaceDuplicate: true
+        });
+        return;
+      case "agent_message":
+        this.upsert_agent_message({
+          type: "AgentMessage",
+          id: agentMessageId(eventId),
+          content: [{ type: "Text", text: event.message }],
+          phase: event.phase ?? null,
+          memory_citation: event.memory_citation ?? null
+        });
+        return;
+      case "item_started":
+        this.upsert_item_in_turn(event.turn_id, event.item, {
+          started: true
+        });
+        return;
+      case "item_completed":
+        this.upsert_item_in_turn(event.turn_id, completedItem(event.item));
+        return;
+      case "agent_message_content_delta":
+        this.apply_agent_message_delta(event.item_id, event.delta);
+        return;
+      case "plan_delta":
+        this.apply_plan_delta(event.item_id, event.delta);
+        return;
+      case "exec_command_begin":
+        this.upsert_item_in_turn(event.turn_id, {
+          type: "CommandExecution",
+          id: event.call_id,
+          command: event.command,
+          cwd: event.cwd,
+          status: "in_progress"
+        });
+        return;
+      case "exec_command_output_delta":
+        this.apply_exec_command_output_delta(event);
+        return;
+      case "exec_command_end":
+        this.apply_exec_command_end(event);
+        return;
+      case "patch_apply_updated":
+        this.upsert_item_in_current_or_existing_turn(event.call_id, {
+          type: "FileChange",
+          id: event.call_id,
+          changes: event.changes,
+          status: event.status ?? null,
+          auto_approved: false,
+          stdout: event.stdout ?? "",
+          stderr: event.stderr ?? ""
+        });
+        return;
+      case "dynamic_tool_call_request":
+        this.upsert_item_in_turn(event.turn_id, dynamicToolRequestTurnItem(event));
+        return;
+      case "dynamic_tool_call_response":
+        this.upsert_item_in_turn(event.turn_id, {
+          type: "DynamicToolCall",
+          id: event.call_id,
+          namespace: event.namespace ?? null,
+          tool: event.tool,
+          arguments: event.arguments,
+          status: event.success ? "completed" : "failed",
+          content_items: event.content_items,
+          success: event.success,
+          duration: event.duration
+        });
+        return;
+      case "mcp_tool_call_progress":
+        this.upsert_item_in_turn(event.turn_id, {
+          type: "McpToolCall",
+          id: event.call_id,
+          server: event.server_name,
+          tool: event.tool_name,
+          arguments: {},
+          status: "inProgress",
+          result: event.progress ?? event.message ?? null
+        });
+        return;
+      case "image_generation_end":
+        this.upsert_item_in_current_or_existing_turn(
+          event.call_id,
+          imageGenerationTurnItem(event, eventId)
+        );
+        return;
+      case "error": {
+        const turn = this.active_turn();
+        if (turn) {
+          turn.status = "failed";
+          turn.error = {
+            message: event.message,
+            codex_error_info: event.codex_error_info ?? null
+          };
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  handle_response_item(item, id) {
+    const turnItem = parseTurnItem(item);
+    if (!turnItem) {
+      return;
+    }
+    const itemWithFallbackId = turnItem.id.length > 0 ? turnItem : { ...turnItem, id };
+    if (itemWithFallbackId.type === "AgentMessage") {
+      this.upsert_agent_message(itemWithFallbackId);
+      return;
+    }
+    if (itemWithFallbackId.type === "UserMessage") {
+      this.append_user_message(itemWithFallbackId, {
+        replaceDuplicate: false
+      });
+      return;
+    }
+    this.append_to_current_turn(itemWithFallbackId);
+  }
+  active_turn_snapshot() {
+    const turn = this.active_turn();
+    return turn ? stripInternalTurn(turn) : null;
+  }
+  active_turn_position() {
+    const turn = this.active_turn();
+    return turn ? this.turns.indexOf(turn) : null;
+  }
+  finish() {
+    return this.turns.map(stripInternalTurn);
+  }
+  has_active_turn() {
+    return this.active_turn() !== null;
+  }
+  reset() {
+    this.turns = [];
+    this.next_item_index = 1;
+  }
+  open_explicit_turn(turnId) {
+    const existing = this.turns.find((turn) => turn.id === turnId);
+    if (existing) {
+      existing.status = "in_progress";
+      existing.opened_explicitly = true;
+      return;
+    }
+    this.turns.push(newTurn(turnId, true));
+  }
+  complete_turn(turnId, input) {
+    const turn = this.turn_by_id(turnId) ?? this.ensure_turn(turnId, true);
+    turn.status = input.status;
+    turn.completed_at = input.completed_at;
+    turn.duration_ms = input.duration_ms;
+  }
+  append_user_message(item, options) {
+    const active = this.active_turn();
+    if (!active || !active.opened_explicitly && active.items.length > 0) {
+      this.turns.push(newTurn(`turn-${this.turns.length + 1}`, false));
+    }
+    const turn = this.active_turn() ?? this.ensure_turn();
+    const lastItem = turn.items.at(-1);
+    if (lastItem?.type === "UserMessage" && userMessageFingerprint(lastItem) === userMessageFingerprint(item)) {
+      if (options.replaceDuplicate) {
+        turn.items[turn.items.length - 1] = item;
+      }
+      return;
+    }
+    turn.items.push(item);
+  }
+  upsert_agent_message(item) {
+    const turn = this.ensure_turn();
+    const lastItem = turn.items.at(-1);
+    if (item.phase === "streaming") {
+      if (lastItem?.type === "AgentMessage" && lastItem.phase === "streaming") {
+        turn.items[turn.items.length - 1] = { ...item, id: lastItem.id };
+        return;
+      }
+      turn.items.push({ ...item, id: `streaming-${item.id}` });
+      return;
+    }
+    if (lastItem?.type === "AgentMessage" && lastItem.phase === "streaming") {
+      turn.items[turn.items.length - 1] = { ...item, id: lastItem.id };
+      return;
+    }
+    if (lastItem?.type === "AgentMessage" && agentMessageText(lastItem) === agentMessageText(item)) {
+      turn.items[turn.items.length - 1] = { ...item, id: lastItem.id };
+      return;
+    }
+    turn.items.push(item);
+  }
+  upsert_item_in_turn(turnId, item, options = {}) {
+    const turn = turnId ? this.ensure_turn(turnId, true) : this.ensure_turn();
+    upsertItem(turn, options.started ? startedItem(item) : item);
+  }
+  upsert_item_in_current_or_existing_turn(itemId, item) {
+    const existingTurn = this.turns.find(
+      (turn) => turn.items.some((candidate) => candidate.id === itemId)
+    );
+    upsertItem(existingTurn ?? this.ensure_turn(), item);
+  }
+  append_to_current_turn(item) {
+    this.ensure_turn().items.push(item);
+  }
+  apply_agent_message_delta(itemId, delta) {
+    const existing = this.find_item(itemId);
+    if (!existing || existing.item.type !== "AgentMessage") {
+      this.append_to_current_turn({
+        type: "AgentMessage",
+        id: itemId,
+        content: [{ type: "Text", text: delta }],
+        phase: "streaming",
+        memory_citation: null
+      });
+      return;
+    }
+    const item = existing.item;
+    const lastContent = item.content.at(-1);
+    const nextContent = lastContent?.type === "Text" ? [
+      ...item.content.slice(0, -1),
+      { type: "Text", text: `${lastContent.text}${delta}` }
+    ] : [...item.content, { type: "Text", text: delta }];
+    existing.turn.items[existing.index] = {
+      ...item,
+      content: nextContent,
+      phase: "streaming"
+    };
+  }
+  apply_plan_delta(itemId, delta) {
+    const existing = this.find_item(itemId);
+    if (!existing || existing.item.type !== "Plan") {
+      this.append_to_current_turn({ type: "Plan", id: itemId, text: delta });
+      return;
+    }
+    existing.turn.items[existing.index] = {
+      ...existing.item,
+      text: `${existing.item.text}${delta}`
+    };
+  }
+  apply_exec_command_output_delta(msg) {
+    const existing = this.find_item(msg.call_id);
+    if (!existing || existing.item.type !== "CommandExecution") {
+      return;
+    }
+    existing.turn.items[existing.index] = {
+      ...existing.item,
+      stdout: msg.stream === "stdout" ? `${existing.item.stdout ?? ""}${msg.chunk}` : existing.item.stdout,
+      stderr: msg.stream === "stderr" ? `${existing.item.stderr ?? ""}${msg.chunk}` : existing.item.stderr
+    };
+  }
+  apply_exec_command_end(msg) {
+    const existing = this.find_item(msg.call_id);
+    const item = existing?.item.type === "CommandExecution" ? existing.item : null;
+    const turn = msg.turn_id ? this.ensure_turn(msg.turn_id, true) : existing?.turn ?? this.ensure_turn();
+    upsertItem(turn, {
+      type: "CommandExecution",
+      id: msg.call_id,
+      command: item?.command ?? [],
+      cwd: item?.cwd ?? "",
+      status: msg.status === "completed" ? "completed" : msg.status === "cancelled" ? "cancelled" : "failed",
+      stdout: msg.stdout ?? msg.output?.stdout.text ?? item?.stdout ?? "",
+      stderr: msg.stderr ?? msg.output?.stderr.text ?? item?.stderr ?? "",
+      exit_code: msg.exit_code,
+      duration_ms: msg.duration_ms ?? msg.output?.duration_ms ?? null
+    });
+  }
+  ensure_turn(id, explicit = false) {
+    if (id) {
+      const existing = this.turn_by_id(id);
+      if (existing) {
+        return existing;
+      }
+      const turn2 = newTurn(id, explicit);
+      this.turns.push(turn2);
+      return turn2;
+    }
+    const active = this.active_turn();
+    if (active) {
+      return active;
+    }
+    const turn = newTurn(`turn-${this.turns.length + 1}`, false);
+    this.turns.push(turn);
+    return turn;
+  }
+  active_turn() {
+    for (let index = this.turns.length - 1; index >= 0; index -= 1) {
+      const turn = this.turns[index];
+      if (turn?.status === "in_progress") {
+        return turn;
+      }
+    }
+    return null;
+  }
+  turn_by_id(id) {
+    return this.turns.find((turn) => turn.id === id) ?? null;
+  }
+  find_item(itemId) {
+    for (const turn of this.turns) {
+      const index = turn.items.findIndex((item) => item.id === itemId);
+      if (index !== -1) {
+        return { turn, item: turn.items[index], index };
+      }
+    }
+    return null;
+  }
+};
+function flattenTurnsToTurnItems(turns) {
+  return turns.flatMap((turn) => turn.items);
+}
+function applyEventToTurns(turns, event, eventId) {
+  const builder = ThreadHistoryBuilder.fromTurns(turns);
+  builder.handle_event(event, eventId);
+  return builder.finish();
+}
+function applyResponseItemToTurns(turns, item, id) {
+  const builder = ThreadHistoryBuilder.fromTurns(turns);
+  builder.handle_response_item(item, id);
+  return builder.finish();
+}
+function appendCompactionTurnToTurns(turns, id) {
+  const builder = ThreadHistoryBuilder.fromTurns(turns);
+  builder.handle_rollout_item({ type: "compacted", payload: { message: "" } }, 0);
+  const next = builder.finish();
+  const last = next.at(-1);
+  if (last?.items.at(-1)?.type === "ContextCompaction") {
+    last.items[last.items.length - 1] = { type: "ContextCompaction", id };
+  }
+  return next;
+}
+function newTurn(id, openedExplicitly) {
+  return {
+    id,
+    items: [],
+    items_view: "full",
+    status: "in_progress",
+    error: null,
+    started_at: null,
+    completed_at: null,
+    duration_ms: null,
+    opened_explicitly: openedExplicitly
+  };
+}
+function stripInternalTurn(turn) {
+  const { opened_explicitly, ...publicTurn } = turn;
+  return cloneTurn(publicTurn);
+}
+function cloneTurn(turn) {
+  return {
+    ...turn,
+    items: turn.items.map((item) => structuredClone(item)),
+    error: turn.error ? { ...turn.error } : null
+  };
+}
+function nextItemIndexFromTurns(turns) {
+  return turns.reduce((count, turn) => count + turn.items.length, 0) + 1;
+}
+function upsertItem(turn, item) {
+  const index = turn.items.findIndex((candidate) => candidate.id === item.id);
+  if (index === -1) {
+    turn.items.push(item);
+    return;
+  }
+  turn.items[index] = item;
+}
+function startedItem(item) {
+  return item.type === "AgentMessage" ? { ...item, phase: item.phase ?? "streaming" } : item;
+}
+function completedItem(item) {
+  return item.type === "AgentMessage" ? { ...item, phase: item.phase ?? null } : item;
+}
+function dynamicToolRequestTurnItem(request) {
+  return {
+    type: "DynamicToolCall",
+    id: request.call_id,
+    namespace: request.namespace ?? null,
+    tool: request.tool,
+    arguments: request.arguments,
+    status: "inProgress",
+    content_items: null,
+    success: null,
+    duration: null
+  };
+}
+function userMessageId(eventId) {
+  return `user-${eventId}`;
+}
+function agentMessageId(eventId) {
+  return `agent-${eventId}`;
+}
+function userMessageTurnItem(msg, id) {
+  return {
+    type: "UserMessage",
+    id,
+    content: userInputFromUserMessage(msg)
+  };
+}
+function userInputFromUserMessage(msg) {
+  const items = [];
+  if (msg.message.length > 0) {
+    items.push({
+      type: "text",
+      text: msg.message,
+      text_elements: msg.text_elements
+    });
+  }
+  for (const imageUrl of msg.images ?? []) {
+    items.push({ type: "image", image_url: imageUrl });
+  }
+  for (const path of msg.local_images ?? []) {
+    items.push({ type: "local_image", path });
+  }
+  return items;
+}
+function imageGenerationTurnItem(msg, id) {
+  return {
+    type: "ImageGeneration",
+    id: msg.call_id || id,
+    status: msg.status,
+    revised_prompt: msg.revised_prompt,
+    result: msg.result,
+    saved_path: msg.saved_path
+  };
+}
+function agentMessageText(item) {
+  return item.content.map((part) => part.text).join("");
+}
+function userMessageFingerprint(item) {
+  return item.content.map((content) => {
+    if (content.type === "text") {
+      return `text:${content.text}`;
+    }
+    if (content.type === "image") {
+      return `image:${content.image_url}`;
+    }
+    if (content.type === "local_image") {
+      return `local_image:${content.path}`;
+    }
+    if (content.type === "skill") {
+      return `skill:${content.name}:${content.path}`;
+    }
+    return `mention:${content.name}:${content.path}`;
+  }).join("\n");
+}
+
+// src/internal/codex/core/src/rendered-thread.ts
+function createRenderedThreadState(threadId) {
+  return {
+    thread_id: threadId,
+    turns: [],
+    items: [],
+    pending_request_user_input: null,
+    pending_request_permissions: null,
+    pending_dynamic_tool_call_requests: [],
+    running_turn_ids: [],
+    warnings: [],
+    errors: [],
+    last_history_fingerprint: null,
+    connection_status: "idle"
+  };
+}
+function renderThreadFromHistory(history) {
+  let state = createRenderedThreadState(history.thread_id);
+  for (const [index, item] of history.items.entries()) {
+    state = applyRolloutItemToRenderedThread(state, item, index);
+  }
+  return {
+    ...state,
+    running_turn_ids: [],
+    last_history_fingerprint: fingerprintRolloutItems(history.items)
+  };
+}
+function applyRolloutItemToRenderedThread(state, item, index = state.items.length) {
+  if (item.type === "event_msg") {
+    return applyEventMsgToRenderedThread(state, item.payload, {
+      event_id: `rollout-${index}`
+    });
+  }
+  if (item.type === "response_item") {
+    return withTurns(
+      state,
+      applyResponseItemToTurns(state.turns, item.payload, `response-${index}`)
+    );
+  }
+  if (item.type === "compacted") {
+    return withTurns(
+      state,
+      appendCompactionTurnToTurns(state.turns, `compacted-${index}`)
+    );
+  }
+  return state;
+}
+function applyEventMsgToRenderedThread(state, msg, options = {}) {
+  const eventId = options.event_id ?? `event-${state.items.length}`;
+  const hadActiveTurn = hasActiveTurn(state.turns);
+  const next = withTurns(state, applyEventToTurns(state.turns, msg, eventId));
+  switch (msg.type) {
+    case "turn_started":
+      return {
+        ...next,
+        running_turn_ids: addUnique(next.running_turn_ids, msg.turn_id)
+      };
+    case "turn_complete":
+      return clearPendingForTurn(
+        {
+          ...next,
+          running_turn_ids: next.running_turn_ids.filter(
+            (turnId) => turnId !== msg.turn_id
+          )
+        },
+        msg.turn_id
+      );
+    case "turn_aborted":
+      return clearPendingForTurn(
+        {
+          ...next,
+          running_turn_ids: next.running_turn_ids.filter(
+            (turnId) => turnId !== msg.turn_id
+          )
+        },
+        msg.turn_id
+      );
+    case "request_user_input":
+      return {
+        ...next,
+        pending_request_user_input: {
+          call_id: msg.call_id,
+          turn_id: msg.turn_id,
+          questions: msg.questions.map((question) => ({
+            ...question,
+            options: question.options.map((option) => ({ ...option }))
+          }))
+        }
+      };
+    case "request_permissions":
+      return {
+        ...next,
+        pending_request_permissions: {
+          call_id: msg.call_id,
+          turn_id: msg.turn_id,
+          reason: msg.reason ?? null,
+          permissions: JSON.parse(JSON.stringify(msg.permissions)),
+          cwd: msg.cwd ?? null
+        }
+      };
+    case "dynamic_tool_call_request":
+      return {
+        ...next,
+        pending_dynamic_tool_call_requests: upsertDynamicToolCallRequest(
+          next.pending_dynamic_tool_call_requests,
+          msg
+        )
+      };
+    case "dynamic_tool_call_response":
+      return {
+        ...next,
+        pending_dynamic_tool_call_requests: next.pending_dynamic_tool_call_requests.filter(
+          (request) => request.call_id !== msg.call_id
+        )
+      };
+    case "warning":
+      return {
+        ...next,
+        warnings: [...next.warnings, msg.message]
+      };
+    case "error":
+      return hadActiveTurn ? next : {
+        ...next,
+        errors: [...next.errors, msg.message]
+      };
+    default:
+      return next;
+  }
+}
+function fingerprintRolloutItems(items) {
+  const last = items.at(-1);
+  return `${items.length}:${hashString(JSON.stringify(last ?? null))}`;
+}
+function withTurns(state, turns) {
+  const nextTurns = turns.map((turn) => ({
+    ...turn,
+    items: turn.items.map((item) => structuredClone(item)),
+    error: turn.error ? { ...turn.error } : null
+  }));
+  return {
+    ...state,
+    turns: nextTurns,
+    items: flattenTurnsToTurnItems(nextTurns)
+  };
+}
+function clearPendingForTurn(state, turnId) {
+  return {
+    ...state,
+    pending_request_user_input: state.pending_request_user_input?.turn_id === turnId ? null : state.pending_request_user_input,
+    pending_dynamic_tool_call_requests: state.pending_dynamic_tool_call_requests.filter(
+      (request) => request.turn_id !== turnId
+    ),
+    pending_request_permissions: state.pending_request_permissions?.turn_id === turnId ? null : state.pending_request_permissions
+  };
+}
+function upsertDynamicToolCallRequest(requests, request) {
+  return [
+    ...requests.filter((item) => item.call_id !== request.call_id),
+    {
+      call_id: request.call_id,
+      turn_id: request.turn_id,
+      started_at_ms: request.started_at_ms,
+      namespace: request.namespace ?? null,
+      tool: request.tool,
+      arguments: request.arguments
+    }
+  ];
+}
+function hasActiveTurn(turns) {
+  return turns.some((turn) => turn.status === "in_progress");
+}
+function addUnique(values, value) {
+  return values.includes(value) ? values : [...values, value];
+}
+function hashString(value) {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = hash * 31 + value.charCodeAt(index) >>> 0;
+  }
+  return hash.toString(16);
+}
+
+// src/internal/codex/app-server-client/src/thread_event_store.ts
+var ThreadEventStore = class _ThreadEventStore {
+  accountRateLimits = null;
+  activeTurnIds = /* @__PURE__ */ new Set();
+  bufferedEvents = [];
+  connectionStatus = "idle";
+  errors = [];
+  pendingRequests = /* @__PURE__ */ new Map();
+  resolvedRequestIds = [];
+  thread = null;
+  tokenUsage = null;
+  turns = [];
+  warnings = [];
+  static fromThread(thread) {
+    const store = new _ThreadEventStore();
+    store.setThread(thread);
+    return store;
+  }
+  applyNotification(notification) {
+    applyServerNotificationToThreadEventStore(this, notification);
+    return this.snapshot();
+  }
+  applyRequest(request) {
+    applyServerRequestToThreadEventStore(this, request);
+    return this.snapshot();
+  }
+  setConnectionStatus(status) {
+    this.connectionStatus = status;
+    return this.snapshot();
+  }
+  setThread(thread) {
+    this.thread = cloneThread(thread);
+    this.turns = thread.turns.map(cloneTurn2);
+    this.activeTurnIds = new Set(
+      this.turns.filter((turn) => turn.status === "inProgress").map((turn) => turn.id)
+    );
+    return this.snapshot();
+  }
+  snapshot() {
+    return {
+      activeTurnIds: [...this.activeTurnIds],
+      accountRateLimits: this.accountRateLimits ? { ...this.accountRateLimits } : null,
+      bufferedEvents: [...this.bufferedEvents],
+      connectionStatus: this.connectionStatus,
+      errors: [...this.errors],
+      pendingRequests: [...this.pendingRequests.values()],
+      resolvedRequestIds: [...this.resolvedRequestIds],
+      thread: this.thread ? cloneThread(this.thread) : null,
+      tokenUsage: this.tokenUsage ? {
+        ...this.tokenUsage,
+        tokenUsage: cloneThreadTokenUsage(this.tokenUsage.tokenUsage)
+      } : null,
+      turns: this.turns.map(cloneTurn2),
+      warnings: [...this.warnings]
+    };
+  }
+  noteNotification(notification) {
+    this.bufferedEvents = [...this.bufferedEvents, { notification, type: "notification" }];
+    switch (notification.method) {
+      case "thread/started":
+        this.setThread(notification.params.thread);
+        return;
+      case "thread/status/changed":
+        if (this.thread) {
+          this.thread = { ...this.thread, status: notification.params.status };
+        }
+        return;
+      case "thread/name/updated":
+        if (this.thread) {
+          this.thread = { ...this.thread, name: notification.params.threadName ?? null };
+        }
+        return;
+      case "thread/archived":
+      case "thread/unarchived":
+      case "thread/closed":
+      case "thread/goal/updated":
+      case "thread/goal/cleared":
+        return;
+      case "thread/tokenUsage/updated":
+        this.tokenUsage = {
+          threadId: notification.params.threadId,
+          tokenUsage: cloneThreadTokenUsage(notification.params.tokenUsage),
+          turnId: notification.params.turnId,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return;
+      case "turn/started":
+        this.upsertTurn(notification.params.turn);
+        this.activeTurnIds.add(notification.params.turn.id);
+        return;
+      case "turn/diff/updated":
+      case "turn/plan/updated":
+        this.ensureTurn(notification.params.turnId);
+        return;
+      case "turn/completed":
+        this.upsertTurn(notification.params.turn);
+        this.activeTurnIds.delete(notification.params.turn.id);
+        if (notification.params.turn.error?.message) {
+          this.errors = appendUnique(this.errors, notification.params.turn.error.message);
+        }
+        return;
+      case "item/started":
+      case "item/completed":
+        this.upsertItem(notification.params.turnId, notification.params.item);
+        return;
+      case "item/agentMessage/delta":
+        this.applyAgentMessageDelta(
+          notification.params.turnId,
+          notification.params.itemId,
+          notification.params.delta
+        );
+        return;
+      case "item/plan/delta":
+        this.applyPlanDelta(
+          notification.params.turnId,
+          notification.params.itemId,
+          notification.params.delta
+        );
+        return;
+      case "item/reasoning/summaryPartAdded":
+        this.applyReasoningSummaryPartAdded(
+          notification.params.turnId,
+          notification.params.itemId,
+          notification.params.summaryIndex
+        );
+        return;
+      case "item/reasoning/summaryTextDelta":
+        this.applyReasoningSummaryTextDelta(
+          notification.params.turnId,
+          notification.params.itemId,
+          notification.params.summaryIndex,
+          notification.params.delta
+        );
+        return;
+      case "item/reasoning/textDelta":
+        this.applyReasoningTextDelta(
+          notification.params.turnId,
+          notification.params.itemId,
+          notification.params.contentIndex,
+          notification.params.delta
+        );
+        return;
+      case "item/commandExecution/outputDelta":
+        this.applyCommandOutputDelta(
+          notification.params.turnId,
+          notification.params.itemId,
+          notification.params.delta
+        );
+        return;
+      case "item/fileChange/outputDelta":
+        this.ensureTurn(notification.params.turnId);
+        return;
+      case "item/fileChange/patchUpdated":
+        this.applyFileChangePatchUpdated(
+          notification.params.turnId,
+          notification.params.itemId,
+          notification.params.changes
+        );
+        return;
+      case "item/mcpToolCall/progress":
+      case "item/commandExecution/terminalInteraction":
+      case "command/exec/outputDelta":
+      case "process/outputDelta":
+      case "process/exited":
+      case "rawResponseItem/completed":
+      case "hook/started":
+      case "hook/completed":
+      case "item/autoApprovalReview/started":
+      case "item/autoApprovalReview/completed":
+        return;
+      case "thread/compacted":
+        this.upsertItem(notification.params.turnId, {
+          id: `compacted-${notification.params.turnId}`,
+          type: "contextCompaction"
+        });
+        return;
+      case "serverRequest/resolved":
+        this.pendingRequests.delete(notification.params.requestId);
+        this.resolvedRequestIds = appendUnique(
+          this.resolvedRequestIds,
+          notification.params.requestId
+        );
+        return;
+      case "warning":
+        this.warnings = appendUnique(this.warnings, notification.params.message);
+        return;
+      case "error":
+        this.errors = appendUnique(this.errors, notification.params.error.message);
+        return;
+      case "guardianWarning":
+        this.warnings = appendUnique(this.warnings, notification.params.message);
+        return;
+      case "deprecationNotice":
+        this.warnings = appendUnique(this.warnings, notification.params.summary);
+        return;
+      case "configWarning":
+        this.warnings = appendUnique(this.warnings, notification.params.summary);
+        return;
+      case "account/rateLimits/updated":
+        this.accountRateLimits = { ...notification.params.rateLimits };
+        return;
+      case "thread/realtime/started":
+      case "thread/realtime/itemAdded":
+      case "thread/realtime/transcript/delta":
+      case "thread/realtime/transcript/done":
+      case "thread/realtime/outputAudio/delta":
+      case "thread/realtime/sdp":
+      case "thread/realtime/error":
+      case "thread/realtime/closed":
+      case "fs/changed":
+      case "model/rerouted":
+      case "model/verification":
+      case "mcpServer/oauthLogin/completed":
+      case "mcpServer/startupStatus/updated":
+      case "fuzzyFileSearch/sessionUpdated":
+      case "fuzzyFileSearch/sessionCompleted":
+      case "windows/worldWritableWarning":
+      case "windowsSandbox/setupCompleted":
+        return;
+      default:
+        if (notificationThreadId(notification)) {
+          this.warnings = appendUnique(
+            this.warnings,
+            `Unsupported Codex app-server notification: ${notification.method}`
+          );
+        }
+        return;
+    }
+  }
+  noteRequest(request) {
+    this.bufferedEvents = [...this.bufferedEvents, { request, type: "request" }];
+    this.pendingRequests.set(request.id, request);
+  }
+  upsertTurn(turn) {
+    const index = this.turns.findIndex((candidate) => candidate.id === turn.id);
+    if (index === -1) {
+      this.turns = [...this.turns, cloneTurn2(turn)];
+      return;
+    }
+    const current = this.turns[index];
+    this.turns = replaceAt(this.turns, index, {
+      ...current,
+      ...turn,
+      items: turn.items.length > 0 ? turn.items.map(cloneThreadItem) : current.items
+    });
+  }
+  upsertItem(turnId, item) {
+    const turn = this.ensureTurn(turnId);
+    const itemIndex = turn.items.findIndex((candidate) => candidate.id === item.id);
+    const nextItems = itemIndex === -1 ? [...turn.items, cloneThreadItem(item)] : replaceAt(turn.items, itemIndex, cloneThreadItem(item));
+    this.replaceTurn({ ...turn, items: nextItems, itemsView: "full" });
+  }
+  applyAgentMessageDelta(turnId, itemId, delta) {
+    const turn = this.ensureTurn(turnId);
+    const item = turn.items.find((candidate) => candidate.id === itemId);
+    if (item?.type === "agentMessage") {
+      this.upsertItem(turnId, { ...item, text: `${item.text}${delta}` });
+      return;
+    }
+    this.upsertItem(turnId, {
+      id: itemId,
+      memoryCitation: null,
+      phase: "commentary",
+      text: delta,
+      type: "agentMessage"
+    });
+  }
+  applyPlanDelta(turnId, itemId, delta) {
+    const turn = this.ensureTurn(turnId);
+    const item = turn.items.find((candidate) => candidate.id === itemId);
+    if (item?.type === "plan") {
+      this.upsertItem(turnId, { ...item, text: `${item.text}${delta}` });
+      return;
+    }
+    this.upsertItem(turnId, {
+      id: itemId,
+      text: delta,
+      type: "plan"
+    });
+  }
+  applyReasoningSummaryPartAdded(turnId, itemId, summaryIndex) {
+    const item = this.reasoningItem(turnId, itemId);
+    const summary = replaceAtOrAppend(item.summary, summaryIndex, "");
+    this.upsertItem(turnId, { ...item, summary });
+  }
+  applyReasoningSummaryTextDelta(turnId, itemId, summaryIndex, delta) {
+    const item = this.reasoningItem(turnId, itemId);
+    const current = item.summary[summaryIndex] ?? "";
+    const summary = replaceAtOrAppend(item.summary, summaryIndex, `${current}${delta}`);
+    this.upsertItem(turnId, { ...item, summary });
+  }
+  applyReasoningTextDelta(turnId, itemId, contentIndex, delta) {
+    const item = this.reasoningItem(turnId, itemId);
+    const current = item.content[contentIndex] ?? "";
+    const content = replaceAtOrAppend(item.content, contentIndex, `${current}${delta}`);
+    this.upsertItem(turnId, { ...item, content });
+  }
+  applyCommandOutputDelta(turnId, itemId, delta) {
+    const turn = this.ensureTurn(turnId);
+    const item = turn.items.find((candidate) => candidate.id === itemId);
+    if (item?.type !== "commandExecution") {
+      return;
+    }
+    this.upsertItem(turnId, {
+      ...item,
+      aggregatedOutput: `${item.aggregatedOutput ?? ""}${delta}`
+    });
+  }
+  applyFileChangePatchUpdated(turnId, itemId, changes) {
+    const turn = this.ensureTurn(turnId);
+    const item = turn.items.find((candidate) => candidate.id === itemId);
+    if (item?.type !== "fileChange") {
+      return;
+    }
+    this.upsertItem(turnId, { ...item, changes });
+  }
+  reasoningItem(turnId, itemId) {
+    const turn = this.ensureTurn(turnId);
+    const item = turn.items.find((candidate) => candidate.id === itemId);
+    if (item?.type === "reasoning") {
+      return item;
+    }
+    return {
+      content: [],
+      id: itemId,
+      summary: [],
+      type: "reasoning"
+    };
+  }
+  ensureTurn(turnId) {
+    const existing = this.turns.find((turn2) => turn2.id === turnId);
+    if (existing) {
+      return existing;
+    }
+    const turn = {
+      completedAt: null,
+      durationMs: null,
+      error: null,
+      id: turnId,
+      items: [],
+      itemsView: "full",
+      startedAt: null,
+      status: "inProgress"
+    };
+    this.turns = [...this.turns, turn];
+    this.activeTurnIds.add(turnId);
+    return turn;
+  }
+  replaceTurn(turn) {
+    const index = this.turns.findIndex((candidate) => candidate.id === turn.id);
+    this.turns = index === -1 ? [...this.turns, turn] : replaceAt(this.turns, index, turn);
+  }
+};
+function applyServerNotificationToThreadEventStore(store, notification) {
+  store.noteNotification(notification);
+  return store.snapshot();
+}
+function applyServerRequestToThreadEventStore(store, request) {
+  store.noteRequest(request);
+  return store.snapshot();
+}
+function notificationThreadId(notification) {
+  if (notification.method === "thread/started") {
+    return notification.params.thread.id;
+  }
+  if ("params" in notification && notification.params && typeof notification.params === "object") {
+    const threadId = notification.params.threadId;
+    return typeof threadId === "string" ? threadId : null;
+  }
+  return null;
+}
+function cloneThread(thread) {
+  return {
+    ...thread,
+    turns: thread.turns.map(cloneTurn2)
+  };
+}
+function cloneTurn2(turn) {
+  return {
+    ...turn,
+    items: turn.items.map(cloneThreadItem)
+  };
+}
+function cloneThreadItem(item) {
+  return { ...item };
+}
+function cloneThreadTokenUsage(tokenUsage) {
+  return {
+    last: { ...tokenUsage.last },
+    modelContextWindow: tokenUsage.modelContextWindow,
+    total: { ...tokenUsage.total }
+  };
+}
+function replaceAt(items, index, item) {
+  return [...items.slice(0, index), item, ...items.slice(index + 1)];
+}
+function replaceAtOrAppend(items, index, item) {
+  if (index < items.length) {
+    return replaceAt(items, index, item);
+  }
+  return [...items, item];
+}
+function appendUnique(items, item) {
+  return items.includes(item) ? [...items] : [...items, item];
+}
+
+// src/internal/codex/core/src/memory.ts
+var ThreadMemoryMode = {
+  Enabled: "Enabled"};
+
+// src/internal/codex/thread-store/src/in_memory.ts
+var stores = /* @__PURE__ */ new Map();
+var InMemoryThreadStore = class _InMemoryThreadStore {
+  state = {
+    calls: emptyCalls(),
+    createdThreads: /* @__PURE__ */ new Map(),
+    histories: /* @__PURE__ */ new Map(),
+    rolloutPaths: /* @__PURE__ */ new Map(),
+    threads: /* @__PURE__ */ new Map()
+  };
+  static forId(id) {
+    const existing = stores.get(id);
+    if (existing) {
+      return existing;
+    }
+    const store = new _InMemoryThreadStore();
+    stores.set(id, store);
+    return store;
+  }
+  static removeId(id) {
+    const store = stores.get(id) ?? null;
+    stores.delete(id);
+    return store;
+  }
+  calls() {
+    return { ...this.state.calls };
+  }
+  snapshot() {
+    return {
+      createdThreads: Array.from(this.state.createdThreads.entries()),
+      histories: Array.from(this.state.histories.entries()).map(
+        ([threadId, items]) => [threadId, [...items]]
+      ),
+      rolloutPaths: Array.from(this.state.rolloutPaths.entries()),
+      threads: Array.from(this.state.threads.entries()).map(
+        ([threadId, thread]) => [threadId, { ...thread }]
+      )
+    };
+  }
+  restoreSnapshot(snapshot) {
+    this.state.createdThreads = new Map(snapshot.createdThreads);
+    this.state.histories = new Map(
+      snapshot.histories.map(([threadId, items]) => [threadId, [...items]])
+    );
+    this.state.rolloutPaths = new Map(snapshot.rolloutPaths);
+    this.state.threads = new Map(
+      snapshot.threads.map(([threadId, thread]) => [threadId, { ...thread }])
+    );
+  }
+  async createThread(params) {
+    this.state.calls.createThread += 1;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.state.createdThreads.set(params.thread_id, params);
+    this.state.histories.set(params.thread_id, []);
+    this.state.threads.set(params.thread_id, {
+      archived_at: null,
+      created_at: now,
+      cwd: String(params.metadata.cwd ?? "/"),
+      forked_from_id: params.forked_from_id ?? null,
+      history: null,
+      model: stringOrNull(params.metadata.model),
+      model_provider: params.metadata.model_provider,
+      name: null,
+      preview: "",
+      reasoning_effort: stringOrNull(params.metadata.reasoning_effort),
+      source: params.source,
+      thread_id: params.thread_id,
+      thread_source: params.thread_source ?? null,
+      token_usage: null,
+      updated_at: now
+    });
+  }
+  async resumeThread(params) {
+    this.state.calls.resumeThread += 1;
+    if (!this.state.threads.has(params.thread_id)) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      this.state.threads.set(params.thread_id, {
+        archived_at: null,
+        created_at: now,
+        cwd: String(params.metadata.cwd ?? "/"),
+        history: null,
+        model: stringOrNull(params.metadata.model),
+        model_provider: params.metadata.model_provider,
+        preview: "",
+        source: "appServer",
+        thread_id: params.thread_id,
+        token_usage: lastTokenInfoFromRolloutItems(params.history ?? []),
+        updated_at: now
+      });
+    }
+    this.state.histories.set(
+      params.thread_id,
+      [...params.history ?? this.state.histories.get(params.thread_id) ?? []]
+    );
+    this.updateThreadTokenUsage(
+      params.thread_id,
+      params.history ?? this.state.histories.get(params.thread_id) ?? []
+    );
+    if (params.rollout_path) {
+      this.state.rolloutPaths.set(params.rollout_path, params.thread_id);
+    }
+  }
+  async appendItems(params) {
+    this.state.calls.appendItems += 1;
+    this.history(params.thread_id).push(...params.items);
+    this.updateThreadTokenUsage(params.thread_id, params.items);
+    this.touch(params.thread_id);
+  }
+  async persistThread(threadId) {
+    this.state.calls.persistThread += 1;
+  }
+  async flushThread(threadId) {
+    this.state.calls.flushThread += 1;
+  }
+  async shutdownThread(threadId) {
+    this.state.calls.shutdownThread += 1;
+  }
+  async discardThread(threadId) {
+    this.state.calls.discardThread += 1;
+  }
+  async loadHistory(params) {
+    this.state.calls.loadHistory += 1;
+    return {
+      items: [...this.history(params.thread_id)],
+      thread_id: params.thread_id
+    };
+  }
+  async readThread(params) {
+    this.state.calls.readThread += 1;
+    return this.storedThread(params.thread_id, params.include_history);
+  }
+  async readThreadByRolloutPath(params) {
+    this.state.calls.readThreadByRolloutPath += 1;
+    const threadId = this.state.rolloutPaths.get(params.rollout_path);
+    if (!threadId) {
+      throw new Error(`Unknown rollout path: ${params.rollout_path}`);
+    }
+    return this.storedThread(threadId, params.include_history);
+  }
+  async listThreads(params) {
+    this.state.calls.listThreads += 1;
+    const items = Array.from(this.state.threads.values()).filter((thread) => params.archived || !thread.archived_at).sort(
+      (left, right) => params.sort_direction === "Asc" ? left.created_at.localeCompare(right.created_at) : right.created_at.localeCompare(left.created_at)
+    ).slice(0, params.page_size).map((thread) => ({ ...thread, history: null }));
+    return { items, next_cursor: null };
+  }
+  async updateThreadMetadata(params) {
+    this.state.calls.updateThreadMetadata += 1;
+    const thread = this.storedThread(params.thread_id, false);
+    const next = {
+      ...thread,
+      name: params.patch.name ?? thread.name,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (params.patch.memory_mode === ThreadMemoryMode.Enabled) {
+      next.preview = thread.preview;
+    }
+    this.state.threads.set(params.thread_id, next);
+    return { ...next };
+  }
+  async archiveThread(params) {
+    this.state.calls.archiveThread += 1;
+    const thread = this.storedThread(params.thread_id, false);
+    this.state.threads.set(params.thread_id, {
+      ...thread,
+      archived_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async unarchiveThread(params) {
+    this.state.calls.unarchiveThread += 1;
+    const thread = this.storedThread(params.thread_id, false);
+    const next = { ...thread, archived_at: null };
+    this.state.threads.set(params.thread_id, next);
+    return next;
+  }
+  history(threadId) {
+    const history = this.state.histories.get(threadId);
+    if (!history) {
+      throw new Error(`Thread not found: ${threadId}`);
+    }
+    return history;
+  }
+  storedThread(threadId, includeHistory) {
+    const thread = this.state.threads.get(threadId);
+    if (!thread) {
+      throw new Error(`Thread not found: ${threadId}`);
+    }
+    return {
+      ...thread,
+      history: includeHistory ? { items: [...this.history(threadId)], thread_id: threadId } : null
+    };
+  }
+  touch(threadId) {
+    const thread = this.state.threads.get(threadId);
+    if (thread) {
+      this.state.threads.set(threadId, {
+        ...thread,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  updateThreadTokenUsage(threadId, items) {
+    const info = lastTokenInfoFromRolloutItems(items);
+    if (!info) {
+      return;
+    }
+    const thread = this.state.threads.get(threadId);
+    if (!thread) {
+      return;
+    }
+    this.state.threads.set(threadId, {
+      ...thread,
+      token_usage: info
+    });
+  }
+};
+function emptyCalls() {
+  return {
+    archiveThread: 0,
+    appendItems: 0,
+    createThread: 0,
+    discardThread: 0,
+    flushThread: 0,
+    listThreads: 0,
+    loadHistory: 0,
+    persistThread: 0,
+    readThread: 0,
+    readThreadByRolloutPath: 0,
+    resumeThread: 0,
+    shutdownThread: 0,
+    unarchiveThread: 0,
+    updateThreadMetadata: 0
+  };
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function lastTokenInfoFromRolloutItems(items) {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    const item = items[index];
+    if (item?.type === "event_msg" && item.payload.type === "token_count" && item.payload.info) {
+      return item.payload.info;
+    }
+  }
+  return null;
+}
+
+// src/internal/codex/thread-store/src/local/mod.ts
+var LocalThreadStore = class extends InMemoryThreadStore {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  config;
+  stateDb() {
+    return null;
+  }
+  async createThread(params) {
+    await this.load();
+    await super.createThread(params);
+    this.attachRolloutPath(params.thread_id);
+    await this.save();
+  }
+  async resumeThread(params) {
+    await this.load();
+    await super.resumeThread({
+      ...params,
+      rollout_path: params.rollout_path ?? this.rolloutPath(params.thread_id)
+    });
+    this.attachRolloutPath(params.thread_id, params.rollout_path ?? void 0);
+    await this.save();
+  }
+  async appendItems(params) {
+    await this.load();
+    await super.appendItems(params);
+    await this.save();
+  }
+  async persistThread(threadId) {
+    await this.load();
+    await super.persistThread(threadId);
+    await this.save();
+  }
+  async flushThread(threadId) {
+    await this.load();
+    await super.flushThread(threadId);
+    await this.save();
+  }
+  async shutdownThread(threadId) {
+    await this.load();
+    await super.shutdownThread(threadId);
+    await this.save();
+  }
+  async discardThread(threadId) {
+    await this.load();
+    await super.discardThread(threadId);
+    await this.save();
+  }
+  async loadHistory(params) {
+    await this.load();
+    return super.loadHistory(params);
+  }
+  async readThread(params) {
+    await this.load();
+    return super.readThread(params);
+  }
+  async readThreadByRolloutPath(params) {
+    await this.load();
+    return super.readThreadByRolloutPath(params);
+  }
+  async listThreads(params) {
+    await this.load();
+    return super.listThreads(params);
+  }
+  async updateThreadMetadata(params) {
+    await this.load();
+    const thread = await super.updateThreadMetadata(params);
+    await this.save();
+    return thread;
+  }
+  async archiveThread(params) {
+    await this.load();
+    await super.archiveThread(params);
+    await this.save();
+  }
+  async unarchiveThread(params) {
+    await this.load();
+    const thread = await super.unarchiveThread(params);
+    await this.save();
+    return thread;
+  }
+  liveRolloutPath(threadId) {
+    return this.rolloutPath(threadId);
+  }
+  attachRolloutPath(threadId, rolloutPath) {
+    const snapshot = this.snapshot();
+    const path = rolloutPath ?? this.rolloutPath(threadId);
+    const threads = snapshot.threads.map(
+      ([candidateThreadId, thread]) => [
+        candidateThreadId,
+        candidateThreadId === threadId ? { ...thread, rollout_path: path } : thread
+      ]
+    );
+    const rolloutPaths = new Map(snapshot.rolloutPaths);
+    rolloutPaths.set(path, threadId);
+    this.restoreSnapshot({
+      ...snapshot,
+      rolloutPaths: Array.from(rolloutPaths.entries()),
+      threads
+    });
+  }
+  async load() {
+    try {
+      const { readFile } = await nodeFsPromises();
+      const raw = await readFile(this.storePath(), "utf8");
+      const data = JSON.parse(raw);
+      this.restoreSnapshot(data);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  }
+  async save() {
+    const { mkdir, writeFile } = await nodeFsPromises();
+    const path = this.storePath();
+    await mkdir(dirname(path), { recursive: true });
+    const data = {
+      version: 1,
+      ...this.snapshot()
+    };
+    await writeFile(path, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  }
+  rolloutPath(threadId) {
+    return `${this.config.codex_home.replace(/\/+$/, "")}/sessions/${threadId}.jsonl`;
+  }
+  storePath() {
+    return `${this.config.codex_home.replace(/\/+$/, "")}/thread-store/store.json`;
+  }
+};
+async function nodeFsPromises() {
+  const moduleName = "node:fs/promises";
+  return import(
+    /* @vite-ignore */
+    moduleName
+  );
+}
+function dirname(path) {
+  const normalized = path.replace(/\/+$/, "");
+  const separatorIndex = normalized.lastIndexOf("/");
+  return separatorIndex <= 0 ? "/" : normalized.slice(0, separatorIndex);
+}
+
+export { InMemoryThreadStore, LocalThreadStore, ThreadEventStore, createRenderedThreadState, renderThreadFromHistory };