@link-assistant/agent 0.13.2 → 0.13.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.13.2",
+  "version": "0.13.5",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/bun/index.ts

@@ -141,6 +141,14 @@ export namespace BunProc {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
+  /**
+   * Staleness threshold for 'latest' version packages (24 hours).
+   * Packages installed as 'latest' will be refreshed after this period.
+   * This ensures users get updated packages with bug fixes and new features.
+   * @see https://github.com/link-assistant/agent/issues/177
+   */
+  const LATEST_VERSION_STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+
   export async function install(pkg: string, version = 'latest') {
     const mod = path.join(Global.Path.cache, 'node_modules', pkg);
 
@@ -150,11 +158,41 @@ export namespace BunProc {
 
     const pkgjson = Bun.file(path.join(Global.Path.cache, 'package.json'));
     const parsed = await pkgjson.json().catch(async () => {
-      const result = { dependencies: {} };
+      const result = { dependencies: {}, _installTime: {} };
       await Bun.write(pkgjson.name!, JSON.stringify(result, null, 2));
       return result;
     });
-    if (parsed.dependencies[pkg] === version) return mod;
+
+    // Initialize _installTime tracking if not present
+    if (!parsed._installTime) {
+      parsed._installTime = {};
+    }
+
+    // Check if package is already installed with the requested version
+    const installedVersion = parsed.dependencies[pkg];
+    const installTime = parsed._installTime[pkg] as number | undefined;
+
+    if (installedVersion === version) {
+      // For 'latest' version, check if installation is stale and needs refresh
+      // This ensures users get updated packages with important fixes
+      // @see https://github.com/link-assistant/agent/issues/177 (specificationVersion v3 support)
+      if (version === 'latest' && installTime) {
+        const age = Date.now() - installTime;
+        if (age < LATEST_VERSION_STALE_THRESHOLD_MS) {
+          return mod;
+        }
+        log.info(() => ({
+          message: 'refreshing stale latest package',
+          pkg,
+          version,
+          ageMs: age,
+          threshold: LATEST_VERSION_STALE_THRESHOLD_MS,
+        }));
+      } else if (version !== 'latest') {
+        // For explicit versions, don't reinstall
+        return mod;
+      }
+    }
 
     // Check for dry-run mode
     if (Flag.OPENCODE_DRY_RUN) {
@@ -205,6 +243,8 @@ export namespace BunProc {
           attempt,
         }));
         parsed.dependencies[pkg] = version;
+        // Track installation time for 'latest' version staleness checks
+        parsed._installTime[pkg] = Date.now();
         await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
         return mod;
       } catch (e) {

package/src/flag/flag.ts

@@ -4,6 +4,11 @@ export namespace Flag {
     return process.env[newKey] ?? process.env[oldKey];
   }
 
+  function truthy(key: string) {
+    const value = process.env[key]?.toLowerCase();
+    return value === 'true' || value === '1';
+  }
+
   function truthyCompat(newKey: string, oldKey: string): boolean {
     const value = (getEnv(newKey, oldKey) ?? '').toLowerCase();
     return value === 'true' || value === '1';
@@ -155,9 +160,4 @@ export namespace Flag {
   export function setCompactJson(value: boolean) {
     _compactJson = value;
   }
-
-  function truthy(key: string) {
-    const value = process.env[key]?.toLowerCase();
-    return value === 'true' || value === '1';
-  }
 }

package/src/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env bun
-
+import { Flag } from './flag/flag.ts';
 import { setProcessName } from './cli/process-name.ts';
-
 setProcessName('agent');
 
 import { Server } from './server/server.ts';
@@ -19,7 +18,6 @@ import {
 } from './json-standard/index.ts';
 import { McpCommand } from './cli/cmd/mcp.ts';
 import { AuthCommand } from './cli/cmd/auth.ts';
-import { Flag } from './flag/flag.ts';
 import { FormatError } from './cli/error.ts';
 import { UI } from './cli/ui.ts';
 import {

package/src/provider/models.ts

@@ -131,8 +131,11 @@ export namespace ModelsDev {
     if (result) return result as Record<string, Provider>;
 
     // Fallback to bundled data if cache read failed
-    log.warn(() => ({
-      message: 'cache read failed, using bundled data',
+    // This is expected behavior when the cache is unavailable or corrupted
+    // Using info level since bundled data is a valid fallback mechanism
+    // @see https://github.com/link-assistant/agent/issues/177
+    log.info(() => ({
+      message: 'cache unavailable, using bundled data',
       path: filepath,
     }));
     const json = await data();

package/src/provider/retry-fetch.ts

@@ -20,7 +20,12 @@ import { Flag } from '../flag/flag';
  * By wrapping fetch, we handle rate limits at the HTTP layer with time-based retries,
  * ensuring the agent's 7-week global timeout is respected.
  *
+ * Important: Rate limit waits use ISOLATED AbortControllers that are NOT subject to
+ * provider/stream timeouts. This prevents long rate limit waits (e.g., 15 hours) from
+ * being aborted by short provider timeouts (e.g., 5 minutes).
+ *
  * @see https://github.com/link-assistant/agent/issues/167
+ * @see https://github.com/link-assistant/agent/issues/183
  * @see https://github.com/vercel/ai/issues/12585
  */
 
@@ -125,8 +130,8 @@ export namespace RetryFetch {
       log.info(() => ({
         message: 'using retry-after value',
         retryAfterMs,
-        delay,
-        minInterval,
+        delayMs: delay,
+        minIntervalMs: minInterval,
       }));
       return addJitter(delay);
     }
@@ -140,33 +145,119 @@ export namespace RetryFetch {
     log.info(() => ({
       message: 'no retry-after header, using exponential backoff',
       attempt,
-      backoffDelay,
-      delay,
-      minInterval,
-      maxBackoffDelay,
+      backoffDelayMs: backoffDelay,
+      delayMs: delay,
+      minIntervalMs: minInterval,
+      maxBackoffDelayMs: maxBackoffDelay,
     }));
     return addJitter(delay);
   }
 
   /**
    * Sleep for the specified duration, but respect abort signals.
+   * Properly cleans up event listeners to prevent memory leaks.
    */
   async function sleep(ms: number, signal?: AbortSignal): Promise<void> {
     return new Promise((resolve, reject) => {
+      // Check if already aborted before starting
+      if (signal?.aborted) {
+        reject(new DOMException('Aborted', 'AbortError'));
+        return;
+      }
+
       const timeout = setTimeout(resolve, ms);
+
       if (signal) {
-        signal.addEventListener(
-          'abort',
-          () => {
-            clearTimeout(timeout);
-            reject(new DOMException('Aborted', 'AbortError'));
-          },
-          { once: true }
-        );
+        const abortHandler = () => {
+          clearTimeout(timeout);
+          reject(new DOMException('Aborted', 'AbortError'));
+        };
+
+        signal.addEventListener('abort', abortHandler, { once: true });
+
+        // Clean up the listener when the timeout completes normally
+        // This prevents memory leaks on long-running processes
+        const originalResolve = resolve;
+        // eslint-disable-next-line no-param-reassign
+        resolve = (value) => {
+          signal.removeEventListener('abort', abortHandler);
+          originalResolve(value);
+        };
       }
     });
   }
 
+  /**
+   * Create an isolated AbortController for rate limit waits.
+   *
+   * This controller is NOT connected to the request's AbortSignal, so it won't be
+   * affected by provider timeouts (default 5 minutes) or stream timeouts.
+   * It only respects the global AGENT_RETRY_TIMEOUT.
+   *
+   * However, it DOES check the user's abort signal periodically (every 10 seconds)
+   * to allow user cancellation during long rate limit waits.
+   *
+   * This solves issue #183 where long rate limit waits (e.g., 15 hours) were being
+   * aborted by the provider timeout (5 minutes).
+   *
+   * @param remainingTimeout Maximum time allowed for this wait (ms)
+   * @param userSignal Optional user abort signal to check periodically
+   * @returns An object with the signal and a cleanup function
+   * @see https://github.com/link-assistant/agent/issues/183
+   */
+  function createIsolatedRateLimitSignal(
+    remainingTimeout: number,
+    userSignal?: AbortSignal
+  ): {
+    signal: AbortSignal;
+    cleanup: () => void;
+  } {
+    const controller = new AbortController();
+    const timers: NodeJS.Timeout[] = [];
+
+    // Set a timeout based on the global AGENT_RETRY_TIMEOUT (not provider timeout)
+    const globalTimeoutId = setTimeout(() => {
+      controller.abort(
+        new DOMException(
+          'Rate limit wait exceeded global timeout',
+          'TimeoutError'
+        )
+      );
+    }, remainingTimeout);
+    timers.push(globalTimeoutId);
+
+    // Periodically check if user canceled (every 10 seconds)
+    // This allows user cancellation during long rate limit waits
+    // without being affected by provider timeouts
+    if (userSignal) {
+      const checkUserCancellation = () => {
+        if (userSignal.aborted) {
+          controller.abort(
+            new DOMException(
+              'User canceled during rate limit wait',
+              'AbortError'
+            )
+          );
+        }
+      };
+
+      // Check immediately and then every 10 seconds
+      checkUserCancellation();
+      const intervalId = setInterval(checkUserCancellation, 10_000);
+      timers.push(intervalId as unknown as NodeJS.Timeout);
+    }
+
+    return {
+      signal: controller.signal,
+      cleanup: () => {
+        for (const timer of timers) {
+          clearTimeout(timer);
+          clearInterval(timer as unknown as NodeJS.Timeout);
+        }
+      },
+    };
+  }
+
   /**
    * Check if an error is retryable (network issues, temporary failures).
    */
@@ -243,8 +334,8 @@ export namespace RetryFetch {
                 message:
                   'network error retry timeout exceeded, re-throwing error',
                 sessionID,
-                elapsed,
-                maxRetryTimeout,
+                elapsedMs: elapsed,
+                maxRetryTimeoutMs: maxRetryTimeout,
                 error: (error as Error).message,
               }));
               throw error;
@@ -259,7 +350,7 @@ export namespace RetryFetch {
               message: 'network error, retrying',
               sessionID,
               attempt,
-              delay,
+              delayMs: delay,
               error: (error as Error).message,
             }));
             await sleep(delay, init?.signal ?? undefined);
@@ -279,8 +370,8 @@ export namespace RetryFetch {
           log.warn(() => ({
             message: 'retry timeout exceeded in fetch wrapper, returning 429',
             sessionID,
-            elapsed,
-            maxRetryTimeout,
+            elapsedMs: elapsed,
+            maxRetryTimeoutMs: maxRetryTimeout,
           }));
           return response; // Let higher-level handling take over
         }
@@ -299,8 +390,8 @@ export namespace RetryFetch {
             message:
               'retry-after exceeds remaining timeout, returning 429 response',
             sessionID,
-            elapsed,
-            remainingTimeout: maxRetryTimeout - elapsed,
+            elapsedMs: elapsed,
+            remainingTimeoutMs: maxRetryTimeout - elapsed,
           }));
           return response;
         }
@@ -310,33 +401,64 @@ export namespace RetryFetch {
           log.warn(() => ({
             message: 'delay would exceed retry timeout, returning 429 response',
             sessionID,
-            elapsed,
-            delay,
-            maxRetryTimeout,
+            elapsedMs: elapsed,
+            delayMs: delay,
+            maxRetryTimeoutMs: maxRetryTimeout,
           }));
           return response;
         }
 
+        const remainingTimeout = maxRetryTimeout - elapsed;
+
         log.info(() => ({
           message: 'rate limited, will retry',
           sessionID,
           attempt,
-          delay,
+          delayMs: delay,
           delayMinutes: (delay / 1000 / 60).toFixed(2),
-          elapsed,
-          remainingTimeout: maxRetryTimeout - elapsed,
+          delayHours: (delay / 1000 / 3600).toFixed(2),
+          elapsedMs: elapsed,
+          remainingTimeoutMs: remainingTimeout,
+          remainingTimeoutHours: (remainingTimeout / 1000 / 3600).toFixed(2),
+          isolatedSignal: true, // Indicates we're using isolated signal for this wait
         }));
 
-        // Wait before retrying
+        // Wait before retrying using ISOLATED signal
+        // This is critical for issue #183: Rate limit waits can be hours long (e.g., 15 hours),
+        // but provider timeouts are typically 5 minutes. By using an isolated AbortController
+        // that only respects AGENT_RETRY_TIMEOUT, we prevent the provider timeout from
+        // aborting long rate limit waits.
+        //
+        // The isolated signal periodically checks the user's abort signal (every 10 seconds)
+        // to allow user cancellation during long waits.
+        const { signal: isolatedSignal, cleanup } =
+          createIsolatedRateLimitSignal(
+            remainingTimeout,
+            init?.signal ?? undefined
+          );
+
         try {
-          await sleep(delay, init?.signal ?? undefined);
-        } catch {
-          // Aborted - return the last response
+          await sleep(delay, isolatedSignal);
+        } catch (sleepError) {
+          // Check if the original request was aborted (user cancellation)
+          // In that case, we should stop retrying
+          if (init?.signal?.aborted) {
+            log.info(() => ({
+              message: 'rate limit wait aborted by user cancellation',
+              sessionID,
+            }));
+            return response;
+          }
+
+          // Otherwise, it was the isolated timeout - log and return
           log.info(() => ({
-            message: 'retry sleep aborted, returning last response',
+            message: 'rate limit wait exceeded global timeout',
             sessionID,
+            sleepError: String(sleepError),
           }));
           return response;
+        } finally {
+          cleanup();
         }
       }
     };

package/src/session/retry.ts

@@ -94,8 +94,8 @@ export namespace SessionRetry {
         message: 'retry timeout exceeded',
         sessionID,
         errorType,
-        elapsedTime,
-        maxTime,
+        elapsedTimeMs: elapsedTime,
+        maxTimeMs: maxTime,
       }));
       return { shouldRetry: false, elapsedTime, maxTime };
     }
@@ -245,8 +245,8 @@ export namespace SessionRetry {
       log.info(() => ({
         message: 'no retry-after header, using exponential backoff',
         attempt,
-        backoffDelay,
-        maxBackoffDelay,
+        backoffDelayMs: backoffDelay,
+        maxBackoffDelayMs: maxBackoffDelay,
       }));
       return addJitter(backoffDelay);
     }
@@ -260,8 +260,8 @@ export namespace SessionRetry {
       message:
         'no response headers, using exponential backoff with conservative cap',
       attempt,
-      backoffDelay,
-      maxCap: RETRY_MAX_DELAY_NO_HEADERS,
+      backoffDelayMs: backoffDelay,
+      maxCapMs: RETRY_MAX_DELAY_NO_HEADERS,
     }));
     return addJitter(backoffDelay);
   }