Preserve free-mode block details

Author: jahooma

common/src/types/session-state.ts

@@ -69,6 +69,9 @@ export const AgentOutputSchema = z.discriminatedUnion('type', [
     message: z.string(),
     statusCode: z.number().optional(),
     error: z.string().optional(),
+    countryCode: z.string().optional(),
+    countryBlockReason: z.string().optional(),
+    ipPrivacySignals: z.array(z.string()).optional(),
   }),
 ])
 export type AgentOutput = z.infer<typeof AgentOutputSchema>

common/src/util/error.ts

@@ -198,18 +198,56 @@ export function unwrapPromptResult<T>(result: PromptResult<T>): T {
 export function parseApiErrorResponseBody(responseBody: unknown): {
   errorCode?: string
   message?: string
+  countryCode?: string
+  countryBlockReason?: string
+  ipPrivacySignals?: string[]
 } {
   if (typeof responseBody !== 'string') return {}
   try {
     const parsed: unknown = JSON.parse(responseBody)
     if (!parsed || typeof parsed !== 'object') return {}
-    const result: { errorCode?: string; message?: string } = {}
-    if ('error' in parsed && typeof (parsed as { error: unknown }).error === 'string') {
+    const result: {
+      errorCode?: string
+      message?: string
+      countryCode?: string
+      countryBlockReason?: string
+      ipPrivacySignals?: string[]
+    } = {}
+    if (
+      'error' in parsed &&
+      typeof (parsed as { error: unknown }).error === 'string'
+    ) {
       result.errorCode = (parsed as { error: string }).error
     }
-    if ('message' in parsed && typeof (parsed as { message: unknown }).message === 'string') {
+    if (
+      'message' in parsed &&
+      typeof (parsed as { message: unknown }).message === 'string'
+    ) {
       result.message = (parsed as { message: string }).message
     }
+    if (
+      'countryCode' in parsed &&
+      typeof (parsed as { countryCode: unknown }).countryCode === 'string'
+    ) {
+      result.countryCode = (parsed as { countryCode: string }).countryCode
+    }
+    if (
+      'countryBlockReason' in parsed &&
+      typeof (parsed as { countryBlockReason: unknown }).countryBlockReason ===
+        'string'
+    ) {
+      result.countryBlockReason = (
+        parsed as { countryBlockReason: string }
+      ).countryBlockReason
+    }
+    if ('ipPrivacySignals' in parsed) {
+      const signals = (parsed as { ipPrivacySignals: unknown }).ipPrivacySignals
+      if (Array.isArray(signals)) {
+        result.ipPrivacySignals = signals.filter(
+          (signal): signal is string => typeof signal === 'string',
+        )
+      }
+    }
     return result
   } catch {
     return {}

packages/agent-runtime/src/__tests__/loop-agent-steps.test.ts

@@ -955,6 +955,9 @@ describe('loopAgentSteps - runAgentStep vs runProgrammaticStep behavior', () =>
           responseBody: JSON.stringify({
             error: 'free_mode_unavailable',
             message: 'Free mode is not available in your country.',
+            countryCode: 'US',
+            countryBlockReason: 'anonymous_network',
+            ipPrivacySignals: ['vpn', 'hosting'],
           }),
           isRetryable: false,
         })
@@ -976,6 +979,9 @@ describe('loopAgentSteps - runAgentStep vs runProgrammaticStep behavior', () =>
         expect(result.output.error).toBe('free_mode_unavailable')
         // Should propagate the status code
         expect(result.output.statusCode).toBe(403)
+        expect(result.output.countryCode).toBe('US')
+        expect(result.output.countryBlockReason).toBe('anonymous_network')
+        expect(result.output.ipPrivacySignals).toEqual(['vpn', 'hosting'])
       }
     })
 

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

@@ -1097,11 +1097,21 @@ export async function loopAgentSteps(
 
     let errorMessage = ''
     let errorCode: string | undefined
+    let countryCode: string | undefined
+    let countryBlockReason: string | undefined
+    let ipPrivacySignals: string[] | undefined
     let hasServerMessage = false
     if (error instanceof APICallError) {
       errorMessage = `${error.message}`
       const parsed = parseApiErrorResponseBody(error.responseBody)
       if (parsed.errorCode) errorCode = parsed.errorCode
+      if (parsed.countryCode) countryCode = parsed.countryCode
+      if (parsed.countryBlockReason) {
+        countryBlockReason = parsed.countryBlockReason
+      }
+      if (parsed.ipPrivacySignals) {
+        ipPrivacySignals = parsed.ipPrivacySignals
+      }
       if (parsed.message) {
         errorMessage = parsed.message
         hasServerMessage = true
@@ -1139,6 +1149,9 @@ export async function loopAgentSteps(
         message: hasServerMessage ? errorMessage : 'Agent run error: ' + errorMessage,
         ...(statusCode !== undefined && { statusCode }),
         ...(errorCode !== undefined && { error: errorCode }),
+        ...(countryCode !== undefined && { countryCode }),
+        ...(countryBlockReason !== undefined && { countryBlockReason }),
+        ...(ipPrivacySignals !== undefined && { ipPrivacySignals }),
       },
     }
   }