remote-codex 0.11.39 → 0.11.41

package/apps/supervisor-api/dist/index.js

@@ -11717,6 +11717,54 @@ import { pathToFileURL } from "url";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var promptPhotoTokenPattern2 = /\[PHOTO\s+([^\]]+)\]/g;
+var claudeCompactSummaryPrefix = "This session is being continued from a previous conversation that ran out of context.";
+var activeTranscriptMatchWindowMs = 12e4;
+function isClaudeCompactBoundaryMessage(message) {
+  if (message.type !== "system") {
+    return false;
+  }
+  if (message.subtype === "compact_boundary" || message.compact_metadata) {
+    return true;
+  }
+  return isRecord8(message.message) && (message.message.subtype === "compact_boundary" || isRecord8(message.message.compact_metadata));
+}
+function isClaudeCompactSummaryMessage(message) {
+  if (message.type !== "user" || message.parent_tool_use_id) {
+    return false;
+  }
+  const payload = isRecord8(message.message) ? message.message : null;
+  if (message.isCompactSummary || message.is_compact_summary || payload?.isCompactSummary === true || payload?.is_compact_summary === true) {
+    return true;
+  }
+  return messageContentText(message.message).trim().startsWith(claudeCompactSummaryPrefix);
+}
+function claudeContextCompactionItem(id, status, error = null) {
+  const completed = status === "completed";
+  const failed = status === "failed";
+  const text2 = failed ? "Context compaction failed" : completed ? "Context compacted" : "Compacting context";
+  return {
+    id,
+    kind: "contextCompaction",
+    text: text2,
+    previewText: text2,
+    detailText: failed ? error : null,
+    status
+  };
+}
+function normalizePromptForTurnReconciliation(value) {
+  return value.replace(/\[PHOTO\s+[^\]]+\]/g, " ").replace(/\s+/g, " ").trim();
+}
+function userPromptForTurn(turn) {
+  return turn.items.find((item) => item.kind === "userMessage")?.text ?? null;
+}
+function isRecentActiveTranscriptTurn(turn, activeStartedAt) {
+  if (!turn.startedAt) {
+    return true;
+  }
+  const transcriptStartedAt = Date.parse(turn.startedAt);
+  const activeStartedAtMs = Date.parse(activeStartedAt);
+  return !Number.isFinite(transcriptStartedAt) || !Number.isFinite(activeStartedAtMs) || Math.abs(transcriptStartedAt - activeStartedAtMs) <= activeTranscriptMatchWindowMs;
+}
 function mimeTypeForImagePath(filePath) {
   const extension = path10.extname(filePath).toLowerCase();
   switch (extension) {
@@ -12908,7 +12956,8 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       suppressedToolUseIds: /* @__PURE__ */ new Set(),
       assistantUsage: null,
       resultUsage: null,
-      modelContextWindow: null
+      modelContextWindow: null,
+      currentCompactionItemId: null
     };
     this.knownSessionIds.add(input.providerSessionId);
     let sessionPrompts = this.liveUserPrompts.get(input.providerSessionId);
@@ -12993,9 +13042,11 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     }
     const activeUserItem = userMessageHistoryItem(`${activeTurn.providerTurnId}:user`, prompt);
     const activeItems = [...activeTurn.itemOrder].map((itemId) => activeTurn.items.get(itemId)).filter((item) => Boolean(item));
-    const transcriptTurnIndex = turns.findLastIndex(
-      (turn) => turn.status === "completed" && turn.items.some((item) => item.kind === "userMessage") && !turn.items.some((item) => item.kind === "agentMessage")
-    );
+    const normalizedPrompt = normalizePromptForTurnReconciliation(prompt);
+    const transcriptTurnIndex = turns.findLastIndex((turn) => {
+      const transcriptPrompt = userPromptForTurn(turn);
+      return turn.status === "completed" && transcriptPrompt !== null && normalizePromptForTurnReconciliation(transcriptPrompt) === normalizedPrompt && !turn.items.some((item) => item.kind === "agentMessage") && isRecentActiveTranscriptTurn(turn, activeTurn.startedAt);
+    });
     if (transcriptTurnIndex < 0) {
       return turns;
     }
@@ -13006,6 +13057,11 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         aliases = /* @__PURE__ */ new Map();
         this.historicalTurnIdAliases.set(providerSessionId, aliases);
       }
+      for (const [historicalTurnId, displayTurnId] of aliases) {
+        if (displayTurnId === activeTurn.providerTurnId && historicalTurnId !== transcriptTurn.providerTurnId) {
+          aliases.delete(historicalTurnId);
+        }
+      }
       aliases.set(transcriptTurn.providerTurnId, activeTurn.providerTurnId);
     }
     return turns.map((turn, index) => {
@@ -13028,9 +13084,16 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     if (!aliases || aliases.size === 0) {
       return turns;
     }
+    const rawTurnIds = new Set(turns.map((turn) => turn.providerTurnId));
+    const usedTurnIds = /* @__PURE__ */ new Set();
     return turns.map((turn) => {
       const providerTurnId = aliases.get(turn.providerTurnId);
-      return providerTurnId ? { ...turn, providerTurnId } : turn;
+      if (!providerTurnId || usedTurnIds.has(providerTurnId) || providerTurnId !== turn.providerTurnId && rawTurnIds.has(providerTurnId)) {
+        usedTurnIds.add(turn.providerTurnId);
+        return turn;
+      }
+      usedTurnIds.add(providerTurnId);
+      return { ...turn, providerTurnId };
     });
   }
   async listMcpServers() {
@@ -13118,6 +13181,53 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       }
       return;
     }
+    if (message.type === "system" && message.subtype === "status") {
+      if (message.status === "compacting") {
+        const existing = state.currentCompactionItemId ? state.items.get(state.currentCompactionItemId) : null;
+        const itemId = existing?.status === "running" ? existing.id : `claude-compaction-${messageUuid(message, randomUUID2())}`;
+        state.currentCompactionItemId = itemId;
+        const item = withHistoryItemCreatedAt(
+          claudeContextCompactionItem(itemId, "running"),
+          messageCreatedAt
+        );
+        addOrUpdateItem(state, item);
+        this.emitItem(state, item, "item.started", { force: Boolean(existing) });
+        return;
+      }
+      if (message.compact_result) {
+        const itemId = state.currentCompactionItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+        const status = message.compact_result === "success" ? "completed" : "failed";
+        const item = withHistoryItemCreatedAt(
+          claudeContextCompactionItem(itemId, status, message.compact_error ?? null),
+          messageCreatedAt
+        );
+        addOrUpdateItem(state, item);
+        this.emitItem(state, item, "item.completed");
+        state.currentCompactionItemId = status === "failed" ? null : itemId;
+        return;
+      }
+      return;
+    }
+    if (isClaudeCompactBoundaryMessage(message)) {
+      const itemId = state.currentCompactionItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+      const previous = state.items.get(itemId);
+      const item = withHistoryItemCreatedAt(
+        claudeContextCompactionItem(itemId, "completed"),
+        previous?.createdAt ?? messageCreatedAt
+      );
+      addOrUpdateItem(state, item);
+      if (!previous) {
+        this.emitItem(state, item, "item.started");
+      }
+      if (previous?.status !== "completed") {
+        this.emitItem(state, item, "item.completed");
+      }
+      state.currentCompactionItemId = null;
+      return;
+    }
+    if (isClaudeCompactSummaryMessage(message)) {
+      return;
+    }
     if (message.type === "stream_event") {
       const nextStreamMessageId = streamMessageId(message.event);
       if (nextStreamMessageId) {
@@ -13469,6 +13579,8 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     const turns = [];
     let current = null;
     let skippingHiddenInit = false;
+    let pendingCompactSummaryItemId = null;
+    let pendingCompactBoundaryItemId = null;
     const suppressedToolUseIds = /* @__PURE__ */ new Set();
     const upsertCurrentItem = (item) => {
       if (!current) {
@@ -13500,6 +13612,18 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       current.itemsById.set(item.id, item);
     };
     for (const message of messages) {
+      if (isClaudeCompactBoundaryMessage(message)) {
+        const itemId = pendingCompactSummaryItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+        pendingCompactSummaryItemId = null;
+        pendingCompactBoundaryItemId = itemId;
+        upsertCurrentItem(
+          withHistoryItemCreatedAt(
+            claudeContextCompactionItem(itemId, "completed"),
+            sessionMessageTimestamp(message) ?? current?.startedAt
+          )
+        );
+        continue;
+      }
       if (message.type === "user") {
         const taskNotification = taskNotificationToolResult(message.message);
         if (taskNotification) {
@@ -13544,6 +13668,20 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         }
       }
       if (message.type === "user" && !message.parent_tool_use_id) {
+        if (isClaudeCompactSummaryMessage(message)) {
+          const itemId = pendingCompactBoundaryItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+          if (!pendingCompactBoundaryItemId) {
+            pendingCompactSummaryItemId = itemId;
+          }
+          pendingCompactBoundaryItemId = null;
+          upsertCurrentItem(
+            withHistoryItemCreatedAt(
+              claudeContextCompactionItem(itemId, "completed"),
+              sessionMessageTimestamp(message) ?? current?.startedAt
+            )
+          );
+          continue;
+        }
         if (isHiddenInitMessage(message.message)) {
           skippingHiddenInit = true;
           current = null;
@@ -13563,19 +13701,19 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
             items: current.items
           }));
         }
-        const messageUuid2 = message.uuid ?? randomUUID2();
-        const userStartedAt = isoFromUuidV7(messageUuid2);
+        const userMessageUuid = message.uuid ?? randomUUID2();
+        const userStartedAt = isoFromUuidV7(userMessageUuid);
         const userItem = await this.userMessageToHistoryItem(
-          messageUuid2,
+          userMessageUuid,
           message.message,
           context
         );
         const stampedUserItem = withHistoryItemCreatedAt(userItem, userStartedAt);
         current = {
-          providerTurnId: `claude-turn-${messageUuid2}`,
+          providerTurnId: `claude-turn-${userMessageUuid}`,
           startedAt: userStartedAt,
           items: [stampedUserItem],
-          itemsById: /* @__PURE__ */ new Map([[messageUuid2, stampedUserItem]])
+          itemsById: /* @__PURE__ */ new Map([[userMessageUuid, stampedUserItem]])
         };
         continue;
       }