lody 0.93.2 → 0.94.0

package/dist/chunks/{index-Bxge7nr7.js → index-rdPvrzqi.js}

@@ -21253,6 +21253,57 @@ function toPromptUsage(tokenCount) {
     thoughtTokens: tokenCount.reasoningOutputTokens
   };
 }
+var CODEX_UNATTRIBUTED_MODEL = "codex:unattributed";
+var counters = [
+  "inputTokens",
+  "outputTokens",
+  "cacheReadInputTokens",
+  "cacheCreationInputTokens",
+  "reasoningOutputTokens"
+];
+var empty = () => ({
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadInputTokens: 0,
+  cacheCreationInputTokens: 0,
+  reasoningOutputTokens: 0
+});
+function normalizeCodexUsage(raw) {
+  return {
+    inputTokens: Math.max(0, raw.inputTokens - raw.cachedInputTokens - raw.cacheWriteInputTokens),
+    outputTokens: Math.max(0, raw.outputTokens - raw.reasoningOutputTokens),
+    cacheReadInputTokens: raw.cachedInputTokens,
+    cacheCreationInputTokens: raw.cacheWriteInputTokens,
+    reasoningOutputTokens: raw.reasoningOutputTokens
+  };
+}
+var CodexUsageAccounting = class {
+  offset = empty();
+  total = empty();
+  atReset = false;
+  update(sessionId, params) {
+    const { total: raw, modelContextWindow } = params.tokenUsage;
+    const reset = modelContextWindow !== null && modelContextWindow > 0 && raw.totalTokens === modelContextWindow && raw.inputTokens === 0 && raw.outputTokens === 0 && raw.cachedInputTokens === 0 && raw.cacheWriteInputTokens === 0 && raw.reasoningOutputTokens === 0;
+    if (reset && !this.atReset) this.offset = { ...this.total };
+    this.atReset = reset;
+    const normalized = normalizeCodexUsage(raw);
+    const next = empty();
+    const difference = empty();
+    for (const key of counters) {
+      next[key] = Math.max(this.total[key] ?? 0, (this.offset[key] ?? 0) + (normalized[key] ?? 0));
+      difference[key] = (next[key] ?? 0) - (this.total[key] ?? 0);
+    }
+    this.total = next;
+    const usage = { ...next };
+    if (modelContextWindow !== null) usage.contextWindow = modelContextWindow;
+    return {
+      sessionId,
+      usage,
+      modelUsage: { [CODEX_UNATTRIBUTED_MODEL]: { ...next } },
+      delta: { usage: { ...difference }, modelUsage: { [CODEX_UNATTRIBUTED_MODEL]: { ...difference } } }
+    };
+  }
+};
 function hasOnlyWinLineEndings(string4) {
   return string4.includes("\r\n") && !string4.startsWith("\n") && !string4.match(/[^\r]\n/);
 }
@@ -23749,17 +23800,8 @@ var CodexEventHandler = class _CodexEventHandler {
     await this.connection.notify(extMethod, params);
   }
   createSessionUsageExtNotification(params) {
-    const totalUsage = params.tokenUsage.total;
-    return {
-      sessionId: this.sessionState.sessionId,
-      usage: {
-        inputTokens: totalUsage.inputTokens,
-        outputTokens: totalUsage.outputTokens,
-        cacheReadInputTokens: totalUsage.cachedInputTokens,
-        reasoningOutputTokens: totalUsage.reasoningOutputTokens,
-        ...params.tokenUsage.modelContextWindow === null ? {} : { contextWindow: params.tokenUsage.modelContextWindow }
-      }
-    };
+    this.sessionState.usageAccounting ??= new CodexUsageAccounting();
+    return this.sessionState.usageAccounting.update(this.sessionState.sessionId, params);
   }
   createSessionRateLimitsExtNotification(rateLimits) {
     return {
@@ -26651,7 +26693,7 @@ var package_default = {
   dependencies: {
     "@agentclientprotocol/sdk": "^1.4.0",
     "@openai/codex": "^0.153.4",
-    "acp-extension-core": "0.1.4",
+    "acp-extension-core": "0.1.5",
     diff: "^9.0.0",
     open: "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",
@@ -27710,8 +27752,8 @@ var CodexAcpClient = class {
       delivery: "inline"
     }, onTurnStarted);
   }
-  async runCompact(sessionId) {
-    await this.codexClient.runCompact({ threadId: sessionId });
+  async runCompact(sessionId, onTurnStarted) {
+    return await this.codexClient.runCompact({ threadId: sessionId }, onTurnStarted);
   }
   async getGoal(sessionId) {
     const response = await this.codexClient.threadGoalGet({ threadId: sessionId });
@@ -28419,7 +28461,7 @@ var CodexAppServerClient = class {
   mcpServerStartupStates = /* @__PURE__ */ new Map();
   mcpServerStartupResolvers = [];
   pendingTurnCompletionResolvers = /* @__PURE__ */ new Map();
-  pendingCompactionCompletionResolvers = /* @__PURE__ */ new Map();
+  pendingCompactTurns = /* @__PURE__ */ new Map();
   turnCompletionCaptures = /* @__PURE__ */ new Map();
   turnRoutingCaptures = /* @__PURE__ */ new Map();
   threadStatusCaptures = /* @__PURE__ */ new Map();
@@ -28448,10 +28490,18 @@ var CodexAppServerClient = class {
         this.resolveMcpServerStartupResolvers();
       }
       if (isTurnCompletedNotification(serverNotification)) {
+        const compact = this.pendingCompactTurns.get(serverNotification.params.threadId);
+        if (compact?.turnId === serverNotification.params.turn.id) {
+          compact.resolve(serverNotification.params);
+        }
         this.recordTurnCompleted(serverNotification.params);
       }
-      if (isCompactionCompletedNotification(serverNotification)) {
-        this.recordCompactionCompleted(serverNotification);
+      if (serverNotification.method === "turn/started") {
+        const compact = this.pendingCompactTurns.get(serverNotification.params.threadId);
+        if (compact && compact.turnId === null) {
+          compact.turnId = serverNotification.params.turn.id;
+          compact.onTurnStarted?.(compact.turnId);
+        }
       }
       if (isThreadStatusChangedNotification(serverNotification)) {
         this.recordThreadStatusChanged(serverNotification.params);
@@ -28753,10 +28803,25 @@ var CodexAppServerClient = class {
       threadStatusChanged: handleThreadStatusChanged
     };
   }
-  async runCompact(params) {
-    const compactionCompleted = this.awaitCompactionCompleted(params.threadId);
-    await this.threadCompactStart(params);
-    return await compactionCompleted;
+  async runCompact(params, onTurnStarted) {
+    if (this.turnCompletionTerminalError) throw this.turnCompletionTerminalError;
+    if (this.pendingCompactTurns.has(params.threadId)) {
+      throw new Error("A compaction request already owns this thread");
+    }
+    const completion = new Promise((resolve, reject) => {
+      this.pendingCompactTurns.set(params.threadId, {
+        turnId: null,
+        onTurnStarted,
+        resolve,
+        reject
+      });
+    });
+    try {
+      const [, completed] = await Promise.all([this.threadCompactStart(params), completion]);
+      return completed;
+    } finally {
+      this.pendingCompactTurns.delete(params.threadId);
+    }
   }
   async turnInterrupt(params) {
     return await this.sendRequest({ method: "turn/interrupt", params });
@@ -28901,13 +28966,6 @@ var CodexAppServerClient = class {
       threadResolvers.set(turnId, { resolve, reject });
     });
   }
-  async awaitCompactionCompleted(threadId) {
-    return await new Promise((resolve) => {
-      const resolvers = this.pendingCompactionCompletionResolvers.get(threadId) ?? /* @__PURE__ */ new Set();
-      resolvers.add(resolve);
-      this.pendingCompactionCompletionResolvers.set(threadId, resolvers);
-    });
-  }
   resolveTurnInterrupted(threadId, turnId) {
     this.recordTurnCompleted({
       threadId,
@@ -28976,20 +29034,6 @@ var CodexAppServerClient = class {
       capture(event);
     }
   }
-  recordCompactionCompleted(event) {
-    const threadId = extractThreadId(event);
-    if (threadId === null) {
-      return;
-    }
-    const resolvers = this.pendingCompactionCompletionResolvers.get(threadId);
-    if (!resolvers) {
-      return;
-    }
-    this.pendingCompactionCompletionResolvers.delete(threadId);
-    for (const resolve of resolvers) {
-      resolve(event);
-    }
-  }
   recordThreadStatusChanged(event) {
     const captures = this.threadStatusCaptures.get(event.threadId);
     if (!captures) {
@@ -29074,6 +29118,8 @@ var CodexAppServerClient = class {
    */
   rejectAllPendingTurnCompletions(error48) {
     this.turnCompletionTerminalError ??= error48;
+    for (const compact of this.pendingCompactTurns.values()) compact.reject(error48);
+    this.pendingCompactTurns.clear();
     const threads = [...this.pendingTurnCompletionResolvers.values()];
     this.pendingTurnCompletionResolvers.clear();
     for (const threadResolvers of threads) {
@@ -29234,12 +29280,6 @@ function isThreadGoalUpdatedNotification(notification) {
 function isThreadGoalClearedNotification(notification) {
   return notification.method === "thread/goal/cleared";
 }
-function isCompactionCompletedNotification(notification) {
-  if (notification.method === "thread/compacted") {
-    return true;
-  }
-  return notification.method === "item/completed" && notification.params.item.type === "contextCompaction";
-}
 function goalsMatch(left, right) {
   return left.threadId === right.threadId && left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget && left.updatedAt === right.updatedAt;
 }
@@ -29504,8 +29544,18 @@ var CodexCommands = class {
         return { handled: options.setConfigOption !== void 0 };
       }
       case "compact": {
-        await this.runWithProcessCheck(() => this.codexAcpClient.runCompact(sessionId));
-        return { handled: true };
+        options.onTurnStartPending?.();
+        options.onCompactionStarted?.();
+        try {
+          const turnCompleted = await this.runWithProcessCheck(
+            () => this.codexAcpClient.runCompact(sessionId, (turnId) => {
+              options.onTurnStarted?.(turnId, sessionId);
+            })
+          );
+          return { handled: true, turnCompleted };
+        } finally {
+          options.onCompactionFinished?.();
+        }
       }
       case "goal": {
         return await this.runGoalCommand(sessionState, command.rest, options);
@@ -33515,6 +33565,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       signal: abortController.signal,
       currentTurn: null,
       hasCompletedTurn: false,
+      compactionInFlight: false,
       requestCancel: () => {
         if (abortController.signal.aborted) {
           return;
@@ -33567,7 +33618,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
   }
   cancelBeforeTurnStarted(activePrompt) {
     return activePrompt.cancelSignal.then(() => {
-      if (activePrompt.currentTurn === null) {
+      if (activePrompt.currentTurn === null && !activePrompt.compactionInFlight) {
         return null;
       }
       return new Promise(() => {
@@ -33635,7 +33686,12 @@ Check ${configPath} and project .codex directories, especially their config.toml
       logger.error(`${requestName} - turnInterrupt failed`, err);
     }
   }
-  interruptLateStartedTurn(turn) {
+  interruptLateStartedTurn(turn, activePrompt) {
+    if (activePrompt.compactionInFlight) {
+      this.codexAcpClient.markTurnStale(turn);
+      void this.requestTurnInterrupt(turn, "Cancel");
+      return;
+    }
     void this.interruptPromptTurn(turn, "Close");
   }
   promptShouldStop(sessionId, activePrompt) {
@@ -33783,7 +33839,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
               const turn = { threadId: params.sessionId, turnId: event.params.turn.id };
               activePrompt.currentTurn = turn;
               if (this.promptShouldStop(params.sessionId, activePrompt)) {
-                this.interruptLateStartedTurn(turn);
+                this.interruptLateStartedTurn(turn, activePrompt);
                 return;
               }
               recoverableSessionFailure = sessionState.sessionFailure;
@@ -33825,13 +33881,19 @@ Check ${configPath} and project .codex directories, especially their config.toml
           if (threadId === params.sessionId) goalLifecycle.startTurn(turnId);
           activePrompt.currentTurn = turn;
           if (this.promptShouldStop(params.sessionId, activePrompt)) {
-            this.interruptLateStartedTurn(turn);
+            this.interruptLateStartedTurn(turn, activePrompt);
             return;
           }
           sessionState.currentTurnId = turnId;
           pendingTurnStart?.resolve(turnId);
           onTurnStarted?.();
         },
+        onCompactionStarted: () => {
+          activePrompt.compactionInFlight = true;
+        },
+        onCompactionFinished: () => {
+          activePrompt.compactionInFlight = false;
+        },
         setConfigOption: async (configId, value) => {
           await this.applySessionConfigOption(sessionState, {
             sessionId: sessionState.sessionId,
@@ -33947,7 +34009,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             }
             activePrompt.currentTurn = turn;
             if (this.promptShouldStop(params.sessionId, activePrompt)) {
-              this.interruptLateStartedTurn(turn);
+              this.interruptLateStartedTurn(turn, activePrompt);
               return;
             }
             sessionState.currentTurnId = turnId;
@@ -34045,7 +34107,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
                 if (!goalLifecycle.startSubmittedTurn(turnId)) return;
                 activePrompt.currentTurn = turn;
                 if (this.promptShouldStop(params.sessionId, activePrompt)) {
-                  this.interruptLateStartedTurn(turn);
+                  this.interruptLateStartedTurn(turn, activePrompt);
                   return;
                 }
                 sessionState.currentTurnId = turnId;
@@ -34287,6 +34349,10 @@ ${stderr}` : "";
       return;
     }
     const activePrompt = this.activePrompts.get(params.sessionId);
+    if (activePrompt?.compactionInFlight) {
+      activePrompt.requestCancel();
+      if (activePrompt.currentTurn === null) return;
+    }
     if (activePrompt?.hasCompletedTurn && activePrompt.currentTurn === null) {
       activePrompt.requestCancel();
       return;