@link-assistant/agent 0.19.0 → 0.19.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "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/auth/plugins.ts

@@ -1542,9 +1542,12 @@ const GooglePlugin: AuthPlugin = {
 
     /**
      * Check if a response status is retryable (transient error).
+     * Includes 500/502 for intermittent server errors (#231).
      */
     const isRetryableStatus = (status: number): boolean => {
-      return status === 429 || status === 503;
+      return (
+        status === 429 || status === 500 || status === 502 || status === 503
+      );
     };
 
     /**

package/src/cli/model-config.js

@@ -68,29 +68,39 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
       modelID,
     }));
 
-    // Validate that the model exists in the provider (#196)
-    // Without this check, a non-existent model silently proceeds and fails at API call time
-    // with confusing "reason: unknown" and zero tokens
+    // Validate that the model exists in the provider (#196, #231)
+    // If user explicitly specified provider/model and the model is not found,
+    // fail immediately instead of silently falling back to a different model.
     try {
       const { Provider } = await import('../provider/provider.ts');
       const s = await Provider.state();
       const provider = s.providers[providerID];
       if (provider && !provider.info.models[modelID]) {
-        // Provider exists but model doesn't - warn and suggest alternatives
-        const availableModels = Object.keys(provider.info.models).slice(0, 5);
-        Log.Default.warn(() => ({
+        // Provider exists but model doesn't — fail with a clear error (#231)
+        // Silent fallback caused kimi-k2.5-free to be routed to minimax-m2.5-free
+        const availableModels = Object.keys(provider.info.models).slice(0, 10);
+        Log.Default.error(() => ({
           message:
-            'model not found in provider - will attempt anyway (provider may support unlisted models)',
+            'model not found in provider — refusing to proceed with explicit provider/model',
           providerID,
           modelID,
           availableModels,
         }));
+        throw new Error(
+          `Model "${modelID}" not found in provider "${providerID}". ` +
+            `Available models include: ${availableModels.join(', ')}. ` +
+            `Use --model ${providerID}/<model-id> with a valid model, or omit the provider prefix for auto-resolution.`
+        );
       }
     } catch (validationError) {
-      // Don't fail on validation errors - the model may still work
-      // This is a best-effort check
+      // Re-throw if this is our own validation error (not an infrastructure issue)
+      if (validationError?.message?.includes('not found in provider')) {
+        throw validationError;
+      }
+      // For infrastructure errors (e.g. can't load provider state), log and continue
       Log.Default.info(() => ({
-        message: 'skipping model existence validation',
+        message:
+          'skipping model existence validation due to infrastructure error',
         reason: validationError?.message,
       }));
     }

package/src/index.js

@@ -27,7 +27,10 @@ import { McpCommand } from './cli/cmd/mcp.ts';
 import { AuthCommand } from './cli/cmd/auth.ts';
 import { FormatError } from './cli/error.ts';
 import { UI } from './cli/ui.ts';
-import { createVerboseFetch } from './util/verbose-fetch.ts';
+import {
+  createVerboseFetch,
+  registerPendingStreamLogExitHandler,
+} from './util/verbose-fetch.ts';
 import {
   runContinuousServerMode,
   runContinuousDirectMode,
@@ -822,6 +825,8 @@ async function main() {
             caller: 'global',
           });
           globalThis.__agentVerboseFetchInstalled = true;
+          // Register handler to warn about pending stream logs at process exit (#231)
+          registerPendingStreamLogExitHandler();
         }
       })
       .fail((msg, err, yargs) => {

package/src/provider/provider.ts

@@ -1623,35 +1623,30 @@ export namespace Provider {
     }
 
     if (!isSyntheticProvider && !info) {
-      // Still not found after refresh - create fallback info and try anyway
-      // Provider may support unlisted models
+      // Model not found even after cache refresh — fail with a clear error (#231)
+      // Previously this created synthetic fallback info, which allowed the API call
+      // to proceed with the wrong model (e.g., kimi-k2.5-free routed to minimax-m2.5-free)
       const availableInProvider = Object.keys(provider.info.models).slice(
         0,
         10
       );
-      log.warn(() => ({
+      log.error(() => ({
         message:
-          'model not in provider catalog after refresh - attempting anyway (may be unlisted)',
+          'model not found in provider catalog after refresh — refusing to proceed',
         providerID,
         modelID,
         availableModels: availableInProvider,
         totalModels: Object.keys(provider.info.models).length,
       }));
 
-      // Create a minimal fallback model info so SDK loading can proceed
-      // Use sensible defaults - the provider will reject if the model truly doesn't exist
-      info = {
-        id: modelID,
-        name: modelID,
-        release_date: '',
-        attachment: false,
-        reasoning: false,
-        temperature: true,
-        tool_call: true,
-        cost: { input: 0, output: 0 },
-        limit: { context: 128000, output: 16384 },
-        options: {},
-      } as ModelsDev.Model;
+      throw new ModelNotFoundError({
+        providerID,
+        modelID,
+        suggestion:
+          `Model "${modelID}" not found in provider "${providerID}" (checked ${Object.keys(provider.info.models).length} models). ` +
+          `Available models include: ${availableInProvider.join(', ')}. ` +
+          `Use --model ${providerID}/<model-id> with a valid model.`,
+      });
     }
 
     try {

package/src/provider/retry-fetch.ts

@@ -2,10 +2,11 @@ import { Log } from '../util/log';
 import { config } from '../config/config';
 
 /**
- * Custom fetch wrapper that handles rate limits (HTTP 429) using time-based retry logic.
+ * Custom fetch wrapper that handles rate limits (HTTP 429) and server errors (HTTP 5xx)
+ * using time-based retry logic.
  *
- * This wrapper intercepts 429 responses at the HTTP level before the AI SDK's internal
- * retry mechanism can interfere. It respects:
+ * This wrapper intercepts 429 and 5xx responses at the HTTP level before the AI SDK's
+ * internal retry mechanism can interfere. It respects:
  * - retry-after headers (both seconds and HTTP date formats)
  * - retry-after-ms header for millisecond precision
  * - LINK_ASSISTANT_AGENT_RETRY_TIMEOUT for global time-based retry limit
@@ -15,10 +16,12 @@ import { config } from '../config/config';
  * The AI SDK's internal retry uses a fixed count (default 3 attempts) and ignores
  * retry-after headers. When providers return long retry-after values (e.g., 64 minutes),
  * the SDK exhausts its retries before the agent can properly wait.
+ * Additionally, server errors (500, 502, 503) from providers like OpenCode API were not
+ * retried, causing compaction cycles to be lost silently.
  *
  * Solution:
- * 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.
+ * By wrapping fetch, we handle rate limits and server errors 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
@@ -26,6 +29,7 @@ import { config } from '../config/config';
  *
  * @see https://github.com/link-assistant/agent/issues/167
  * @see https://github.com/link-assistant/agent/issues/183
+ * @see https://github.com/link-assistant/agent/issues/231
  * @see https://github.com/vercel/ai/issues/12585
  */
 
@@ -37,6 +41,20 @@ export namespace RetryFetch {
   const RETRY_BACKOFF_FACTOR = 2;
   const RETRY_MAX_DELAY_NO_HEADERS = 30_000;
 
+  // Maximum number of retries for server errors (5xx) — unlike rate limits (429)
+  // which retry indefinitely within the global timeout, server errors use a fixed
+  // retry count to avoid retrying permanently broken endpoints (#231)
+  const SERVER_ERROR_MAX_RETRIES = 3;
+
+  /**
+   * Check if an HTTP status code is a retryable server error.
+   * Retries on 500 (Internal Server Error), 502 (Bad Gateway), and 503 (Service Unavailable).
+   * @see https://github.com/link-assistant/agent/issues/231
+   */
+  function isRetryableServerError(status: number): boolean {
+    return status === 500 || status === 502 || status === 503;
+  }
+
   // Minimum retry interval to prevent rapid retries (default: 30 seconds)
   // Can be configured via AGENT_MIN_RETRY_INTERVAL env var
   function getMinRetryInterval(): number {
@@ -298,19 +316,20 @@ export namespace RetryFetch {
   };
 
   /**
-   * Create a fetch function that handles rate limits with time-based retry logic.
+   * Create a fetch function that handles rate limits and server errors with retry logic.
    *
    * This wrapper:
-   * 1. Intercepts HTTP 429 responses
-   * 2. Parses retry-after headers
-   * 3. Waits for the specified duration (respecting global timeout)
-   * 4. Retries the request
+   * 1. Intercepts HTTP 429 (rate limit) responses — retries with retry-after headers
+   * 2. Intercepts HTTP 500/502/503 (server error) responses — retries up to SERVER_ERROR_MAX_RETRIES
+   * 3. Parses retry-after headers for 429 responses
+   * 4. Uses exponential backoff for server errors and network errors
+   * 5. Respects global LINK_ASSISTANT_AGENT_RETRY_TIMEOUT for all retries
    *
    * If retry-after exceeds LINK_ASSISTANT_AGENT_RETRY_TIMEOUT, the original 429 response is returned
    * to let higher-level error handling take over.
    *
    * @param options Configuration options
-   * @returns A fetch function with rate limit retry handling
+   * @returns A fetch function with rate limit and server error retry handling
    */
   export function create(options: RetryFetchOptions = {}): typeof fetch {
     const baseFetch = options.baseFetch ?? fetch;
@@ -365,7 +384,74 @@ export namespace RetryFetch {
           throw error;
         }
 
-        // Only handle rate limit errors (429)
+        // Handle retryable server errors (500, 502, 503) with limited retries (#231)
+        // Unlike rate limits (429) which retry indefinitely within timeout,
+        // server errors use a fixed count to avoid retrying broken endpoints.
+        if (isRetryableServerError(response.status)) {
+          if (attempt > SERVER_ERROR_MAX_RETRIES) {
+            // Read response body for diagnostics before returning (#231)
+            // This ensures the actual server error is visible in logs,
+            // preventing misleading downstream errors like "input_tokens undefined"
+            let errorBody = '';
+            try {
+              errorBody = await response.clone().text();
+            } catch {
+              errorBody = '<failed to read response body>';
+            }
+            log.warn(() => ({
+              message:
+                'server error max retries exceeded, returning error response',
+              sessionID,
+              status: response.status,
+              attempt,
+              maxRetries: SERVER_ERROR_MAX_RETRIES,
+              responseBody: errorBody.slice(0, 500),
+            }));
+            return response;
+          }
+
+          const elapsed = Date.now() - startTime;
+          if (elapsed >= maxRetryTimeout) {
+            let errorBody = '';
+            try {
+              errorBody = await response.clone().text();
+            } catch {
+              errorBody = '<failed to read response body>';
+            }
+            log.warn(() => ({
+              message:
+                'retry timeout exceeded for server error, returning error response',
+              sessionID,
+              status: response.status,
+              elapsedMs: elapsed,
+              maxRetryTimeoutMs: maxRetryTimeout,
+              responseBody: errorBody.slice(0, 500),
+            }));
+            return response;
+          }
+
+          // Use exponential backoff for server errors (no retry-after expected)
+          const delay = addJitter(
+            Math.min(
+              RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1),
+              Math.min(maxBackoffDelay, RETRY_MAX_DELAY_NO_HEADERS)
+            )
+          );
+
+          log.info(() => ({
+            message: 'server error, will retry',
+            sessionID,
+            status: response.status,
+            attempt,
+            maxRetries: SERVER_ERROR_MAX_RETRIES,
+            delayMs: delay,
+          }));
+
+          await sleep(delay, init?.signal ?? undefined);
+          continue;
+        }
+
+        // Only handle rate limit errors (429) beyond this point
         if (response.status !== 429) {
           return response;
         }

package/src/storage/storage.ts

@@ -180,8 +180,19 @@ export namespace Storage {
     for (let index = migration; index < MIGRATIONS.length; index++) {
       log.info(() => ({ message: 'running migration', index }));
       const migration = MIGRATIONS[index];
-      await migration(dir).catch(() =>
-        log.error(() => ({ message: 'failed to run migration', index }))
+      await migration(dir).catch((migrationError) =>
+        log.error(() => ({
+          message: 'failed to run migration',
+          index,
+          error:
+            migrationError instanceof Error
+              ? {
+                  name: migrationError.name,
+                  message: migrationError.message,
+                  stack: migrationError.stack,
+                }
+              : String(migrationError),
+        }))
       );
       await Bun.write(path.join(dir, 'migration'), (index + 1).toString());
     }

package/src/util/verbose-fetch.ts

@@ -24,6 +24,21 @@ const log = Log.create({ service: 'http' });
 /** Global call counter shared across all verbose fetch wrappers */
 let globalHttpCallCount = 0;
 
+/**
+ * Track pending async stream log operations (#231).
+ * When the process exits while stream logging is in progress, we log a warning
+ * so missing HTTP response bodies are visible in the logs rather than silently lost.
+ */
+let pendingStreamLogs = 0;
+
+/**
+ * Get the current count of pending stream log operations.
+ * Useful for diagnostics and testing.
+ */
+export function getPendingStreamLogCount(): number {
+  return pendingStreamLogs;
+}
+
 /**
  * Sanitize HTTP headers by masking sensitive values.
  * Masks authorization, x-api-key, and api-key headers.
@@ -196,7 +211,8 @@ export function createVerboseFetch(
           if (isStreaming) {
             const [sdkStream, logStream] = response.body.tee();
 
-            // Consume log stream asynchronously
+            // Consume log stream asynchronously, tracking pending operations (#231)
+            pendingStreamLogs++;
             (async () => {
               try {
                 const reader = logStream.getReader();
@@ -225,6 +241,8 @@ export function createVerboseFetch(
                 });
               } catch {
                 // Ignore logging errors
+              } finally {
+                pendingStreamLogs--;
               }
             })();
 
@@ -304,3 +322,18 @@ export function getHttpCallCount(): number {
 export function resetHttpCallCount(): void {
   globalHttpCallCount = 0;
 }
+
+/**
+ * Register a process exit handler that warns about pending stream log operations.
+ * Call this once at startup when verbose mode is enabled (#231).
+ */
+export function registerPendingStreamLogExitHandler(): void {
+  process.once('exit', () => {
+    if (pendingStreamLogs > 0) {
+      // Use stderr directly since the process is exiting and log infrastructure may be unavailable
+      process.stderr.write(
+        `[verbose] warning: ${pendingStreamLogs} HTTP stream response log(s) were still pending at process exit — response bodies may be missing from logs\n`
+      );
+    }
+  });
+}