@link-assistant/agent 0.16.14 → 0.16.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.16.14",
+  "version": "0.16.17",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",
@@ -9,7 +9,8 @@
   },
   "scripts": {
     "dev": "bun run src/index.js",
-    "test": "bun test",
+    "test": "bun test tests/*.test.js tests/*.test.ts",
+    "test:integration": "bun test tests/integration/basic.test.js",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",
@@ -117,6 +118,7 @@
     "eslint": "^9.38.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-promise": "^7.2.1",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.6",
     "prettier": "^3.6.2"

package/src/cli/continuous-mode.js

@@ -377,15 +377,24 @@ export async function runContinuousServerMode(
 
     // Wait for stdin to end (EOF or close)
     await new Promise((resolve) => {
+      let resolved = false;
+      const safeResolve = () => {
+        if (!resolved) {
+          resolved = true;
+          resolve();
+        }
+      };
+
       const checkRunning = setInterval(() => {
         if (!stdinReader.isRunning()) {
           clearInterval(checkRunning);
           // Wait for any pending messages to complete
           const waitForPending = () => {
             if (!isProcessing && pendingMessages.length === 0) {
-              resolve();
+              safeResolve();
             } else {
-              setTimeout(waitForPending, 100);
+              // Use .unref() to prevent keeping the event loop alive (#213)
+              setTimeout(waitForPending, 100).unref();
             }
           };
           waitForPending();
@@ -394,8 +403,8 @@ export async function runContinuousServerMode(
       // Allow process to exit naturally when no other work remains
       checkRunning.unref();
 
-      // Also handle SIGINT
-      process.on('SIGINT', () => {
+      // Handle SIGINT — use 'once' to avoid accumulating handlers (#213)
+      const sigintHandler = () => {
         outputStatus(
           {
             type: 'status',
@@ -404,8 +413,9 @@ export async function runContinuousServerMode(
           compactJson
         );
         clearInterval(checkRunning);
-        resolve();
-      });
+        safeResolve();
+      };
+      process.once('SIGINT', sigintHandler);
     });
   } finally {
     if (stdinReader) {
@@ -596,15 +606,24 @@ export async function runContinuousDirectMode(
 
     // Wait for stdin to end (EOF or close)
     await new Promise((resolve) => {
+      let resolved = false;
+      const safeResolve = () => {
+        if (!resolved) {
+          resolved = true;
+          resolve();
+        }
+      };
+
       const checkRunning = setInterval(() => {
         if (!stdinReader.isRunning()) {
           clearInterval(checkRunning);
           // Wait for any pending messages to complete
           const waitForPending = () => {
             if (!isProcessing && pendingMessages.length === 0) {
-              resolve();
+              safeResolve();
             } else {
-              setTimeout(waitForPending, 100);
+              // Use .unref() to prevent keeping the event loop alive (#213)
+              setTimeout(waitForPending, 100).unref();
             }
           };
           waitForPending();
@@ -613,8 +632,8 @@ export async function runContinuousDirectMode(
       // Allow process to exit naturally when no other work remains
       checkRunning.unref();
 
-      // Also handle SIGINT
-      process.on('SIGINT', () => {
+      // Handle SIGINT — use 'once' to avoid accumulating handlers (#213)
+      const sigintHandler = () => {
         outputStatus(
           {
             type: 'status',
@@ -623,8 +642,9 @@ export async function runContinuousDirectMode(
           compactJson
         );
         clearInterval(checkRunning);
-        resolve();
-      });
+        safeResolve();
+      };
+      process.once('SIGINT', sigintHandler);
     });
   } finally {
     if (stdinReader) {

package/src/cli/input-queue.js

@@ -178,11 +178,13 @@ export function createContinuousStdinReader(options = {}) {
     isRunning = false;
   };
 
+  const handleError = () => {
+    isRunning = false;
+  };
+
   process.stdin.on('data', handleData);
   process.stdin.on('end', handleEnd);
-  process.stdin.on('error', () => {
-    isRunning = false;
-  });
+  process.stdin.on('error', handleError);
 
   return {
     queue: inputQueue,
@@ -191,6 +193,7 @@ export function createContinuousStdinReader(options = {}) {
       inputQueue.flush();
       process.stdin.removeListener('data', handleData);
       process.stdin.removeListener('end', handleEnd);
+      process.stdin.removeListener('error', handleError);
     },
     isRunning: () => isRunning,
   };

package/src/flag/flag.ts

@@ -194,4 +194,13 @@ export namespace Flag {
   export function setCompactJson(value: boolean) {
     _compactJson = value;
   }
+
+  // Retry on rate limits - when disabled, 429 responses are returned immediately without retrying
+  // Enabled by default. Use --no-retry-on-rate-limits in integration tests to avoid waiting for rate limits.
+  export let RETRY_ON_RATE_LIMITS = true;
+
+  // Allow setting retry-on-rate-limits mode programmatically (e.g., from CLI --retry-on-rate-limits flag)
+  export function setRetryOnRateLimits(value: boolean) {
+    RETRY_ON_RATE_LIMITS = value;
+  }
 }

package/src/index.js

@@ -309,7 +309,12 @@ async function runAgentMode(argv, request) {
     },
   });
 
-  // Explicitly exit to ensure process terminates
+  // Explicitly exit to ensure process terminates (#213)
+  Log.Default.info(() => ({
+    message: 'Agent exiting',
+    hasError,
+    uptimeSeconds: Math.round(process.uptime()),
+  }));
   process.exit(hasError ? 1 : 0);
 }
 
@@ -387,7 +392,12 @@ async function runContinuousAgentMode(argv) {
     },
   });
 
-  // Explicitly exit to ensure process terminates
+  // Explicitly exit to ensure process terminates (#213)
+  Log.Default.info(() => ({
+    message: 'Agent exiting',
+    hasError,
+    uptimeSeconds: Math.round(process.uptime()),
+  }));
   process.exit(hasError ? 1 : 0);
 }
 
@@ -708,6 +718,12 @@ async function main() {
               description:
                 'Maximum total retry time in seconds for rate limit errors (default: 604800 = 7 days)',
             })
+            .option('retry-on-rate-limits', {
+              type: 'boolean',
+              description:
+                'Retry AI completions API requests when rate limited (HTTP 429). Use --no-retry-on-rate-limits in integration tests to fail fast instead of waiting.',
+              default: true,
+            })
             .option('output-response-model', {
               type: 'boolean',
               description: 'Include model info in step_finish output',
@@ -902,6 +918,10 @@ async function main() {
         if (argv['summarize-session'] === true) {
           Flag.setSummarizeSession(true);
         }
+        // retry-on-rate-limits is enabled by default, only set if explicitly disabled
+        if (argv['retry-on-rate-limits'] === false) {
+          Flag.setRetryOnRateLimits(false);
+        }
         await Log.init({
           print: Flag.OPENCODE_VERBOSE,
           level: Flag.OPENCODE_VERBOSE ? 'DEBUG' : 'INFO',

package/src/provider/provider.ts

@@ -1272,22 +1272,26 @@ export namespace Provider {
             }
           }
 
-          log.info(() => ({
-            message: 'HTTP request',
+          // Use direct (non-lazy) logging for HTTP request/response to ensure output
+          // is not lost when piped through external process wrappers (e.g., solve.mjs).
+          // The verbose check is already done above, so lazy evaluation is not needed here.
+          // See: https://github.com/link-assistant/agent/issues/211
+          log.info('HTTP request', {
             providerID: provider.id,
             method,
             url,
             headers: sanitizedHeaders,
             bodyPreview,
-          }));
+          });
 
           const startMs = Date.now();
           try {
             const response = await innerFetch(input, init);
             const durationMs = Date.now() - startMs;
 
-            log.info(() => ({
-              message: 'HTTP response',
+            // Use direct (non-lazy) logging to ensure HTTP response details are captured
+            // See: https://github.com/link-assistant/agent/issues/211
+            log.info('HTTP response', {
               providerID: provider.id,
               method,
               url,
@@ -1295,7 +1299,7 @@ export namespace Provider {
               statusText: response.statusText,
               durationMs,
               responseHeaders: Object.fromEntries(response.headers.entries()),
-            }));
+            });
 
             // Log response body for debugging provider failures
             // For streaming responses (SSE/event-stream), tee() the stream so the AI SDK
@@ -1335,14 +1339,15 @@ export namespace Provider {
                         }
                       }
                     }
-                    log.info(() => ({
-                      message: 'HTTP response body (stream)',
+                    // Use direct (non-lazy) logging for stream body
+                    // See: https://github.com/link-assistant/agent/issues/211
+                    log.info('HTTP response body (stream)', {
                       providerID: provider.id,
                       url,
                       bodyPreview: truncated
                         ? bodyPreview + `... [truncated]`
                         : bodyPreview,
-                    }));
+                    });
                   } catch {
                     // Ignore logging errors — do not affect the SDK stream
                   }
@@ -1362,12 +1367,13 @@ export namespace Provider {
                     ? bodyText.slice(0, responseBodyMaxChars) +
                       `... [truncated, total ${bodyText.length} chars]`
                     : bodyText;
-                log.info(() => ({
-                  message: 'HTTP response body',
+                // Use direct (non-lazy) logging for non-streaming body
+                // See: https://github.com/link-assistant/agent/issues/211
+                log.info('HTTP response body', {
                   providerID: provider.id,
                   url,
                   bodyPreview,
-                }));
+                });
                 return new Response(bodyText, {
                   status: response.status,
                   statusText: response.statusText,
@@ -1379,8 +1385,9 @@ export namespace Provider {
             return response;
           } catch (error) {
             const durationMs = Date.now() - startMs;
-            log.error(() => ({
-              message: 'HTTP request failed',
+            // Use direct (non-lazy) logging for error path
+            // See: https://github.com/link-assistant/agent/issues/211
+            log.error('HTTP request failed', {
               providerID: provider.id,
               method,
               url,
@@ -1389,7 +1396,7 @@ export namespace Provider {
                 error instanceof Error
                   ? { name: error.name, message: error.message }
                   : String(error),
-            }));
+            });
             throw error;
           }
         };

package/src/provider/retry-fetch.ts

@@ -166,6 +166,8 @@ export namespace RetryFetch {
       }
 
       const timeout = setTimeout(resolve, ms);
+      // Prevent sleep timer from keeping event loop alive (#213)
+      if (timeout.unref) timeout.unref();
 
       if (signal) {
         const abortHandler = () => {
@@ -224,6 +226,8 @@ export namespace RetryFetch {
         )
       );
     }, remainingTimeout);
+    // Prevent timer from keeping event loop alive after cleanup (#213)
+    if (globalTimeoutId.unref) globalTimeoutId.unref();
     timers.push(globalTimeoutId);
 
     // Periodically check if user canceled (every 10 seconds)
@@ -244,6 +248,8 @@ export namespace RetryFetch {
       // Check immediately and then every 10 seconds
       checkUserCancellation();
       const intervalId = setInterval(checkUserCancellation, 10_000);
+      // Prevent interval from keeping event loop alive after cleanup (#213)
+      if ((intervalId as any).unref) (intervalId as any).unref();
       timers.push(intervalId as unknown as NodeJS.Timeout);
     }
 
@@ -364,6 +370,16 @@ export namespace RetryFetch {
           return response;
         }
 
+        // If retry on rate limits is disabled, return 429 immediately
+        if (!Flag.RETRY_ON_RATE_LIMITS) {
+          log.info(() => ({
+            message:
+              'rate limit retry disabled (--no-retry-on-rate-limits), returning 429',
+            sessionID,
+          }));
+          return response;
+        }
+
         // Check if we're within the global retry timeout
         const elapsed = Date.now() - startTime;
         if (elapsed >= maxRetryTimeout) {

package/src/server/server.ts

@@ -246,7 +246,9 @@ export namespace Server {
     const server = Bun.serve({
       port: opts.port,
       hostname: opts.hostname,
-      idleTimeout: 0,
+      // Use default idle timeout (255s) instead of 0 (infinite) to prevent
+      // keeping the event loop alive after server.stop(). See #213.
+      idleTimeout: 255,
       fetch: App().fetch,
     });
     return server;

package/src/session/index.ts

@@ -630,9 +630,14 @@ export namespace Session {
           }
         | undefined;
 
+      // Check if standard usage has valid data (inputTokens or outputTokens defined)
+      // Also check for zero-valued tokens (some providers set them to 0 instead of undefined)
       const standardUsageIsEmpty =
-        input.usage.inputTokens === undefined &&
-        input.usage.outputTokens === undefined;
+        (input.usage.inputTokens === undefined &&
+          input.usage.outputTokens === undefined) ||
+        (input.usage.inputTokens === 0 &&
+          input.usage.outputTokens === 0 &&
+          !input.usage.totalTokens);
 
       // If standard usage is empty but openrouter metadata has usage, use it as source
       let effectiveUsage = input.usage;
@@ -658,6 +663,41 @@ export namespace Session {
         };
       }
 
+      // If still empty, try providerMetadata.anthropic.usage as fallback
+      // Some providers (e.g., opencode using @ai-sdk/anthropic) return usage in
+      // Anthropic-specific metadata with snake_case keys (input_tokens, output_tokens)
+      // while the standard AI SDK usage object remains empty.
+      // See: https://github.com/link-assistant/agent/issues/211
+      if (standardUsageIsEmpty && !openrouterUsage) {
+        const anthropicUsage = input.metadata?.['anthropic']?.['usage'] as
+          | {
+              input_tokens?: number;
+              output_tokens?: number;
+              cache_creation_input_tokens?: number;
+              cache_read_input_tokens?: number;
+            }
+          | undefined;
+
+        if (
+          anthropicUsage &&
+          (anthropicUsage.input_tokens || anthropicUsage.output_tokens)
+        ) {
+          if (Flag.OPENCODE_VERBOSE) {
+            log.debug(() => ({
+              message:
+                'Standard usage empty, falling back to anthropic provider metadata',
+              anthropicUsage: JSON.stringify(anthropicUsage),
+            }));
+          }
+          effectiveUsage = {
+            ...input.usage,
+            inputTokens: anthropicUsage.input_tokens ?? 0,
+            outputTokens: anthropicUsage.output_tokens ?? 0,
+            cachedInputTokens: anthropicUsage.cache_read_input_tokens ?? 0,
+          };
+        }
+      }
+
       // Extract top-level cachedInputTokens
       const topLevelCachedInputTokens = safeNum(
         toNumber(effectiveUsage.cachedInputTokens, 'cachedInputTokens')

package/src/session/retry.ts

@@ -123,6 +123,8 @@ export namespace SessionRetry {
   export async function sleep(ms: number, signal: AbortSignal): Promise<void> {
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(resolve, ms);
+      // Prevent sleep timer from keeping event loop alive (#213)
+      if (timeout.unref) timeout.unref();
       signal.addEventListener(
         'abort',
         () => {

package/src/util/timeout.ts

@@ -9,6 +9,8 @@ export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
       timeout = setTimeout(() => {
         reject(new Error(`Operation timed out after ${ms}ms`));
       }, ms);
+      // Prevent timeout from keeping the event loop alive (#213)
+      timeout.unref();
     }),
   ]);
 }