@link-assistant/agent 0.13.4 → 0.13.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.13.4",
+  "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

@@ -130,8 +130,8 @@ export namespace RetryFetch {
       log.info(() => ({
         message: 'using retry-after value',
         retryAfterMs,
-        delay,
-        minInterval,
+        delayMs: delay,
+        minIntervalMs: minInterval,
       }));
       return addJitter(delay);
     }
@@ -145,10 +145,10 @@ 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);
   }
@@ -334,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;
@@ -350,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);
@@ -370,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
         }
@@ -390,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;
         }
@@ -401,9 +401,9 @@ 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;
         }
@@ -414,11 +414,11 @@ export namespace RetryFetch {
           message: 'rate limited, will retry',
           sessionID,
           attempt,
-          delay,
+          delayMs: delay,
           delayMinutes: (delay / 1000 / 60).toFixed(2),
           delayHours: (delay / 1000 / 3600).toFixed(2),
-          elapsed,
-          remainingTimeout,
+          elapsedMs: elapsed,
+          remainingTimeoutMs: remainingTimeout,
           remainingTimeoutHours: (remainingTimeout / 1000 / 3600).toFixed(2),
           isolatedSignal: true, // Indicates we're using isolated signal for this wait
         }));

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);
   }