@link-assistant/agent 0.22.7 → 0.22.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.22.7",
+  "version": "0.22.9",
   "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/session/message-v2.ts

@@ -849,6 +849,48 @@ export namespace MessageV2 {
     return result;
   }
 
+  function normalizeProviderErrorObject(e: unknown) {
+    if (!e || typeof e !== 'object') return;
+
+    const root = e as Record<string, unknown>;
+    const candidate =
+      root['error'] && typeof root['error'] === 'object'
+        ? (root['error'] as Record<string, unknown>)
+        : root;
+    const rawCode =
+      candidate['code'] ?? candidate['statusCode'] ?? candidate['status'];
+    const statusCode =
+      typeof rawCode === 'number'
+        ? rawCode
+        : typeof rawCode === 'string' && /^\d+$/.test(rawCode)
+          ? Number.parseInt(rawCode, 10)
+          : undefined;
+
+    if (statusCode === undefined) return;
+
+    let responseBody: string | undefined;
+    try {
+      responseBody = JSON.stringify(e);
+    } catch {
+      responseBody = undefined;
+    }
+
+    const message =
+      typeof candidate['message'] === 'string'
+        ? candidate['message']
+        : typeof root['message'] === 'string'
+          ? root['message']
+          : `Provider returned HTTP ${statusCode}`;
+
+    return {
+      message,
+      statusCode,
+      isRetryable:
+        statusCode === 429 || (statusCode >= 500 && statusCode < 600),
+      responseBody,
+    };
+  }
+
   export function fromError(e: unknown, ctx: { providerID: string }) {
     switch (true) {
       case e instanceof DOMException && e.name === 'AbortError':
@@ -884,6 +926,10 @@ export namespace MessageV2 {
           },
           { cause: e }
         ).toObject();
+      case normalizeProviderErrorObject(e) !== undefined: {
+        const providerError = normalizeProviderErrorObject(e)!;
+        return new MessageV2.APIError(providerError, { cause: e }).toObject();
+      }
       case e instanceof Error: {
         const message = e.message || e.toString();
         // Detect Bun socket connection errors (known Bun issue with 10s idle timeout)

package/src/session/processor.ts

@@ -52,6 +52,40 @@ export namespace SessionProcessor {
     }
   }
 
+  /**
+   * Detect AI SDK/provider usage-shape crashes.
+   *
+   * Some provider error streams end before a valid finish-step usage object is
+   * available. Depending on the provider adapter, that can surface as a
+   * TypeError while reading token fields instead of the original provider
+   * error. Treat it as retryable provider failure rather than a generic crash.
+   *
+   * See: https://github.com/link-assistant/agent/issues/264
+   */
+  export function isUsageDataTypeError(error: unknown): boolean {
+    const message =
+      error instanceof Error
+        ? `${error.name}: ${error.message}`
+        : typeof error === 'string'
+          ? error
+          : '';
+
+    if (!(error instanceof TypeError) && !message.startsWith('TypeError:')) {
+      return false;
+    }
+
+    return [
+      'input_tokens',
+      'output_tokens',
+      'usage.inputTokens',
+      'usage.outputTokens',
+      'inputTokens.total',
+      'outputTokens.total',
+      "reading 'inputTokens'",
+      "reading 'outputTokens'",
+    ].some((pattern) => message.includes(pattern));
+  }
+
   export type Info = Awaited<ReturnType<typeof create>>;
   export type Result = Awaited<ReturnType<Info['process']>>;
 
@@ -542,37 +576,34 @@ export namespace SessionProcessor {
           } catch (e) {
             log.error(() => ({ message: 'process', error: e }));
 
-            // Check for AI SDK usage-related TypeError (input_tokens undefined)
-            // This happens when providers return incomplete usage data
-            // See: https://github.com/link-assistant/agent/issues/152
-            if (
-              e instanceof TypeError &&
-              (e.message.includes('input_tokens') ||
-                e.message.includes('output_tokens') ||
-                e.message.includes("reading 'input_tokens'") ||
-                e.message.includes("reading 'output_tokens'"))
-            ) {
+            let error = MessageV2.fromError(e, {
+              providerID: input.providerID,
+            });
+
+            // Check for AI SDK usage-related TypeErrors. These usually come
+            // from provider adapters after malformed/incomplete usage data, so
+            // retry them with normal API-error backoff instead of surfacing a
+            // misleading UnknownError.
+            if (isUsageDataTypeError(e)) {
               log.warn(() => ({
                 message:
-                  'Provider returned invalid usage data, continuing with zero usage',
-                errorMessage: e.message,
+                  'provider returned invalid usage data; retrying as provider API error',
+                errorMessage: e instanceof Error ? e.message : String(e),
                 providerID: input.providerID,
+                issue: 'https://github.com/link-assistant/agent/issues/264',
               }));
-              // Set default token values to prevent crash
-              input.assistantMessage.tokens = {
-                input: 0,
-                output: 0,
-                reasoning: 0,
-                cache: { read: 0, write: 0 },
-              };
-              // Continue processing instead of failing
-              continue;
+              error = new MessageV2.APIError(
+                {
+                  message:
+                    e instanceof Error
+                      ? e.message
+                      : 'Provider returned invalid usage data',
+                  isRetryable: true,
+                },
+                { cause: e }
+              ).toObject();
             }
 
-            const error = MessageV2.fromError(e, {
-              providerID: input.providerID,
-            });
-
             // Check if error is retryable (APIError, SocketConnectionError, TimeoutError)
             const isRetryableAPIError =
               error?.name === 'APIError' && error.data.isRetryable;