@jrkropp/codex-js 0.1.1 → 0.1.3

package/dist/chunk-DYLHN3HG.js

@@ -0,0 +1,937 @@
+// src/upstream/codex-rs/core/src/event-mapping.ts
+var CONTEXTUAL_DEVELOPER_PREFIXES = [
+  "<permissions instructions>",
+  "<developer_instructions>",
+  "<model_switch>",
+  "<collaboration_mode>",
+  "<realtime_conversation>",
+  "<personality_spec>",
+  "<hook_additional_context>"
+];
+function isContextualUserMessageContent(message) {
+  return message.some(isContextualUserFragment);
+}
+function isContextualDevMessageContent(message) {
+  return message.some(isContextualDevFragment);
+}
+function hasNonContextualDevMessageContent(message) {
+  return message.some((contentItem) => !isContextualDevFragment(contentItem));
+}
+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 isContextualDevFragment(contentItem) {
+  if (contentItem.type !== "input_text") {
+    return false;
+  }
+  const trimmed = contentItem.text.trimStart();
+  return CONTEXTUAL_DEVELOPER_PREFIXES.some(
+    (prefix) => trimmed.slice(0, prefix.length).toLowerCase() === prefix.toLowerCase()
+  );
+}
+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/upstream/codex-rs/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 buildTurnsFromRolloutItems(items) {
+  const builder = new ThreadHistoryBuilder();
+  for (const [index, item] of items.entries()) {
+    builder.handle_rollout_item(item, index);
+  }
+  return builder.finish();
+}
+function applyEventToThreadHistoryBuilder(builder, event, eventId) {
+  builder.handle_event(event, eventId);
+  return builder;
+}
+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/upstream/codex-rs/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 setRenderedThreadConnectionStatus(state, connectionStatus) {
+  return {
+    ...state,
+    connection_status: connectionStatus
+  };
+}
+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);
+}
+
+export { ThreadHistoryBuilder, appendCompactionTurnToTurns, applyEventMsgToRenderedThread, applyEventToThreadHistoryBuilder, applyEventToTurns, applyResponseItemToTurns, applyRolloutItemToRenderedThread, buildTurnsFromRolloutItems, createRenderedThreadState, fingerprintRolloutItems, flattenTurnsToTurnItems, hasNonContextualDevMessageContent, isContextualDevMessageContent, isContextualUserMessageContent, parseAgentMessage, parseTurnItem, parseUserMessage, parseVisibleHookPromptMessage, renderThreadFromHistory, setRenderedThreadConnectionStatus };
+//# sourceMappingURL=chunk-DYLHN3HG.js.map
+//# sourceMappingURL=chunk-DYLHN3HG.js.map