@link-assistant/agent 0.25.5 → 0.25.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.25.5",
+  "version": "0.25.7",
   "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/cmd/run.ts

@@ -264,7 +264,11 @@ export const RunCommand = cmd({
               err = String(props.error.data.message);
             }
             errorMsg = errorMsg ? errorMsg + EOL + err : err;
-            if (outputJsonEvent('error', { error: props.error })) continue;
+            // Always include the human-readable string alongside the
+            // machine-readable object so consumers never print
+            // "[object Object]" (#289).
+            if (outputJsonEvent('error', { message: err, error: props.error }))
+              continue;
             UI.error(err);
           }
 

package/src/cli/continuous-mode.js

@@ -11,6 +11,7 @@ import { SessionPrompt } from '../session/prompt.ts';
 import { createEventHandler, serializeOutput } from '../json-standard/index.ts';
 import { createContinuousStdinReader } from './input-queue.js';
 import { outputBusEvent } from './event-handler.js';
+import { errorText } from '../util/error-text.ts';
 import { Permission } from '../permission/index.ts';
 import { Log } from '../util/log.ts';
 import { config } from '../config/config.ts';
@@ -365,7 +366,7 @@ export async function runContinuousServerMode(
       });
 
       // Send message
-      fetch(
+      const requestPromise = fetch(
         `http://${server.hostname}:${server.port}/session/${sessionID}/message`,
         {
           method: 'POST',
@@ -385,11 +386,15 @@ export async function runContinuousServerMode(
           type: 'error',
           timestamp: Date.now(),
           sessionID,
+          message: errorText(error),
           error: error instanceof Error ? error.message : String(error),
         });
       });
 
+      // 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
@@ -584,7 +589,7 @@ export async function runContinuousDirectMode(
       });
 
       // Send message directly
-      SessionPrompt.prompt({
+      const promptPromise = SessionPrompt.prompt({
         sessionID,
         parts,
         model: { providerID, modelID },
@@ -598,11 +603,17 @@ export async function runContinuousDirectMode(
           type: 'error',
           timestamp: Date.now(),
           sessionID,
+          message: errorText(error),
           error: error instanceof Error ? error.message : String(error),
         });
       });
 
+      // 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/event-handler.js

@@ -4,6 +4,7 @@
  */
 
 import { Bus } from '../bus/index.ts';
+import { errorText } from '../util/error-text.ts';
 
 /**
  * Create a subscription for session bus events that outputs events in the selected JSON format.
@@ -90,11 +91,13 @@ export function outputBusEvent({
 
       // If tool failed, also output an error event
       if (part.state?.status === 'error') {
+        const stateError = part.state.error;
         eventHandler.output({
           type: 'error',
           timestamp: Date.now(),
           sessionID,
-          error: part.state.error || 'Tool execution failed',
+          message: errorText(stateError, 'Tool execution failed'),
+          error: stateError || 'Tool execution failed',
         });
       }
     }
@@ -145,6 +148,7 @@ export function outputBusEvent({
       type: 'error',
       timestamp: Date.now(),
       sessionID,
+      message: errorText(props.error),
       error: props.error,
     });
   }

package/src/index.js

@@ -27,6 +27,7 @@ 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 { errorText } from './util/error-text.ts';
 import {
   createVerboseFetch,
   registerPendingStreamLogExitHandler,
@@ -35,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';
@@ -424,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',
@@ -496,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',
@@ -520,12 +528,15 @@ async function runServerMode(
         type: 'error',
         timestamp: Date.now(),
         sessionID,
+        message: errorText(error),
         error: error instanceof Error ? error.message : String(error),
       });
     });
 
-    // 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) {
@@ -588,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: {
@@ -605,12 +616,17 @@ async function runDirectMode(
         type: 'error',
         timestamp: Date.now(),
         sessionID,
+        message: errorText(error),
         error: error instanceof Error ? error.message : String(error),
       });
     });
 
-    // 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/error-text.ts

@@ -0,0 +1,82 @@
+/**
+ * Human-readable rendering of arbitrary error values (issue #289).
+ *
+ * JSON `error` events used to carry only the machine-readable
+ * `NamedError.toObject()` shape (`{name, data: {message}}`), so consumers doing
+ * `` `${record.error}` `` published `[object Object]` and the real cause was
+ * lost. Every emitted `error` event now also carries a `message` string
+ * produced by `stringifyErrorValue`.
+ *
+ * The renderer is circular-safe and depth-limited, and never invents a
+ * placeholder: when nothing readable can be derived it returns an empty
+ * string so the caller can pick its own fallback.
+ */
+
+const MAX_DEPTH = 5;
+
+function fromParts(name: string | undefined, message: string | undefined) {
+  if (name && message) return `${name}: ${message}`;
+  return message || name || '';
+}
+
+function render(value: unknown, depth: number, seen: Set<object>): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value.trim();
+  if (typeof value === 'number' || typeof value === 'boolean')
+    return String(value);
+  if (typeof value !== 'object') return '';
+
+  const object = value as Record<string, unknown>;
+  if (seen.has(object)) return '';
+  if (depth >= MAX_DEPTH) return '';
+  seen.add(object);
+
+  if (Array.isArray(object)) {
+    const rendered = object
+      .map((item) => render(item, depth + 1, seen))
+      .filter((item) => item.length > 0);
+    return rendered.join('; ');
+  }
+
+  if (object instanceof Error) {
+    return fromParts(object.name, object.message) || String(object);
+  }
+
+  // NamedError.toObject(): { name, data: { message, ... } }
+  const name = typeof object.name === 'string' ? object.name : undefined;
+  const data = object.data;
+  if (data && typeof data === 'object') {
+    const dataMessage = render(
+      (data as Record<string, unknown>).message,
+      depth + 1,
+      seen
+    );
+    if (dataMessage) return fromParts(name, dataMessage);
+  }
+
+  const message = render(object.message, depth + 1, seen);
+  if (message) return fromParts(name, message);
+
+  // Envelope shapes: { error: … }, { cause: … }
+  const nested =
+    render(object.error, depth + 1, seen) ||
+    render(object.cause, depth + 1, seen);
+  if (nested) return name ? fromParts(name, nested) : nested;
+
+  return name || '';
+}
+
+/**
+ * Render any error-ish value as a human-readable string.
+ * Returns an empty string when nothing readable can be derived.
+ */
+export function stringifyErrorValue(value: unknown): string {
+  return render(value, 0, new Set<object>());
+}
+
+/**
+ * Same as {@link stringifyErrorValue} but guarantees a non-empty string.
+ */
+export function errorText(value: unknown, fallback = 'Unknown error'): string {
+  return stringifyErrorValue(value) || fallback;
+}

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