@link-assistant/agent 0.16.16 → 0.16.18

package/src/provider/models.ts

@@ -1,11 +1,13 @@
 import { Global } from '../global';
 import { Log } from '../util/log';
+import { createVerboseFetch } from '../util/verbose-fetch';
 import path from 'path';
 import z from 'zod';
 import { data } from './models-macro';
 
 export namespace ModelsDev {
   const log = Log.create({ service: 'models.dev' });
+  const verboseFetch = createVerboseFetch(fetch, { caller: 'models.dev' });
   const filepath = path.join(Global.Path.cache, 'models.json');
 
   export const Model = z
@@ -145,7 +147,7 @@ export namespace ModelsDev {
   export async function refresh() {
     const file = Bun.file(filepath);
     log.info(() => ({ message: 'refreshing', file }));
-    const result = await fetch('https://models.dev/api.json', {
+    const result = await verboseFetch('https://models.dev/api.json', {
       headers: {
         'User-Agent': 'agent-cli/1.0.0',
       },

package/src/provider/provider.ts

@@ -1207,8 +1207,22 @@ export namespace Provider {
       // When verbose is disabled, the wrapper is a no-op passthrough with negligible overhead.
       // See: https://github.com/link-assistant/agent/issues/200
       // See: https://github.com/link-assistant/agent/issues/206
+      // See: https://github.com/link-assistant/agent/issues/215
       {
         const innerFetch = options['fetch'];
+        let verboseWrapperConfirmed = false;
+        let httpCallCount = 0;
+
+        // Log at SDK creation time that the fetch wrapper is installed.
+        // This runs once per provider SDK creation (not per request).
+        // If verbose is off at creation time, the per-request check still applies.
+        // See: https://github.com/link-assistant/agent/issues/215
+        log.info('verbose HTTP fetch wrapper installed', {
+          providerID: provider.id,
+          pkg,
+          verboseAtCreation: Flag.OPENCODE_VERBOSE,
+        });
+
         options['fetch'] = async (
           input: RequestInfo | URL,
           init?: RequestInit
@@ -1218,6 +1232,24 @@ export namespace Provider {
             return innerFetch(input, init);
           }
 
+          httpCallCount++;
+          const callNum = httpCallCount;
+
+          // Log a one-time confirmation that the verbose wrapper is active for this provider.
+          // This diagnostic breadcrumb confirms the wrapper is in the fetch chain.
+          // Also write to stderr as a redundant channel — stdout JSON may be filtered by wrappers.
+          // See: https://github.com/link-assistant/agent/issues/215
+          if (!verboseWrapperConfirmed) {
+            verboseWrapperConfirmed = true;
+            log.info('verbose HTTP logging active', {
+              providerID: provider.id,
+            });
+            // Redundant stderr confirmation — visible even if stdout is piped/filtered
+            process.stderr.write(
+              `[verbose] HTTP logging active for provider: ${provider.id}\n`
+            );
+          }
+
           const url =
             typeof input === 'string'
               ? input
@@ -1226,50 +1258,64 @@ export namespace Provider {
                 : input.url;
           const method = init?.method ?? 'GET';
 
-          // Sanitize headers - mask authorization values
-          const sanitizedHeaders: Record<string, string> = {};
-          const rawHeaders = init?.headers;
-          if (rawHeaders) {
-            const entries =
-              rawHeaders instanceof Headers
-                ? Array.from(rawHeaders.entries())
-                : Array.isArray(rawHeaders)
-                  ? rawHeaders
-                  : Object.entries(rawHeaders);
-            for (const [key, value] of entries) {
-              const lower = key.toLowerCase();
-              if (
-                lower === 'authorization' ||
-                lower === 'x-api-key' ||
-                lower === 'api-key'
-              ) {
-                sanitizedHeaders[key] =
-                  typeof value === 'string' && value.length > 8
-                    ? value.slice(0, 4) + '...' + value.slice(-4)
-                    : '[REDACTED]';
-              } else {
-                sanitizedHeaders[key] = String(value);
+          // Wrap all verbose logging in try/catch so it never breaks the actual HTTP request.
+          // If logging fails, the request must still proceed — logging is observability, not control flow.
+          // See: https://github.com/link-assistant/agent/issues/215
+          let sanitizedHeaders: Record<string, string> = {};
+          let bodyPreview: string | undefined;
+          try {
+            // Sanitize headers - mask authorization values
+            const rawHeaders = init?.headers;
+            if (rawHeaders) {
+              const entries =
+                rawHeaders instanceof Headers
+                  ? Array.from(rawHeaders.entries())
+                  : Array.isArray(rawHeaders)
+                    ? rawHeaders
+                    : Object.entries(rawHeaders);
+              for (const [key, value] of entries) {
+                const lower = key.toLowerCase();
+                if (
+                  lower === 'authorization' ||
+                  lower === 'x-api-key' ||
+                  lower === 'api-key'
+                ) {
+                  sanitizedHeaders[key] =
+                    typeof value === 'string' && value.length > 8
+                      ? value.slice(0, 4) + '...' + value.slice(-4)
+                      : '[REDACTED]';
+                } else {
+                  sanitizedHeaders[key] = String(value);
+                }
               }
             }
-          }
 
-          // Log request body preview (truncated)
-          let bodyPreview: string | undefined;
-          if (init?.body) {
-            const bodyStr =
-              typeof init.body === 'string'
-                ? init.body
-                : init.body instanceof ArrayBuffer ||
-                    init.body instanceof Uint8Array
-                  ? `[binary ${(init.body as ArrayBuffer).byteLength ?? (init.body as Uint8Array).length} bytes]`
-                  : undefined;
-            if (bodyStr && typeof bodyStr === 'string') {
-              bodyPreview =
-                bodyStr.length > 2000
-                  ? bodyStr.slice(0, 2000) +
-                    `... [truncated, total ${bodyStr.length} chars]`
-                  : bodyStr;
+            // Log request body preview (truncated)
+            if (init?.body) {
+              const bodyStr =
+                typeof init.body === 'string'
+                  ? init.body
+                  : init.body instanceof ArrayBuffer ||
+                      init.body instanceof Uint8Array
+                    ? `[binary ${(init.body as ArrayBuffer).byteLength ?? (init.body as Uint8Array).length} bytes]`
+                    : undefined;
+              if (bodyStr && typeof bodyStr === 'string') {
+                bodyPreview =
+                  bodyStr.length > 2000
+                    ? bodyStr.slice(0, 2000) +
+                      `... [truncated, total ${bodyStr.length} chars]`
+                    : bodyStr;
+              }
             }
+          } catch (prepError) {
+            // If header/body processing fails, log the error but continue with the request
+            log.warn('verbose logging: failed to prepare request details', {
+              providerID: provider.id,
+              error:
+                prepError instanceof Error
+                  ? prepError.message
+                  : String(prepError),
+            });
           }
 
           // Use direct (non-lazy) logging for HTTP request/response to ensure output
@@ -1277,7 +1323,9 @@ export namespace Provider {
           // 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', {
+            caller: `provider/${provider.id}`,
             providerID: provider.id,
+            callNum,
             method,
             url,
             headers: sanitizedHeaders,
@@ -1286,13 +1334,21 @@ export namespace Provider {
 
           const startMs = Date.now();
           try {
-            const response = await innerFetch(input, init);
+            // Pass Bun-specific verbose:true to get detailed connection debugging
+            // (prints request/response headers to stderr on socket errors).
+            // This is a no-op on non-Bun runtimes.
+            // See: https://bun.sh/docs/api/fetch
+            // See: https://github.com/link-assistant/agent/issues/215
+            const verboseInit = { ...init, verbose: true } as RequestInit;
+            const response = await innerFetch(input, verboseInit);
             const durationMs = Date.now() - startMs;
 
             // 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', {
+              caller: `provider/${provider.id}`,
               providerID: provider.id,
+              callNum,
               method,
               url,
               status: response.status,
@@ -1342,7 +1398,9 @@ export namespace Provider {
                     // Use direct (non-lazy) logging for stream body
                     // See: https://github.com/link-assistant/agent/issues/211
                     log.info('HTTP response body (stream)', {
+                      caller: `provider/${provider.id}`,
                       providerID: provider.id,
+                      callNum,
                       url,
                       bodyPreview: truncated
                         ? bodyPreview + `... [truncated]`
@@ -1370,7 +1428,9 @@ export namespace Provider {
                 // Use direct (non-lazy) logging for non-streaming body
                 // See: https://github.com/link-assistant/agent/issues/211
                 log.info('HTTP response body', {
+                  caller: `provider/${provider.id}`,
                   providerID: provider.id,
+                  callNum,
                   url,
                   bodyPreview,
                 });
@@ -1386,15 +1446,29 @@ export namespace Provider {
           } catch (error) {
             const durationMs = Date.now() - startMs;
             // Use direct (non-lazy) logging for error path
+            // Include stack trace and error cause for better debugging of socket errors
             // See: https://github.com/link-assistant/agent/issues/211
+            // See: https://github.com/link-assistant/agent/issues/215
             log.error('HTTP request failed', {
+              caller: `provider/${provider.id}`,
               providerID: provider.id,
+              callNum,
               method,
               url,
               durationMs,
               error:
                 error instanceof Error
-                  ? { name: error.name, message: error.message }
+                  ? {
+                      name: error.name,
+                      message: error.message,
+                      stack: error.stack,
+                      cause:
+                        error.cause instanceof Error
+                          ? error.cause.message
+                          : error.cause
+                            ? String(error.cause)
+                            : undefined,
+                    }
                   : 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/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/tool/codesearch.ts

@@ -1,6 +1,9 @@
 import z from 'zod';
 import { Tool } from './tool';
 import DESCRIPTION from './codesearch.txt';
+import { createVerboseFetch } from '../util/verbose-fetch';
+
+const verboseFetch = createVerboseFetch(fetch, { caller: 'codesearch' });
 
 const API_CONFIG = {
   BASE_URL: 'https://mcp.exa.ai',
@@ -73,7 +76,7 @@ export const CodeSearchTool = Tool.define('codesearch', {
         'content-type': 'application/json',
       };
 
-      const response = await fetch(
+      const response = await verboseFetch(
         `${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.CONTEXT}`,
         {
           method: 'POST',

package/src/tool/webfetch.ts

@@ -2,6 +2,9 @@ import z from 'zod';
 import { Tool } from './tool';
 import TurndownService from 'turndown';
 import DESCRIPTION from './webfetch.txt';
+import { createVerboseFetch } from '../util/verbose-fetch';
+
+const verboseFetch = createVerboseFetch(fetch, { caller: 'webfetch' });
 
 const MAX_RESPONSE_SIZE = 5 * 1024 * 1024; // 5MB
 const DEFAULT_TIMEOUT = 30 * 1000; // 30 seconds
@@ -59,7 +62,7 @@ export const WebFetchTool = Tool.define('webfetch', {
           'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8';
     }
 
-    const response = await fetch(params.url, {
+    const response = await verboseFetch(params.url, {
       signal: AbortSignal.any([controller.signal, ctx.abort]),
       headers: {
         'User-Agent':

package/src/tool/websearch.ts

@@ -2,6 +2,9 @@ import z from 'zod';
 import { Tool } from './tool';
 import DESCRIPTION from './websearch.txt';
 import { Config } from '../config/config';
+import { createVerboseFetch } from '../util/verbose-fetch';
+
+const verboseFetch = createVerboseFetch(fetch, { caller: 'websearch' });
 
 const API_CONFIG = {
   BASE_URL: 'https://mcp.exa.ai',
@@ -91,7 +94,7 @@ export const WebSearchTool = Tool.define('websearch', {
         'content-type': 'application/json',
       };
 
-      const response = await fetch(
+      const response = await verboseFetch(
         `${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.SEARCH}`,
         {
           method: 'POST',

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();
     }),
   ]);
 }