better retry display

packages/opencode/src/session/processor.ts

@@ -325,16 +325,15 @@ export namespace SessionProcessor {
             const error = MessageV2.fromError(e, { providerID: input.providerID })
             if (error?.name === "APIError" && error.data.isRetryable) {
               attempt++
-              const delay = SessionRetry.getRetryDelayInMs(error, attempt)
-              if (delay) {
-                SessionStatus.set(input.sessionID, {
-                  type: "retry",
-                  attempt,
-                  message: error.data.message,
-                })
-                await SessionRetry.sleep(delay, input.abort).catch(() => {})
-                continue
-              }
+              const delay = SessionRetry.delay(error, attempt)
+              SessionStatus.set(input.sessionID, {
+                type: "retry",
+                attempt,
+                message: error.data.message,
+                next: Date.now() + delay,
+              })
+              await SessionRetry.sleep(delay, input.abort).catch(() => {})
+              continue
             }
             input.assistantMessage.error = error
             Bus.publish(Session.Event.Error, {

packages/opencode/src/session/retry.ts

@@ -4,7 +4,7 @@ import { MessageV2 } from "./message-v2"
 export namespace SessionRetry {
   export const RETRY_INITIAL_DELAY = 2000
   export const RETRY_BACKOFF_FACTOR = 2
-  export const RETRY_MAX_DELAY = 600_000 // 10 minutes
+  export const RETRY_MAX_DELAY_NO_HEADERS = 30_000 // 30 seconds
 
   export async function sleep(ms: number, signal: AbortSignal): Promise<void> {
     return new Promise((resolve, reject) => {
@@ -20,57 +20,34 @@ export namespace SessionRetry {
     })
   }
 
-  export function getRetryDelayInMs(error: MessageV2.APIError, attempt: number) {
-    const delay = iife(() => {
-      const headers = error.data.responseHeaders
-      if (headers) {
-        const retryAfterMs = headers["retry-after-ms"]
-        if (retryAfterMs) {
-          const parsedMs = Number.parseFloat(retryAfterMs)
-          if (!Number.isNaN(parsedMs)) {
-            return parsedMs
-          }
+  export function delay(error: MessageV2.APIError, attempt: number) {
+    const headers = error.data.responseHeaders
+    if (headers) {
+      const retryAfterMs = headers["retry-after-ms"]
+      if (retryAfterMs) {
+        const parsedMs = Number.parseFloat(retryAfterMs)
+        if (!Number.isNaN(parsedMs)) {
+          return parsedMs
         }
+      }
 
-        const retryAfter = headers["retry-after"]
-        if (retryAfter) {
-          const parsedSeconds = Number.parseFloat(retryAfter)
-          if (!Number.isNaN(parsedSeconds)) {
-            // convert seconds to milliseconds
-            return Math.ceil(parsedSeconds * 1000)
-          }
-          // Try parsing as HTTP date format
-          const parsed = Date.parse(retryAfter) - Date.now()
-          if (!Number.isNaN(parsed) && parsed > 0) {
-            return Math.ceil(parsed)
-          }
+      const retryAfter = headers["retry-after"]
+      if (retryAfter) {
+        const parsedSeconds = Number.parseFloat(retryAfter)
+        if (!Number.isNaN(parsedSeconds)) {
+          // convert seconds to milliseconds
+          return Math.ceil(parsedSeconds * 1000)
+        }
+        // Try parsing as HTTP date format
+        const parsed = Date.parse(retryAfter) - Date.now()
+        if (!Number.isNaN(parsed) && parsed > 0) {
+          return Math.ceil(parsed)
         }
       }
 
       return RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1)
-    })
+    }
 
-    // dont retry if wait is too far from now
-    if (delay > RETRY_MAX_DELAY) return undefined
-
-    return delay
-  }
-
-  export function getBoundedDelay(input: {
-    error: MessageV2.APIError
-    attempt: number
-    startTime: number
-    maxDuration?: number
-  }) {
-    const elapsed = Date.now() - input.startTime
-    const maxDuration = input.maxDuration ?? RETRY_MAX_DELAY
-    const remaining = maxDuration - elapsed
-
-    if (remaining <= 0) return undefined
-
-    const delay = getRetryDelayInMs(input.error, input.attempt)
-    if (!delay) return undefined
-
-    return Math.min(delay, remaining)
+    return Math.min(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1), RETRY_MAX_DELAY_NO_HEADERS)
   }
 }

packages/opencode/src/session/status.ts

@@ -12,6 +12,7 @@ export namespace SessionStatus {
         type: z.literal("retry"),
         attempt: z.number(),
         message: z.string(),
+        next: z.number(),
       }),
       z.object({
         type: z.literal("busy"),