@link-assistant/agent 0.8.11 → 0.8.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.8.11",
+  "version": "0.8.14",
   "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/index.js

@@ -1,5 +1,10 @@
 #!/usr/bin/env bun
 
+// Set process title to 'agent' so it appears correctly in process monitoring tools like top/ps
+// Both process.title and process.argv0 need to be set for maximum compatibility
+process.title = 'agent';
+process.argv0 = 'agent';
+
 import { Server } from './server/server.ts';
 import { Instance } from './project/instance.ts';
 import { Log } from './util/log.ts';

package/src/session/message-v2.ts

@@ -58,6 +58,21 @@ export namespace MessageV2 {
     typeof SocketConnectionError.Schema
   >;
 
+  /**
+   * Timeout error - caused by AbortSignal.timeout() firing when an API request
+   * takes too long. These are DOMException with name === 'TimeoutError'.
+   * These errors are transient and should be retried with increasing intervals.
+   * See: https://github.com/link-assistant/agent/issues/142
+   */
+  export const TimeoutError = NamedError.create(
+    'TimeoutError',
+    z.object({
+      message: z.string(),
+      isRetryable: z.literal(true),
+    })
+  );
+  export type TimeoutError = z.infer<typeof TimeoutError.Schema>;
+
   const PartBase = z.object({
     id: z.string(),
     sessionID: z.string(),
@@ -782,6 +797,11 @@ export namespace MessageV2 {
             cause: e,
           }
         ).toObject();
+      case e instanceof DOMException && e.name === 'TimeoutError':
+        return new MessageV2.TimeoutError(
+          { message: e.message, isRetryable: true },
+          { cause: e }
+        ).toObject();
       case MessageV2.OutputLengthError.isInstance(e):
         return e;
       case LoadAPIKeyError.isInstance(e):
@@ -816,6 +836,18 @@ export namespace MessageV2 {
             { cause: e }
           ).toObject();
         }
+        // Detect timeout errors from various sources
+        // See: https://github.com/link-assistant/agent/issues/142
+        const isTimeoutError =
+          message.includes('The operation timed out') ||
+          message.includes('timed out') ||
+          e.name === 'TimeoutError';
+        if (isTimeoutError) {
+          return new MessageV2.TimeoutError(
+            { message, isRetryable: true },
+            { cause: e }
+          ).toObject();
+        }
         return new NamedError.Unknown(
           { message: e.toString() },
           { cause: e }

package/src/session/processor.ts

@@ -326,21 +326,31 @@ export namespace SessionProcessor {
               providerID: input.providerID,
             });
 
-            // Check if error is retryable (APIError or SocketConnectionError)
+            // Check if error is retryable (APIError, SocketConnectionError, or TimeoutError)
             const isRetryableAPIError =
               error?.name === 'APIError' && error.data.isRetryable;
             const isRetryableSocketError =
               error?.name === 'SocketConnectionError' &&
               error.data.isRetryable &&
               attempt < SessionRetry.SOCKET_ERROR_MAX_RETRIES;
+            const isRetryableTimeoutError =
+              error?.name === 'TimeoutError' &&
+              error.data.isRetryable &&
+              attempt < SessionRetry.TIMEOUT_MAX_RETRIES;
 
-            if (isRetryableAPIError || isRetryableSocketError) {
+            if (
+              isRetryableAPIError ||
+              isRetryableSocketError ||
+              isRetryableTimeoutError
+            ) {
               attempt++;
-              // Use socket-specific delay for socket errors
+              // Use error-specific delay calculation
               const delay =
                 error?.name === 'SocketConnectionError'
                   ? SessionRetry.socketErrorDelay(attempt)
-                  : SessionRetry.delay(error, attempt);
+                  : error?.name === 'TimeoutError'
+                    ? SessionRetry.timeoutDelay(attempt)
+                    : SessionRetry.delay(error, attempt);
               log.info(() => ({
                 message: 'retrying',
                 errorType: error?.name,

package/src/session/retry.ts

@@ -13,6 +13,12 @@ export namespace SessionRetry {
   export const SOCKET_ERROR_INITIAL_DELAY = 1000; // 1 second
   export const SOCKET_ERROR_BACKOFF_FACTOR = 2;
 
+  // Timeout error retry configuration
+  // When API requests time out (AbortSignal.timeout), retry with increasing intervals
+  // See: https://github.com/link-assistant/agent/issues/142
+  export const TIMEOUT_MAX_RETRIES = 3;
+  export const TIMEOUT_DELAYS = [30_000, 60_000, 120_000]; // 30s, 60s, 120s
+
   export async function sleep(ms: number, signal: AbortSignal): Promise<void> {
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(resolve, ms);
@@ -71,4 +77,14 @@ export namespace SessionRetry {
       Math.pow(SOCKET_ERROR_BACKOFF_FACTOR, attempt - 1)
     );
   }
+
+  /**
+   * Calculate delay for timeout error retries.
+   * Uses fixed intervals: 30s, 60s, 120s.
+   * See: https://github.com/link-assistant/agent/issues/142
+   */
+  export function timeoutDelay(attempt: number): number {
+    const index = Math.min(attempt - 1, TIMEOUT_DELAYS.length - 1);
+    return TIMEOUT_DELAYS[index];
+  }
 }