@jrkropp/codex-js 0.1.4 → 0.2.0

package/dist/client/index.js

@@ -1,16 +1,2522 @@
-import '../chunk-ZX5OIIJX.js';
-export { AppServerSession, CodexAppServerClientTransportError, PendingAppServerRequests, ThreadEventStore, createCodexAppServerClient, parseCodexAppServerEvent, requestMethodName, requestTyped, serverNotificationRequiresDelivery, serverNotificationThreadTarget, serverRequestThreadId, threadEventSnapshotHasStarted } from '../chunk-6ZMJ34KE.js';
-import '../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';
-import '../chunk-DYLHN3HG.js';
-import '../chunk-SYPHCDRD.js';
-import '../chunk-O44XP7LH.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+// src/internal/codex/core/src/protocol.ts
+var BASE_INSTRUCTIONS_DEFAULT = `You are Codex, based on GPT-5. You are running as a coding agent in the Codex CLI on a user's computer.
+
+## General
+
+- Prefer to be concise, direct, and useful.
+- When asked to modify code, inspect the repository first and follow existing patterns.
+- Do not make unrelated changes.
+- If you run commands or edit files, summarize what changed and how you verified it.`;
+
+// src/internal/codex/app-server-protocol/src/protocol/event-mapping.ts
+function durationMsFromString(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function threadTokenUsageFromTokenUsageInfo(info) {
+  return {
+    total: appServerTokenUsageBreakdown(info.total_token_usage),
+    last: appServerTokenUsageBreakdown(info.last_token_usage),
+    modelContextWindow: info.model_context_window ?? null
+  };
+}
+function appServerTokenUsageBreakdown(usage) {
+  return {
+    totalTokens: usage.total_tokens,
+    inputTokens: usage.input_tokens,
+    cachedInputTokens: usage.cached_input_tokens,
+    outputTokens: usage.output_tokens,
+    reasoningOutputTokens: usage.reasoning_output_tokens
+  };
+}
+function appServerUserInputsFromCore(inputs) {
+  return inputs.map((input) => {
+    if (input.type === "text") {
+      return {
+        type: "text",
+        text: input.text,
+        text_elements: appServerTextElementsFromCore(input.text_elements ?? [])
+      };
+    }
+    if (input.type === "image") {
+      return { type: "image", url: input.image_url };
+    }
+    if (input.type === "local_image") {
+      return { type: "localImage", path: input.path };
+    }
+    return input;
+  });
+}
+function appServerTextElementsFromCore(elements) {
+  return elements.map((element) => ({
+    byteRange: element.byte_range,
+    placeholder: element.placeholder ?? null
+  }));
+}
+function appServerMessagePhase(value) {
+  return value === "commentary" || value === "final_answer" ? value : null;
+}
+function appServerMemoryCitationFromCore(citation) {
+  return citation ? {
+    entries: citation.entries,
+    threadIds: citation.rolloutIds ?? []
+  } : null;
+}
+function coreTurnItemToThreadItem(item) {
+  if (!item || typeof item !== "object" || !("type" in item)) {
+    return null;
+  }
+  const value = item;
+  switch (value.type) {
+    case "UserMessage":
+      return {
+        type: "userMessage",
+        id: String(value.id ?? ""),
+        content: appServerUserInputsFromCore(value.content ?? [])
+      };
+    case "AgentMessage":
+      return {
+        type: "agentMessage",
+        id: String(value.id ?? ""),
+        text: (value.content ?? []).map((part) => part.text ?? "").join(""),
+        phase: appServerMessagePhase(value.phase),
+        memoryCitation: appServerMemoryCitationFromCore(
+          value.memory_citation ?? null
+        )
+      };
+    case "Plan":
+      return {
+        type: "plan",
+        id: String(value.id ?? ""),
+        text: String(value.text ?? "")
+      };
+    case "Reasoning":
+      return {
+        type: "reasoning",
+        id: String(value.id ?? ""),
+        summary: value.summary_text ?? [],
+        content: value.raw_content ?? []
+      };
+    case "WebSearch": {
+      const action = appServerWebSearchAction(value.action);
+      return {
+        type: "webSearch",
+        id: String(value.id ?? ""),
+        query: typeof value.query === "string" ? value.query : webSearchActionDetail(action),
+        action
+      };
+    }
+    case "CommandExecution":
+      return {
+        type: "commandExecution",
+        id: String(value.id ?? ""),
+        command: (value.command ?? []).join(" "),
+        cwd: String(value.cwd ?? ""),
+        processId: null,
+        source: "agent",
+        status: commandStatusToAppServer(value.status),
+        commandActions: [],
+        aggregatedOutput: [value.stdout, value.stderr].filter(Boolean).join("") || null,
+        exitCode: typeof value.exit_code === "number" ? value.exit_code : null,
+        durationMs: typeof value.duration_ms === "number" ? value.duration_ms : null
+      };
+    case "FileChange":
+      return {
+        type: "fileChange",
+        id: String(value.id ?? ""),
+        changes: [],
+        status: value.status ?? "completed"
+      };
+    case "DynamicToolCall":
+      return {
+        type: "dynamicToolCall",
+        id: String(value.id ?? ""),
+        namespace: value.namespace ?? null,
+        tool: String(value.tool ?? ""),
+        arguments: value.arguments ?? null,
+        status: dynamicToolStatusToAppServer(value.status),
+        contentItems: value.content_items ?? null,
+        success: value.success ?? null,
+        durationMs: durationMsFromString(value.duration)
+      };
+    case "ContextCompaction":
+      return {
+        type: "contextCompaction",
+        id: String(value.id ?? "")
+      };
+    default:
+      return null;
+  }
+}
+function appServerWebSearchAction(action) {
+  if (!action || typeof action !== "object") {
+    return { type: "other" };
+  }
+  const record = action;
+  if (record.type === "search") {
+    return {
+      type: "search",
+      query: typeof record.query === "string" ? record.query : null,
+      queries: Array.isArray(record.queries) ? record.queries.filter((query) => typeof query === "string") : null
+    };
+  }
+  if (record.type === "open_page" || record.type === "openPage") {
+    return {
+      type: "openPage",
+      url: typeof record.url === "string" ? record.url : null
+    };
+  }
+  if (record.type === "find_in_page" || record.type === "findInPage") {
+    return {
+      type: "findInPage",
+      url: typeof record.url === "string" ? record.url : null,
+      pattern: typeof record.pattern === "string" ? record.pattern : null
+    };
+  }
+  return { type: "other" };
+}
+function webSearchActionDetail(action) {
+  switch (action.type) {
+    case "search":
+      return action.query ?? action.queries?.join(", ") ?? "";
+    case "openPage":
+      return action.url ?? "";
+    case "findInPage": {
+      const pattern = action.pattern ?? "";
+      const url = action.url ?? "";
+      return pattern && url ? `'${pattern}' in ${url}` : pattern || url;
+    }
+    case "other":
+      return "";
+  }
+}
+function commandStatusToAppServer(value) {
+  if (value === "completed" || value === "failed") {
+    return value;
+  }
+  if (value === "cancelled") {
+    return "failed";
+  }
+  return "inProgress";
+}
+function dynamicToolStatusToAppServer(value) {
+  if (value === "completed" || value === "failed") {
+    return value;
+  }
+  return "inProgress";
+}
+
+// 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: webSearchActionDetail2(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 webSearchActionDetail2(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 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/app-server-protocol/src/protocol/thread-resume.ts
+function appServerTurnFromCoreTurn(turn) {
+  return {
+    id: turn.id,
+    items: turn.items.map(coreTurnItemToThreadItem).filter((item) => item !== null),
+    itemsView: turn.items_view === "not_loaded" ? "notLoaded" : turn.items_view,
+    status: coreTurnStatusToAppServer(turn.status),
+    error: turn.error ? {
+      message: turn.error.message,
+      codexErrorInfo: turn.error.codex_error_info ?? null,
+      additionalDetails: turn.error.additional_details ?? null
+    } : null,
+    startedAt: epochSeconds(turn.started_at),
+    completedAt: epochSeconds(turn.completed_at),
+    durationMs: turn.duration_ms
+  };
+}
+function coreTurnStatusToAppServer(status) {
+  if (status === "in_progress") {
+    return "inProgress";
+  }
+  return status;
+}
+function epochSeconds(value) {
+  return typeof value === "number" ? value / 1e3 : null;
+}
+
+// src/internal/codex/app-server-transport/src/transport/mod.ts
+function parseJsonRpcTransportPayload(payload) {
+  let value;
+  if (typeof payload === "string") {
+    try {
+      value = JSON.parse(payload);
+    } catch {
+      return {
+        error: jsonRpcParseError("Parse error"),
+        id: null,
+        type: "invalid"
+      };
+    }
+  } else if (payload instanceof ArrayBuffer || ArrayBuffer.isView(payload)) {
+    const bytes = payload instanceof ArrayBuffer ? new Uint8Array(payload) : new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength);
+    try {
+      value = JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      return {
+        error: jsonRpcParseError("Parse error"),
+        id: null,
+        type: "invalid"
+      };
+    }
+  } else {
+    value = payload;
+  }
+  return parseJsonRpcMessage(value);
+}
+function parseJsonRpcMessage(value) {
+  if (!isRecord(value)) {
+    return {
+      error: jsonRpcInvalidRequestError("Invalid JSON-RPC message"),
+      id: null,
+      type: "invalid"
+    };
+  }
+  const candidateId = requestIdFromValue(value.id);
+  const id = candidateId ?? null;
+  if (typeof value.method === "string") {
+    if (candidateId !== null) {
+      return {
+        message: jsonRpcRequest(value.method, candidateId, value.params),
+        type: "ok"
+      };
+    }
+    if (Object.prototype.hasOwnProperty.call(value, "id")) {
+      return {
+        error: jsonRpcInvalidRequestError("Invalid JSON-RPC request id"),
+        id: null,
+        type: "invalid"
+      };
+    }
+    return {
+      message: jsonRpcNotification(value.method, value.params),
+      type: "ok"
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(value, "error")) {
+    if (!isJsonRpcErrorError(value.error)) {
+      return {
+        error: jsonRpcInvalidRequestError("Invalid JSON-RPC error object"),
+        id,
+        type: "invalid"
+      };
+    }
+    return {
+      message: { error: value.error, id },
+      type: "ok"
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(value, "result")) {
+    if (candidateId === null) {
+      return {
+        error: jsonRpcInvalidRequestError("Invalid JSON-RPC response id"),
+        id: null,
+        type: "invalid"
+      };
+    }
+    return {
+      message: { id: candidateId, result: value.result },
+      type: "ok"
+    };
+  }
+  return {
+    error: jsonRpcInvalidRequestError("Invalid JSON-RPC message"),
+    id,
+    type: "invalid"
+  };
+}
+function parseClientTransportPayload(payload) {
+  const parsed = parseJsonRpcTransportPayload(payload);
+  if (parsed.type === "invalid") {
+    return parsed;
+  }
+  return {
+    message: clientTransportMessage(parsed.message),
+    type: "ok"
+  };
+}
+function serializeOutgoingMessage(message) {
+  return JSON.stringify(message);
+}
+function serializeJsonRpcResponse(id, result) {
+  return serializeOutgoingMessage({ id, result });
+}
+function serializeJsonRpcError(id, error) {
+  return JSON.stringify({ error, id });
+}
+function jsonRpcParseError(message) {
+  return { code: -32700, message };
+}
+function jsonRpcInvalidRequestError(message) {
+  return { code: -32600, message };
+}
+function clientTransportMessage(message) {
+  if (isRequest(message)) {
+    return { request: message, type: "server_request" };
+  }
+  if (isNotification(message)) {
+    return {
+      notification: message,
+      type: "server_notification"
+    };
+  }
+  if (isError(message)) {
+    return { error: message, type: "error" };
+  }
+  return { response: message, type: "response" };
+}
+function jsonRpcRequest(method, id, params) {
+  return params === void 0 ? { id, method } : { id, method, params };
+}
+function jsonRpcNotification(method, params) {
+  return params === void 0 ? { method } : { method, params };
+}
+function isRequest(message) {
+  return typeof message.method === "string" && Object.prototype.hasOwnProperty.call(message, "id");
+}
+function isNotification(message) {
+  return typeof message.method === "string" && !Object.prototype.hasOwnProperty.call(message, "id");
+}
+function isError(message) {
+  return Object.prototype.hasOwnProperty.call(message, "error");
+}
+function requestIdFromValue(value) {
+  return typeof value === "string" || typeof value === "number" ? value : null;
+}
+function isJsonRpcErrorError(value) {
+  return isRecord(value) && typeof value.code === "number" && typeof value.message === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/internal/codex/app-server-client/src/remote.ts
+var CodexAppServerClientTransportError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "CodexAppServerClientTransportError";
+  }
+  status;
+  body;
+};
+function createCodexAppServerClient(options) {
+  let socket = null;
+  let openPromise = null;
+  let initializePromise = null;
+  let initialized = false;
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const eventQueue = createEventQueue();
+  async function ensureOpenSocket() {
+    const openState = 1;
+    if (socket?.readyState === openState) {
+      return socket;
+    }
+    openPromise ??= openSocket();
+    return openPromise;
+  }
+  async function ensureInitialized() {
+    if (initialized) {
+      return;
+    }
+    initializePromise ??= sendClientRequest({
+      id: 0,
+      method: "initialize",
+      params: await resolveInitializeParams(options.initializeParams)
+    });
+    await initializePromise;
+    initialized = true;
+  }
+  async function request(request2) {
+    if (request2.method !== "initialize") {
+      await ensureInitialized();
+      return sendClientRequest(request2);
+    }
+    const result = await sendClientRequest(request2);
+    initialized = true;
+    return result;
+  }
+  async function sendClientRequest(request2) {
+    const websocket = await ensureOpenSocket();
+    return new Promise((resolve, reject) => {
+      pendingRequests.set(request2.id, { reject, resolve });
+      try {
+        websocket.send(JSON.stringify(request2));
+      } catch (error) {
+        pendingRequests.delete(request2.id);
+        reject(error);
+      }
+    });
+  }
+  async function sendClientResponse(requestId, result) {
+    const websocket = await ensureOpenSocket();
+    websocket.send(serializeJsonRpcResponse(requestId, result));
+  }
+  async function sendClientError(requestId, error) {
+    const websocket = await ensureOpenSocket();
+    websocket.send(serializeJsonRpcError(requestId, error));
+  }
+  async function openSocket() {
+    options.onConnectionStatus?.("connecting");
+    eventQueue.reopen();
+    const WebSocketCtor = options.WebSocket ?? WebSocket;
+    const websocketUrl = await resolveUrl(options.url);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const nextSocket = new WebSocketCtor(websocketUrl);
+      socket = nextSocket;
+      nextSocket.addEventListener("open", () => {
+        settled = true;
+        options.onConnectionStatus?.("connected");
+        resolve(nextSocket);
+      });
+      nextSocket.addEventListener("message", (message) => {
+        handleSocketMessage(message.data);
+      });
+      nextSocket.addEventListener("close", () => {
+        const error = new CodexAppServerClientTransportError(
+          "Codex app-server WebSocket closed."
+        );
+        closeSocketState(error);
+        eventQueue.push({ message: "closed", type: "disconnected" });
+        eventQueue.close();
+        options.onConnectionStatus?.("closed");
+        if (!settled) {
+          reject(error);
+        }
+      });
+      nextSocket.addEventListener("error", () => {
+        const error = new CodexAppServerClientTransportError(
+          "Codex app-server WebSocket failed."
+        );
+        closeSocketState(error);
+        eventQueue.fail(error);
+        options.onConnectionStatus?.("error");
+        if (!settled) {
+          reject(error);
+        }
+      });
+    });
+  }
+  function handleSocketMessage(value) {
+    const parsed = parseClientTransportPayload(value);
+    if (parsed.type === "invalid") {
+      const event = options.parseEvent?.(value);
+      if (event) {
+        eventQueue.push(event);
+      }
+      return;
+    }
+    const message = parsed.message;
+    switch (message.type) {
+      case "response": {
+        const pending = pendingRequests.get(message.response.id);
+        if (!pending) {
+          return;
+        }
+        pendingRequests.delete(message.response.id);
+        pending.resolve(message.response.result);
+        return;
+      }
+      case "error": {
+        if (message.error.id === null) {
+          eventQueue.fail(message.error.error);
+          return;
+        }
+        const pending = pendingRequests.get(message.error.id);
+        if (!pending) {
+          return;
+        }
+        pendingRequests.delete(message.error.id);
+        pending.reject(message.error.error);
+        return;
+      }
+      case "server_notification":
+        eventQueue.push({
+          notification: message.notification,
+          type: "server_notification"
+        });
+        return;
+      case "server_request":
+        eventQueue.push({ request: message.request, type: "server_request" });
+        return;
+    }
+  }
+  function closeSocketState(error) {
+    socket = null;
+    openPromise = null;
+    initializePromise = null;
+    initialized = false;
+    for (const pending of pendingRequests.values()) {
+      pending.reject(error);
+    }
+    pendingRequests.clear();
+  }
+  function close() {
+    const currentSocket = socket;
+    closeSocketState(
+      new CodexAppServerClientTransportError(
+        "Codex app-server WebSocket closed."
+      )
+    );
+    eventQueue.close();
+    if (currentSocket && currentSocket.readyState !== 3) {
+      currentSocket.close();
+    }
+  }
+  return {
+    close,
+    events() {
+      void ensureInitialized().catch((error) => eventQueue.fail(error));
+      return eventQueue.iterable();
+    },
+    request,
+    requestTyped(clientRequest) {
+      return requestTyped(clientRequest, request);
+    },
+    rejectServerRequest(requestId, error) {
+      return sendClientError(requestId, error);
+    },
+    resolveServerRequest(requestId, result) {
+      return sendClientResponse(requestId, result);
+    }
+  };
+}
+function parseCodexAppServerEvent(value) {
+  const parsed = parseClientTransportPayload(value);
+  if (parsed.type === "ok") {
+    switch (parsed.message.type) {
+      case "server_notification":
+        return {
+          notification: parsed.message.notification,
+          type: "server_notification"
+        };
+      case "server_request":
+        return { request: parsed.message.request, type: "server_request" };
+      case "error":
+      case "response":
+        return null;
+    }
+  }
+  if (typeof value !== "string") {
+    return appServerEventFromParsed(value);
+  }
+  try {
+    return appServerEventFromParsed(JSON.parse(value));
+  } catch {
+    return null;
+  }
+}
+async function resolveInitializeParams(params) {
+  if (typeof params === "function") {
+    return params();
+  }
+  return params ?? defaultInitializeParams();
+}
+async function resolveUrl(url) {
+  return typeof url === "function" ? await url() : url;
+}
+function defaultInitializeParams() {
+  return {
+    capabilities: {
+      experimentalApi: false,
+      optOutNotificationMethods: []
+    },
+    clientInfo: {
+      name: "codex-js",
+      title: null,
+      version: "0.0.0"
+    }
+  };
+}
+function appServerEventFromParsed(value) {
+  if (isObject(value) && typeof value.type === "string") {
+    if (value.type === "server_notification" || value.type === "server_request" || value.type === "lagged" || value.type === "disconnected") {
+      return value;
+    }
+  }
+  if (isObject(value) && typeof value.method === "string" && "params" in value) {
+    if ("id" in value) {
+      return { request: value, type: "server_request" };
+    }
+    return {
+      notification: value,
+      type: "server_notification"
+    };
+  }
+  return null;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function createEventQueue() {
+  const values = [];
+  const waiters = [];
+  let closed = false;
+  let failure = null;
+  return {
+    close() {
+      closed = true;
+      for (const waiter of waiters.splice(0)) {
+        waiter.settled = true;
+        waiter.resolve({ done: true, value: void 0 });
+      }
+    },
+    fail(error) {
+      failure = error;
+      for (const waiter of waiters.splice(0)) {
+        waiter.settled = true;
+        waiter.reject(error);
+      }
+    },
+    push(value) {
+      while (waiters.length > 0) {
+        const waiter = waiters.shift();
+        if (waiter.settled) {
+          continue;
+        }
+        waiter.settled = true;
+        waiter.resolve({ done: false, value });
+        return;
+      }
+      values.push(value);
+    },
+    reopen() {
+      values.splice(0);
+      closed = false;
+      failure = null;
+    },
+    iterable(options = {}) {
+      return {
+        [Symbol.asyncIterator]() {
+          let active = true;
+          let pendingWaiter = null;
+          return {
+            next() {
+              if (!active) {
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              if (failure) {
+                return Promise.reject(failure);
+              }
+              if (values.length > 0) {
+                return Promise.resolve({
+                  done: false,
+                  value: values.shift()
+                });
+              }
+              if (closed) {
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              return new Promise((resolve, reject) => {
+                const waiter = { reject, resolve, settled: false };
+                pendingWaiter = waiter;
+                waiters.push(waiter);
+              });
+            },
+            return() {
+              options.onReturn?.();
+              active = false;
+              if (pendingWaiter && !pendingWaiter.settled) {
+                pendingWaiter.settled = true;
+                const index = waiters.indexOf(pendingWaiter);
+                if (index !== -1) {
+                  waiters.splice(index, 1);
+                }
+                pendingWaiter.resolve({ done: true, value: void 0 });
+              }
+              return Promise.resolve({ done: true, value: void 0 });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+
+// src/internal/codex/app-server-client/src/session.ts
+var AppServerSession = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  nextRequestIdValue = 1;
+  nextRequestId() {
+    const requestId = this.nextRequestIdValue;
+    this.nextRequestIdValue += 1;
+    return requestId;
+  }
+  nextEvent() {
+    return this.client.nextEvent?.() ?? Promise.resolve(null);
+  }
+  events() {
+    return this.client.events?.() ?? null;
+  }
+  requestTyped(request) {
+    return this.client.requestTyped(request);
+  }
+  initialize(params = defaultInitializeParams2()) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "initialize",
+      params
+    });
+  }
+  threadStart(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/start",
+      params
+    });
+  }
+  threadResume(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/resume",
+      params
+    });
+  }
+  threadList(params = {}) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/list",
+      params
+    });
+  }
+  collaborationModeList(params = {}) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "collaborationMode/list",
+      params
+    });
+  }
+  configMcpServerReload() {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "config/mcpServer/reload",
+      params: void 0
+    });
+  }
+  mcpServerStatusList(params = {}) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "mcpServerStatus/list",
+      params
+    });
+  }
+  mcpResourceRead(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "mcpServer/resource/read",
+      params
+    });
+  }
+  mcpServerToolCall(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "mcpServer/tool/call",
+      params
+    });
+  }
+  mcpServerOauthLogin(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "mcpServer/oauth/login",
+      params
+    });
+  }
+  threadRead(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/read",
+      params
+    });
+  }
+  threadNameSet(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/name/set",
+      params
+    });
+  }
+  threadArchive(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/archive",
+      params
+    });
+  }
+  threadUnarchive(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/unarchive",
+      params
+    });
+  }
+  threadMetadataUpdate(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/metadata/update",
+      params
+    });
+  }
+  turnStart(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "turn/start",
+      params
+    });
+  }
+  turnSteer(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "turn/steer",
+      params
+    });
+  }
+  turnInterrupt(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "turn/interrupt",
+      params
+    });
+  }
+  threadCompactStart(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/compact/start",
+      params
+    });
+  }
+  resolveServerRequest(requestId, result) {
+    return this.client.resolveServerRequest(requestId, result);
+  }
+  rejectServerRequest(requestId, error) {
+    return this.client.rejectServerRequest(requestId, error);
+  }
+};
+function defaultInitializeParams2() {
+  return {
+    capabilities: {
+      experimentalApi: false,
+      optOutNotificationMethods: []
+    },
+    clientInfo: {
+      name: "codex-js",
+      title: null,
+      version: "0.0.0"
+    }
+  };
+}
+
+// src/internal/codex/app-server-client/src/pending_requests.ts
+var PendingAppServerRequests = class {
+  dynamicToolCalls = /* @__PURE__ */ new Map();
+  execApprovals = /* @__PURE__ */ new Map();
+  fileChangeApprovals = /* @__PURE__ */ new Map();
+  mcpRequests = /* @__PURE__ */ new Map();
+  permissionsApprovals = /* @__PURE__ */ new Map();
+  userInputs = /* @__PURE__ */ new Map();
+  clear() {
+    this.dynamicToolCalls.clear();
+    this.execApprovals.clear();
+    this.fileChangeApprovals.clear();
+    this.mcpRequests.clear();
+    this.permissionsApprovals.clear();
+    this.userInputs.clear();
+  }
+  noteServerRequest(request) {
+    switch (request.method) {
+      case "item/commandExecution/requestApproval": {
+        const id = request.params.approvalId ?? request.params.itemId;
+        this.execApprovals.set(id, request.id);
+        return null;
+      }
+      case "item/fileChange/requestApproval":
+        this.fileChangeApprovals.set(request.params.itemId, request.id);
+        return null;
+      case "item/permissions/requestApproval":
+        this.permissionsApprovals.set(request.params.itemId, request.id);
+        return null;
+      case "item/tool/requestUserInput": {
+        const queue = this.userInputs.get(request.params.turnId) ?? [];
+        queue.push({
+          itemId: request.params.itemId,
+          requestId: request.id
+        });
+        this.userInputs.set(request.params.turnId, queue);
+        return null;
+      }
+      case "mcpServer/elicitation/request":
+        this.mcpRequests.set(
+          mcpRequestKey(request.params.serverName, request.id),
+          request.id
+        );
+        return null;
+      case "item/tool/call":
+        this.dynamicToolCalls.set(request.params.callId, request.id);
+        return null;
+      default:
+        return {
+          message: `Unsupported Codex app-server request: ${request.method}`,
+          requestId: request.id
+        };
+    }
+  }
+  takeCommandExecutionApprovalResolution(id, response) {
+    return takeMapResolution(this.execApprovals, id, response);
+  }
+  takeFileChangeApprovalResolution(id, response) {
+    return takeMapResolution(this.fileChangeApprovals, id, response);
+  }
+  takePermissionsApprovalResolution(id, response) {
+    return takeMapResolution(this.permissionsApprovals, id, response);
+  }
+  takeDynamicToolCallResolution(callId, response) {
+    return takeMapResolution(this.dynamicToolCalls, callId, response);
+  }
+  takeUserInputResolution(turnId, response) {
+    const pending = this.popUserInputRequestForTurn(turnId);
+    return pending ? { requestId: pending.requestId, result: response } : null;
+  }
+  takeMcpElicitationResolution(serverName, requestId, response) {
+    return takeMapResolution(
+      this.mcpRequests,
+      mcpRequestKey(serverName, requestId),
+      response
+    );
+  }
+  resolveNotification(requestId) {
+    const execApproval = removeValue(this.execApprovals, requestId);
+    if (execApproval) {
+      return { id: execApproval, type: "exec_approval" };
+    }
+    const fileChangeApproval = removeValue(
+      this.fileChangeApprovals,
+      requestId
+    );
+    if (fileChangeApproval) {
+      return { id: fileChangeApproval, type: "file_change_approval" };
+    }
+    const permissionsApproval = removeValue(
+      this.permissionsApprovals,
+      requestId
+    );
+    if (permissionsApproval) {
+      return { id: permissionsApproval, type: "permissions_approval" };
+    }
+    const userInput = this.removeUserInputRequest(requestId);
+    if (userInput) {
+      return { itemId: userInput.itemId, type: "user_input" };
+    }
+    const dynamicToolCall = removeValue(this.dynamicToolCalls, requestId);
+    if (dynamicToolCall) {
+      return { callId: dynamicToolCall, type: "dynamic_tool_call" };
+    }
+    const mcpRequest = removeValue(this.mcpRequests, requestId);
+    if (mcpRequest) {
+      const [serverName] = mcpRequest.split(":");
+      return { requestId, serverName, type: "mcp_elicitation" };
+    }
+    return null;
+  }
+  containsServerRequest(request) {
+    return this.requestIds().some((requestId) => requestId === request.id);
+  }
+  requestIds() {
+    return [
+      ...this.execApprovals.values(),
+      ...this.fileChangeApprovals.values(),
+      ...this.permissionsApprovals.values(),
+      ...this.dynamicToolCalls.values(),
+      ...this.mcpRequests.values(),
+      ...Array.from(this.userInputs.values()).flatMap(
+        (queue) => queue.map((request) => request.requestId)
+      )
+    ];
+  }
+  popUserInputRequestForTurn(turnId) {
+    const queue = this.userInputs.get(turnId);
+    const pending = queue?.shift() ?? null;
+    if (queue && queue.length === 0) {
+      this.userInputs.delete(turnId);
+    }
+    return pending;
+  }
+  removeUserInputRequest(requestId) {
+    for (const [turnId, queue] of this.userInputs) {
+      const index = queue.findIndex((pending2) => pending2.requestId === requestId);
+      if (index === -1) {
+        continue;
+      }
+      const [pending] = queue.splice(index, 1);
+      if (queue.length === 0) {
+        this.userInputs.delete(turnId);
+      }
+      return pending ?? null;
+    }
+    return null;
+  }
+};
+function takeMapResolution(map, key, result) {
+  const requestId = map.get(key);
+  if (requestId === void 0) {
+    return null;
+  }
+  map.delete(key);
+  return { requestId, result };
+}
+function removeValue(map, value) {
+  for (const [key, current] of map) {
+    if (current === value) {
+      map.delete(key);
+      return key;
+    }
+  }
+  return null;
+}
+function mcpRequestKey(serverName, requestId) {
+  return `${serverName}:${requestId}`;
+}
+
+// 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 serverRequestThreadId(request) {
+  if ("params" in request && request.params && typeof request.params === "object") {
+    const threadId = request.params.threadId;
+    return typeof threadId === "string" ? threadId : null;
+  }
+  return null;
+}
+function serverNotificationThreadTarget(notification) {
+  const threadId = notificationThreadId(notification);
+  if (!threadId) {
+    return { type: "global" };
+  }
+  return isUuidLike(threadId) ? { threadId, type: "thread" } : { threadId, type: "invalid_thread_id" };
+}
+function threadEventSnapshotHasStarted(snapshot) {
+  if (!snapshot) {
+    return false;
+  }
+  return snapshot.turns.some((turn) => turn.items.length > 0) || snapshot.activeTurnIds.length > 0 || snapshot.pendingRequests.length > 0 || snapshot.warnings.length > 0 || snapshot.errors.length > 0;
+}
+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];
+}
+function isUuidLike(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value);
+}
+
+// src/internal/codex/app-server-client/src/lib.ts
+async function requestTyped(request, send) {
+  try {
+    return await send(request);
+  } catch (source) {
+    if (isJsonRpcError(source)) {
+      throw {
+        method: request.method,
+        source,
+        type: "server"
+      };
+    }
+    throw {
+      method: request.method,
+      source,
+      type: "transport"
+    };
+  }
+}
+function serverNotificationRequiresDelivery(notification) {
+  return notification.method === "turn/completed" || notification.method === "item/completed" || notification.method === "item/agentMessage/delta" || notification.method === "item/plan/delta" || notification.method === "item/reasoning/summaryTextDelta" || notification.method === "item/reasoning/textDelta";
+}
+function requestMethodName(request) {
+  return request.method;
+}
+function isJsonRpcError(value) {
+  return typeof value === "object" && value !== null && typeof value.code === "number" && typeof value.message === "string";
+}
+
+// src/internal/codex/core/src/model-provider.ts
+var defaultCodexModel = "gpt-5.5";
+var defaultCodexReasoningEffort = "medium";
+var DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 95;
+var reasoningOptions = [
+  { reasoning_effort: "low", description: "Fast responses with lighter reasoning." },
+  { reasoning_effort: "medium", description: "Balanced speed and reasoning depth." },
+  { reasoning_effort: "high", description: "Deeper reasoning for complex planning." },
+  { reasoning_effort: "xhigh", description: "Maximum reasoning depth for hard tasks." }
+];
+var StaticModelsManager = class {
+  models;
+  constructor(models = defaultCodexModelInfo()) {
+    this.models = [...models];
+  }
+  list_models(params = {}) {
+    const presets = this.build_available_models();
+    const visible = params.include_hidden ? presets : presets.filter((model) => !model.hidden);
+    const total = visible.length;
+    const limit = Math.max(1, Math.min(total || 1, params.limit ?? (total || 1)));
+    const start = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    if (!Number.isInteger(start) || start < 0 || start > total) {
+      throw new Error(`invalid cursor: ${params.cursor}`);
+    }
+    const end = Math.min(total, start + limit);
+    return {
+      data: visible.slice(start, end),
+      next_cursor: end < total ? String(end) : null
+    };
+  }
+  raw_model_catalog() {
+    return { models: [...this.models] };
+  }
+  get_model_info(model) {
+    return findModelByLongestPrefix(model, this.models) ?? findModelByNamespacedSuffix(model, this.models) ?? modelInfoFromSlug(model);
+  }
+  get_default_model(model) {
+    if (model) {
+      return model;
+    }
+    const selected = this.build_available_models().find((preset) => preset.is_default);
+    return selected?.model ?? this.build_available_models()[0]?.model ?? defaultCodexModel;
+  }
+  default_reasoning_effort(model) {
+    const info = this.get_model_info(this.get_default_model(model));
+    return info.default_reasoning_level ?? defaultCodexReasoningEffort;
+  }
+  build_available_models() {
+    const sorted = [...this.models].sort((left, right) => left.priority - right.priority);
+    const presets = sorted.map(modelInfoToPreset);
+    markDefaultByPickerVisibility(presets);
+    return presets;
+  }
+};
+function defaultModelsManager() {
+  return new StaticModelsManager();
+}
+function defaultCodexModelInfo() {
+  return [
+    {
+      slug: "gpt-5.5",
+      display_name: "GPT-5.5",
+      description: "Frontier model for complex planning and implementation.",
+      default_reasoning_level: defaultCodexReasoningEffort,
+      supported_reasoning_levels: reasoningOptions,
+      visibility: "list",
+      supported_in_api: true,
+      priority: 0,
+      upgrade: null,
+      upgrade_info: null,
+      availability_nux: null,
+      input_modalities: ["text", "image"],
+      supports_personality: true,
+      additional_speed_tiers: [],
+      service_tiers: [],
+      base_instructions: BASE_INSTRUCTIONS_DEFAULT,
+      model_messages: null,
+      context_window: 272e3,
+      max_context_window: null,
+      auto_compact_token_limit: null,
+      effective_context_window_percent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT
+    },
+    {
+      slug: "gpt-5.4",
+      display_name: "GPT-5.4",
+      description: "Strong everyday model for coding and product work.",
+      default_reasoning_level: defaultCodexReasoningEffort,
+      supported_reasoning_levels: reasoningOptions,
+      visibility: "list",
+      supported_in_api: true,
+      priority: 1,
+      upgrade: null,
+      upgrade_info: null,
+      availability_nux: null,
+      input_modalities: ["text", "image"],
+      supports_personality: true,
+      additional_speed_tiers: [],
+      service_tiers: [],
+      base_instructions: BASE_INSTRUCTIONS_DEFAULT,
+      model_messages: null,
+      context_window: 272e3,
+      max_context_window: null,
+      auto_compact_token_limit: null,
+      effective_context_window_percent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT
+    },
+    {
+      slug: "gpt-5.4-mini",
+      display_name: "GPT-5.4 Mini",
+      description: "Faster, smaller model for simple chat and iteration.",
+      default_reasoning_level: defaultCodexReasoningEffort,
+      supported_reasoning_levels: reasoningOptions.filter(
+        (option) => option.reasoning_effort !== "xhigh"
+      ),
+      visibility: "list",
+      supported_in_api: true,
+      priority: 2,
+      upgrade: null,
+      upgrade_info: null,
+      availability_nux: null,
+      input_modalities: ["text", "image"],
+      supports_personality: true,
+      additional_speed_tiers: [],
+      service_tiers: [],
+      base_instructions: BASE_INSTRUCTIONS_DEFAULT,
+      model_messages: null,
+      context_window: 128e3,
+      max_context_window: null,
+      auto_compact_token_limit: null,
+      effective_context_window_percent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT
+    }
+  ];
+}
+function modelInfoToPreset(info) {
+  return {
+    id: info.slug,
+    model: info.slug,
+    upgrade: info.upgrade,
+    upgrade_info: info.upgrade_info,
+    availability_nux: info.availability_nux,
+    display_name: info.display_name,
+    description: info.description ?? info.display_name,
+    hidden: info.visibility !== "list",
+    supported_reasoning_efforts: info.supported_reasoning_levels,
+    default_reasoning_effort: info.default_reasoning_level ?? defaultCodexReasoningEffort,
+    input_modalities: info.input_modalities,
+    supports_personality: info.supports_personality,
+    additional_speed_tiers: info.additional_speed_tiers,
+    service_tiers: info.service_tiers,
+    is_default: false,
+    supported_in_api: info.supported_in_api
+  };
+}
+function modelInfoFromSlug(slug) {
+  const known = defaultCodexModelInfo().find((model) => model.slug === slug);
+  if (known) {
+    return known;
+  }
+  return {
+    slug,
+    display_name: slug,
+    description: null,
+    default_reasoning_level: defaultCodexReasoningEffort,
+    supported_reasoning_levels: reasoningOptions,
+    visibility: "none",
+    supported_in_api: true,
+    priority: 99,
+    upgrade: null,
+    upgrade_info: null,
+    availability_nux: null,
+    input_modalities: ["text", "image"],
+    supports_personality: false,
+    additional_speed_tiers: [],
+    service_tiers: [],
+    base_instructions: BASE_INSTRUCTIONS_DEFAULT,
+    model_messages: null,
+    context_window: null,
+    max_context_window: null,
+    auto_compact_token_limit: null,
+    effective_context_window_percent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT
+  };
+}
+function isReasoningEffortSupported(model, effort, manager = defaultModelsManager()) {
+  if (!effort) {
+    return false;
+  }
+  return manager.get_model_info(model).supported_reasoning_levels.some((option) => option.reasoning_effort === effort);
+}
+function resolveReasoningEffortForModel(model, effort, manager = defaultModelsManager()) {
+  return isReasoningEffortSupported(model, effort, manager) ? effort : manager.default_reasoning_effort(model);
+}
+function markDefaultByPickerVisibility(presets) {
+  for (const preset of presets) {
+    preset.is_default = false;
+  }
+  const visibleDefault = presets.find((preset) => preset.model === defaultCodexModel && !preset.hidden) ?? presets.find((preset) => !preset.hidden) ?? presets[0];
+  if (visibleDefault) {
+    visibleDefault.is_default = true;
+  }
+}
+function findModelByLongestPrefix(model, candidates) {
+  let best = null;
+  for (const candidate of candidates) {
+    if (!model.startsWith(candidate.slug)) {
+      continue;
+    }
+    if (!best || candidate.slug.length > best.slug.length) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+function findModelByNamespacedSuffix(model, candidates) {
+  const [namespace, suffix, extra] = model.split("/");
+  if (!namespace || !suffix || extra) {
+    return null;
+  }
+  if (!/^[A-Za-z0-9_-]+$/.test(namespace)) {
+    return null;
+  }
+  return findModelByLongestPrefix(suffix, candidates);
+}
+
+// src/internal/codex/core/src/ids.ts
+function asThreadId(value) {
+  const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+  if (!uuidPattern.test(value)) {
+    throw new Error(`Invalid ThreadId: ${value}`);
+  }
+  return value;
+}
+
+// src/internal/codex/app-server/src/request_processors/token_usage_replay.ts
+function latest_token_usage_turn_id_from_rollout_items(rolloutItems, turns) {
+  const builder = new ThreadHistoryBuilder();
+  let tokenUsageTurnOwner = null;
+  for (const item of rolloutItems) {
+    if (item.type === "event_msg" && item.payload.type === "token_count") {
+      const turn = builder.active_turn_snapshot();
+      tokenUsageTurnOwner = turn ? {
+        id: appServerTurnFromCoreTurn(turn).id,
+        position: builder.active_turn_position()
+      } : null;
+    }
+    builder.handle_rollout_item(item);
+  }
+  if (!tokenUsageTurnOwner) {
+    return null;
+  }
+  if (turns.some((turn) => turn.id === tokenUsageTurnOwner.id)) {
+    return tokenUsageTurnOwner.id;
+  }
+  return tokenUsageTurnOwner.position === null ? null : turns[tokenUsageTurnOwner.position]?.id ?? null;
+}
+function latest_token_usage_turn_id(thread) {
+  return [...thread.turns].reverse().find((turn) => turn.status === "completed" || turn.status === "failed")?.id ?? thread.turns.at(-1)?.id ?? "";
+}
+function last_token_info_from_rollout_items(rolloutItems) {
+  for (let index = rolloutItems.length - 1; index >= 0; index -= 1) {
+    const item = rolloutItems[index];
+    if (item?.type === "event_msg" && item.payload.type === "token_count" && item.payload.info) {
+      return item.payload.info;
+    }
+  }
+  return null;
+}
+function thread_token_usage_updated_notification_from_info(input) {
+  const params = {
+    threadId: String(input.threadId),
+    turnId: input.tokenUsageTurnId ?? latest_token_usage_turn_id(input.thread),
+    tokenUsage: threadTokenUsageFromTokenUsageInfo(input.tokenUsageInfo)
+  };
+  return {
+    method: "thread/tokenUsage/updated",
+    params
+  };
+}
+function thread_token_usage_updated_notification_from_rollout_items(input) {
+  const tokenUsageInfo = last_token_info_from_rollout_items(input.rolloutItems);
+  if (!tokenUsageInfo) {
+    return null;
+  }
+  return thread_token_usage_updated_notification_from_info({
+    thread: input.thread,
+    threadId: input.threadId,
+    tokenUsageInfo,
+    tokenUsageTurnId: latest_token_usage_turn_id_from_rollout_items(
+      input.rolloutItems,
+      input.thread.turns
+    )
+  });
+}
+
+export { AppServerSession, CodexAppServerClientTransportError, PendingAppServerRequests, ThreadEventStore, asThreadId, createCodexAppServerClient, defaultModelsManager, parseCodexAppServerEvent, requestMethodName, requestTyped, resolveReasoningEffortForModel, serverNotificationRequiresDelivery, serverNotificationThreadTarget, serverRequestThreadId, threadEventSnapshotHasStarted, thread_token_usage_updated_notification_from_rollout_items };