feat(sdk): propagate NetworkError through agent-runtime for retry

support

- Throw NetworkError with proper error codes from promptAiSdkStream on
AI SDK errors - Re-throw NetworkError from runAgentStep instead of
converting to error output - Add reject() to promise in runOnce to
properly propagate retryable errors - Export getRetryableErrorCode for
reuse in CLI - Add comprehensive error code detection for AI_RetryError
messages - Add debug logging in callMainPrompt error handler

This allows the SDK retry wrapper to catch and retry network errors
properly.

Author: brandonkachen

packages/agent-runtime/src/run-agent-step.ts

@@ -880,6 +880,12 @@ export async function loopAgentSteps(
       errorMessage,
     })
 
+    // Re-throw NetworkError so retry logic can handle it
+    // For other error types, wrap in error output for graceful handling
+    if (error && typeof error === 'object' && 'code' in error && 'name' in error && error.name === 'NetworkError') {
+      throw error
+    }
+
     const errorObject = getErrorObject(error)
     return {
       agentState: currentAgentState,

sdk/src/impl/llm.ts

@@ -21,8 +21,11 @@ import {
 import { streamText, APICallError, generateText, generateObject } from 'ai'
 
 import { WEBSITE_URL } from '../constants'
+import { NetworkError, ErrorCodes } from '../errors'
 
+import type { ErrorCode } from '../errors'
 import type { LanguageModelV2 } from '@ai-sdk/provider'
+import type { OpenRouterProviderRoutingOptions } from '@codebuff/common/types/agent-template'
 import type {
   PromptAiSdkFn,
   PromptAiSdkStreamFn,
@@ -31,7 +34,6 @@ import type {
 } from '@codebuff/common/types/contracts/llm'
 import type { ParamsOf } from '@codebuff/common/types/function-params'
 import type { JSONObject } from '@codebuff/common/types/json'
-import type { OpenRouterProviderRoutingOptions } from '@codebuff/common/types/agent-template'
 import type { OpenRouterProviderOptions } from '@openrouter/ai-sdk-provider'
 import type z from 'zod/v4'
 
@@ -252,12 +254,50 @@ export async function* promptAiSdkStream(
             ? chunk.error
             : JSON.stringify(chunk.error)
       const errorMessage = `Error from AI SDK (model ${params.model}): ${buildArray([mainErrorMessage, errorBody]).join('\n')}`
-      yield {
-        type: 'error',
-        message: errorMessage,
+
+      // Determine error code from the error
+      let errorCode: ErrorCode = ErrorCodes.UNKNOWN_ERROR
+      let statusCode: number | undefined
+
+      if (APICallError.isInstance(chunk.error)) {
+        statusCode = chunk.error.statusCode
+        if (statusCode) {
+          if (statusCode === 503) {
+            errorCode = ErrorCodes.SERVICE_UNAVAILABLE
+          } else if (statusCode >= 500) {
+            errorCode = ErrorCodes.SERVER_ERROR
+          } else if (statusCode === 408 || statusCode === 429) {
+            errorCode = ErrorCodes.TIMEOUT
+          }
+        }
+      } else if (chunk.error instanceof Error) {
+        // Check error message for error type indicators (case-insensitive)
+        const msg = chunk.error.message.toLowerCase()
+        if (msg.includes('service unavailable') || msg.includes('503')) {
+          errorCode = ErrorCodes.SERVICE_UNAVAILABLE
+        } else if (
+          msg.includes('econnrefused') ||
+          msg.includes('connection refused')
+        ) {
+          errorCode = ErrorCodes.CONNECTION_REFUSED
+        } else if (msg.includes('enotfound') || msg.includes('dns')) {
+          errorCode = ErrorCodes.DNS_FAILURE
+        } else if (msg.includes('timeout')) {
+          errorCode = ErrorCodes.TIMEOUT
+        } else if (
+          msg.includes('server error') ||
+          msg.includes('500') ||
+          msg.includes('502') ||
+          msg.includes('504')
+        ) {
+          errorCode = ErrorCodes.SERVER_ERROR
+        } else if (msg.includes('network') || msg.includes('fetch failed')) {
+          errorCode = ErrorCodes.NETWORK_ERROR
+        }
       }
 
-      return null
+      // Throw NetworkError so retry logic can handle it
+      throw new NetworkError(errorMessage, errorCode, statusCode, chunk.error)
     }
     if (chunk.type === 'reasoning-delta') {
       for (const provider of ['openrouter', 'codebuff'] as const) {

sdk/src/index.ts

@@ -2,7 +2,7 @@ export type * from '../../common/src/types/json'
 export type * from '../../common/src/types/messages/codebuff-message'
 export type * from '../../common/src/types/messages/data-content'
 export type * from '../../common/src/types/print-mode'
-export { run } from './run'
+export { run, getRetryableErrorCode } from './run'
 export type { RunOptions, RetryOptions } from './run'
 // Agent type exports
 export type { AgentDefinition } from '../../common/src/templates/initial-agents-dir/types/agent-definition'

sdk/src/run.ts

@@ -12,8 +12,9 @@ import { cloneDeep } from 'lodash'
 
 import { getAgentRuntimeImpl } from './impl/agent-runtime'
 import { getUserInfoFromApiKey } from './impl/database'
-import { RETRYABLE_ERROR_CODES, isNetworkError } from './errors'
+import { RETRYABLE_ERROR_CODES, isNetworkError, ErrorCodes, NetworkError } from './errors'
 import type { ErrorCode } from './errors'
+import { getErrorObject } from '@codebuff/common/util/error'
 import { initialSessionState, applyOverridesToSessionState } from './run-state'
 import {
   MAX_RETRIES_PER_MESSAGE,
@@ -428,8 +429,10 @@ export async function runOnce({
   }
 
   let resolve: (value: RunReturnType) => any = () => {}
-  const promise = new Promise<RunReturnType>((res) => {
+  let reject: (error: any) => any = () => {}
+  const promise = new Promise<RunReturnType>((res, rej) => {
     resolve = res
+    reject = rej
   })
 
   async function onError(error: { message: string }) {
@@ -700,8 +703,21 @@ export async function runOnce({
     signal: signal ?? new AbortController().signal,
   }).catch((error) => {
     // Let retryable errors propagate so the retry wrapper can handle them
-    if (isRetryableError(error)) {
-      throw error
+    const isRetryable = isRetryableError(error)
+    logger?.warn(
+      {
+        isNetworkError: isNetworkError(error),
+        errorCode: isNetworkError(error) ? error.code : undefined,
+        isRetryable,
+        error: getErrorObject(error),
+      },
+      'callMainPrompt caught error, checking if retryable',
+    )
+
+    if (isRetryable) {
+      // Reject the promise so the retry wrapper can catch it
+      reject(error)
+      return
     }
 
     // For non-retryable errors, resolve with cancelled state
@@ -857,13 +873,24 @@ async function handleToolCall({
  * Extracts an error code from a prompt error message.
  * Returns the appropriate ErrorCode if the error is retryable, null otherwise.
  */
-const getRetryableErrorCode = (errorMessage: string): ErrorCode | null => {
+export const getRetryableErrorCode = (errorMessage: string): ErrorCode | null => {
   const lowerMessage = errorMessage.toLowerCase()
 
   // AI SDK's built-in retry error (e.g., "Failed after 4 attempts. Last error: Service Unavailable")
-  // Don't retry at SDK level since AI SDK already retried. Just log it for accountability.
+  // The AI SDK already retried 4 times, but we still want our SDK wrapper to retry 3 more times
   if (lowerMessage.includes('failed after') && lowerMessage.includes('attempts')) {
-    return null
+    // Extract the underlying error type from the message
+    if (lowerMessage.includes('service unavailable')) {
+      return ErrorCodes.SERVICE_UNAVAILABLE
+    }
+    if (lowerMessage.includes('timeout')) {
+      return ErrorCodes.TIMEOUT
+    }
+    if (lowerMessage.includes('connection refused')) {
+      return ErrorCodes.CONNECTION_REFUSED
+    }
+    // Default to SERVER_ERROR for other AI SDK retry failures
+    return ErrorCodes.SERVER_ERROR
   }
 
   if (errorMessage.includes('503') || lowerMessage.includes('service unavailable')) {