fix: clear stale recovery retry state

src/hooks/anthropic-context-window-limit-recovery/recovery-hook.ts

@@ -11,6 +11,12 @@ import { log } from "../../shared/logger"
 export interface AnthropicContextWindowLimitRecoveryOptions {
   experimental?: ExperimentalConfig
   pluginConfig: OhMyOpenCodeConfig
+  dependencies?: {
+    executeCompact?: typeof executeCompact
+    getLastAssistant?: typeof getLastAssistant
+    log?: typeof log
+    parseAnthropicTokenLimitError?: typeof parseAnthropicTokenLimitError
+  }
 }
 
 function createRecoveryState(): AutoCompactState {
@@ -33,19 +39,30 @@ export function createAnthropicContextWindowLimitRecoveryHook(
   const autoCompactState = createRecoveryState()
   const experimental = options?.experimental
   const pluginConfig = options?.pluginConfig ?? {} as OhMyOpenCodeConfig
+  const dependencies = {
+    executeCompact,
+    getLastAssistant,
+    log,
+    parseAnthropicTokenLimitError,
+    ...options?.dependencies,
+  }
   const pendingCompactionTimeoutBySession = new Map<string, ReturnType<typeof setTimeout>>()
 
+  function clearPendingCompactionTimeout(sessionID: string): void {
+    const timeoutID = pendingCompactionTimeoutBySession.get(sessionID)
+    if (timeoutID !== undefined) {
+      clearTimeout(timeoutID)
+      pendingCompactionTimeoutBySession.delete(sessionID)
+    }
+  }
+
   const eventHandler = async ({ event }: { event: { type: string; properties?: unknown } }) => {
     const props = event.properties as Record<string, unknown> | undefined
 
     if (event.type === "session.deleted") {
       const sessionInfo = props?.info as { id?: string } | undefined
       if (sessionInfo?.id) {
-        const timeoutID = pendingCompactionTimeoutBySession.get(sessionInfo.id)
-        if (timeoutID !== undefined) {
-          clearTimeout(timeoutID)
-          pendingCompactionTimeoutBySession.delete(sessionInfo.id)
-        }
+        clearPendingCompactionTimeout(sessionInfo.id)
 
         clearSessionState(autoCompactState, sessionInfo.id)
       }
@@ -54,11 +71,11 @@ export function createAnthropicContextWindowLimitRecoveryHook(
 
     if (event.type === "session.error") {
       const sessionID = props?.sessionID as string | undefined
-      log("[auto-compact] session.error received", { sessionID, error: props?.error })
+      dependencies.log("[auto-compact] session.error received", { sessionID, error: props?.error })
       if (!sessionID) return
 
-      const parsed = parseAnthropicTokenLimitError(props?.error)
-      log("[auto-compact] parsed result", { parsed, hasError: !!props?.error })
+      const parsed = dependencies.parseAnthropicTokenLimitError(props?.error)
+      dependencies.log("[auto-compact] parsed result", { parsed, hasError: !!props?.error })
       if (parsed) {
         autoCompactState.pendingCompact.add(sessionID)
         autoCompactState.errorDataBySession.set(sessionID, parsed)
@@ -68,7 +85,11 @@ export function createAnthropicContextWindowLimitRecoveryHook(
           return
         }
 
-        const lastAssistant = await getLastAssistant(sessionID, ctx.client, ctx.directory)
+        const lastAssistant = await dependencies.getLastAssistant(
+          sessionID,
+          ctx.client,
+          ctx.directory,
+        )
         const lastAssistantInfo = lastAssistant?.info
         const providerID = parsed.providerID ?? (lastAssistantInfo?.providerID as string | undefined)
         const modelID = parsed.modelID ?? (lastAssistantInfo?.modelID as string | undefined)
@@ -84,9 +105,11 @@ export function createAnthropicContextWindowLimitRecoveryHook(
           })
           .catch(() => {})
 
+        clearPendingCompactionTimeout(sessionID)
+
         const timeoutID = setTimeout(() => {
           pendingCompactionTimeoutBySession.delete(sessionID)
-          executeCompact(
+          dependencies.executeCompact(
             sessionID,
             { providerID, modelID },
             autoCompactState,
@@ -107,9 +130,9 @@ export function createAnthropicContextWindowLimitRecoveryHook(
       const sessionID = info?.sessionID as string | undefined
 
       if (sessionID && info?.role === "assistant" && info.error) {
-        log("[auto-compact] message.updated with error", { sessionID, error: info.error })
-        const parsed = parseAnthropicTokenLimitError(info.error)
-        log("[auto-compact] message.updated parsed result", { parsed })
+        dependencies.log("[auto-compact] message.updated with error", { sessionID, error: info.error })
+        const parsed = dependencies.parseAnthropicTokenLimitError(info.error)
+        dependencies.log("[auto-compact] message.updated parsed result", { parsed })
         if (parsed) {
           parsed.providerID = info.providerID as string | undefined
           parsed.modelID = info.modelID as string | undefined
@@ -126,18 +149,18 @@ export function createAnthropicContextWindowLimitRecoveryHook(
 
       if (!autoCompactState.pendingCompact.has(sessionID)) return
 
-      const timeoutID = pendingCompactionTimeoutBySession.get(sessionID)
-      if (timeoutID !== undefined) {
-        clearTimeout(timeoutID)
-        pendingCompactionTimeoutBySession.delete(sessionID)
-      }
+      clearPendingCompactionTimeout(sessionID)
 
       const errorData = autoCompactState.errorDataBySession.get(sessionID)
-      const lastAssistant = await getLastAssistant(sessionID, ctx.client, ctx.directory)
+      const lastAssistant = await dependencies.getLastAssistant(
+        sessionID,
+        ctx.client,
+        ctx.directory,
+      )
       const lastAssistantInfo = lastAssistant?.info
 
       if (lastAssistantInfo?.summary === true && lastAssistant?.hasContent) {
-        autoCompactState.pendingCompact.delete(sessionID)
+        clearSessionState(autoCompactState, sessionID)
         return
       }
 
@@ -155,7 +178,7 @@ export function createAnthropicContextWindowLimitRecoveryHook(
         })
         .catch(() => {})
 
-      await executeCompact(
+      await dependencies.executeCompact(
         sessionID,
         { providerID, modelID },
         autoCompactState,