@link-assistant/agent 0.25.6 → 0.25.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.25.6",
+  "version": "0.25.8",
   "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/cli/continuous-mode.js

@@ -366,7 +366,7 @@ export async function runContinuousServerMode(
       });
 
       // Send message
-      fetch(
+      const requestPromise = fetch(
         `http://${server.hostname}:${server.port}/session/${sessionID}/message`,
         {
           method: 'POST',
@@ -391,7 +391,10 @@ export async function runContinuousServerMode(
         });
       });
 
+      // See the direct-mode comment below: the request rejection must be
+      // observed before the process can exit (#290).
       await messagePromise;
+      await requestPromise;
       isProcessing = false;
 
       // Process next pending message if any
@@ -586,7 +589,7 @@ export async function runContinuousDirectMode(
       });
 
       // Send message directly
-      SessionPrompt.prompt({
+      const promptPromise = SessionPrompt.prompt({
         sessionID,
         parts,
         model: { providerID, modelID },
@@ -605,7 +608,12 @@ export async function runContinuousDirectMode(
         });
       });
 
+      // Await BOTH the idle event and the prompt promise. A fatal failure
+      // publishes `session.idle` while unwinding, so waiting only on the idle
+      // event let the process exit before the rejection handler above ran —
+      // no error record, exit code 0 (#290).
       await messagePromise;
+      await promptPromise;
       isProcessing = false;
 
       // Process next pending message if any

package/src/cli/model-config.js

@@ -15,6 +15,17 @@ import {
   getDefaultCompactionSafetyMarginPercent,
 } from './defaults.ts';
 
+export class ModelResolutionError extends Error {
+  constructor({ modelArgv, defaultModel }) {
+    super(
+      `Detected a --model flag that could not be parsed reliably from argv ${JSON.stringify(modelArgv)}. ` +
+        `Refusing to continue with default model "${defaultModel}". ` +
+        'Pass each option and value as a separate argv element, for example: ["--model", "provider/model", "--verbose"].'
+    );
+    this.name = 'ModelResolutionError';
+  }
+}
+
 /**
  * Parse model config from argv. Supports "provider/model" or short "model" format.
  * @param {object} argv - Parsed command line arguments
@@ -75,18 +86,13 @@ export async function parseModelConfig(
       rawArgvStr.includes('-m ') ||
       rawArgvStr.includes('-m=')
     ) {
-      Log.Default.error(() => ({
-        message:
-          'CRITICAL: --model flag detected in process.argv but both getModelFromProcessArgv() and yargs returned default. ' +
-          'This is likely a Bun/yargs argument parsing bug (oven-sh/bun#22157). ' +
-          'The requested model will NOT be used — the default model will be used instead.',
-        processArgv: process.argv,
-        bunArgv:
-          typeof globalThis.Bun !== 'undefined' && globalThis.Bun.argv
-            ? globalThis.Bun.argv
-            : '(not available)',
+      const modelArgv = process.argv.filter(
+        (arg) => typeof arg === 'string' && /(^|\s)(--model|-m)(=|\s)/.test(arg)
+      );
+      throw new ModelResolutionError({
+        modelArgv: modelArgv.length > 0 ? modelArgv : process.argv,
         defaultModel,
-      }));
+      });
     }
   }
 

package/src/index.js

@@ -36,6 +36,7 @@ import {
   runContinuousServerMode,
   runContinuousDirectMode,
   resolveResumeSession,
+  getHasError,
 } from './cli/continuous-mode.js';
 import { parseStreamJsonInput } from './cli/input-queue.js';
 import { createBusEventSubscription } from './cli/event-handler.js';
@@ -425,6 +426,12 @@ async function runContinuousAgentMode(argv) {
     },
   });
 
+  // Continuous mode tracks its own error state in its module scope — fold it
+  // in here, otherwise a fatal run always exits 0 (#290, recurrence of #22).
+  if (getHasError()) {
+    hasError = true;
+  }
+
   // Explicitly exit to ensure process terminates (#213)
   Log.Default.info(() => ({
     message: 'Agent exiting',
@@ -497,8 +504,8 @@ async function runServerMode(
     const message = request.message || 'hi';
     const parts = [{ type: 'text', text: message }];
 
-    // Start the prompt (don't wait for response, events come via Bus)
-    fetch(
+    // Start the prompt (don't wait for the body, events come via Bus)
+    const requestPromise = fetch(
       `http://${server.hostname}:${server.port}/session/${sessionID}/message`,
       {
         method: 'POST',
@@ -526,8 +533,10 @@ async function runServerMode(
       });
     });
 
-    // Wait for session to become idle
+    // Wait for session to become idle, then for the request rejection to be
+    // observed (see runDirectMode, #290).
     await eventPromise;
+    await requestPromise;
   } finally {
     // Always clean up resources
     if (unsub) {
@@ -590,7 +599,7 @@ async function runDirectMode(
     const parts = [{ type: 'text', text: message }];
 
     // Start the prompt directly without HTTP
-    SessionPrompt.prompt({
+    const promptPromise = SessionPrompt.prompt({
       sessionID,
       parts,
       model: {
@@ -612,8 +621,12 @@ async function runDirectMode(
       });
     });
 
-    // Wait for session to become idle
+    // Wait for session to become idle, then for the prompt itself. A fatal
+    // failure publishes `session.idle` while unwinding, so awaiting only the
+    // idle event let the process exit before the rejection handler above ran
+    // — no error record, exit code 0 (#290).
     await eventPromise;
+    await promptPromise;
   } finally {
     // Always clean up resources
     if (unsub) {

package/src/provider/retry-fetch.ts

@@ -1,5 +1,6 @@
 import { Log } from '../util/log';
 import { config } from '../config/config';
+import { isUnreachableNetworkError } from '../util/network-error';
 
 /**
  * Custom fetch wrapper that handles rate limits (HTTP 429) and server errors (HTTP 5xx)
@@ -295,12 +296,17 @@ export namespace RetryFetch {
   function isRetryableError(error: unknown): boolean {
     if (!(error instanceof Error)) return false;
 
+    // Connection refused / host not found is not transient — nothing will
+    // start listening as a side effect of retrying, so do not burn the
+    // (default 7 day) retry budget on it.
+    // See: https://github.com/link-assistant/agent/issues/290
+    if (isUnreachableNetworkError(error)) return false;
+
     // Socket/connection errors (Bun has known timeout issues)
     // See: https://github.com/oven-sh/bun/issues/14439
     if (
       error.message.includes('ConnectionClosed') ||
       error.message.includes('ECONNRESET') ||
-      error.message.includes('ECONNREFUSED') ||
       error.message.includes('socket') ||
       error.message.includes('connection')
     ) {

package/src/session/message-v2.ts

@@ -13,6 +13,7 @@ import { Identifier } from '../id/id';
 import { Snapshot } from '../snapshot';
 import { fn } from '../util/fn';
 import { Storage } from '../storage/storage';
+import { isUnreachableNetworkError } from '../util/network-error';
 
 export namespace MessageV2 {
   export const OutputLengthError = NamedError.create(
@@ -920,7 +921,10 @@ export namespace MessageV2 {
           {
             message: e.message,
             statusCode: e.statusCode,
-            isRetryable: e.isRetryable,
+            // A refused connection / unresolvable host is not transient: the
+            // AI SDK marks it retryable, but retrying it for the 7-day global
+            // budget makes the CLI hang forever (#290).
+            isRetryable: isUnreachableNetworkError(e) ? false : e.isRetryable,
             responseHeaders: e.responseHeaders,
             responseBody: e.responseBody,
           },

package/src/session/prompt.ts

@@ -457,6 +457,21 @@ export namespace SessionPrompt {
           stack: error instanceof Error ? error.stack : undefined,
           hint: 'Check that the model exists in the provider. Use --verbose for more details.',
         }));
+        // Publish the fatal error on the bus so streaming consumers see an
+        // `error` event instead of only a `log` record, and so the CLI can
+        // exit non-zero (#290, recurrence of #22).
+        const cause = error instanceof Error ? error : new Error(String(error));
+        const fatal = new Error(
+          `Failed to initialize model "${lastUser.model.providerID}/${lastUser.model.modelID}": ${cause.message || cause.name}`,
+          { cause }
+        );
+        fatal.name = cause.name;
+        Bus.publish(Session.Event.Error, {
+          sessionID,
+          error: MessageV2.fromError(fatal, {
+            providerID: lastUser.model.providerID,
+          }),
+        });
         // Re-throw the error so it can be handled by the caller
         throw error;
       }

package/src/util/network-error.ts

@@ -0,0 +1,56 @@
+/**
+ * Classification of network-level errors that are *not* transient.
+ *
+ * A refused connection or an unresolvable host will not start working as a
+ * side effect of retrying: nothing is listening on the port, or the name does
+ * not resolve. Retrying those for the global retry budget (7 days by default,
+ * see #167) makes the CLI hang forever instead of failing fast.
+ *
+ * Transient DNS failures (EAI_AGAIN) are deliberately NOT included — those can
+ * recover on their own and stay retryable.
+ *
+ * @see https://github.com/link-assistant/agent/issues/290
+ */
+
+/** Error codes/markers that mean "the endpoint is unreachable, permanently". */
+const UNREACHABLE_MARKERS = [
+  'ConnectionRefused',
+  'ECONNREFUSED',
+  'ENOTFOUND',
+  'EAI_NONAME',
+  'ERR_NAME_NOT_RESOLVED',
+  'failed to lookup address information',
+  'Unable to connect. Is the computer able to access the url?',
+];
+
+function collectStrings(value: unknown, depth: number, out: string[]): void {
+  if (depth > 5 || value === null || value === undefined) return;
+
+  if (typeof value === 'string') {
+    out.push(value);
+    return;
+  }
+
+  if (typeof value !== 'object') return;
+
+  const record = value as Record<string, unknown>;
+  for (const key of ['code', 'errno', 'name', 'message', 'syscall']) {
+    const field = record[key];
+    if (typeof field === 'string') out.push(field);
+  }
+  collectStrings(record['cause'], depth + 1, out);
+  collectStrings(record['error'], depth + 1, out);
+  collectStrings(record['data'], depth + 1, out);
+}
+
+/**
+ * Returns true when the error means the endpoint cannot be reached at all
+ * (connection refused, host not found) and retrying cannot help.
+ */
+export function isUnreachableNetworkError(error: unknown): boolean {
+  const haystack: string[] = [];
+  collectStrings(error, 0, haystack);
+  const joined = haystack.join('\n');
+  if (!joined) return false;
+  return UNREACHABLE_MARKERS.some((marker) => joined.includes(marker));
+}