GPU Retry & Push Notification

// SQS message body (ChatGpuRetryQueue)
GpuRetryRecord {
  chat_id: string
  message_id: string
  user_id: string
  question: string
  retry_count: number   // 0-based; compared against GPU_RETRY_MAX_ATTEMPTS (default 15)
}

retry_handler(event, context):
  for record in event.Records:
    body = json.loads(record.body)
    { chat_id, message_id, user_id, question, retry_count } = body

    validate all fields present

    max_attempts = GPU_RETRY_MAX_ATTEMPTS env (default 15)
    gpu_wait_ms  = GPU_RETRY_WAIT_MS env (default 240000)

    if retry_count >= max_attempts:
      repo.update_message_ready(chat_id, message_id, failure_message)
      push_token = _get_push_token(user_id)     // Sessions.get_item(Key={sessionId: user_id})
      if push_token:
        _send_push_notification(push_token, "Couldn't answer",
          "The GPU took too long to start. Please open the app and retry.")
      return

    // GPU resolution — tag-based only (no SSM read in retry Lambda)
    running = _find_running_gpu_instance_by_tag(region)
    if not running:
      _re_enqueue(chat_id, message_id, user_id, question, retry_count)  // retry_count+1 inside
      return

    ip = running.PrivateIpAddress or running.PublicIpAddress
    gpu_worker_url = http://{ip}:{GPU_WORKER_PORT}

    is_healthy, _ = wait_for_gpu_health(gpu_worker_url, max_wait_ms=gpu_wait_ms,
                                        initial_delay_ms=5000, lambda_context=None)
    if not is_healthy:
      _re_enqueue(chat_id, message_id, user_id, question, retry_count)
      return

    // Run full reasoning pipeline
    handle_chat(user_id, question, chat_id, gpu_worker_url,
                gpu_instance_id=running.InstanceId, verbose=False,
                _repo=repo, message_id=message_id)
    // handle_chat calls update_message_ready internally (ready=True, content=answer)

    push_token = _get_push_token(user_id)
    if push_token:
      _send_push_notification(push_token, "Your answer is ready", question[:80])

// _re_enqueue(chat_id, message_id, user_id, question, retry_count):
  sqs.send_message(
    QueueUrl=CHAT_GPU_RETRY_QUEUE_URL,
    MessageBody=json.dumps({...retry_count+1}),
    DelaySeconds=120,
  )

implementation(payload, auth_context, _skip_user_message_save=False):
  ...
  if not gpu_worker_url:
    if message_id:   // async dispatcher path
      repo.mark_gpu_pending(chat_id, message_id)
      // mark_gpu_pending: SET gpu_pending=True, ready=False, content="", updated_at=now
      _enqueue_gpu_retry(chat_id, message_id, user_id, question, retry_count=0, delay_seconds=120)
      return { status: "gpu_retry_enqueued", chat_id, message_id }
    else:            // legacy sync path
      repo.save_message(chat_id, "assistant", fallback_string)
      repo.touch_chat(user_id, chat_id)
      return { answer: fallback_string, chat_id }

// PUT /users/push-token request body
PushTokenRequest {
  push_token: string (required, non-empty)
}

// PUT /users/push-token response (HTTP 200)
PushTokenResponse {
  success: true
}

// _layout.tsx
useEffect([user]):
  if user:
    token = await registerForPushNotifications()
    if token: await savePushToken(token)

// push-notifications.ts
registerForPushNotifications():
  if not Device.isDevice: return null
  { status } = await Notifications.getPermissionsAsync()
  if status != "granted":
    { status } = await Notifications.requestPermissionsAsync()
  if status != "granted": return null
  projectId = process.env.EXPO_PUBLIC_EAS_PROJECT_ID
  if not projectId: return null
  token = await Notifications.getExpoPushTokenAsync({ projectId })
  return token.data   // "ExponentPushToken[...]"

// UsersPushTokenFunction (PUT /users/push-token)
handle_push_token(payload, auth_context):
  push_token = payload.get("push_token", "").strip()
  if not push_token: raise InvalidInputError
  user_id = auth_context.user_id
  Sessions.update_item(
    Key={ sessionId: user_id },
    UpdateExpression="SET push_token = :t, updated_at = :u"
  )
  return { success: True }